Adding upstream version 8.4.4.upstream/8.4.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 4942 insertions, 0 deletions

diff --git a/vtysh/vtysh.c b/vtysh/vtysh.c
new file mode 100644
index 0000000..f39ecf0
--- /dev/null
+++ b/vtysh/vtysh.c
@@ -0,0 +1,4942 @@
+/* Virtual terminal interface shell.
+ * Copyright (C) 2000 Kunihiro Ishiguro
+ *
+ * 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 <sys/un.h>
+#include <setjmp.h>
+#include <sys/wait.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+
+/* readline carries some ancient definitions around */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-prototypes"
+#include <readline/readline.h>
+#include <readline/history.h>
+#pragma GCC diagnostic pop
+
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "linklist.h"
+#include "command.h"
+#include "memory.h"
+#include "network.h"
+#include "filter.h"
+#include "vtysh/vtysh.h"
+#include "vtysh/vtysh_daemons.h"
+#include "log.h"
+#include "vrf.h"
+#include "libfrr.h"
+#include "command_graph.h"
+#include "frrstr.h"
+#include "json.h"
+#include "ferr.h"
+#include "bgpd/bgp_vty.h"
+
+DEFINE_MTYPE_STATIC(MVTYSH, VTYSH_CMD, "Vtysh cmd copy");
+
+/* Struct VTY. */
+struct vty *vty;
+
+/* VTY shell pager name. */
+char *vtysh_pager_name = NULL;
+
+/* VTY should add timestamp */
+bool vtysh_add_timestamp;
+
+/* VTY shell client structure */
+struct vtysh_client {
+	int fd;
+	const char *name;
+	int flag;
+	char path[MAXPATHLEN];
+	struct vtysh_client *next;
+
+	struct thread *log_reader;
+	int log_fd;
+	uint32_t lost_msgs;
+};
+
+static bool stderr_tty;
+static bool stderr_stdout_same;
+
+/* Some utility functions for working on vtysh-specific vty tasks */
+
+static FILE *vty_open_pager(struct vty *vty)
+{
+	if (vty->is_paged)
+		return vty->of;
+
+	if (!vtysh_pager_name)
+		return NULL;
+
+	vty->of_saved = vty->of;
+	vty->of = popen(vtysh_pager_name, "w");
+	if (vty->of == NULL) {
+		vty->of = vty->of_saved;
+		perror("popen");
+		exit(1);
+	}
+
+	vty->is_paged = true;
+
+	return vty->of;
+}
+
+static int vty_close_pager(struct vty *vty)
+{
+	if (!vty->is_paged)
+		return 0;
+
+	fflush(vty->of);
+	if (pclose(vty->of) == -1) {
+		perror("pclose");
+		exit(1);
+	}
+
+	vty->of = vty->of_saved;
+	vty->is_paged = false;
+
+	return 0;
+}
+
+static void vtysh_pager_envdef(bool fallback)
+{
+	char *pager_defined;
+
+	pager_defined = getenv("VTYSH_PAGER");
+
+	if (pager_defined)
+		vtysh_pager_name = strdup(pager_defined);
+	else if (fallback)
+		vtysh_pager_name = strdup(VTYSH_PAGER);
+}
+
+/* --- */
+
+struct vtysh_client vtysh_client[] = {
+	{.name = "zebra", .flag = VTYSH_ZEBRA},
+	{.name = "ripd", .flag = VTYSH_RIPD},
+	{.name = "ripngd", .flag = VTYSH_RIPNGD},
+	{.name = "ospfd", .flag = VTYSH_OSPFD},
+	{.name = "ospf6d", .flag = VTYSH_OSPF6D},
+	{.name = "ldpd", .flag = VTYSH_LDPD},
+	{.name = "bgpd", .flag = VTYSH_BGPD},
+	{.name = "isisd", .flag = VTYSH_ISISD},
+	{.name = "pimd", .flag = VTYSH_PIMD},
+	{.name = "nhrpd", .flag = VTYSH_NHRPD},
+	{.name = "eigrpd", .flag = VTYSH_EIGRPD},
+	{.name = "babeld", .flag = VTYSH_BABELD},
+	{.name = "sharpd", .flag = VTYSH_SHARPD},
+	{.name = "fabricd", .flag = VTYSH_FABRICD},
+	{.name = "watchfrr", .flag = VTYSH_WATCHFRR},
+	{.name = "pbrd", .flag = VTYSH_PBRD},
+	{.name = "staticd", .flag = VTYSH_STATICD},
+	{.name = "bfdd", .flag = VTYSH_BFDD},
+	{.name = "vrrpd", .flag = VTYSH_VRRPD},
+	{.name = "pathd", .flag = VTYSH_PATHD},
+	{.name = "pim6d", .flag = VTYSH_PIM6D},
+};
+
+/* Searches for client by name, returns index */
+static int vtysh_client_lookup(const char *name)
+{
+	int idx = -1;
+
+	for (unsigned int i = 0; i < array_size(vtysh_client); i++) {
+		if (strmatch(vtysh_client[i].name, name)) {
+			idx = i;
+			break;
+		}
+	}
+
+	return idx;
+}
+
+enum vtysh_write_integrated vtysh_write_integrated =
+	WRITE_INTEGRATED_UNSPECIFIED;
+
+static int vtysh_reconnect(struct vtysh_client *vclient);
+
+static void vclient_close(struct vtysh_client *vclient)
+{
+	if (vclient->fd >= 0) {
+		if (vty->of)
+			vty_out(vty,
+				"Warning: closing connection to %s because of an I/O error!\n",
+				vclient->name);
+		close(vclient->fd);
+		/* indicate as candidate for reconnect */
+		vclient->fd = VTYSH_WAS_ACTIVE;
+	}
+}
+
+static ssize_t vtysh_client_receive(struct vtysh_client *vclient, char *buf,
+				    size_t bufsz, int *pass_fd)
+{
+	struct iovec iov[1] = {
+		{
+			.iov_base = buf,
+			.iov_len = bufsz,
+		},
+	};
+	union {
+		uint8_t buf[CMSG_SPACE(sizeof(int))];
+		struct cmsghdr align;
+	} u;
+	struct msghdr mh = {
+		.msg_iov = iov,
+		.msg_iovlen = array_size(iov),
+		.msg_control = u.buf,
+		.msg_controllen = sizeof(u.buf),
+	};
+	struct cmsghdr *cmh = CMSG_FIRSTHDR(&mh);
+	ssize_t ret;
+
+	cmh->cmsg_level = SOL_SOCKET;
+	cmh->cmsg_type = SCM_RIGHTS;
+	cmh->cmsg_len = CMSG_LEN(sizeof(int));
+	memset(CMSG_DATA(cmh), -1, sizeof(int));
+
+	do {
+		ret = recvmsg(vclient->fd, &mh, 0);
+		if (ret >= 0 || (errno != EINTR && errno != EAGAIN))
+			break;
+	} while (true);
+
+	if (cmh->cmsg_len == CMSG_LEN(sizeof(int))) {
+		int fd;
+
+		memcpy(&fd, CMSG_DATA(cmh), sizeof(int));
+		if (fd != -1) {
+			if (pass_fd)
+				*pass_fd = fd;
+			else
+				close(fd);
+		}
+	}
+	return ret;
+}
+
+/*
+ * Send a CLI command to a client and read the response.
+ *
+ * Output will be printed to vty->of. If you want to suppress output, set that
+ * to NULL.
+ *
+ * vclient
+ *    the client to send the command to
+ *
+ * line
+ *    the command to send
+ *
+ * callback
+ *    if non-null, this will be called with each line of output received from
+ *    the client passed in the second parameter
+ *
+ * cbarg
+ *    optional first argument to pass to callback
+ *
+ * Returns:
+ *    a status code
+ */
+static int vtysh_client_run(struct vtysh_client *vclient, const char *line,
+			    void (*callback)(void *, const char *), void *cbarg,
+			    int *pass_fd)
+{
+	int ret;
+	char stackbuf[4096];
+	char *buf = stackbuf;
+	size_t bufsz = sizeof(stackbuf);
+	char *bufvalid, *end = NULL;
+	char terminator[3] = {0, 0, 0};
+
+	/* vclinet was previously active, try to reconnect */
+	if (vclient->fd == VTYSH_WAS_ACTIVE) {
+		ret = vtysh_reconnect(vclient);
+		if (ret < 0)
+			goto out_err;
+	}
+
+	if (vclient->fd < 0)
+		return CMD_SUCCESS;
+
+	ret = write(vclient->fd, line, strlen(line) + 1);
+	if (ret <= 0) {
+		/* close connection and try to reconnect */
+		vclient_close(vclient);
+		ret = vtysh_reconnect(vclient);
+		if (ret < 0)
+			goto out_err;
+		/* retry line */
+		ret = write(vclient->fd, line, strlen(line) + 1);
+		if (ret <= 0)
+			goto out_err;
+	}
+
+	bufvalid = buf;
+	do {
+		ssize_t nread;
+
+		nread = vtysh_client_receive(
+			vclient, bufvalid, buf + bufsz - bufvalid - 1, pass_fd);
+
+		if (nread < 0 && (errno == EINTR || errno == EAGAIN))
+			continue;
+
+		if (nread <= 0) {
+			if (vty->of)
+				vty_out(vty,
+					"vtysh: error reading from %s: %s (%d)",
+					vclient->name, safe_strerror(errno),
+					errno);
+			goto out_err;
+		}
+
+		bufvalid += nread;
+
+		/* Null terminate so we may pass this to *printf later. */
+		bufvalid[0] = '\0';
+
+		/*
+		 * We expect string output from daemons, so instead of looking
+		 * for the full 3 null bytes of the terminator, we check for
+		 * just one instead and assume it is the first byte of the
+		 * terminator. The presence of the full terminator is checked
+		 * later.
+		 */
+		if (bufvalid - buf >= 4)
+			end = memmem(bufvalid - 4, 4, "\0", 1);
+
+		/*
+		 * calculate # bytes we have, up to & not including the
+		 * terminator if present
+		 */
+		size_t textlen = (end ? end : bufvalid) - buf;
+		bool b = false;
+
+		/* feed line processing callback if present */
+		while (callback && bufvalid > buf && (end > buf || !end)) {
+			textlen = (end ? end : bufvalid) - buf;
+			char *eol = memchr(buf, '\n', textlen);
+			if (eol)
+				/* line break */
+				*eol++ = '\0';
+			else if (end == buf)
+				/*
+				 * no line break, end of input, no text left
+				 * before end; nothing to write
+				 */
+				b = true;
+			else if (end)
+				/* no nl, end of input, but some text left */
+				eol = end;
+			else if (bufvalid == buf + bufsz - 1) {
+				/*
+				 * no nl, no end of input, no buffer space;
+				 * realloc
+				 */
+				char *new;
+
+				bufsz *= 2;
+				if (buf == stackbuf) {
+					new = XMALLOC(MTYPE_TMP, bufsz);
+					memcpy(new, stackbuf, sizeof(stackbuf));
+				} else
+					new = XREALLOC(MTYPE_TMP, buf, bufsz);
+
+				bufvalid = bufvalid - buf + new;
+				buf = new;
+				/* if end != NULL, we won't be reading more
+				 * data... */
+				assert(end == NULL);
+				b = true;
+			} else
+				b = true;
+
+			if (b)
+				break;
+
+			/* eol is at line end now, either \n => \0 or \0\0\0 */
+			assert(eol && eol <= bufvalid);
+
+			if (vty->of)
+				vty_out(vty, "%s\n", buf);
+
+			callback(cbarg, buf);
+
+			/* shift back data and adjust bufvalid */
+			memmove(buf, eol, bufvalid - eol);
+			bufvalid -= eol - buf;
+			if (end)
+				end -= eol - buf;
+		}
+
+		/* else if no callback, dump raw */
+		if (!callback) {
+			if (vty->of)
+				vty_out(vty, "%s", buf);
+			memmove(buf, buf + textlen, bufvalid - buf - textlen);
+			bufvalid -= textlen;
+			if (end)
+				end -= textlen;
+
+			/*
+			 * ----------------------------------------------------
+			 * At this point `buf` should be in one of two states:
+			 * - Empty (i.e. buf == bufvalid)
+			 * - Contains up to 4 bytes of the terminator
+			 * ----------------------------------------------------
+			 */
+			assert(((buf == bufvalid)
+				|| (bufvalid - buf <= 4 && buf[0] == 0x00)));
+		}
+
+		/* if we have the terminator, break */
+		if (end && bufvalid - buf == 4) {
+			assert(!memcmp(buf, terminator, 3));
+			ret = buf[3];
+			break;
+		}
+
+	} while (true);
+	goto out;
+
+out_err:
+	vclient_close(vclient);
+	ret = CMD_SUCCESS;
+out:
+	if (buf != stackbuf)
+		XFREE(MTYPE_TMP, buf);
+	return ret;
+}
+
+static int vtysh_client_run_all(struct vtysh_client *head_client,
+				const char *line, int continue_on_err,
+				void (*callback)(void *, const char *),
+				void *cbarg)
+{
+	struct vtysh_client *client;
+	int rc, rc_all = CMD_SUCCESS;
+	int correct_instance = 0, wrong_instance = 0;
+
+	for (client = head_client; client; client = client->next) {
+		rc = vtysh_client_run(client, line, callback, cbarg, NULL);
+		if (rc == CMD_NOT_MY_INSTANCE) {
+			wrong_instance++;
+			continue;
+		}
+		if (client->fd > 0)
+			correct_instance++;
+		if (rc != CMD_SUCCESS) {
+			if (!continue_on_err)
+				return rc;
+			rc_all = rc;
+		}
+	}
+	if (wrong_instance && !correct_instance && vty->of) {
+		vty_out(vty,
+			"%% [%s]: command ignored as it targets an instance that is not running\n",
+			head_client->name);
+		rc_all = CMD_WARNING_CONFIG_FAILED;
+	}
+	return rc_all;
+}
+
+/*
+ * Execute command against all daemons.
+ *
+ * head_client
+ *    where to start walking in the daemon list
+ *
+ * line
+ *    the specific command to execute
+ *
+ * Returns:
+ *    a status code
+ */
+static int vtysh_client_execute(struct vtysh_client *head_client,
+				const char *line)
+{
+	return vtysh_client_run_all(head_client, line, 0, NULL, NULL);
+}
+
+/* Execute by name */
+static int vtysh_client_execute_name(const char *name, const char *line)
+{
+	int ret = CMD_SUCCESS;
+	int idx_client = -1;
+
+	idx_client = vtysh_client_lookup(name);
+	if (idx_client != -1)
+		ret = vtysh_client_execute(&vtysh_client[idx_client], line);
+	else {
+		vty_out(vty, "Client not found\n");
+		ret = CMD_WARNING;
+	}
+
+	return ret;
+}
+
+/*
+ * Retrieve all running config from daemons and parse it with the vtysh config
+ * parser. Returned output is not displayed to the user.
+ *
+ * head_client
+ *    where to start walking in the daemon list
+ *
+ * line
+ *    the specific command to execute
+ */
+static void vtysh_client_config(struct vtysh_client *head_client, char *line)
+{
+	/* watchfrr currently doesn't load any config, and has some hardcoded
+	 * settings that show up in "show run".  skip it here (for now at
+	 * least) so we don't get that mangled up in config-write.
+	 */
+	if (head_client->flag == VTYSH_WATCHFRR)
+		return;
+
+	/* suppress output to user */
+	vty->of_saved = vty->of;
+	vty->of = NULL;
+	vtysh_client_run_all(head_client, line, 1, vtysh_config_parse_line,
+			     NULL);
+	vty->of = vty->of_saved;
+}
+
+/* Command execution over the vty interface. */
+static int vtysh_execute_func(const char *line, int pager)
+{
+	int ret, cmd_stat;
+	unsigned int i;
+	vector vline;
+	const struct cmd_element *cmd;
+	int tried = 0;
+	int saved_ret, saved_node;
+
+	/* Split readline string up into the vector. */
+	vline = cmd_make_strvec(line);
+
+	if (vline == NULL)
+		return CMD_SUCCESS;
+
+	if (vtysh_add_timestamp && strncmp(line, "exit", 4)) {
+		char ts[48];
+
+		(void)frr_timestamp(3, ts, sizeof(ts));
+		vty_out(vty, "%% %s\n\n", ts);
+	}
+
+	saved_ret = ret = cmd_execute(vty, line, &cmd, 1);
+	saved_node = vty->node;
+
+	/*
+	 * If command doesn't succeeded in current node, try to walk up in node
+	 * tree. Changing vty->node is enough to try it just out without actual
+	 * walkup in the vtysh.
+	 */
+	while (ret != CMD_SUCCESS && ret != CMD_SUCCESS_DAEMON
+	       && ret != CMD_WARNING && ret != CMD_WARNING_CONFIG_FAILED
+	       && ret != CMD_ERR_AMBIGUOUS && ret != CMD_ERR_INCOMPLETE
+	       && vty->node > CONFIG_NODE) {
+		vty->node = node_parent(vty->node);
+		ret = cmd_execute(vty, line, &cmd, 1);
+		tried++;
+	}
+
+	vty->node = saved_node;
+
+	/*
+	 * If command succeeded in any other node than current (tried > 0) we
+	 * have to move into node in the vtysh where it succeeded.
+	 */
+	if (ret == CMD_SUCCESS || ret == CMD_SUCCESS_DAEMON
+	    || ret == CMD_WARNING) {
+		while (tried-- > 0)
+			vtysh_execute("exit");
+	}
+	/*
+	 * If command didn't succeed in any node, continue with return value
+	 * from first try.
+	 */
+	else if (tried) {
+		ret = saved_ret;
+	}
+
+	cmd_free_strvec(vline);
+
+	cmd_stat = ret;
+	switch (ret) {
+	case CMD_WARNING:
+	case CMD_WARNING_CONFIG_FAILED:
+		if (vty->type == VTY_FILE)
+			vty_out(vty, "Warning...\n");
+		break;
+	case CMD_ERR_AMBIGUOUS:
+		vty_out(vty, "%% Ambiguous command: %s\n", line);
+		break;
+	case CMD_ERR_NO_MATCH:
+		vty_out(vty, "%% Unknown command: %s\n", line);
+		break;
+	case CMD_ERR_INCOMPLETE:
+		vty_out(vty, "%% Command incomplete: %s\n", line);
+		break;
+	case CMD_SUCCESS_DAEMON: {
+		/*
+		 * FIXME: Don't open pager for exit commands. popen() causes
+		 * problems if exited from vtysh at all. This hack shouldn't
+		 * cause any problem but is really ugly.
+		 */
+		if (pager && strncmp(line, "exit", 4))
+			vty_open_pager(vty);
+
+		if (!strcmp(cmd->string, "configure")) {
+			for (i = 0; i < array_size(vtysh_client); i++) {
+				cmd_stat = vtysh_client_execute(
+					&vtysh_client[i], line);
+				if (cmd_stat == CMD_WARNING)
+					break;
+			}
+
+			if (cmd_stat) {
+				line = "end";
+				vline = cmd_make_strvec(line);
+
+
+				if (vline == NULL) {
+					if (vty->is_paged)
+						vty_close_pager(vty);
+					return CMD_SUCCESS;
+				}
+
+				ret = cmd_execute_command(vline, vty, &cmd, 1);
+				cmd_free_strvec(vline);
+				if (ret != CMD_SUCCESS_DAEMON)
+					break;
+			} else if (cmd->func) {
+				(*cmd->func)(cmd, vty, 0, NULL);
+				break;
+			}
+		}
+
+		cmd_stat = CMD_SUCCESS;
+		struct vtysh_client *vc;
+		for (i = 0; i < array_size(vtysh_client); i++) {
+			if (cmd->daemon & vtysh_client[i].flag) {
+				if (vtysh_client[i].fd < 0
+				    && (cmd->daemon == vtysh_client[i].flag)) {
+					for (vc = &vtysh_client[i]; vc;
+					     vc = vc->next)
+						if (vc->fd == VTYSH_WAS_ACTIVE)
+							vtysh_reconnect(vc);
+				}
+				if (vtysh_client[i].fd < 0
+				    && (cmd->daemon == vtysh_client[i].flag)) {
+					bool any_inst = false;
+					for (vc = &vtysh_client[i]; vc;
+					     vc = vc->next)
+						any_inst = any_inst
+							   || (vc->fd > 0);
+					if (!any_inst) {
+						fprintf(stderr,
+							"%s is not running\n",
+							vtysh_client[i].name);
+						cmd_stat = CMD_ERR_NO_DAEMON;
+						break;
+					}
+				}
+				cmd_stat = vtysh_client_execute(
+					&vtysh_client[i], line);
+				if (cmd_stat != CMD_SUCCESS)
+					break;
+			}
+		}
+		if (cmd_stat != CMD_SUCCESS && cmd_stat != CMD_ERR_NO_DAEMON)
+			break;
+
+		if (cmd->func)
+			(*cmd->func)(cmd, vty, 0, NULL);
+	}
+	}
+	if (vty->is_paged)
+		vty_close_pager(vty);
+
+	return cmd_stat;
+}
+
+int vtysh_execute_no_pager(const char *line)
+{
+	return vtysh_execute_func(line, 0);
+}
+
+int vtysh_execute(const char *line)
+{
+	return vtysh_execute_func(line, 1);
+}
+
+static char *trim(char *s)
+{
+	size_t size;
+	char *end;
+
+	size = strlen(s);
+
+	if (!size)
+		return s;
+
+	end = s + size - 1;
+	while (end >= s && isspace((unsigned char)*end))
+		end--;
+	*(end + 1) = '\0';
+
+	while (*s && isspace((unsigned char)*s))
+		s++;
+
+	return s;
+}
+
+int vtysh_mark_file(const char *filename)
+{
+	struct vty *vty;
+	FILE *confp = NULL;
+	int ret;
+	vector vline;
+	int tried = 0;
+	const struct cmd_element *cmd;
+	int saved_ret, prev_node;
+	int lineno = 0;
+	char *vty_buf_copy = NULL;
+	char *vty_buf_trimmed = NULL;
+
+	if (strncmp("-", filename, 1) == 0)
+		confp = stdin;
+	else
+		confp = fopen(filename, "r");
+
+	if (confp == NULL) {
+		fprintf(stderr, "%% Can't open config file %s due to '%s'.\n",
+			filename, safe_strerror(errno));
+		return CMD_ERR_NO_FILE;
+	}
+
+	vty = vty_new();
+	vty->wfd = STDOUT_FILENO;
+	vty->type = VTY_TERM;
+	vty->node = CONFIG_NODE;
+
+	vtysh_execute_no_pager("enable");
+	vtysh_execute_no_pager("configure");
+	vty_buf_copy = XCALLOC(MTYPE_VTYSH_CMD, VTY_BUFSIZ);
+
+	while (fgets(vty->buf, VTY_BUFSIZ, confp)) {
+		lineno++;
+		tried = 0;
+		strlcpy(vty_buf_copy, vty->buf, VTY_BUFSIZ);
+		vty_buf_trimmed = trim(vty_buf_copy);
+
+		if (vty_buf_trimmed[0] == '!' || vty_buf_trimmed[0] == '#') {
+			vty_out(vty, "%s", vty->buf);
+			continue;
+		}
+
+		/* Split readline string up into the vector. */
+		vline = cmd_make_strvec(vty->buf);
+
+		if (vline == NULL) {
+			vty_out(vty, "%s", vty->buf);
+			continue;
+		}
+
+		/*
+		 * Ignore the "end" lines, we will generate these where
+		 * appropriate
+		 */
+		if (strlen(vty_buf_trimmed) == 3
+		    && strncmp("end", vty_buf_trimmed, 3) == 0) {
+			cmd_free_strvec(vline);
+			continue;
+		}
+
+		prev_node = vty->node;
+		saved_ret = ret = cmd_execute_command_strict(vline, vty, &cmd);
+
+		/*
+		 * If command doesn't succeeded in current node, try to walk up
+		 * in node tree. Changing vty->node is enough to try it just
+		 * out without actual walkup in the vtysh.
+		 */
+		while (ret != CMD_SUCCESS && ret != CMD_SUCCESS_DAEMON
+		       && ret != CMD_WARNING && ret != CMD_WARNING_CONFIG_FAILED
+		       && ret != CMD_ERR_AMBIGUOUS && ret != CMD_ERR_INCOMPLETE
+		       && vty->node > CONFIG_NODE) {
+			vty->node = node_parent(vty->node);
+			ret = cmd_execute_command_strict(vline, vty, &cmd);
+			tried++;
+		}
+
+		/*
+		 * If command succeeded in any other node than current (tried >
+		 * 0) we have to move into node in the vtysh where it
+		 * succeeded.
+		 */
+		if (ret == CMD_SUCCESS || ret == CMD_SUCCESS_DAEMON
+		    || ret == CMD_WARNING) {
+			while (tried-- > 0)
+				vty_out(vty, "exit\n");
+		}
+		/*
+		 * If command didn't succeed in any node, continue with return
+		 * value from first try.
+		 */
+		else if (tried) {
+			ret = saved_ret;
+			vty->node = prev_node;
+		}
+
+		cmd_free_strvec(vline);
+		switch (ret) {
+		case CMD_WARNING:
+		case CMD_WARNING_CONFIG_FAILED:
+			if (vty->type == VTY_FILE)
+				fprintf(stderr, "line %d: Warning...: %s\n",
+					lineno, vty->buf);
+			fclose(confp);
+			vty_close(vty);
+			XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
+			return ret;
+		case CMD_ERR_AMBIGUOUS:
+			fprintf(stderr, "line %d: %% Ambiguous command: %s\n",
+				lineno, vty->buf);
+			fclose(confp);
+			vty_close(vty);
+			XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
+			return CMD_ERR_AMBIGUOUS;
+		case CMD_ERR_NO_MATCH:
+			fprintf(stderr, "line %d: %% Unknown command: %s\n",
+				lineno, vty->buf);
+			fclose(confp);
+			vty_close(vty);
+			XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
+			return CMD_ERR_NO_MATCH;
+		case CMD_ERR_INCOMPLETE:
+			fprintf(stderr, "line %d: %% Command incomplete: %s\n",
+				lineno, vty->buf);
+			fclose(confp);
+			vty_close(vty);
+			XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
+			return CMD_ERR_INCOMPLETE;
+		case CMD_SUCCESS:
+			vty_out(vty, "%s", vty->buf);
+			if (strmatch(vty_buf_trimmed, "exit-vrf"))
+				vty_out(vty, "end\n");
+			break;
+		case CMD_SUCCESS_DAEMON: {
+			int cmd_stat;
+
+			vty_out(vty, "%s", vty->buf);
+			if (strmatch(vty_buf_trimmed, "exit-vrf"))
+				vty_out(vty, "end\n");
+			cmd_stat = vtysh_client_execute(&vtysh_client[0],
+							vty->buf);
+			if (cmd_stat != CMD_SUCCESS)
+				break;
+
+			if (cmd->func)
+				(*cmd->func)(cmd, vty, 0, NULL);
+		}
+		}
+	}
+	/* This is the end */
+	vty_out(vty, "\nend\n");
+	vty_close(vty);
+	XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
+
+	if (confp != stdin)
+		fclose(confp);
+
+	return 0;
+}
+
+/* Configuration make from file. */
+int vtysh_config_from_file(struct vty *vty, FILE *fp)
+{
+	int ret;
+	const struct cmd_element *cmd;
+	int lineno = 0;
+	/* once we have an error, we remember & return that */
+	int retcode = CMD_SUCCESS;
+	char *vty_buf_copy = XCALLOC(MTYPE_VTYSH_CMD, VTY_BUFSIZ);
+	char *vty_buf_trimmed = NULL;
+
+	while (fgets(vty->buf, VTY_BUFSIZ, fp)) {
+		lineno++;
+
+		strlcpy(vty_buf_copy, vty->buf, VTY_BUFSIZ);
+		vty_buf_trimmed = trim(vty_buf_copy);
+
+		/*
+		 * Ignore the "end" lines, we will generate these where
+		 * appropriate, otherwise we never execute
+		 * XFRR_end_configuration, and start/end markers do not work.
+		 */
+		if (strmatch(vty_buf_trimmed, "end"))
+			continue;
+
+		ret = command_config_read_one_line(vty, &cmd, lineno, 1);
+
+		switch (ret) {
+		case CMD_WARNING:
+		case CMD_WARNING_CONFIG_FAILED:
+			if (vty->type == VTY_FILE)
+				fprintf(stderr, "line %d: Warning[%d]...: %s\n",
+					lineno, vty->node, vty->buf);
+			retcode = ret;
+
+			break;
+		case CMD_ERR_AMBIGUOUS:
+			fprintf(stderr,
+				"line %d: %% Ambiguous command[%d]: %s\n",
+				lineno, vty->node, vty->buf);
+			retcode = CMD_ERR_AMBIGUOUS;
+			break;
+		case CMD_ERR_NO_MATCH:
+			fprintf(stderr, "line %d: %% Unknown command[%d]: %s",
+				lineno, vty->node, vty->buf);
+			retcode = CMD_ERR_NO_MATCH;
+			break;
+		case CMD_ERR_INCOMPLETE:
+			fprintf(stderr,
+				"line %d: %% Command incomplete[%d]: %s\n",
+				lineno, vty->node, vty->buf);
+			retcode = CMD_ERR_INCOMPLETE;
+			break;
+		case CMD_SUCCESS_DAEMON: {
+			unsigned int i;
+			int cmd_stat = CMD_SUCCESS;
+
+			for (i = 0; i < array_size(vtysh_client); i++) {
+				if (cmd->daemon & vtysh_client[i].flag) {
+					cmd_stat = vtysh_client_execute(
+						&vtysh_client[i], vty->buf);
+					/*
+					 * CMD_WARNING - Can mean that the
+					 * command was parsed successfully but
+					 * it was already entered in a few
+					 * spots. As such if we receive a
+					 * CMD_WARNING from a daemon we
+					 * shouldn't stop talking to the other
+					 * daemons for the particular command.
+					 */
+					if (cmd_stat != CMD_SUCCESS
+					    && cmd_stat != CMD_WARNING) {
+						fprintf(stderr,
+							"line %d: Failure to communicate[%d] to %s, line: %s\n",
+							lineno, cmd_stat,
+							vtysh_client[i].name,
+							vty->buf);
+						retcode = cmd_stat;
+						break;
+					}
+				}
+			}
+			if (cmd_stat != CMD_SUCCESS)
+				break;
+
+			if (cmd->func)
+				(*cmd->func)(cmd, vty, 0, NULL);
+		}
+		}
+	}
+
+	XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
+
+	return (retcode);
+}
+
+/*
+ * Function processes cli commands terminated with '?' character when entered
+ * through either 'vtysh' or 'vtysh -c' interfaces.
+ */
+static int vtysh_process_questionmark(const char *input, int input_len)
+{
+	int ret, width = 0;
+	unsigned int i;
+	vector vline, describe;
+	struct cmd_token *token;
+
+	if (!input)
+		return 1;
+
+	vline = cmd_make_strvec(input);
+
+	/* In case of '> ?'. */
+	if (vline == NULL) {
+		vline = vector_init(1);
+		vector_set(vline, NULL);
+	} else if (input_len && isspace((unsigned char)input[input_len - 1]))
+		vector_set(vline, NULL);
+
+	describe = cmd_describe_command(vline, vty, &ret);
+
+	/* Ambiguous and no match error. */
+	switch (ret) {
+	case CMD_ERR_AMBIGUOUS:
+		cmd_free_strvec(vline);
+		vector_free(describe);
+		vty_out(vty, "%% Ambiguous command.\n");
+		rl_on_new_line();
+		return 0;
+	case CMD_ERR_NO_MATCH:
+		cmd_free_strvec(vline);
+		if (describe)
+			vector_free(describe);
+		vty_out(vty, "%% There is no matched command.\n");
+		rl_on_new_line();
+		return 0;
+	}
+
+	/* Get width of command string. */
+	width = 0;
+	for (i = 0; i < vector_active(describe); i++)
+		if ((token = vector_slot(describe, i)) != NULL) {
+			if (token->text[0] == '\0')
+				continue;
+
+			int len = strlen(token->text);
+
+			if (width < len)
+				width = len;
+		}
+
+	for (i = 0; i < vector_active(describe); i++)
+		if ((token = vector_slot(describe, i)) != NULL) {
+			if (!token->desc)
+				vty_out(vty, "  %-s\n", token->text);
+			else
+				vty_out(vty, "  %-*s  %s\n", width, token->text,
+					token->desc);
+
+			if (IS_VARYING_TOKEN(token->type)) {
+				const char *ref = vector_slot(
+					vline, vector_active(vline) - 1);
+
+				vector varcomps = vector_init(VECTOR_MIN_SIZE);
+				cmd_variable_complete(token, ref, varcomps);
+
+				if (vector_active(varcomps) > 0) {
+					int rows, cols;
+					rl_get_screen_size(&rows, &cols);
+
+					char *ac = cmd_variable_comp2str(
+						varcomps, cols);
+					vty_out(vty, "%s\n", ac);
+					XFREE(MTYPE_TMP, ac);
+				}
+
+				vector_free(varcomps);
+			}
+		}
+
+	cmd_free_strvec(vline);
+	vector_free(describe);
+
+	return 0;
+}
+
+/*
+ * Entry point for user commands terminated with '?' character and typed through
+ * the usual vtysh's stdin interface. This is the function being registered with
+ * readline() api's.
+ */
+static int vtysh_rl_describe(int a, int b)
+{
+	int ret;
+
+	vty_out(vty, "\n");
+
+	ret = vtysh_process_questionmark(rl_line_buffer, rl_end);
+	rl_on_new_line();
+
+	return ret;
+}
+
+/*
+ * Function in charged of processing vtysh instructions terminating with '?'
+ * character and received through the 'vtysh -c' interface. If user's
+ * instruction is well-formatted, we will call the same processing routine
+ * utilized by the traditional vtysh's stdin interface.
+ */
+int vtysh_execute_command_questionmark(char *input)
+{
+	int input_len, qmark_count = 0;
+	const char *str;
+
+	if (!(input && *input))
+		return 1;
+
+	/* Finding out question_mark count and strlen */
+	for (str = input; *str; ++str) {
+		if (*str == '?')
+			qmark_count++;
+	}
+	input_len = str - input;
+
+	/*
+	 * Verify that user's input terminates in '?' and that patterns such as
+	 * 'cmd ? subcmd ?' are prevented.
+	 */
+	if (qmark_count != 1 || input[input_len - 1] != '?')
+		return 1;
+
+	/*
+	 * Questionmark-processing function is not expecting to receive '?'
+	 * character in input string.
+	 */
+	input[input_len - 1] = '\0';
+
+	return vtysh_process_questionmark(input, input_len - 1);
+}
+
+/* Result of cmd_complete_command() call will be stored here
+ * and used in new_completion() in order to put the space in
+ * correct places only. */
+int complete_status;
+
+static char *command_generator(const char *text, int state)
+{
+	vector vline;
+	static char **matched = NULL;
+	static int index = 0;
+
+	/* First call. */
+	if (!state) {
+		index = 0;
+
+		if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
+			return NULL;
+
+		vline = cmd_make_strvec(rl_line_buffer);
+		if (vline == NULL)
+			return NULL;
+
+		if (rl_end &&
+		    isspace((unsigned char)rl_line_buffer[rl_end - 1]))
+			vector_set(vline, NULL);
+
+		matched = cmd_complete_command(vline, vty, &complete_status);
+		cmd_free_strvec(vline);
+	}
+
+	if (matched && matched[index]) {
+		XCOUNTFREE(MTYPE_COMPLETION, matched[index]);
+		return matched[index++];
+	}
+
+	XFREE(MTYPE_TMP, matched);
+
+	return NULL;
+}
+
+static char **new_completion(const char *text, int start, int end)
+{
+	char **matches;
+
+	matches = rl_completion_matches(text, command_generator);
+
+	if (matches) {
+		rl_point = rl_end;
+		if (complete_status != CMD_COMPLETE_FULL_MATCH)
+			/* only append a space on full match */
+			rl_completion_append_character = '\0';
+	}
+
+	return matches;
+}
+
+/* Vty node structures. */
+#ifdef HAVE_BGPD
+static struct cmd_node bgp_node = {
+	.name = "bgp",
+	.node = BGP_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+#endif /* HAVE_BGPD */
+
+static struct cmd_node rip_node = {
+	.name = "rip",
+	.node = RIP_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+
+#ifdef HAVE_ISISD
+static struct cmd_node isis_node = {
+	.name = "isis",
+	.node = ISIS_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+#endif /* HAVE_ISISD */
+
+#ifdef HAVE_FABRICD
+static struct cmd_node openfabric_node = {
+	.name = "openfabric",
+	.node = OPENFABRIC_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+#endif /* HAVE_FABRICD */
+
+static struct cmd_node interface_node = {
+	.name = "interface",
+	.node = INTERFACE_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-if)# ",
+};
+
+static struct cmd_node pw_node = {
+	.name = "pw",
+	.node = PW_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-pw)# ",
+};
+
+static struct cmd_node segment_routing_node = {
+	.name = "segment-routing",
+	.node = SEGMENT_ROUTING_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-sr)# ",
+};
+
+#if defined(HAVE_PATHD)
+static struct cmd_node sr_traffic_eng_node = {
+	.name = "sr traffic-eng",
+	.node = SR_TRAFFIC_ENG_NODE,
+	.parent_node = SEGMENT_ROUTING_NODE,
+	.prompt = "%s(config-sr-te)# ",
+};
+
+static struct cmd_node srte_segment_list_node = {
+	.name = "srte segment-list",
+	.node = SR_SEGMENT_LIST_NODE,
+	.parent_node = SR_TRAFFIC_ENG_NODE,
+	.prompt = "%s(config-sr-te-segment-list)# ",
+};
+
+static struct cmd_node srte_policy_node = {
+	.name = "srte policy",
+	.node = SR_POLICY_NODE,
+	.parent_node = SR_TRAFFIC_ENG_NODE,
+	.prompt = "%s(config-sr-te-policy)# ",
+};
+
+static struct cmd_node srte_candidate_dyn_node = {
+	.name = "srte candidate-dyn",
+	.node = SR_CANDIDATE_DYN_NODE,
+	.parent_node = SR_POLICY_NODE,
+	.prompt = "%s(config-sr-te-candidate)# ",
+};
+
+static struct cmd_node pcep_node = {
+	.name = "srte pcep",
+	.node = PCEP_NODE,
+	.parent_node = SR_TRAFFIC_ENG_NODE,
+	.prompt = "%s(config-sr-te-pcep)# "
+};
+
+static struct cmd_node pcep_pcc_node = {
+	.name = "srte pcep pcc",
+	.node = PCEP_PCC_NODE,
+	.parent_node = PCEP_NODE,
+	.prompt = "%s(config-sr-te-pcep-pcc)# ",
+};
+
+static struct cmd_node pcep_pce_node = {
+	.name = "srte pcep pce-peer",
+	.node = PCEP_PCE_NODE,
+	.parent_node = PCEP_NODE,
+	.prompt = "%s(config-sr-te-pcep-pce-peer)# ",
+};
+
+static struct cmd_node pcep_pce_config_node = {
+	.name = "srte pcep pce-config",
+	.node = PCEP_PCE_CONFIG_NODE,
+	.parent_node = PCEP_NODE,
+	.prompt = "%s(pcep-sr-te-pcep-pce-config)# ",
+};
+#endif /* HAVE_PATHD */
+
+static struct cmd_node vrf_node = {
+	.name = "vrf",
+	.node = VRF_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-vrf)# ",
+};
+
+static struct cmd_node nh_group_node = {
+	.name = "nexthop-group",
+	.node = NH_GROUP_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-nh-group)# ",
+};
+
+static struct cmd_node rmap_node = {
+	.name = "routemap",
+	.node = RMAP_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-route-map)# ",
+};
+
+static struct cmd_node srv6_node = {
+	.name = "srv6",
+	.node = SRV6_NODE,
+	.parent_node = SEGMENT_ROUTING_NODE,
+	.prompt = "%s(config-srv6)# ",
+};
+
+static struct cmd_node srv6_locs_node = {
+	.name = "srv6-locators",
+	.node = SRV6_LOCS_NODE,
+	.parent_node = SRV6_NODE,
+	.prompt = "%s(config-srv6-locators)# ",
+};
+
+static struct cmd_node srv6_loc_node = {
+	.name = "srv6-locator",
+	.node = SRV6_LOC_NODE,
+	.parent_node = SRV6_LOCS_NODE,
+	.prompt = "%s(config-srv6-locator)# ",
+};
+
+#ifdef HAVE_PBRD
+static struct cmd_node pbr_map_node = {
+	.name = "pbr-map",
+	.node = PBRMAP_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-pbr-map)# ",
+};
+#endif /* HAVE_PBRD */
+
+static struct cmd_node zebra_node = {
+	.name = "zebra",
+	.node = ZEBRA_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+
+#ifdef HAVE_BGPD
+static struct cmd_node bgp_vpnv4_node = {
+	.name = "bgp vpnv4",
+	.node = BGP_VPNV4_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_vpnv6_node = {
+	.name = "bgp vpnv6",
+	.node = BGP_VPNV6_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_flowspecv4_node = {
+	.name = "bgp ipv4 flowspec",
+	.node = BGP_FLOWSPECV4_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_flowspecv6_node = {
+	.name = "bgp ipv6 flowspec",
+	.node = BGP_FLOWSPECV6_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_ipv4_node = {
+	.name = "bgp ipv4 unicast",
+	.node = BGP_IPV4_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_ipv4m_node = {
+	.name = "bgp ipv4 multicast",
+	.node = BGP_IPV4M_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_ipv4l_node = {
+	.name = "bgp ipv4 labeled unicast",
+	.node = BGP_IPV4L_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_ipv6_node = {
+	.name = "bgp ipv6",
+	.node = BGP_IPV6_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_ipv6m_node = {
+	.name = "bgp ipv6 multicast",
+	.node = BGP_IPV6M_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_evpn_node = {
+	.name = "bgp evpn",
+	.node = BGP_EVPN_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+static struct cmd_node bgp_evpn_vni_node = {
+	.name = "bgp evpn vni",
+	.node = BGP_EVPN_VNI_NODE,
+	.parent_node = BGP_EVPN_NODE,
+	.prompt = "%s(config-router-af-vni)# ",
+};
+
+static struct cmd_node bgp_ipv6l_node = {
+	.name = "bgp ipv6 labeled unicast",
+	.node = BGP_IPV6L_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-af)# ",
+	.no_xpath = true,
+};
+
+#ifdef ENABLE_BGP_VNC
+static struct cmd_node bgp_vnc_defaults_node = {
+	.name = "bgp vnc defaults",
+	.node = BGP_VNC_DEFAULTS_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-vnc-defaults)# ",
+};
+
+static struct cmd_node bgp_vnc_nve_group_node = {
+	.name = "bgp vnc nve",
+	.node = BGP_VNC_NVE_GROUP_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-vnc-nve-group)# ",
+};
+
+static struct cmd_node bgp_vrf_policy_node = {
+	.name = "bgp vrf policy",
+	.node = BGP_VRF_POLICY_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-vrf-policy)# ",
+};
+
+static struct cmd_node bgp_vnc_l2_group_node = {
+	.name = "bgp vnc l2",
+	.node = BGP_VNC_L2_GROUP_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-vnc-l2-group)# ",
+};
+#endif /* ENABLE_BGP_VNC */
+
+static struct cmd_node bmp_node = {
+	.name = "bmp",
+	.node = BMP_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-bgp-bmp)# "
+};
+
+static struct cmd_node bgp_srv6_node = {
+	.name = "bgp srv6",
+	.node = BGP_SRV6_NODE,
+	.parent_node = BGP_NODE,
+	.prompt = "%s(config-router-srv6)# ",
+};
+#endif /* HAVE_BGPD */
+
+#ifdef HAVE_OSPFD
+static struct cmd_node ospf_node = {
+	.name = "ospf",
+	.node = OSPF_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+#endif /* HAVE_OSPFD */
+
+#ifdef HAVE_EIGRPD
+static struct cmd_node eigrp_node = {
+	.name = "eigrp",
+	.node = EIGRP_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+#endif /* HAVE_EIGRPD */
+
+#ifdef HAVE_BABELD
+static struct cmd_node babel_node = {
+	.name = "babel",
+	.node = BABEL_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+#endif /* HAVE_BABELD */
+
+static struct cmd_node ripng_node = {
+	.name = "ripng",
+	.node = RIPNG_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-router)# ",
+};
+
+#ifdef HAVE_OSPF6D
+static struct cmd_node ospf6_node = {
+	.name = "ospf6",
+	.node = OSPF6_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-ospf6)# ",
+};
+#endif /* HAVE_OSPF6D */
+
+#ifdef HAVE_LDPD
+static struct cmd_node ldp_node = {
+	.name = "ldp",
+	.node = LDP_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-ldp)# ",
+};
+
+static struct cmd_node ldp_ipv4_node = {
+	.name = "ldp ipv4",
+	.node = LDP_IPV4_NODE,
+	.parent_node = LDP_NODE,
+	.prompt = "%s(config-ldp-af)# ",
+};
+
+static struct cmd_node ldp_ipv6_node = {
+	.name = "ldp ipv6",
+	.node = LDP_IPV6_NODE,
+	.parent_node = LDP_NODE,
+	.prompt = "%s(config-ldp-af)# ",
+};
+
+static struct cmd_node ldp_ipv4_iface_node = {
+	.name = "ldp ipv4 interface",
+	.node = LDP_IPV4_IFACE_NODE,
+	.parent_node = LDP_IPV4_NODE,
+	.prompt = "%s(config-ldp-af-if)# ",
+};
+
+static struct cmd_node ldp_ipv6_iface_node = {
+	.name = "ldp ipv6 interface",
+	.node = LDP_IPV6_IFACE_NODE,
+	.parent_node = LDP_IPV6_NODE,
+	.prompt = "%s(config-ldp-af-if)# ",
+};
+
+static struct cmd_node ldp_l2vpn_node = {
+	.name = "ldp l2vpn",
+	.node = LDP_L2VPN_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-l2vpn)# ",
+};
+
+static struct cmd_node ldp_pseudowire_node = {
+	.name = "ldp",
+	.node = LDP_PSEUDOWIRE_NODE,
+	.parent_node = LDP_L2VPN_NODE,
+	.prompt = "%s(config-l2vpn-pw)# ",
+};
+#endif /* HAVE_LDPD */
+
+static struct cmd_node keychain_node = {
+	.name = "keychain",
+	.node = KEYCHAIN_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-keychain)# ",
+};
+
+static struct cmd_node keychain_key_node = {
+	.name = "keychain key",
+	.node = KEYCHAIN_KEY_NODE,
+	.parent_node = KEYCHAIN_NODE,
+	.prompt = "%s(config-keychain-key)# ",
+};
+
+struct cmd_node link_params_node = {
+	.name = "link-params",
+	.node = LINK_PARAMS_NODE,
+	.parent_node = INTERFACE_NODE,
+	.prompt = "%s(config-link-params)# ",
+	.no_xpath = true,
+};
+
+#ifdef HAVE_BGPD
+static struct cmd_node rpki_node = {
+	.name = "rpki",
+	.node = RPKI_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-rpki)# ",
+};
+#endif /* HAVE_BGPD */
+
+#if HAVE_BFDD > 0
+static struct cmd_node bfd_node = {
+	.name = "bfd",
+	.node = BFD_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-bfd)# ",
+};
+
+static struct cmd_node bfd_peer_node = {
+	.name = "bfd peer",
+	.node = BFD_PEER_NODE,
+	.parent_node = BFD_NODE,
+	.prompt = "%s(config-bfd-peer)# ",
+};
+
+static struct cmd_node bfd_profile_node = {
+	.name = "bfd profile",
+	.node = BFD_PROFILE_NODE,
+	.parent_node = BFD_NODE,
+	.prompt = "%s(config-bfd-profile)# ",
+};
+#endif /* HAVE_BFDD */
+
+/* Defined in lib/vty.c */
+extern struct cmd_node vty_node;
+
+/* When '^Z' is received from vty, move down to the enable mode. */
+static int vtysh_end(void)
+{
+	switch (vty->node) {
+	case VIEW_NODE:
+	case ENABLE_NODE:
+		/* Nothing to do. */
+		break;
+	default:
+		vty->node = ENABLE_NODE;
+		break;
+	}
+	return CMD_SUCCESS;
+}
+
+#include "vtysh/vtysh_clippy.c"
+
+DEFUNSH(VTYSH_REALLYALL, vtysh_end_all, vtysh_end_all_cmd, "end",
+	"End current mode and change to enable mode\n")
+{
+	return vtysh_end();
+}
+
+DEFUNSH(VTYSH_ZEBRA, srv6, srv6_cmd,
+	"srv6",
+	"Segment-Routing SRv6 configuration\n")
+{
+	vty->node = SRV6_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, srv6_locators, srv6_locators_cmd,
+	"locators",
+	"Segment-Routing SRv6 locators configuration\n")
+{
+	vty->node = SRV6_LOCS_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, srv6_locator, srv6_locator_cmd,
+	"locator WORD",
+	"Segment Routing SRv6 locator\n"
+	"Specify locator-name\n")
+{
+	vty->node = SRV6_LOC_NODE;
+	return CMD_SUCCESS;
+}
+
+#ifdef HAVE_BGPD
+DEFUNSH(VTYSH_BGPD, router_bgp, router_bgp_cmd,
+	"router bgp [(1-4294967295) [<view|vrf> VIEWVRFNAME]]",
+	ROUTER_STR BGP_STR AS_STR
+	"BGP view\nBGP VRF\n"
+	"View/VRF name\n")
+{
+	vty->node = BGP_NODE;
+	return CMD_SUCCESS;
+}
+
+#ifdef KEEP_OLD_VPN_COMMANDS
+DEFUNSH(VTYSH_BGPD, address_family_vpnv4, address_family_vpnv4_cmd,
+	"address-family vpnv4 [unicast]",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_VPNV4_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_vpnv6, address_family_vpnv6_cmd,
+	"address-family vpnv6 [unicast]",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_VPNV6_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* KEEP_OLD_VPN_COMMANDS */
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv4, address_family_ipv4_cmd,
+	"address-family ipv4 [unicast]",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_IPV4_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_flowspecv4, address_family_flowspecv4_cmd,
+	"address-family ipv4 flowspec",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_FLOWSPECV4_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_flowspecv6, address_family_flowspecv6_cmd,
+	"address-family ipv6 flowspec",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_FLOWSPECV6_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv4_multicast,
+	address_family_ipv4_multicast_cmd, "address-family ipv4 multicast",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_IPV4M_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv4_vpn, address_family_ipv4_vpn_cmd,
+	"address-family ipv4 vpn",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_VPNV4_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv4_labeled_unicast,
+	address_family_ipv4_labeled_unicast_cmd,
+	"address-family ipv4 labeled-unicast",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_IPV4L_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv6, address_family_ipv6_cmd,
+	"address-family ipv6 [unicast]",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_IPV6_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv6_multicast,
+	address_family_ipv6_multicast_cmd, "address-family ipv6 multicast",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_IPV6M_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv6_vpn, address_family_ipv6_vpn_cmd,
+	"address-family ipv6 vpn",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_VPNV6_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_ipv6_labeled_unicast,
+	address_family_ipv6_labeled_unicast_cmd,
+	"address-family ipv6 labeled-unicast",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_IPV6L_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD,
+	rpki,
+	rpki_cmd,
+	"rpki",
+	"Enable rpki and enter rpki configuration mode\n")
+{
+	vty->node = RPKI_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD,
+	bmp_targets,
+	bmp_targets_cmd,
+	"bmp targets BMPTARGETS",
+	"BGP Monitoring Protocol\n"
+	"Create BMP target group\n"
+	"Name of the BMP target group\n")
+{
+	vty->node = BMP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD,
+        bgp_srv6,
+        bgp_srv6_cmd,
+        "segment-routing srv6",
+        "Segment-Routing configuration\n"
+        "Segment-Routing SRv6 configuration\n")
+{
+	vty->node = BGP_SRV6_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD,
+        exit_bgp_srv6,
+        exit_bgp_srv6_cmd,
+        "exit",
+        "exit Segment-Routing SRv6 configuration\n")
+{
+	if (vty->node == BGP_SRV6_NODE)
+		vty->node = BGP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD,
+        quit_bgp_srv6,
+        quit_bgp_srv6_cmd,
+        "quit",
+        "quit Segment-Routing SRv6 configuration\n")
+{
+	if (vty->node == BGP_SRV6_NODE)
+		vty->node = BGP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, address_family_evpn, address_family_evpn_cmd,
+	"address-family <l2vpn evpn>",
+	"Enter Address Family command mode\n"
+	BGP_AF_STR
+	BGP_AF_MODIFIER_STR)
+{
+	vty->node = BGP_EVPN_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, bgp_evpn_vni, bgp_evpn_vni_cmd, "vni " CMD_VNI_RANGE,
+	"VXLAN Network Identifier\n"
+	"VNI number\n")
+{
+	vty->node = BGP_EVPN_VNI_NODE;
+	return CMD_SUCCESS;
+}
+
+#if defined(ENABLE_BGP_VNC)
+DEFUNSH(VTYSH_BGPD, vnc_defaults, vnc_defaults_cmd, "vnc defaults",
+	"VNC/RFP related configuration\n"
+	"Configure default NVE group\n")
+{
+	vty->node = BGP_VNC_DEFAULTS_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, vnc_nve_group, vnc_nve_group_cmd, "vnc nve-group NAME",
+	"VNC/RFP related configuration\n"
+	"Configure a NVE group\n"
+	"Group name\n")
+{
+	vty->node = BGP_VNC_NVE_GROUP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, vnc_vrf_policy, vnc_vrf_policy_cmd, "vrf-policy NAME",
+	"Configure a VRF policy group\n"
+	"Group name\n")
+{
+	vty->node = BGP_VRF_POLICY_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, vnc_l2_group, vnc_l2_group_cmd, "vnc l2-group NAME",
+	"VNC/RFP related configuration\n"
+	"Configure a L2 group\n"
+	"Group name\n")
+{
+	vty->node = BGP_VNC_L2_GROUP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, exit_vnc_config, exit_vnc_config_cmd, "exit-vnc",
+	"Exit from VNC configuration mode\n")
+{
+	if (vty->node == BGP_VNC_DEFAULTS_NODE
+	    || vty->node == BGP_VNC_NVE_GROUP_NODE
+	    || vty->node == BGP_VNC_L2_GROUP_NODE)
+		vty->node = BGP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, exit_vrf_policy, exit_vrf_policy_cmd, "exit-vrf-policy",
+	"Exit from VRF policy configuration mode\n")
+{
+	if (vty->node == BGP_VRF_POLICY_NODE)
+		vty->node = BGP_NODE;
+	return CMD_SUCCESS;
+}
+#endif
+#endif /* HAVE_BGPD */
+
+DEFUNSH(VTYSH_KEYS, key_chain, key_chain_cmd, "key chain WORD",
+	"Authentication key management\n"
+	"Key-chain management\n"
+	"Key-chain name\n")
+{
+	vty->node = KEYCHAIN_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_KEYS, key, key_cmd, "key (0-2147483647)",
+	"Configure a key\n"
+	"Key identifier number\n")
+{
+	vty->node = KEYCHAIN_KEY_NODE;
+	return CMD_SUCCESS;
+}
+
+#ifdef HAVE_RIPD
+DEFUNSH(VTYSH_RIPD, router_rip, router_rip_cmd, "router rip [vrf NAME]",
+	ROUTER_STR "RIP\n" VRF_CMD_HELP_STR)
+{
+	vty->node = RIP_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_RIPD */
+
+#ifdef HAVE_RIPNGD
+DEFUNSH(VTYSH_RIPNGD, router_ripng, router_ripng_cmd, "router ripng [vrf NAME]",
+	ROUTER_STR "RIPng\n" VRF_CMD_HELP_STR)
+{
+	vty->node = RIPNG_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_RIPNGD */
+
+#ifdef HAVE_OSPFD
+DEFUNSH(VTYSH_OSPFD, router_ospf, router_ospf_cmd,
+	"router ospf [(1-65535)] [vrf NAME]",
+	"Enable a routing process\n"
+	"Start OSPF configuration\n"
+	"Instance ID\n"
+	VRF_CMD_HELP_STR)
+{
+	vty->node = OSPF_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_OSPFD */
+
+#ifdef HAVE_EIGRPD
+DEFUNSH(VTYSH_EIGRPD, router_eigrp, router_eigrp_cmd, "router eigrp (1-65535) [vrf NAME]",
+	"Enable a routing process\n"
+	"Start EIGRP configuration\n"
+	"AS number to use\n"
+	VRF_CMD_HELP_STR)
+{
+	vty->node = EIGRP_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_EIGRPD */
+
+#ifdef HAVE_BABELD
+DEFUNSH(VTYSH_BABELD, router_babel, router_babel_cmd, "router babel",
+	"Enable a routing process\n"
+	"Make Babel instance command\n")
+{
+	vty->node = BABEL_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_BABELD */
+
+#ifdef HAVE_OSPF6D
+DEFUNSH(VTYSH_OSPF6D, router_ospf6, router_ospf6_cmd, "router ospf6 [vrf NAME]",
+	ROUTER_STR OSPF6_STR VRF_CMD_HELP_STR)
+{
+	vty->node = OSPF6_NODE;
+	return CMD_SUCCESS;
+}
+#endif
+
+#if defined(HAVE_LDPD)
+DEFUNSH(VTYSH_LDPD, ldp_mpls_ldp, ldp_mpls_ldp_cmd, "mpls ldp",
+	"Global MPLS configuration subcommands\n"
+	"Label Distribution Protocol\n")
+{
+	vty->node = LDP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_LDPD, ldp_address_family_ipv4, ldp_address_family_ipv4_cmd,
+	"address-family ipv4",
+	"Configure Address Family and its parameters\n"
+	"IPv4\n")
+{
+	vty->node = LDP_IPV4_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_LDPD, ldp_address_family_ipv6, ldp_address_family_ipv6_cmd,
+	"address-family ipv6",
+	"Configure Address Family and its parameters\n"
+	"IPv6\n")
+{
+	vty->node = LDP_IPV6_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_LDPD, ldp_exit_address_family, ldp_exit_address_family_cmd,
+	"exit-address-family", "Exit from Address Family configuration mode\n")
+{
+	if (vty->node == LDP_IPV4_NODE || vty->node == LDP_IPV6_NODE)
+		vty->node = LDP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_LDPD, ldp_interface_ifname, ldp_interface_ifname_cmd,
+	"interface IFNAME",
+	"Enable LDP on an interface and enter interface submode\n"
+	"Interface's name\n")
+{
+	switch (vty->node) {
+	case LDP_IPV4_NODE:
+		vty->node = LDP_IPV4_IFACE_NODE;
+		break;
+	case LDP_IPV6_NODE:
+		vty->node = LDP_IPV6_IFACE_NODE;
+		break;
+	default:
+		break;
+	}
+
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_LDPD, ldp_l2vpn_word_type_vpls, ldp_l2vpn_word_type_vpls_cmd,
+	"l2vpn WORD type vpls",
+	"Configure l2vpn commands\n"
+	"L2VPN name\n"
+	"L2VPN type\n"
+	"Virtual Private LAN Service\n")
+{
+	vty->node = LDP_L2VPN_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_LDPD, ldp_member_pseudowire_ifname,
+	ldp_member_pseudowire_ifname_cmd, "member pseudowire IFNAME",
+	"L2VPN member configuration\n"
+	"Pseudowire interface\n"
+	"Interface's name\n")
+{
+	vty->node = LDP_PSEUDOWIRE_NODE;
+	return CMD_SUCCESS;
+}
+#endif
+
+#ifdef HAVE_ISISD
+DEFUNSH(VTYSH_ISISD, router_isis, router_isis_cmd,
+	"router isis WORD [vrf NAME]",
+	ROUTER_STR
+	"ISO IS-IS\n"
+	"ISO Routing area tag\n" VRF_CMD_HELP_STR)
+{
+	vty->node = ISIS_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_ISISD */
+
+#ifdef HAVE_FABRICD
+DEFUNSH(VTYSH_FABRICD, router_openfabric, router_openfabric_cmd, "router openfabric WORD",
+	ROUTER_STR
+	"OpenFabric routing protocol\n"
+	"ISO Routing area tag\n")
+{
+	vty->node = OPENFABRIC_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_FABRICD */
+
+DEFUNSH(VTYSH_SR, segment_routing, segment_routing_cmd,
+	"segment-routing",
+	"Configure segment routing\n")
+{
+	vty->node = SEGMENT_ROUTING_NODE;
+	return CMD_SUCCESS;
+}
+
+#if defined (HAVE_PATHD)
+DEFUNSH(VTYSH_PATHD, sr_traffic_eng, sr_traffic_eng_cmd,
+	"traffic-eng",
+	"Configure SR traffic engineering\n")
+{
+	vty->node = SR_TRAFFIC_ENG_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_PATHD, srte_segment_list, srte_segment_list_cmd,
+	"segment-list WORD$name",
+	"Segment List\n"
+	"Segment List Name\n")
+{
+	vty->node = SR_SEGMENT_LIST_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_PATHD, srte_policy, srte_policy_cmd,
+	"policy color (0-4294967295) endpoint <A.B.C.D|X:X::X:X>",
+	"Segment Routing Policy\n"
+	"SR Policy color\n"
+	"SR Policy color value\n"
+	"SR Policy endpoint\n"
+	"SR Policy endpoint IPv4 address\n"
+	"SR Policy endpoint IPv6 address\n")
+{
+	vty->node = SR_POLICY_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_PATHD, srte_policy_candidate_dyn_path,
+	srte_policy_candidate_dyn_path_cmd,
+	"candidate-path preference (0-4294967295) name WORD dynamic",
+	"Segment Routing Policy Candidate Path\n"
+	"Segment Routing Policy Candidate Path Preference\n"
+	"Administrative Preference\n"
+	"Segment Routing Policy Candidate Path Name\n"
+	"Symbolic Name\n"
+	"Dynamic Path\n")
+{
+	vty->node = SR_CANDIDATE_DYN_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_PATHD, pcep, pcep_cmd,
+	"pcep",
+	"Configure SR pcep\n")
+{
+	vty->node = PCEP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_PATHD, pcep_cli_pcc, pcep_cli_pcc_cmd,
+	"pcc",
+	"PCC configuration\n")
+{
+	vty->node = PCEP_PCC_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_PATHD, pcep_cli_pce, pcep_cli_pce_cmd,
+	"pce WORD",
+	"PCE configuration\n"
+	"Peer name\n")
+{
+	vty->node = PCEP_PCE_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_PATHD, pcep_cli_pcep_pce_config, pcep_cli_pcep_pce_config_cmd,
+	"pce-config WORD",
+	"PCEP peer Configuration Group\n"
+	"PCEP peer Configuration Group name\n")
+{
+	vty->node = PCEP_PCE_CONFIG_NODE;
+	return CMD_SUCCESS;
+}
+
+#endif /* HAVE_PATHD */
+
+DEFUNSH(VTYSH_RMAP, vtysh_route_map, vtysh_route_map_cmd,
+	"route-map RMAP_NAME <deny|permit> (1-65535)",
+	"Create route-map or enter route-map command mode\n"
+	"Route map tag\n"
+	"Route map denies set operations\n"
+	"Route map permits set operations\n"
+	"Sequence to insert to/delete from existing route-map entry\n")
+{
+	vty->node = RMAP_NODE;
+	return CMD_SUCCESS;
+}
+
+#ifdef HAVE_PBRD
+DEFUNSH(VTYSH_PBRD, vtysh_pbr_map, vtysh_pbr_map_cmd,
+	"pbr-map PBRMAP seq (1-700)",
+	"Create pbr-map or enter pbr-map command mode\n"
+	"The name of the PBR MAP\n"
+	"Sequence to insert to/delete from existing pbr-map entry\n"
+	"Sequence number\n")
+{
+	vty->node = PBRMAP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFSH(VTYSH_PBRD, vtysh_no_pbr_map_cmd, "no pbr-map PBRMAP [seq (1-700)]",
+	NO_STR
+	"Delete pbr-map\n"
+	"The name of  the PBR MAP\n"
+	"Sequence to delete from existing pbr-map entry\n"
+	"Sequence number\n")
+#endif /* HAVE_PBRD */
+
+#if HAVE_BFDD > 0
+DEFUNSH(VTYSH_BFDD, bfd_enter, bfd_enter_cmd, "bfd", "Configure BFD peers\n")
+{
+	vty->node = BFD_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BFDD, bfd_peer_enter, bfd_peer_enter_cmd,
+	"peer <A.B.C.D|X:X::X:X> [{multihop|local-address <A.B.C.D|X:X::X:X>|interface IFNAME|vrf NAME}]",
+	"Configure peer\n"
+	"IPv4 peer address\n"
+	"IPv6 peer address\n"
+	"Configure multihop\n"
+	"Configure local address\n"
+	"IPv4 local address\n"
+	"IPv6 local address\n"
+	INTERFACE_STR
+	"Configure interface name to use\n"
+	"Configure VRF\n"
+	"Configure VRF name\n")
+{
+	vty->node = BFD_PEER_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BFDD, bfd_profile_enter, bfd_profile_enter_cmd,
+	"profile BFDPROF",
+	BFD_PROFILE_STR
+	BFD_PROFILE_NAME_STR)
+{
+	vty->node = BFD_PROFILE_NODE;
+	return CMD_SUCCESS;
+}
+#endif /* HAVE_BFDD */
+
+DEFUNSH(VTYSH_ALL, vtysh_line_vty, vtysh_line_vty_cmd, "line vty",
+	"Configure a terminal line\n"
+	"Virtual terminal\n")
+{
+	vty->node = VTY_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_REALLYALL, vtysh_enable, vtysh_enable_cmd, "enable",
+	"Turn on privileged mode command\n")
+{
+	vty->node = ENABLE_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_REALLYALL, vtysh_disable, vtysh_disable_cmd, "disable",
+	"Turn off privileged mode command\n")
+{
+	if (vty->node == ENABLE_NODE)
+		vty->node = VIEW_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_REALLYALL, vtysh_config_terminal, vtysh_config_terminal_cmd,
+	"configure [terminal]",
+	"Configuration from vty interface\n"
+	"Configuration terminal\n")
+{
+	vty->node = CONFIG_NODE;
+	return CMD_SUCCESS;
+}
+
+static int vtysh_exit(struct vty *vty)
+{
+	struct cmd_node *cnode = vector_lookup(cmdvec, vty->node);
+
+	if (vty->node == VIEW_NODE || vty->node == ENABLE_NODE)
+		exit(0);
+	if (cnode->node_exit)
+		cnode->node_exit(vty);
+	if (cnode->parent_node)
+		vty->node = cnode->parent_node;
+
+	if (vty->node == CONFIG_NODE) {
+		/* resync in case one of the daemons is somewhere else */
+		vtysh_execute("end");
+		vtysh_execute("configure");
+	}
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_REALLYALL, vtysh_exit_all, vtysh_exit_all_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_REALLYALL, vtysh_quit_all, vtysh_quit_all_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_all(self, vty, argc, argv);
+}
+
+#ifdef HAVE_BGPD
+DEFUNSH(VTYSH_BGPD, exit_address_family, exit_address_family_cmd,
+	"exit-address-family", "Exit from Address Family configuration mode\n")
+{
+	if (vty->node == BGP_IPV4_NODE || vty->node == BGP_IPV4M_NODE
+	    || vty->node == BGP_IPV4L_NODE || vty->node == BGP_VPNV4_NODE
+	    || vty->node == BGP_VPNV6_NODE || vty->node == BGP_IPV6_NODE
+	    || vty->node == BGP_IPV6L_NODE || vty->node == BGP_IPV6M_NODE
+	    || vty->node == BGP_EVPN_NODE
+	    || vty->node == BGP_FLOWSPECV4_NODE
+	    || vty->node == BGP_FLOWSPECV6_NODE)
+		vty->node = BGP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, exit_vni, exit_vni_cmd, "exit-vni", "Exit from VNI mode\n")
+{
+	if (vty->node == BGP_EVPN_VNI_NODE)
+		vty->node = BGP_EVPN_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, rpki_exit, rpki_exit_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	vtysh_exit(vty);
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, rpki_quit, rpki_quit_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return rpki_exit(self, vty, argc, argv);
+}
+
+DEFUNSH(VTYSH_BGPD, bmp_exit, bmp_exit_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	vtysh_exit(vty);
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_BGPD, bmp_quit, bmp_quit_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return bmp_exit(self, vty, argc, argv);
+}
+#endif /* HAVE_BGPD */
+
+DEFUNSH(VTYSH_VRF, exit_vrf_config, exit_vrf_config_cmd, "exit-vrf",
+	"Exit from VRF configuration mode\n")
+{
+	if (vty->node == VRF_NODE)
+		vty->node = CONFIG_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, exit_srv6_config, exit_srv6_config_cmd, "exit",
+	"Exit from SRv6 configuration mode\n")
+{
+	if (vty->node == SRV6_NODE)
+		vty->node = SEGMENT_ROUTING_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, exit_srv6_locs_config, exit_srv6_locs_config_cmd, "exit",
+	"Exit from SRv6-locator configuration mode\n")
+{
+	if (vty->node == SRV6_LOCS_NODE)
+		vty->node = SRV6_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, exit_srv6_loc_config, exit_srv6_loc_config_cmd, "exit",
+	"Exit from SRv6-locators configuration mode\n")
+{
+	if (vty->node == SRV6_LOC_NODE)
+		vty->node = SRV6_LOCS_NODE;
+	return CMD_SUCCESS;
+}
+
+#ifdef HAVE_RIPD
+DEFUNSH(VTYSH_RIPD, vtysh_exit_ripd, vtysh_exit_ripd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_RIPD, vtysh_quit_ripd, vtysh_quit_ripd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_ripd(self, vty, argc, argv);
+}
+#endif /* HAVE_RIPD */
+
+#ifdef HAVE_RIPNGD
+DEFUNSH(VTYSH_RIPNGD, vtysh_exit_ripngd, vtysh_exit_ripngd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_RIPNGD, vtysh_quit_ripngd, vtysh_quit_ripngd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_ripngd(self, vty, argc, argv);
+}
+#endif /* HAVE_RIPNGD */
+
+DEFUNSH(VTYSH_RMAP, vtysh_exit_rmap, vtysh_exit_rmap_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_RMAP, vtysh_quit_rmap, vtysh_quit_rmap_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_rmap(self, vty, argc, argv);
+}
+
+#ifdef HAVE_PBRD
+DEFUNSH(VTYSH_PBRD, vtysh_exit_pbr_map, vtysh_exit_pbr_map_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_PBRD, vtysh_quit_pbr_map, vtysh_quit_pbr_map_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_rmap(self, vty, argc, argv);
+}
+#endif /* HAVE_PBRD */
+
+#ifdef HAVE_BGPD
+DEFUNSH(VTYSH_BGPD, vtysh_exit_bgpd, vtysh_exit_bgpd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_BGPD, vtysh_quit_bgpd, vtysh_quit_bgpd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_bgpd(self, vty, argc, argv);
+}
+#endif /* HAVE_BGPD */
+
+#ifdef HAVE_OSPFD
+DEFUNSH(VTYSH_OSPFD, vtysh_exit_ospfd, vtysh_exit_ospfd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_OSPFD, vtysh_quit_ospfd, vtysh_quit_ospfd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_ospfd(self, vty, argc, argv);
+}
+#endif /* HAVE_OSPFD */
+
+#ifdef HAVE_EIGRPD
+DEFUNSH(VTYSH_EIGRPD, vtysh_exit_eigrpd, vtysh_exit_eigrpd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_EIGRPD, vtysh_quit_eigrpd, vtysh_quit_eigrpd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+#endif /* HAVE_EIGRPD */
+
+#ifdef HAVE_BABELD
+DEFUNSH(VTYSH_BABELD, vtysh_exit_babeld, vtysh_exit_babeld_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_BABELD, vtysh_quit_babeld, vtysh_quit_babeld_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+#endif /* HAVE_BABELD */
+
+#ifdef HAVE_OSPF6D
+DEFUNSH(VTYSH_OSPF6D, vtysh_exit_ospf6d, vtysh_exit_ospf6d_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_OSPF6D, vtysh_quit_ospf6d, vtysh_quit_ospf6d_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_ospf6d(self, vty, argc, argv);
+}
+#endif /* HAVE_OSPF6D */
+
+#if defined(HAVE_LDPD)
+DEFUNSH(VTYSH_LDPD, vtysh_exit_ldpd, vtysh_exit_ldpd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+ALIAS(vtysh_exit_ldpd, vtysh_quit_ldpd_cmd, "quit",
+      "Exit current mode and down to previous mode\n")
+#endif
+
+#ifdef HAVE_ISISD
+DEFUNSH(VTYSH_ISISD, vtysh_exit_isisd, vtysh_exit_isisd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_ISISD, vtysh_quit_isisd, vtysh_quit_isisd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_isisd(self, vty, argc, argv);
+}
+#endif /* HAVE_ISISD */
+
+#if HAVE_BFDD > 0
+DEFUNSH(VTYSH_BFDD, vtysh_exit_bfdd, vtysh_exit_bfdd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+ALIAS(vtysh_exit_bfdd, vtysh_quit_bfdd_cmd, "quit",
+      "Exit current mode and down to previous mode\n")
+#endif
+
+#ifdef HAVE_FABRICD
+DEFUNSH(VTYSH_FABRICD, vtysh_exit_fabricd, vtysh_exit_fabricd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_FABRICD, vtysh_quit_fabricd, vtysh_quit_fabricd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_fabricd(self, vty, argc, argv);
+}
+#endif /* HAVE_FABRICD */
+
+DEFUNSH(VTYSH_KEYS, vtysh_exit_keys, vtysh_exit_keys_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_KEYS, vtysh_quit_keys, vtysh_quit_keys_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_keys(self, vty, argc, argv);
+}
+
+DEFUNSH(VTYSH_SR, vtysh_exit_sr, vtysh_exit_sr_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_SR, vtysh_quit_sr, vtysh_quit_sr_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+#if defined(HAVE_PATHD)
+DEFUNSH(VTYSH_PATHD, vtysh_exit_pathd, vtysh_exit_pathd_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_PATHD, vtysh_quit_pathd, vtysh_quit_pathd_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_pathd(self, vty, argc, argv);
+}
+#endif /* HAVE_PATHD */
+
+DEFUNSH(VTYSH_ALL, vtysh_exit_line_vty, vtysh_exit_line_vty_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_ALL, vtysh_quit_line_vty, vtysh_quit_line_vty_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_line_vty(self, vty, argc, argv);
+}
+
+DEFUNSH(VTYSH_INTERFACE, vtysh_interface, vtysh_interface_cmd,
+	"interface IFNAME [vrf NAME]",
+	"Select an interface to configure\n"
+	"Interface's name\n" VRF_CMD_HELP_STR)
+{
+	vty->node = INTERFACE_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, vtysh_pseudowire, vtysh_pseudowire_cmd,
+	"pseudowire IFNAME",
+	"Static pseudowire configuration\n"
+	"Pseudowire name\n")
+{
+	vty->node = PW_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_NH_GROUP,
+	vtysh_nexthop_group, vtysh_nexthop_group_cmd,
+	"nexthop-group NHGNAME",
+	"Nexthop Group configuration\n"
+	"Name of the Nexthop Group\n")
+{
+	vty->node = NH_GROUP_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFSH(VTYSH_NH_GROUP, vtysh_no_nexthop_group_cmd,
+      "no nexthop-group NHGNAME",
+      NO_STR
+      "Nexthop Group Configuration\n"
+      "Name of the Nexthop Group\n")
+
+DEFUNSH(VTYSH_VRF, vtysh_vrf, vtysh_vrf_cmd, "vrf NAME",
+	"Select a VRF to configure\n"
+	"VRF's name\n")
+{
+	vty->node = VRF_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_VRF, vtysh_exit_vrf, vtysh_exit_vrf_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_VRF, vtysh_quit_vrf, vtysh_quit_vrf_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_vrf(self, vty, argc, argv);
+}
+
+DEFUNSH(VTYSH_NH_GROUP,
+	vtysh_exit_nexthop_group, vtysh_exit_nexthop_group_cmd,
+	"exit", "Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_NH_GROUP,
+	vtysh_quit_nexthop_group, vtysh_quit_nexthop_group_cmd,
+	"quit", "Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_nexthop_group(self, vty, argc, argv);
+}
+
+DEFUNSH(VTYSH_INTERFACE, vtysh_exit_interface, vtysh_exit_interface_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_INTERFACE, vtysh_quit_interface, vtysh_quit_interface_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_interface(self, vty, argc, argv);
+}
+
+DEFUNSH(VTYSH_ZEBRA, vtysh_exit_pseudowire, vtysh_exit_pseudowire_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit(vty);
+}
+
+DEFUNSH(VTYSH_ZEBRA, vtysh_quit_pseudowire, vtysh_quit_pseudowire_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_pseudowire(self, vty, argc, argv);
+}
+
+static char *do_prepend(struct vty *vty, struct cmd_token **argv, int argc)
+{
+	const char *argstr[argc + 1];
+	int i, off = 0;
+
+	if (vty->node != VIEW_NODE) {
+		off = 1;
+		argstr[0] = "do";
+	}
+
+	for (i = 0; i < argc; i++)
+		argstr[i + off] = argv[i]->arg;
+
+	return frrstr_join(argstr, argc + off, " ");
+}
+
+static int show_per_daemon(struct vty *vty, struct cmd_token **argv, int argc,
+			   const char *headline)
+{
+	unsigned int i;
+	int ret = CMD_SUCCESS;
+	char *line = do_prepend(vty, argv, argc);
+
+	for (i = 0; i < array_size(vtysh_client); i++)
+		if (vtysh_client[i].fd >= 0 || vtysh_client[i].next) {
+			vty_out(vty, headline, vtysh_client[i].name);
+			ret = vtysh_client_execute(&vtysh_client[i], line);
+			vty_out(vty, "\n");
+		}
+
+	XFREE(MTYPE_TMP, line);
+
+	return ret;
+}
+
+static int show_one_daemon(struct vty *vty, struct cmd_token **argv, int argc,
+			   const char *name)
+{
+	int ret;
+	char *line = do_prepend(vty, argv, argc);
+
+	ret = vtysh_client_execute_name(name, line);
+
+	XFREE(MTYPE_TMP, line);
+
+	return ret;
+}
+
+DEFUN (vtysh_show_thread_timer,
+       vtysh_show_thread_timer_cmd,
+       "show thread timers",
+       SHOW_STR
+       "Thread information\n"
+       "Show all timers and how long they have in the system\n")
+{
+	return show_per_daemon(vty, argv, argc, "Thread timers for %s:\n");
+}
+
+DEFUN (vtysh_show_poll,
+       vtysh_show_poll_cmd,
+       "show thread poll",
+       SHOW_STR
+       "Thread information\n"
+       "Thread Poll Information\n")
+{
+	return show_per_daemon(vty, argv, argc, "Thread statistics for %s:\n");
+}
+
+DEFUN (vtysh_show_thread,
+       vtysh_show_thread_cmd,
+       "show thread cpu [FILTER]",
+       SHOW_STR
+       "Thread information\n"
+       "Thread CPU usage\n"
+       "Display filter (rwtexb)\n")
+{
+	return show_per_daemon(vty, argv, argc, "Thread statistics for %s:\n");
+}
+
+DEFUN (vtysh_show_work_queues,
+       vtysh_show_work_queues_cmd,
+       "show work-queues",
+       SHOW_STR
+       "Work Queue information\n")
+{
+	return show_per_daemon(vty, argv, argc,
+			       "Work queue statistics for %s:\n");
+}
+
+DEFUN (vtysh_show_work_queues_daemon,
+       vtysh_show_work_queues_daemon_cmd,
+       "show work-queues " DAEMONS_LIST,
+       SHOW_STR
+       "Work Queue information\n"
+       DAEMONS_STR)
+{
+	return show_one_daemon(vty, argv, argc - 1, argv[argc - 1]->text);
+}
+
+DEFUNSH(VTYSH_ZEBRA, vtysh_link_params, vtysh_link_params_cmd, "link-params",
+	LINK_PARAMS_STR)
+{
+	vty->node = LINK_PARAMS_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, exit_link_params, exit_link_params_cmd, "exit-link-params",
+	"Exit from Link Params configuration node\n")
+{
+	if (vty->node == LINK_PARAMS_NODE)
+		vty->node = INTERFACE_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, vtysh_exit_link_params, vtysh_exit_link_params_cmd, "exit",
+	"Exit current mode and down to previous mode\n")
+{
+	if (vty->node == LINK_PARAMS_NODE)
+		vty->node = INTERFACE_NODE;
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ZEBRA, vtysh_quit_link_params, vtysh_quit_link_params_cmd, "quit",
+	"Exit current mode and down to previous mode\n")
+{
+	return vtysh_exit_link_params(self, vty, argc, argv);
+}
+
+DEFUNSH_HIDDEN (0x00,
+                vtysh_debug_all,
+                vtysh_debug_all_cmd,
+                "[no] debug all",
+                NO_STR
+                DEBUG_STR
+                "Toggle all debugs on or off\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_show_debugging,
+       vtysh_show_debugging_cmd,
+       "show debugging",
+       SHOW_STR
+       DEBUG_STR)
+{
+	return show_per_daemon(vty, argv, argc, "");
+}
+
+DEFUN (vtysh_show_debugging_hashtable,
+       vtysh_show_debugging_hashtable_cmd,
+       "show debugging hashtable [statistics]",
+       SHOW_STR
+       DEBUG_STR
+       "Statistics about hash tables\n"
+       "Statistics about hash tables\n")
+{
+	bool stats = strmatch(argv[argc - 1]->text, "statistics");
+
+	vty_out(vty, "\n");
+	vty_out(vty,
+		"Load factor (LF) - average number of elements across all buckets\n");
+	vty_out(vty,
+		"Full load factor (FLF) - average number of elements across full buckets\n\n");
+	vty_out(vty,
+		"Standard deviation (SD) is calculated for both the LF and FLF\n");
+	vty_out(vty,
+		"and indicates the typical deviation of bucket chain length\n");
+	vty_out(vty, "from the value in the corresponding load factor.\n\n");
+
+	return show_per_daemon(vty, argv, stats ? argc - 1 : argc,
+			       "Hashtable statistics for %s:\n");
+}
+
+DEFUN (vtysh_show_error_code,
+       vtysh_show_error_code_cmd,
+       "show error <(1-4294967296)|all> [json]",
+       SHOW_STR
+       "Information on errors\n"
+       "Error code to get info about\n"
+       "Information on all errors\n"
+       JSON_STR)
+{
+	uint32_t arg = 0;
+
+	if (!strmatch(argv[2]->text, "all"))
+		arg = strtoul(argv[2]->arg, NULL, 10);
+
+	/* If it's not a shared code, send it to all the daemons */
+	if (arg < LIB_FERR_START || arg > LIB_FERR_END) {
+		show_per_daemon(vty, argv, argc, "");
+		/* Otherwise, print it ourselves to avoid duplication */
+	} else {
+		bool json = strmatch(argv[argc - 1]->text, "json");
+
+		if (!strmatch(argv[2]->text, "all"))
+			arg = strtoul(argv[2]->arg, NULL, 10);
+
+		log_ref_display(vty, arg, json);
+	}
+
+	return CMD_SUCCESS;
+}
+
+/* Northbound. */
+DEFUN_HIDDEN (show_config_running,
+       show_config_running_cmd,
+       "show configuration running\
+          [<json|xml> [translate WORD]]\
+          [with-defaults]" DAEMONS_LIST,
+       SHOW_STR
+       "Configuration information\n"
+       "Running configuration\n"
+       "Change output format to JSON\n"
+       "Change output format to XML\n"
+       "Translate output\n"
+       "YANG module translator\n"
+       "Show default values\n"
+       DAEMONS_STR)
+{
+	return show_one_daemon(vty, argv, argc - 1, argv[argc - 1]->text);
+}
+
+DEFUN (show_yang_operational_data,
+       show_yang_operational_data_cmd,
+       "show yang operational-data XPATH\
+         [{\
+	   format <json|xml>\
+	   |translate WORD\
+	   |with-config\
+	 }]" DAEMONS_LIST,
+       SHOW_STR
+       "YANG information\n"
+       "Show YANG operational data\n"
+       "XPath expression specifying the YANG data path\n"
+       "Set the output format\n"
+       "JavaScript Object Notation\n"
+       "Extensible Markup Language\n"
+       "Translate operational data\n"
+       "YANG module translator\n"
+       "Merge configuration data\n"
+       DAEMONS_STR)
+{
+	return show_one_daemon(vty, argv, argc - 1, argv[argc - 1]->text);
+}
+
+DEFUN(show_yang_module, show_yang_module_cmd,
+      "show yang module [module-translator WORD] " DAEMONS_LIST,
+      SHOW_STR
+      "YANG information\n"
+      "Show loaded modules\n"
+      "YANG module translator\n"
+      "YANG module translator\n" DAEMONS_STR)
+{
+	return show_one_daemon(vty, argv, argc - 1, argv[argc - 1]->text);
+}
+
+DEFUN(show_yang_module_detail, show_yang_module_detail_cmd,
+      "show yang module\
+          [module-translator WORD]\
+          WORD <compiled|summary|tree|yang|yin> " DAEMONS_LIST,
+      SHOW_STR
+      "YANG information\n"
+      "Show loaded modules\n"
+      "YANG module translator\n"
+      "YANG module translator\n"
+      "Module name\n"
+      "Display compiled module in YANG format\n"
+      "Display summary information about the module\n"
+      "Display module in the tree (RFC 8340) format\n"
+      "Display module in the YANG format\n"
+      "Display module in the YIN format\n" DAEMONS_STR)
+{
+	return show_one_daemon(vty, argv, argc - 1, argv[argc - 1]->text);
+}
+
+
+DEFUNSH(VTYSH_ALL, debug_nb,
+	debug_nb_cmd,
+	"[no] debug northbound\
+	   [<\
+	    callbacks [{configuration|state|rpc}]\
+	    |notifications\
+	    |events\
+	    |libyang\
+	   >]",
+	NO_STR
+	DEBUG_STR
+	"Northbound debugging\n"
+	"Callbacks\n"
+	"Configuration\n"
+	"State\n"
+	"RPC\n"
+	"Notifications\n"
+	"Events\n"
+	"libyang debugging\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_show_history,
+       vtysh_show_history_cmd,
+       "show history",
+       SHOW_STR
+       "The list of commands stored in history\n")
+{
+	HIST_ENTRY **hlist = history_list();
+	int i = 0;
+
+	while (hlist[i]) {
+		vty_out(vty, "%s\n", hlist[i]->line);
+		i++;
+	}
+	return CMD_SUCCESS;
+}
+
+/* Memory */
+DEFUN (vtysh_show_memory,
+       vtysh_show_memory_cmd,
+       "show memory [" DAEMONS_LIST "]",
+       SHOW_STR
+       "Memory statistics\n"
+       DAEMONS_STR)
+{
+	if (argc == 3)
+		return show_one_daemon(vty, argv, argc - 1,
+				       argv[argc - 1]->text);
+
+	return show_per_daemon(vty, argv, argc, "Memory statistics for %s:\n");
+}
+
+DEFUN (vtysh_show_modules,
+       vtysh_show_modules_cmd,
+       "show modules",
+       SHOW_STR
+       "Loaded modules\n")
+{
+	return show_per_daemon(vty, argv, argc, "Module information for %s:\n");
+}
+
+/* Logging commands. */
+DEFUN (vtysh_show_logging,
+       vtysh_show_logging_cmd,
+       "show logging",
+       SHOW_STR
+       "Show current logging configuration\n")
+{
+	return show_per_daemon(vty, argv, argc,
+			       "Logging configuration for %s:\n");
+}
+
+DEFUNSH(VTYSH_ALL, vtysh_debug_memstats,
+	vtysh_debug_memstats_cmd, "[no] debug memstats-at-exit",
+	NO_STR
+	"Debug\n"
+	"Print memory statistics at exit\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUN(vtysh_debug_uid_backtrace,
+      vtysh_debug_uid_backtrace_cmd,
+      "[no] debug unique-id UID backtrace",
+      NO_STR
+      DEBUG_STR
+      "Options per individual log message, by unique ID\n"
+      "Log message unique ID (XXXXX-XXXXX)\n"
+      "Add backtrace to log when message is printed\n")
+{
+	unsigned int i, ok = 0;
+	int err = CMD_SUCCESS, ret;
+	const char *uid;
+	char line[64];
+
+	if (!strcmp(argv[0]->text, "no")) {
+		uid = argv[3]->arg;
+		snprintfrr(line, sizeof(line),
+			   "no debug unique-id %s backtrace", uid);
+	} else {
+		uid = argv[2]->arg;
+		snprintfrr(line, sizeof(line), "debug unique-id %s backtrace",
+			   uid);
+	}
+
+	for (i = 0; i < array_size(vtysh_client); i++)
+		if (vtysh_client[i].fd >= 0 || vtysh_client[i].next) {
+			ret = vtysh_client_execute(&vtysh_client[i], line);
+			switch (ret) {
+			case CMD_SUCCESS:
+				ok++;
+				break;
+			case CMD_ERR_NOTHING_TODO:
+				/* ignore this daemon
+				 *
+				 * note this doesn't need to handle instances
+				 * of the same daemon individually because
+				 * the same daemon will have the same UIDs
+				 */
+				break;
+			default:
+				if (err == CMD_SUCCESS)
+					err = ret;
+				break;
+			}
+		}
+
+	if (err == CMD_SUCCESS && !ok) {
+		vty_out(vty, "%% no running daemon recognizes unique-ID %s\n",
+			uid);
+		err = CMD_WARNING;
+	}
+	return err;
+}
+
+DEFUNSH(VTYSH_ALL, vtysh_allow_reserved_ranges, vtysh_allow_reserved_ranges_cmd,
+	"allow-reserved-ranges",
+	"Allow using IPv4 (Class E) reserved IP space\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ALL, no_vtysh_allow_reserved_ranges,
+	no_vtysh_allow_reserved_ranges_cmd, "no allow-reserved-ranges",
+	NO_STR "Allow using IPv4 (Class E) reserved IP space\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ALL, vtysh_service_password_encrypt,
+	vtysh_service_password_encrypt_cmd, "service password-encryption",
+	"Set up miscellaneous service\n"
+	"Enable encrypted passwords\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ALL, no_vtysh_service_password_encrypt,
+	no_vtysh_service_password_encrypt_cmd, "no service password-encryption",
+	NO_STR
+	"Set up miscellaneous service\n"
+	"Enable encrypted passwords\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ALL, vtysh_config_password, vtysh_password_cmd,
+	"password [(8-8)] LINE",
+	"Modify the terminal connection password\n"
+	"Specifies a HIDDEN password will follow\n"
+	"The password string\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ALL, no_vtysh_config_password, no_vtysh_password_cmd,
+	"no password", NO_STR
+	"Modify the terminal connection password\n")
+{
+	vty_out(vty, NO_PASSWD_CMD_WARNING);
+
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ALL, vtysh_config_enable_password, vtysh_enable_password_cmd,
+	"enable password [(8-8)] LINE",
+	"Modify enable password parameters\n"
+	"Assign the privileged level password\n"
+	"Specifies a HIDDEN password will follow\n"
+	"The 'enable' password string\n")
+{
+	return CMD_SUCCESS;
+}
+
+DEFUNSH(VTYSH_ALL, no_vtysh_config_enable_password,
+	no_vtysh_enable_password_cmd, "no enable password", NO_STR
+	"Modify enable password parameters\n"
+	"Assign the privileged level password\n")
+{
+	vty_out(vty, NO_PASSWD_CMD_WARNING);
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_write_terminal,
+       vtysh_write_terminal_cmd,
+       "write terminal ["DAEMONS_LIST"] [no-header]",
+       "Write running configuration to memory, network, or terminal\n"
+       "Write to terminal\n"
+       DAEMONS_STR
+       "Skip \"Building configuration...\" header\n")
+{
+	unsigned int i;
+	char line[] = "do write terminal";
+
+	if (!strcmp(argv[argc - 1]->arg, "no-header"))
+		argc--;
+	else {
+		vty_out(vty, "Building configuration...\n");
+		vty_out(vty, "\nCurrent configuration:\n");
+		vty_out(vty, "!\n");
+	}
+
+	for (i = 0; i < array_size(vtysh_client); i++)
+		if ((argc < 3)
+		    || (strmatch(vtysh_client[i].name, argv[2]->text)))
+			vtysh_client_config(&vtysh_client[i], line);
+
+	/* Integrate vtysh specific configuration. */
+	vty_open_pager(vty);
+	vtysh_config_write();
+	vtysh_config_dump();
+	vty_close_pager(vty);
+	vty_out(vty, "end\n");
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_show_running_config,
+       vtysh_show_running_config_cmd,
+       "show running-config ["DAEMONS_LIST"] [no-header]",
+       SHOW_STR
+       "Current operating configuration\n"
+       DAEMONS_STR
+       "Skip \"Building configuration...\" header\n")
+{
+	return vtysh_write_terminal(self, vty, argc, argv);
+}
+
+DEFUN (vtysh_integrated_config,
+       vtysh_integrated_config_cmd,
+       "service integrated-vtysh-config",
+       "Set up miscellaneous service\n"
+       "Write configuration into integrated file\n")
+{
+	vtysh_write_integrated = WRITE_INTEGRATED_YES;
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_vtysh_integrated_config,
+       no_vtysh_integrated_config_cmd,
+       "no service integrated-vtysh-config",
+       NO_STR
+       "Set up miscellaneous service\n"
+       "Write configuration into integrated file\n")
+{
+	vtysh_write_integrated = WRITE_INTEGRATED_NO;
+	return CMD_SUCCESS;
+}
+
+static void backup_config_file(const char *fbackup)
+{
+	char *integrate_sav = NULL;
+
+	size_t integrate_sav_sz = strlen(fbackup) + strlen(CONF_BACKUP_EXT) + 1;
+	integrate_sav = malloc(integrate_sav_sz);
+	strlcpy(integrate_sav, fbackup, integrate_sav_sz);
+	strlcat(integrate_sav, CONF_BACKUP_EXT, integrate_sav_sz);
+
+	/* Move current configuration file to backup config file. */
+	if (unlink(integrate_sav) != 0 && errno != ENOENT)
+		vty_out(vty, "Unlink failed for %s: %s\n", integrate_sav,
+			strerror(errno));
+	if (rename(fbackup, integrate_sav) != 0 && errno != ENOENT)
+		vty_out(vty, "Error renaming %s to %s: %s\n", fbackup,
+			integrate_sav, strerror(errno));
+	free(integrate_sav);
+}
+
+int vtysh_write_config_integrated(void)
+{
+	unsigned int i;
+	char line[] = "do write terminal";
+	FILE *fp;
+	int fd;
+#ifdef FRR_USER
+	struct passwd *pwentry;
+#endif
+#ifdef FRR_GROUP
+	struct group *grentry;
+#endif
+	uid_t uid = -1;
+	gid_t gid = -1;
+	struct stat st;
+	int err = 0;
+
+	vty_out(vty, "Building Configuration...\n");
+
+	backup_config_file(frr_config);
+	fp = fopen(frr_config, "w");
+	if (fp == NULL) {
+		vty_out(vty,
+			"%% Error: failed to open configuration file %s: %s\n",
+			frr_config, safe_strerror(errno));
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+	fd = fileno(fp);
+
+	for (i = 0; i < array_size(vtysh_client); i++)
+		vtysh_client_config(&vtysh_client[i], line);
+
+	vtysh_config_write();
+	vty->of_saved = vty->of;
+	vty->of = fp;
+	vtysh_config_dump();
+	vty->of = vty->of_saved;
+
+	if (fchmod(fd, CONFIGFILE_MASK) != 0) {
+		printf("%% Warning: can't chmod configuration file %s: %s\n",
+		       frr_config, safe_strerror(errno));
+		err++;
+	}
+
+#ifdef FRR_USER
+	pwentry = getpwnam(FRR_USER);
+	if (pwentry)
+		uid = pwentry->pw_uid;
+	else {
+		printf("%% Warning: could not look up user \"%s\"\n", FRR_USER);
+		err++;
+	}
+#endif
+#ifdef FRR_GROUP
+	grentry = getgrnam(FRR_GROUP);
+	if (grentry)
+		gid = grentry->gr_gid;
+	else {
+		printf("%% Warning: could not look up group \"%s\"\n",
+		       FRR_GROUP);
+		err++;
+	}
+#endif
+
+	if (!fstat(fd, &st)) {
+		if (st.st_uid == uid)
+			uid = -1;
+		if (st.st_gid == gid)
+			gid = -1;
+		if ((uid != (uid_t)-1 || gid != (gid_t)-1)
+		    && fchown(fd, uid, gid)) {
+			printf("%% Warning: can't chown configuration file %s: %s\n",
+			       frr_config, safe_strerror(errno));
+			err++;
+		}
+	} else {
+		printf("%% Warning: stat() failed on %s: %s\n", frr_config,
+		       safe_strerror(errno));
+		err++;
+	}
+
+	if (fflush(fp) != 0) {
+		printf("%% Warning: fflush() failed on %s: %s\n", frr_config,
+		       safe_strerror(errno));
+		err++;
+	}
+
+	if (fsync(fd) < 0) {
+		printf("%% Warning: fsync() failed on %s: %s\n", frr_config,
+		       safe_strerror(errno));
+		err++;
+	}
+
+	fclose(fp);
+
+	printf("Integrated configuration saved to %s\n", frr_config);
+	if (err)
+		return CMD_WARNING;
+
+	printf("[OK]\n");
+	return CMD_SUCCESS;
+}
+
+static bool want_config_integrated(void)
+{
+	struct stat s;
+
+	switch (vtysh_write_integrated) {
+	case WRITE_INTEGRATED_UNSPECIFIED:
+		if (stat(frr_config, &s) && errno == ENOENT)
+			return false;
+		return true;
+	case WRITE_INTEGRATED_NO:
+		return false;
+	case WRITE_INTEGRATED_YES:
+		return true;
+	}
+	return true;
+}
+
+DEFUN (vtysh_write_memory,
+       vtysh_write_memory_cmd,
+       "write [<memory|file>]",
+       "Write running configuration to memory, network, or terminal\n"
+       "Write configuration to the file (same as write file)\n"
+       "Write configuration to the file (same as write memory)\n")
+{
+	int ret = CMD_SUCCESS;
+	char line[] = "do write memory";
+	unsigned int i;
+
+	vty_out(vty, "Note: this version of vtysh never writes vtysh.conf\n");
+
+	/* If integrated frr.conf explicitly set. */
+	if (want_config_integrated()) {
+		ret = CMD_WARNING_CONFIG_FAILED;
+
+		/* first attempt to use watchfrr if it's available */
+		bool used_watchfrr = false;
+
+		for (i = 0; i < array_size(vtysh_client); i++)
+			if (vtysh_client[i].flag == VTYSH_WATCHFRR)
+				break;
+		if (i < array_size(vtysh_client) && vtysh_client[i].fd != -1) {
+			used_watchfrr = true;
+			ret = vtysh_client_execute(&vtysh_client[i],
+						   "do write integrated");
+		}
+
+		/*
+		 * If we didn't use watchfrr, fallback to writing the config
+		 * ourselves
+		 */
+		if (!used_watchfrr) {
+			printf("\nWarning: attempting direct configuration write without watchfrr.\nFile permissions and ownership may be incorrect, or write may fail.\n\n");
+			ret = vtysh_write_config_integrated();
+		}
+		return ret;
+	}
+
+	vty_out(vty, "Building Configuration...\n");
+
+	for (i = 0; i < array_size(vtysh_client); i++)
+		ret = vtysh_client_execute(&vtysh_client[i], line);
+
+	return ret;
+}
+
+DEFUN (vtysh_copy_running_config,
+       vtysh_copy_running_config_cmd,
+       "copy running-config startup-config",
+       "Copy from one file to another\n"
+       "Copy from current system configuration\n"
+       "Copy to startup configuration\n")
+{
+	return vtysh_write_memory(self, vty, argc, argv);
+}
+
+DEFUN (vtysh_copy_to_running,
+       vtysh_copy_to_running_cmd,
+       "copy FILENAME running-config",
+       "Apply a configuration file\n"
+       "Configuration file to read\n"
+       "Apply to current configuration\n")
+{
+	int ret;
+	const char *fname = argv[1]->arg;
+
+	ret = vtysh_read_config(fname, true);
+
+	/* Return to enable mode - the 'read_config' api leaves us up a level */
+	vtysh_execute_no_pager("enable");
+
+	return ret;
+}
+
+DEFUN (vtysh_terminal_paginate,
+       vtysh_terminal_paginate_cmd,
+       "[no] terminal paginate",
+       NO_STR
+       "Set terminal line parameters\n"
+       "Use pager for output scrolling\n")
+{
+	free(vtysh_pager_name);
+	vtysh_pager_name = NULL;
+
+	if (strcmp(argv[0]->text, "no"))
+		vtysh_pager_envdef(true);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_terminal_length,
+       vtysh_terminal_length_cmd,
+       "[no] terminal length (0-4294967295)",
+       NO_STR
+       "Set terminal line parameters\n"
+       "Set number of lines on a screen\n"
+       "Number of lines on screen (0 for no pausing, nonzero to use pager)\n")
+{
+	int idx_number = 2;
+	unsigned long lines;
+
+	free(vtysh_pager_name);
+	vtysh_pager_name = NULL;
+
+	if (!strcmp(argv[0]->text, "no") || !strcmp(argv[1]->text, "no")) {
+		/* "terminal no length" = use VTYSH_PAGER */
+		vtysh_pager_envdef(true);
+		return CMD_SUCCESS;
+	}
+
+	lines = strtoul(argv[idx_number]->arg, NULL, 10);
+	if (lines != 0) {
+		vty_out(vty,
+			"%% The \"terminal length\" command is deprecated and its value is ignored.\n"
+			"%% Please use \"terminal paginate\" instead with OS TTY length handling.\n");
+		vtysh_pager_envdef(true);
+	}
+
+	return CMD_SUCCESS;
+}
+
+ALIAS_DEPRECATED(vtysh_terminal_length,
+       vtysh_terminal_no_length_cmd,
+       "terminal no length",
+       "Set terminal line parameters\n"
+       NO_STR
+       "Set number of lines on a screen\n")
+
+DEFUN (vtysh_show_daemons,
+       vtysh_show_daemons_cmd,
+       "show daemons",
+       SHOW_STR
+       "Show list of running daemons\n")
+{
+	unsigned int i;
+
+	for (i = 0; i < array_size(vtysh_client); i++)
+		if (vtysh_client[i].fd >= 0)
+			vty_out(vty, " %s", vtysh_client[i].name);
+	vty_out(vty, "\n");
+
+	return CMD_SUCCESS;
+}
+
+struct visual_prio {
+	/* 4 characters for nice alignment */
+	const char *label;
+
+	int c256_background;
+	int c256_formatarg;
+};
+
+/* clang-format off */
+struct visual_prio visual_prios[] = {
+	[LOG_EMERG] = {
+		.label = "\e[31;1mEMRG",
+		.c256_background = 53,
+		.c256_formatarg = 225,
+	},
+	[LOG_ALERT] = {
+		.label = "\e[31;1mALRT",
+		.c256_background = 53,
+		.c256_formatarg = 225,
+	},
+	[LOG_CRIT] = {
+		.label = "\e[31;1mCRIT",
+		.c256_background = 53,
+		.c256_formatarg = 225,
+	},
+	[LOG_ERR] = {
+		.label = "\e[38;5;202mERR!",
+		.c256_background = 52,
+		.c256_formatarg = 224,
+	},
+	[LOG_WARNING] = {
+		.label = "\e[38;5;222mWARN",
+		.c256_background = 58,
+		.c256_formatarg = 230,
+	},
+	[LOG_NOTICE] = {
+		.label = "NTFY",
+		.c256_background = 234,
+		.c256_formatarg = 195,
+	},
+	[LOG_INFO] = {
+		.label = "\e[38;5;192mINFO",
+		.c256_background = 236,
+		.c256_formatarg = 195,
+	},
+	[LOG_DEBUG] = {
+		.label = "\e[38;5;116mDEBG",
+		.c256_background = 238,
+		.c256_formatarg = 195,
+	},
+};
+/* clang-format on */
+
+static void vtysh_log_print(struct vtysh_client *vclient,
+			    struct zlog_live_hdr *hdr, const char *text)
+{
+	size_t textlen = hdr->textlen, textpos = 0;
+	time_t ts = hdr->ts_sec;
+	struct visual_prio *vis;
+	struct tm tm;
+	char ts_buf[32];
+
+	if (hdr->prio >= array_size(visual_prios))
+		vis = &visual_prios[LOG_CRIT];
+	else
+		vis = &visual_prios[hdr->prio];
+
+	localtime_r(&ts, &tm);
+	strftime(ts_buf, sizeof(ts_buf), "%Y-%m-%d %H:%M:%S", &tm);
+
+	if (!stderr_tty) {
+		const char *label = vis->label + strlen(vis->label) - 4;
+
+		fprintf(stderr, "%s.%03u [%s] %s: %.*s\n", ts_buf,
+			hdr->ts_nsec / 1000000U, label, vclient->name,
+			(int)textlen, text);
+		return;
+	}
+
+	fprintf(stderr,
+		"\e[48;5;%dm\e[38;5;247m%s.%03u [%s\e[38;5;247m] \e[38;5;255m%s\e[38;5;247m: \e[38;5;251m",
+		vis->c256_background, ts_buf, hdr->ts_nsec / 1000000U,
+		vis->label, vclient->name);
+
+	for (size_t fmtpos = 0; fmtpos < hdr->n_argpos; fmtpos++) {
+		struct fmt_outpos *fmt = &hdr->argpos[fmtpos];
+
+		if (fmt->off_start < textpos || fmt->off_end < fmt->off_start ||
+		    fmt->off_end > textlen)
+			continue;
+
+		while (fmt->off_end > fmt->off_start &&
+		       text[fmt->off_end - 1] == ' ')
+			fmt->off_end--;
+
+		fprintf(stderr, "%.*s\e[38;5;%dm%.*s\e[38;5;251m",
+			(int)(fmt->off_start - textpos), text + textpos,
+			vis->c256_formatarg,
+			(int)(fmt->off_end - fmt->off_start),
+			text + fmt->off_start);
+		textpos = fmt->off_end;
+	}
+	fprintf(stderr, "%.*s\033[K\033[m\n", (int)(textlen - textpos),
+		text + textpos);
+}
+
+static void vtysh_log_read(struct thread *thread)
+{
+	struct vtysh_client *vclient = THREAD_ARG(thread);
+	struct {
+		struct zlog_live_hdr hdr;
+		char text[4096];
+	} buf;
+	const char *text;
+	ssize_t ret;
+
+	thread_add_read(master, vtysh_log_read, vclient, vclient->log_fd,
+			&vclient->log_reader);
+
+	ret = recv(vclient->log_fd, &buf, sizeof(buf), 0);
+
+	if (ret < 0 && ERRNO_IO_RETRY(errno))
+		return;
+
+	if (stderr_stdout_same) {
+#ifdef HAVE_RL_CLEAR_VISIBLE_LINE
+		rl_clear_visible_line();
+#else
+		puts("\r");
+#endif
+		fflush(stdout);
+	}
+
+	if (ret <= 0) {
+		struct timespec ts;
+
+		buf.text[0] = '\0'; /* coverity */
+
+		if (ret != 0)
+			snprintfrr(buf.text, sizeof(buf.text),
+				   "log monitor connection error: %m");
+		else
+			snprintfrr(
+				buf.text, sizeof(buf.text),
+				"log monitor connection closed unexpectedly");
+		buf.hdr.textlen = strlen(buf.text);
+
+		THREAD_OFF(vclient->log_reader);
+		close(vclient->log_fd);
+		vclient->log_fd = -1;
+
+		clock_gettime(CLOCK_REALTIME, &ts);
+		buf.hdr.ts_sec = ts.tv_sec;
+		buf.hdr.ts_nsec = ts.tv_nsec;
+		buf.hdr.prio = LOG_ERR;
+		buf.hdr.flags = 0;
+		buf.hdr.texthdrlen = 0;
+		buf.hdr.n_argpos = 0;
+	} else {
+		int32_t lost_msgs = buf.hdr.lost_msgs - vclient->lost_msgs;
+
+		if (lost_msgs > 0) {
+			vclient->lost_msgs = buf.hdr.lost_msgs;
+			fprintf(stderr,
+				"%d log messages from %s lost (vtysh reading too slowly)\n",
+				lost_msgs, vclient->name);
+		}
+	}
+
+	text = buf.text + sizeof(buf.hdr.argpos[0]) * buf.hdr.n_argpos;
+	vtysh_log_print(vclient, &buf.hdr, text);
+
+	if (stderr_stdout_same)
+		rl_forced_update_display();
+
+	return;
+}
+
+#ifdef CLIPPY
+/* clippy/clidef can't process the DEFPY below without some value for this */
+#define DAEMONS_LIST "daemon"
+#endif
+
+DEFPY (vtysh_terminal_monitor,
+       vtysh_terminal_monitor_cmd,
+       "terminal monitor ["DAEMONS_LIST"]$daemon",
+       "Set terminal line parameters\n"
+       "Receive log messages to active VTY session\n"
+       DAEMONS_STR)
+{
+	static const char line[] = "terminal monitor";
+	int ret_all = CMD_SUCCESS, ret, fd;
+	size_t i, ok = 0;
+
+	for (i = 0; i < array_size(vtysh_client); i++) {
+		struct vtysh_client *vclient = &vtysh_client[i];
+
+		if (daemon && strcmp(vclient->name, daemon))
+			continue;
+
+		for (; vclient; vclient = vclient->next) {
+			if (vclient->log_fd != -1) {
+				vty_out(vty, "%% %s: already monitoring logs\n",
+					vclient->name);
+				ok++;
+				continue;
+			}
+
+			fd = -1;
+			ret = vtysh_client_run(vclient, line, NULL, NULL, &fd);
+			if (fd != -1) {
+				set_nonblocking(fd);
+				vclient->log_fd = fd;
+				thread_add_read(master, vtysh_log_read, vclient,
+						vclient->log_fd,
+						&vclient->log_reader);
+			}
+			if (ret != CMD_SUCCESS) {
+				vty_out(vty, "%% failed to enable logs on %s\n",
+					vclient->name);
+				ret_all = CMD_WARNING;
+			} else
+				ok++;
+		}
+	}
+
+	if (!ok && ret_all == CMD_SUCCESS) {
+		vty_out(vty,
+			"%% command had no effect, relevant daemons not connected?\n");
+		ret_all = CMD_WARNING;
+	}
+	return ret_all;
+}
+
+DEFPY (no_vtysh_terminal_monitor,
+       no_vtysh_terminal_monitor_cmd,
+       "no terminal monitor ["DAEMONS_LIST"]$daemon",
+       NO_STR
+       "Set terminal line parameters\n"
+       "Receive log messages to active VTY session\n"
+       DAEMONS_STR)
+{
+	static const char line[] = "no terminal monitor";
+	int ret_all = CMD_SUCCESS, ret;
+	size_t i, ok = 0;
+
+	for (i = 0; i < array_size(vtysh_client); i++) {
+		struct vtysh_client *vclient = &vtysh_client[i];
+
+		if (daemon && strcmp(vclient->name, daemon))
+			continue;
+
+		for (; vclient; vclient = vclient->next) {
+			/* run this even if log_fd == -1, in case something
+			 * got desync'd
+			 */
+			ret = vtysh_client_run(vclient, line, NULL, NULL, NULL);
+			if (ret != CMD_SUCCESS) {
+				vty_out(vty,
+					"%% failed to disable logs on %s\n",
+					vclient->name);
+				ret_all = CMD_WARNING;
+			} else
+				ok++;
+
+			/* with this being a datagram socket, we can't expect
+			 * a close notification...
+			 */
+			if (vclient->log_fd != -1) {
+				THREAD_OFF(vclient->log_reader);
+
+				close(vclient->log_fd);
+				vclient->log_fd = -1;
+			}
+		}
+	}
+
+	if (!ok && ret_all == CMD_SUCCESS) {
+		vty_out(vty,
+			"%% command had no effect, relevant daemons not connected?\n");
+		ret_all = CMD_WARNING;
+	}
+	return ret_all;
+}
+
+
+/* Execute command in child process. */
+static void execute_command(const char *command, int argc, const char *arg1,
+			    const char *arg2)
+{
+	pid_t pid;
+	int status;
+
+	/* Call fork(). */
+	pid = fork();
+
+	if (pid < 0) {
+		/* Failure of fork(). */
+		fprintf(stderr, "Can't fork: %s\n", safe_strerror(errno));
+		exit(1);
+	} else if (pid == 0) {
+		/* This is child process. */
+		switch (argc) {
+		case 0:
+			execlp(command, command, (const char *)NULL);
+			break;
+		case 1:
+			execlp(command, command, arg1, (const char *)NULL);
+			break;
+		case 2:
+			execlp(command, command, arg1, arg2,
+			       (const char *)NULL);
+			break;
+		}
+
+		/* When execlp suceed, this part is not executed. */
+		fprintf(stderr, "Can't execute %s: %s\n", command,
+			safe_strerror(errno));
+		exit(1);
+	} else {
+		/* This is parent. */
+		execute_flag = 1;
+		wait4(pid, &status, 0, NULL);
+		execute_flag = 0;
+	}
+}
+
+DEFUN (vtysh_ping,
+       vtysh_ping_cmd,
+       "ping WORD",
+       "Send echo messages\n"
+       "Ping destination address or hostname\n")
+{
+	int idx = 1;
+
+	argv_find(argv, argc, "WORD", &idx);
+	execute_command("ping", 1, argv[idx]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+ALIAS(vtysh_ping, vtysh_ping_ip_cmd, "ping ip WORD",
+      "Send echo messages\n"
+      "IP echo\n"
+      "Ping destination address or hostname\n")
+
+DEFUN (vtysh_traceroute,
+       vtysh_traceroute_cmd,
+       "traceroute WORD",
+       "Trace route to destination\n"
+       "Trace route to destination address or hostname\n")
+{
+	int idx = 1;
+
+	argv_find(argv, argc, "WORD", &idx);
+	execute_command("traceroute", 1, argv[idx]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+ALIAS(vtysh_traceroute, vtysh_traceroute_ip_cmd, "traceroute ip WORD",
+      "Trace route to destination\n"
+      "IP trace\n"
+      "Trace route to destination address or hostname\n")
+
+DEFUN (vtysh_mtrace,
+       vtysh_mtrace_cmd,
+       "mtrace WORD [WORD]",
+       "Multicast trace route to multicast source\n"
+       "Multicast trace route to multicast source address\n"
+       "Multicast trace route for multicast group address\n")
+{
+	if (argc == 2)
+		execute_command("mtracebis", 1, argv[1]->arg, NULL);
+	else
+		execute_command("mtracebis", 2, argv[1]->arg, argv[2]->arg);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_ping6,
+       vtysh_ping6_cmd,
+       "ping ipv6 WORD",
+       "Send echo messages\n"
+       "IPv6 echo\n"
+       "Ping destination address or hostname\n")
+{
+	execute_command("ping6", 1, argv[2]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_traceroute6,
+       vtysh_traceroute6_cmd,
+       "traceroute ipv6 WORD",
+       "Trace route to destination\n"
+       "IPv6 trace\n"
+       "Trace route to destination address or hostname\n")
+{
+	execute_command("traceroute6", 1, argv[2]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+#if defined(HAVE_SHELL_ACCESS)
+DEFUN (vtysh_telnet,
+       vtysh_telnet_cmd,
+       "telnet WORD",
+       "Open a telnet connection\n"
+       "IP address or hostname of a remote system\n")
+{
+	execute_command("telnet", 1, argv[1]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_telnet_port,
+       vtysh_telnet_port_cmd,
+       "telnet WORD PORT",
+       "Open a telnet connection\n"
+       "IP address or hostname of a remote system\n"
+       "TCP Port number\n")
+{
+	execute_command("telnet", 2, argv[1]->arg, argv[2]->arg);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_ssh,
+       vtysh_ssh_cmd,
+       "ssh WORD",
+       "Open an ssh connection\n"
+       "[user@]host\n")
+{
+	execute_command("ssh", 1, argv[1]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_start_shell,
+       vtysh_start_shell_cmd,
+       "start-shell",
+       "Start UNIX shell\n")
+{
+	execute_command("sh", 0, NULL, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_start_bash,
+       vtysh_start_bash_cmd,
+       "start-shell bash",
+       "Start UNIX shell\n"
+       "Start bash\n")
+{
+	execute_command("bash", 0, NULL, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (vtysh_start_zsh,
+       vtysh_start_zsh_cmd,
+       "start-shell zsh",
+       "Start UNIX shell\n"
+       "Start Z shell\n")
+{
+	execute_command("zsh", 0, NULL, NULL);
+	return CMD_SUCCESS;
+}
+#endif
+
+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 (vtysh_output_file,
+       vtysh_output_file_cmd,
+       "output file FILE",
+       "Direct vtysh output to file\n"
+       "Direct vtysh output to file\n"
+       "Path to dump output to\n")
+{
+	const char *path = argv[argc - 1]->arg;
+	vty->of = fopen(path, "a");
+	if (!vty->of) {
+		vty_out(vty, "Failed to open file '%s': %s\n", path,
+			safe_strerror(errno));
+		vty->of = stdout;
+	}
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_vtysh_output_file,
+       no_vtysh_output_file_cmd,
+       "no output file [FILE]",
+       NO_STR
+       "Direct vtysh output to file\n"
+       "Direct vtysh output to file\n"
+       "Path to dump output to\n")
+{
+	if (vty->of != stdout) {
+		fclose(vty->of);
+		vty->of = stdout;
+	}
+	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);
+}
+
+DEFUN_HIDDEN(show_cli_graph_vtysh,
+	     show_cli_graph_vtysh_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_graph_dump_dot(cn->cmdgraph);
+
+	vty_out(vty, "%s\n", dot);
+	XFREE(MTYPE_TMP, dot);
+	return CMD_SUCCESS;
+}
+
+static void vtysh_install_default(enum node_type node)
+{
+	_install_element(node, &config_list_cmd);
+	_install_element(node, &find_cmd);
+	_install_element(node, &show_cli_graph_vtysh_cmd);
+	_install_element(node, &vtysh_output_file_cmd);
+	_install_element(node, &no_vtysh_output_file_cmd);
+}
+
+/* Making connection to protocol daemon. */
+static int vtysh_connect(struct vtysh_client *vclient)
+{
+	int ret;
+	int sock, len;
+	struct sockaddr_un addr;
+	struct stat s_stat;
+	const char *path;
+
+	if (!vclient->path[0])
+		snprintf(vclient->path, sizeof(vclient->path), "%s/%s.vty",
+			 vtydir, vclient->name);
+	path = vclient->path;
+
+	/* Stat socket to see if we have permission to access it. */
+	ret = stat(path, &s_stat);
+	if (ret < 0 && errno != ENOENT) {
+		fprintf(stderr, "vtysh_connect(%s): stat = %s\n", path,
+			safe_strerror(errno));
+		exit(1);
+	}
+
+	if (ret >= 0) {
+		if (!S_ISSOCK(s_stat.st_mode)) {
+			fprintf(stderr, "vtysh_connect(%s): Not a socket\n",
+				path);
+			exit(1);
+		}
+	}
+
+	sock = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (sock < 0) {
+#ifdef DEBUG
+		fprintf(stderr, "vtysh_connect(%s): socket = %s\n", path,
+			safe_strerror(errno));
+#endif /* DEBUG */
+		return -1;
+	}
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	strlcpy(addr.sun_path, path, sizeof(addr.sun_path));
+#ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
+	len = addr.sun_len = SUN_LEN(&addr);
+#else
+	len = sizeof(addr.sun_family) + strlen(addr.sun_path);
+#endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
+
+	ret = connect(sock, (struct sockaddr *)&addr, len);
+	if (ret < 0) {
+#ifdef DEBUG
+		fprintf(stderr, "vtysh_connect(%s): connect = %s\n", path,
+			safe_strerror(errno));
+#endif /* DEBUG */
+		close(sock);
+		return -1;
+	}
+	vclient->fd = sock;
+
+	return 0;
+}
+
+static int vtysh_reconnect(struct vtysh_client *vclient)
+{
+	int ret;
+
+	fprintf(stderr, "Warning: connecting to %s...", vclient->name);
+	ret = vtysh_connect(vclient);
+	if (ret < 0) {
+		fprintf(stderr, "failed!\n");
+		return ret;
+	}
+	fprintf(stderr, "success!\n");
+	if (vtysh_client_execute(vclient, "enable") < 0)
+		return -1;
+	return vtysh_execute_no_pager("end");
+}
+
+/* Return true if str ends with suffix, else return false */
+static int ends_with(const char *str, const char *suffix)
+{
+	if (!str || !suffix)
+		return 0;
+	size_t lenstr = strlen(str);
+	size_t lensuffix = strlen(suffix);
+	if (lensuffix > lenstr)
+		return 0;
+	return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
+}
+
+static void vtysh_client_sorted_insert(struct vtysh_client *head_client,
+				       struct vtysh_client *client)
+{
+	struct vtysh_client *prev_node, *current_node;
+
+	prev_node = head_client;
+	current_node = head_client->next;
+	while (current_node) {
+		if (strcmp(current_node->path, client->path) > 0)
+			break;
+
+		prev_node = current_node;
+		current_node = current_node->next;
+	}
+	client->next = current_node;
+	prev_node->next = client;
+}
+
+#define MAXIMUM_INSTANCES 10
+
+static void vtysh_update_all_instances(struct vtysh_client *head_client)
+{
+	struct vtysh_client *client;
+	DIR *dir;
+	struct dirent *file;
+	int n = 0;
+
+	if (head_client->flag != VTYSH_OSPFD)
+		return;
+
+	/* ls vty_sock_dir and look for all files ending in .vty */
+	dir = opendir(vtydir);
+	if (dir) {
+		while ((file = readdir(dir)) != NULL) {
+			if (frrstr_startswith(file->d_name, "ospfd-")
+			    && ends_with(file->d_name, ".vty")) {
+				if (n == MAXIMUM_INSTANCES) {
+					fprintf(stderr,
+						"Parsing %s, client limit(%d) reached!\n",
+						vtydir, n);
+					break;
+				}
+				client = (struct vtysh_client *)malloc(
+					sizeof(struct vtysh_client));
+				client->fd = -1;
+				client->name = "ospfd";
+				client->flag = VTYSH_OSPFD;
+				snprintf(client->path, sizeof(client->path),
+					 "%s/%s", vtydir, file->d_name);
+				client->next = NULL;
+				vtysh_client_sorted_insert(head_client, client);
+				n++;
+			}
+		}
+		closedir(dir);
+	}
+}
+
+static int vtysh_connect_all_instances(struct vtysh_client *head_client)
+{
+	struct vtysh_client *client;
+	int rc = 0;
+
+	vtysh_update_all_instances(head_client);
+
+	client = head_client->next;
+	while (client) {
+		if (vtysh_connect(client) == 0)
+			rc++;
+		client = client->next;
+	}
+
+	return rc;
+}
+
+int vtysh_connect_all(const char *daemon_name)
+{
+	unsigned int i;
+	int rc = 0;
+	int matches = 0;
+
+	for (i = 0; i < array_size(vtysh_client); i++) {
+		if (!daemon_name
+		    || !strcmp(daemon_name, vtysh_client[i].name)) {
+			matches++;
+			if (vtysh_connect(&vtysh_client[i]) == 0)
+				rc++;
+
+			rc += vtysh_connect_all_instances(&vtysh_client[i]);
+		}
+	}
+	if (!matches)
+		fprintf(stderr, "Error: no daemons match name %s!\n",
+			daemon_name);
+	return rc;
+}
+
+/* To disable readline's filename completion. */
+static char *vtysh_completion_entry_function(const char *ignore,
+					     int invoking_key)
+{
+	return NULL;
+}
+
+void vtysh_readline_init(void)
+{
+	/* readline related settings. */
+	char *disable_bracketed_paste =
+		XSTRDUP(MTYPE_TMP, "set enable-bracketed-paste off");
+
+	rl_initialize();
+	rl_parse_and_bind(disable_bracketed_paste);
+	rl_bind_key('?', (rl_command_func_t *)vtysh_rl_describe);
+	rl_completion_entry_function = vtysh_completion_entry_function;
+	rl_attempted_completion_function = new_completion;
+
+	XFREE(MTYPE_TMP, disable_bracketed_paste);
+}
+
+char *vtysh_prompt(void)
+{
+	static char buf[512];
+
+	snprintf(buf, sizeof(buf), cmd_prompt(vty->node), cmd_hostname_get());
+	return buf;
+}
+
+static void vtysh_ac_line(void *arg, const char *line)
+{
+	vector comps = arg;
+	size_t i;
+	for (i = 0; i < vector_active(comps); i++)
+		if (!strcmp(line, (char *)vector_slot(comps, i)))
+			return;
+	vector_set(comps, XSTRDUP(MTYPE_COMPLETION, line));
+}
+
+static void vtysh_autocomplete(vector comps, struct cmd_token *token)
+{
+	char accmd[256];
+	size_t i;
+
+	snprintf(accmd, sizeof(accmd), "autocomplete %d %s %s", token->type,
+		 token->text, token->varname ? token->varname : "-");
+
+	vty->of_saved = vty->of;
+	vty->of = NULL;
+	for (i = 0; i < array_size(vtysh_client); i++)
+		vtysh_client_run_all(&vtysh_client[i], accmd, 1, vtysh_ac_line,
+				     comps);
+	vty->of = vty->of_saved;
+}
+
+static const struct cmd_variable_handler vtysh_var_handler[] = {
+	{/* match all */
+	 .tokenname = NULL,
+	 .varname = NULL,
+	 .completions = vtysh_autocomplete},
+	{.completions = NULL}};
+
+void vtysh_uninit(void)
+{
+	if (vty->of != stdout)
+		fclose(vty->of);
+}
+
+void vtysh_init_vty(void)
+{
+	struct stat st_out, st_err;
+
+	cmd_defer_tree(true);
+
+	for (size_t i = 0; i < array_size(vtysh_client); i++) {
+		vtysh_client[i].fd = -1;
+		vtysh_client[i].log_fd = -1;
+	}
+
+	stderr_tty = isatty(STDERR_FILENO);
+
+	if (fstat(STDOUT_FILENO, &st_out) || fstat(STDERR_FILENO, &st_err) ||
+	    (st_out.st_dev == st_err.st_dev && st_out.st_ino == st_err.st_ino))
+		stderr_stdout_same = true;
+
+	/* Make vty structure. */
+	vty = vty_new();
+	vty->type = VTY_SHELL;
+	vty->node = VIEW_NODE;
+
+	/* set default output */
+	vty->of = stdout;
+	vtysh_pager_envdef(false);
+
+	/* Initialize commands. */
+	cmd_init(0);
+	cmd_variable_handler_register(vtysh_var_handler);
+
+	/* bgpd */
+#ifdef HAVE_BGPD
+	install_node(&bgp_node);
+	install_element(CONFIG_NODE, &router_bgp_cmd);
+	install_element(BGP_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_NODE, &vtysh_end_all_cmd);
+
+	install_node(&bgp_vpnv4_node);
+	install_element(BGP_NODE, &address_family_ipv4_vpn_cmd);
+#ifdef KEEP_OLD_VPN_COMMANDS
+	install_element(BGP_NODE, &address_family_vpnv4_cmd);
+#endif /* KEEP_OLD_VPN_COMMANDS */
+	install_element(BGP_VPNV4_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_VPNV4_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_VPNV4_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_VPNV4_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_vpnv6_node);
+	install_element(BGP_NODE, &address_family_ipv6_vpn_cmd);
+#ifdef KEEP_OLD_VPN_COMMANDS
+	install_element(BGP_NODE, &address_family_vpnv6_cmd);
+#endif /* KEEP_OLD_VPN_COMMANDS */
+	install_element(BGP_VPNV6_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_VPNV6_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_VPNV6_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_VPNV6_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_flowspecv4_node);
+	install_element(BGP_NODE, &address_family_flowspecv4_cmd);
+	install_element(BGP_FLOWSPECV4_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_FLOWSPECV4_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_FLOWSPECV4_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_FLOWSPECV4_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_flowspecv6_node);
+	install_element(BGP_NODE, &address_family_flowspecv6_cmd);
+	install_element(BGP_FLOWSPECV6_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_FLOWSPECV6_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_FLOWSPECV6_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_FLOWSPECV6_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_ipv4_node);
+	install_element(BGP_NODE, &address_family_ipv4_cmd);
+	install_element(BGP_IPV4_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_IPV4_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_IPV4_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_IPV4_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_ipv4m_node);
+	install_element(BGP_NODE, &address_family_ipv4_multicast_cmd);
+	install_element(BGP_IPV4M_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_IPV4M_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_IPV4M_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_IPV4M_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_ipv4l_node);
+	install_element(BGP_NODE, &address_family_ipv4_labeled_unicast_cmd);
+	install_element(BGP_IPV4L_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_IPV4L_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_IPV4L_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_IPV4L_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_ipv6_node);
+	install_element(BGP_NODE, &address_family_ipv6_cmd);
+	install_element(BGP_IPV6_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_IPV6_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_IPV6_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_IPV6_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_ipv6m_node);
+	install_element(BGP_NODE, &address_family_ipv6_multicast_cmd);
+	install_element(BGP_IPV6M_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_IPV6M_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_IPV6M_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_IPV6M_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_ipv6l_node);
+	install_element(BGP_NODE, &address_family_ipv6_labeled_unicast_cmd);
+	install_element(BGP_IPV6L_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_IPV6L_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_IPV6L_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_IPV6L_NODE, &exit_address_family_cmd);
+
+#if defined(ENABLE_BGP_VNC)
+	install_node(&bgp_vrf_policy_node);
+	install_element(BGP_NODE, &vnc_vrf_policy_cmd);
+	install_element(BGP_VRF_POLICY_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_VRF_POLICY_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_VRF_POLICY_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_VRF_POLICY_NODE, &exit_vrf_policy_cmd);
+
+	install_node(&bgp_vnc_defaults_node);
+	install_element(BGP_NODE, &vnc_defaults_cmd);
+	install_element(BGP_VNC_DEFAULTS_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_VNC_DEFAULTS_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_VNC_DEFAULTS_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_VNC_DEFAULTS_NODE, &exit_vnc_config_cmd);
+
+	install_node(&bgp_vnc_nve_group_node);
+	install_element(BGP_NODE, &vnc_nve_group_cmd);
+	install_element(BGP_VNC_NVE_GROUP_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_VNC_NVE_GROUP_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_VNC_NVE_GROUP_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_VNC_NVE_GROUP_NODE, &exit_vnc_config_cmd);
+
+	install_node(&bgp_vnc_l2_group_node);
+	install_element(BGP_NODE, &vnc_l2_group_cmd);
+	install_element(BGP_VNC_L2_GROUP_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_VNC_L2_GROUP_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_VNC_L2_GROUP_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_VNC_L2_GROUP_NODE, &exit_vnc_config_cmd);
+#endif
+
+	install_node(&bgp_evpn_node);
+	install_element(BGP_NODE, &address_family_evpn_cmd);
+	install_element(BGP_EVPN_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_EVPN_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_EVPN_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_EVPN_NODE, &exit_address_family_cmd);
+
+	install_node(&bgp_evpn_vni_node);
+	install_element(BGP_EVPN_NODE, &bgp_evpn_vni_cmd);
+	install_element(BGP_EVPN_VNI_NODE, &vtysh_exit_bgpd_cmd);
+	install_element(BGP_EVPN_VNI_NODE, &vtysh_quit_bgpd_cmd);
+	install_element(BGP_EVPN_VNI_NODE, &vtysh_end_all_cmd);
+	install_element(BGP_EVPN_VNI_NODE, &exit_vni_cmd);
+
+	install_node(&rpki_node);
+	install_element(CONFIG_NODE, &rpki_cmd);
+	install_element(RPKI_NODE, &rpki_exit_cmd);
+	install_element(RPKI_NODE, &rpki_quit_cmd);
+	install_element(RPKI_NODE, &vtysh_end_all_cmd);
+
+	install_node(&bmp_node);
+	install_element(BGP_NODE, &bmp_targets_cmd);
+	install_element(BMP_NODE, &bmp_exit_cmd);
+	install_element(BMP_NODE, &bmp_quit_cmd);
+	install_element(BMP_NODE, &vtysh_end_all_cmd);
+
+	install_node(&bgp_srv6_node);
+	install_element(BGP_NODE, &bgp_srv6_cmd);
+	install_element(BGP_SRV6_NODE, &exit_bgp_srv6_cmd);
+	install_element(BGP_SRV6_NODE, &quit_bgp_srv6_cmd);
+	install_element(BGP_SRV6_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_BGPD */
+
+	/* ripd */
+	install_node(&rip_node);
+#ifdef HAVE_RIPD
+	install_element(CONFIG_NODE, &router_rip_cmd);
+	install_element(RIP_NODE, &vtysh_exit_ripd_cmd);
+	install_element(RIP_NODE, &vtysh_quit_ripd_cmd);
+	install_element(RIP_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_RIPD */
+
+	/* ripngd */
+	install_node(&ripng_node);
+#ifdef HAVE_RIPNGD
+	install_element(CONFIG_NODE, &router_ripng_cmd);
+	install_element(RIPNG_NODE, &vtysh_exit_ripngd_cmd);
+	install_element(RIPNG_NODE, &vtysh_quit_ripngd_cmd);
+	install_element(RIPNG_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_RIPNGD */
+
+	/* ospfd */
+#ifdef HAVE_OSPFD
+	install_node(&ospf_node);
+	install_element(CONFIG_NODE, &router_ospf_cmd);
+	install_element(OSPF_NODE, &vtysh_exit_ospfd_cmd);
+	install_element(OSPF_NODE, &vtysh_quit_ospfd_cmd);
+	install_element(OSPF_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_OSPFD */
+
+	/* ospf6d */
+#ifdef HAVE_OSPF6D
+	install_node(&ospf6_node);
+	install_element(CONFIG_NODE, &router_ospf6_cmd);
+	install_element(OSPF6_NODE, &vtysh_exit_ospf6d_cmd);
+	install_element(OSPF6_NODE, &vtysh_quit_ospf6d_cmd);
+	install_element(OSPF6_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_OSPF6D */
+
+	/* ldpd */
+#if defined(HAVE_LDPD)
+	install_node(&ldp_node);
+	install_element(CONFIG_NODE, &ldp_mpls_ldp_cmd);
+	install_element(LDP_NODE, &vtysh_exit_ldpd_cmd);
+	install_element(LDP_NODE, &vtysh_quit_ldpd_cmd);
+	install_element(LDP_NODE, &vtysh_end_all_cmd);
+
+	install_node(&ldp_ipv4_node);
+	install_element(LDP_NODE, &ldp_address_family_ipv4_cmd);
+	install_element(LDP_IPV4_NODE, &vtysh_exit_ldpd_cmd);
+	install_element(LDP_IPV4_NODE, &vtysh_quit_ldpd_cmd);
+	install_element(LDP_IPV4_NODE, &ldp_exit_address_family_cmd);
+	install_element(LDP_IPV4_NODE, &vtysh_end_all_cmd);
+
+	install_node(&ldp_ipv6_node);
+	install_element(LDP_NODE, &ldp_address_family_ipv6_cmd);
+	install_element(LDP_IPV6_NODE, &vtysh_exit_ldpd_cmd);
+	install_element(LDP_IPV6_NODE, &vtysh_quit_ldpd_cmd);
+	install_element(LDP_IPV6_NODE, &ldp_exit_address_family_cmd);
+	install_element(LDP_IPV6_NODE, &vtysh_end_all_cmd);
+
+	install_node(&ldp_ipv4_iface_node);
+	install_element(LDP_IPV4_NODE, &ldp_interface_ifname_cmd);
+	install_element(LDP_IPV4_IFACE_NODE, &vtysh_exit_ldpd_cmd);
+	install_element(LDP_IPV4_IFACE_NODE, &vtysh_quit_ldpd_cmd);
+	install_element(LDP_IPV4_IFACE_NODE, &vtysh_end_all_cmd);
+
+	install_node(&ldp_ipv6_iface_node);
+	install_element(LDP_IPV6_NODE, &ldp_interface_ifname_cmd);
+	install_element(LDP_IPV6_IFACE_NODE, &vtysh_exit_ldpd_cmd);
+	install_element(LDP_IPV6_IFACE_NODE, &vtysh_quit_ldpd_cmd);
+	install_element(LDP_IPV6_IFACE_NODE, &vtysh_end_all_cmd);
+
+	install_node(&ldp_l2vpn_node);
+	install_element(CONFIG_NODE, &ldp_l2vpn_word_type_vpls_cmd);
+	install_element(LDP_L2VPN_NODE, &vtysh_exit_ldpd_cmd);
+	install_element(LDP_L2VPN_NODE, &vtysh_quit_ldpd_cmd);
+	install_element(LDP_L2VPN_NODE, &vtysh_end_all_cmd);
+
+	install_node(&ldp_pseudowire_node);
+	install_element(LDP_L2VPN_NODE, &ldp_member_pseudowire_ifname_cmd);
+	install_element(LDP_PSEUDOWIRE_NODE, &vtysh_exit_ldpd_cmd);
+	install_element(LDP_PSEUDOWIRE_NODE, &vtysh_quit_ldpd_cmd);
+	install_element(LDP_PSEUDOWIRE_NODE, &vtysh_end_all_cmd);
+#endif
+
+	/* eigrpd */
+#ifdef HAVE_EIGRPD
+	install_node(&eigrp_node);
+	install_element(CONFIG_NODE, &router_eigrp_cmd);
+	install_element(EIGRP_NODE, &vtysh_exit_eigrpd_cmd);
+	install_element(EIGRP_NODE, &vtysh_quit_eigrpd_cmd);
+	install_element(EIGRP_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_EIGRPD */
+
+	/* babeld */
+#ifdef HAVE_BABELD
+	install_node(&babel_node);
+	install_element(CONFIG_NODE, &router_babel_cmd);
+	install_element(BABEL_NODE, &vtysh_exit_babeld_cmd);
+	install_element(BABEL_NODE, &vtysh_quit_babeld_cmd);
+	install_element(BABEL_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_BABELD */
+
+	/* isisd */
+#ifdef HAVE_ISISD
+	install_node(&isis_node);
+	install_element(CONFIG_NODE, &router_isis_cmd);
+	install_element(ISIS_NODE, &vtysh_exit_isisd_cmd);
+	install_element(ISIS_NODE, &vtysh_quit_isisd_cmd);
+	install_element(ISIS_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_ISISD */
+
+	/* fabricd */
+#ifdef HAVE_FABRICD
+	install_node(&openfabric_node);
+	install_element(CONFIG_NODE, &router_openfabric_cmd);
+	install_element(OPENFABRIC_NODE, &vtysh_exit_fabricd_cmd);
+	install_element(OPENFABRIC_NODE, &vtysh_quit_fabricd_cmd);
+	install_element(OPENFABRIC_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_FABRICD */
+
+	/* pbrd */
+#ifdef HAVE_PBRD
+	install_node(&pbr_map_node);
+	install_element(CONFIG_NODE, &vtysh_pbr_map_cmd);
+	install_element(CONFIG_NODE, &vtysh_no_pbr_map_cmd);
+	install_element(PBRMAP_NODE, &vtysh_exit_pbr_map_cmd);
+	install_element(PBRMAP_NODE, &vtysh_quit_pbr_map_cmd);
+	install_element(PBRMAP_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_PBRD */
+
+	/* bfdd */
+#if HAVE_BFDD > 0
+	install_node(&bfd_node);
+	install_element(CONFIG_NODE, &bfd_enter_cmd);
+	install_element(BFD_NODE, &vtysh_exit_bfdd_cmd);
+	install_element(BFD_NODE, &vtysh_quit_bfdd_cmd);
+	install_element(BFD_NODE, &vtysh_end_all_cmd);
+
+	install_node(&bfd_peer_node);
+	install_element(BFD_NODE, &bfd_peer_enter_cmd);
+	install_element(BFD_PEER_NODE, &vtysh_exit_bfdd_cmd);
+	install_element(BFD_PEER_NODE, &vtysh_quit_bfdd_cmd);
+	install_element(BFD_PEER_NODE, &vtysh_end_all_cmd);
+
+	install_node(&bfd_profile_node);
+	install_element(BFD_NODE, &bfd_profile_enter_cmd);
+	install_element(BFD_PROFILE_NODE, &vtysh_exit_bfdd_cmd);
+	install_element(BFD_PROFILE_NODE, &vtysh_quit_bfdd_cmd);
+	install_element(BFD_PROFILE_NODE, &vtysh_end_all_cmd);
+#endif /* HAVE_BFDD */
+
+	install_node(&segment_routing_node);
+	install_element(CONFIG_NODE, &segment_routing_cmd);
+	install_element(SEGMENT_ROUTING_NODE, &vtysh_exit_sr_cmd);
+	install_element(SEGMENT_ROUTING_NODE, &vtysh_quit_sr_cmd);
+	install_element(SEGMENT_ROUTING_NODE, &vtysh_end_all_cmd);
+
+#if defined(HAVE_PATHD)
+	install_node(&sr_traffic_eng_node);
+	install_node(&srte_segment_list_node);
+	install_node(&srte_policy_node);
+	install_node(&srte_candidate_dyn_node);
+
+	install_element(SR_TRAFFIC_ENG_NODE, &vtysh_exit_pathd_cmd);
+	install_element(SR_TRAFFIC_ENG_NODE, &vtysh_quit_pathd_cmd);
+	install_element(SR_SEGMENT_LIST_NODE, &vtysh_exit_pathd_cmd);
+	install_element(SR_SEGMENT_LIST_NODE, &vtysh_quit_pathd_cmd);
+	install_element(SR_POLICY_NODE, &vtysh_exit_pathd_cmd);
+	install_element(SR_POLICY_NODE, &vtysh_quit_pathd_cmd);
+	install_element(SR_CANDIDATE_DYN_NODE, &vtysh_exit_pathd_cmd);
+	install_element(SR_CANDIDATE_DYN_NODE, &vtysh_quit_pathd_cmd);
+
+
+	install_element(SR_TRAFFIC_ENG_NODE, &vtysh_end_all_cmd);
+	install_element(SR_SEGMENT_LIST_NODE, &vtysh_end_all_cmd);
+	install_element(SR_POLICY_NODE, &vtysh_end_all_cmd);
+	install_element(SR_CANDIDATE_DYN_NODE, &vtysh_end_all_cmd);
+
+	install_element(SEGMENT_ROUTING_NODE, &sr_traffic_eng_cmd);
+	install_element(SR_TRAFFIC_ENG_NODE, &srte_segment_list_cmd);
+	install_element(SR_TRAFFIC_ENG_NODE, &srte_policy_cmd);
+	install_element(SR_POLICY_NODE, &srte_policy_candidate_dyn_path_cmd);
+
+	install_node(&pcep_node);
+	install_node(&pcep_pcc_node);
+	install_node(&pcep_pce_node);
+	install_node(&pcep_pce_config_node);
+
+	install_element(PCEP_NODE, &vtysh_exit_pathd_cmd);
+	install_element(PCEP_NODE, &vtysh_quit_pathd_cmd);
+	install_element(PCEP_PCC_NODE, &vtysh_exit_pathd_cmd);
+	install_element(PCEP_PCC_NODE, &vtysh_quit_pathd_cmd);
+	install_element(PCEP_PCE_NODE, &vtysh_exit_pathd_cmd);
+	install_element(PCEP_PCE_NODE, &vtysh_quit_pathd_cmd);
+	install_element(PCEP_PCE_CONFIG_NODE, &vtysh_exit_pathd_cmd);
+	install_element(PCEP_PCE_CONFIG_NODE, &vtysh_quit_pathd_cmd);
+
+	install_element(PCEP_NODE, &vtysh_end_all_cmd);
+	install_element(PCEP_PCC_NODE, &vtysh_end_all_cmd);
+	install_element(PCEP_PCE_NODE, &vtysh_end_all_cmd);
+	install_element(PCEP_PCE_CONFIG_NODE, &vtysh_end_all_cmd);
+
+	install_element(SR_TRAFFIC_ENG_NODE, &pcep_cmd);
+	install_element(PCEP_NODE, &pcep_cli_pcc_cmd);
+	install_element(PCEP_NODE, &pcep_cli_pcep_pce_config_cmd);
+	install_element(PCEP_NODE, &pcep_cli_pce_cmd);
+
+#endif /* HAVE_PATHD */
+
+	/* keychain */
+	install_node(&keychain_node);
+	install_element(CONFIG_NODE, &key_chain_cmd);
+	install_element(KEYCHAIN_NODE, &key_chain_cmd);
+	install_element(KEYCHAIN_NODE, &vtysh_exit_keys_cmd);
+	install_element(KEYCHAIN_NODE, &vtysh_quit_keys_cmd);
+	install_element(KEYCHAIN_NODE, &vtysh_end_all_cmd);
+
+	install_node(&keychain_key_node);
+	install_element(KEYCHAIN_NODE, &key_cmd);
+	install_element(KEYCHAIN_KEY_NODE, &key_chain_cmd);
+	install_element(KEYCHAIN_KEY_NODE, &vtysh_exit_keys_cmd);
+	install_element(KEYCHAIN_KEY_NODE, &vtysh_quit_keys_cmd);
+	install_element(KEYCHAIN_KEY_NODE, &vtysh_end_all_cmd);
+
+	/* nexthop-group */
+	install_node(&nh_group_node);
+	install_element(CONFIG_NODE, &vtysh_nexthop_group_cmd);
+	install_element(CONFIG_NODE, &vtysh_no_nexthop_group_cmd);
+	install_element(NH_GROUP_NODE, &vtysh_end_all_cmd);
+	install_element(NH_GROUP_NODE, &vtysh_exit_nexthop_group_cmd);
+	install_element(NH_GROUP_NODE, &vtysh_quit_nexthop_group_cmd);
+
+	/* zebra and all */
+	install_node(&zebra_node);
+
+	install_node(&interface_node);
+	install_element(CONFIG_NODE, &vtysh_interface_cmd);
+	install_element(INTERFACE_NODE, &vtysh_end_all_cmd);
+	install_element(INTERFACE_NODE, &vtysh_exit_interface_cmd);
+	install_element(INTERFACE_NODE, &vtysh_quit_interface_cmd);
+
+	install_node(&link_params_node);
+	install_element(INTERFACE_NODE, &vtysh_link_params_cmd);
+	install_element(LINK_PARAMS_NODE, &exit_link_params_cmd);
+	install_element(LINK_PARAMS_NODE, &vtysh_end_all_cmd);
+	install_element(LINK_PARAMS_NODE, &vtysh_exit_link_params_cmd);
+	install_element(LINK_PARAMS_NODE, &vtysh_quit_link_params_cmd);
+
+	install_node(&pw_node);
+	install_element(CONFIG_NODE, &vtysh_pseudowire_cmd);
+	install_element(PW_NODE, &vtysh_end_all_cmd);
+	install_element(PW_NODE, &vtysh_exit_pseudowire_cmd);
+	install_element(PW_NODE, &vtysh_quit_pseudowire_cmd);
+
+	install_node(&vrf_node);
+	install_element(CONFIG_NODE, &vtysh_vrf_cmd);
+	install_element(VRF_NODE, &exit_vrf_config_cmd);
+	install_element(VRF_NODE, &vtysh_end_all_cmd);
+	install_element(VRF_NODE, &vtysh_exit_vrf_cmd);
+	install_element(VRF_NODE, &vtysh_quit_vrf_cmd);
+
+	install_node(&rmap_node);
+	install_element(CONFIG_NODE, &vtysh_route_map_cmd);
+	install_element(RMAP_NODE, &vtysh_exit_rmap_cmd);
+	install_element(RMAP_NODE, &vtysh_quit_rmap_cmd);
+	install_element(RMAP_NODE, &vtysh_end_all_cmd);
+
+	install_node(&vty_node);
+	install_element(CONFIG_NODE, &vtysh_line_vty_cmd);
+	install_element(VTY_NODE, &vtysh_exit_line_vty_cmd);
+	install_element(VTY_NODE, &vtysh_quit_line_vty_cmd);
+	install_element(VTY_NODE, &vtysh_end_all_cmd);
+
+
+	struct cmd_node *node;
+	for (unsigned int i = 0; i < vector_active(cmdvec); i++) {
+		node = vector_slot(cmdvec, i);
+		if (!node || node->node == VIEW_NODE)
+			continue;
+		vtysh_install_default(node->node);
+	}
+
+	/* vtysh */
+
+	if (!user_mode)
+		install_element(VIEW_NODE, &vtysh_enable_cmd);
+	install_element(ENABLE_NODE, &vtysh_config_terminal_cmd);
+	install_element(ENABLE_NODE, &vtysh_disable_cmd);
+
+	/* "exit" command. */
+	install_element(VIEW_NODE, &vtysh_exit_all_cmd);
+	install_element(CONFIG_NODE, &vtysh_exit_all_cmd);
+	install_element(VIEW_NODE, &vtysh_quit_all_cmd);
+	install_element(CONFIG_NODE, &vtysh_quit_all_cmd);
+
+	/* "end" command. */
+	install_element(CONFIG_NODE, &vtysh_end_all_cmd);
+	install_element(ENABLE_NODE, &vtysh_end_all_cmd);
+
+	/* SRv6 Data-plane */
+	install_node(&srv6_node);
+	install_element(SEGMENT_ROUTING_NODE, &srv6_cmd);
+	install_element(SRV6_NODE, &srv6_locators_cmd);
+	install_element(SRV6_NODE, &exit_srv6_config_cmd);
+	install_element(SRV6_NODE, &vtysh_end_all_cmd);
+
+	install_node(&srv6_locs_node);
+	install_element(SRV6_LOCS_NODE, &srv6_locator_cmd);
+	install_element(SRV6_LOCS_NODE, &exit_srv6_locs_config_cmd);
+	install_element(SRV6_LOCS_NODE, &vtysh_end_all_cmd);
+
+	install_node(&srv6_loc_node);
+	install_element(SRV6_LOC_NODE, &exit_srv6_loc_config_cmd);
+	install_element(SRV6_LOC_NODE, &vtysh_end_all_cmd);
+
+	install_element(ENABLE_NODE, &vtysh_show_running_config_cmd);
+	install_element(ENABLE_NODE, &vtysh_copy_running_config_cmd);
+	install_element(ENABLE_NODE, &vtysh_copy_to_running_cmd);
+
+	/* "write terminal" command. */
+	install_element(ENABLE_NODE, &vtysh_write_terminal_cmd);
+
+	install_element(CONFIG_NODE, &vtysh_integrated_config_cmd);
+	install_element(CONFIG_NODE, &no_vtysh_integrated_config_cmd);
+
+	/* "write memory" command. */
+	install_element(ENABLE_NODE, &vtysh_write_memory_cmd);
+
+	install_element(CONFIG_NODE, &vtysh_terminal_paginate_cmd);
+	install_element(VIEW_NODE, &vtysh_terminal_paginate_cmd);
+	install_element(VIEW_NODE, &vtysh_terminal_length_cmd);
+	install_element(VIEW_NODE, &vtysh_terminal_no_length_cmd);
+	install_element(VIEW_NODE, &vtysh_show_daemons_cmd);
+
+	install_element(VIEW_NODE, &vtysh_terminal_monitor_cmd);
+	install_element(VIEW_NODE, &no_vtysh_terminal_monitor_cmd);
+
+	install_element(VIEW_NODE, &vtysh_ping_cmd);
+	install_element(VIEW_NODE, &vtysh_ping_ip_cmd);
+	install_element(VIEW_NODE, &vtysh_traceroute_cmd);
+	install_element(VIEW_NODE, &vtysh_traceroute_ip_cmd);
+	install_element(VIEW_NODE, &vtysh_mtrace_cmd);
+	install_element(VIEW_NODE, &vtysh_ping6_cmd);
+	install_element(VIEW_NODE, &vtysh_traceroute6_cmd);
+#if defined(HAVE_SHELL_ACCESS)
+	install_element(VIEW_NODE, &vtysh_telnet_cmd);
+	install_element(VIEW_NODE, &vtysh_telnet_port_cmd);
+	install_element(VIEW_NODE, &vtysh_ssh_cmd);
+#endif
+#if defined(HAVE_SHELL_ACCESS)
+	install_element(ENABLE_NODE, &vtysh_start_shell_cmd);
+	install_element(ENABLE_NODE, &vtysh_start_bash_cmd);
+	install_element(ENABLE_NODE, &vtysh_start_zsh_cmd);
+#endif
+
+	/* debugging */
+	install_element(VIEW_NODE, &vtysh_show_error_code_cmd);
+	install_element(ENABLE_NODE, &vtysh_show_debugging_cmd);
+	install_element(ENABLE_NODE, &vtysh_show_debugging_hashtable_cmd);
+	install_element(ENABLE_NODE, &vtysh_debug_all_cmd);
+	install_element(CONFIG_NODE, &vtysh_debug_all_cmd);
+	install_element(ENABLE_NODE, &vtysh_debug_memstats_cmd);
+	install_element(CONFIG_NODE, &vtysh_debug_memstats_cmd);
+	install_element(ENABLE_NODE, &vtysh_debug_uid_backtrace_cmd);
+	install_element(CONFIG_NODE, &vtysh_debug_uid_backtrace_cmd);
+
+	/* northbound */
+	install_element(ENABLE_NODE, &show_config_running_cmd);
+	install_element(ENABLE_NODE, &show_yang_operational_data_cmd);
+	install_element(ENABLE_NODE, &show_yang_module_cmd);
+	install_element(ENABLE_NODE, &show_yang_module_detail_cmd);
+	install_element(ENABLE_NODE, &debug_nb_cmd);
+	install_element(CONFIG_NODE, &debug_nb_cmd);
+
+	/* misc lib show commands */
+	install_element(VIEW_NODE, &vtysh_show_history_cmd);
+	install_element(VIEW_NODE, &vtysh_show_memory_cmd);
+	install_element(VIEW_NODE, &vtysh_show_modules_cmd);
+	install_element(VIEW_NODE, &vtysh_show_work_queues_cmd);
+	install_element(VIEW_NODE, &vtysh_show_work_queues_daemon_cmd);
+	install_element(VIEW_NODE, &vtysh_show_thread_cmd);
+	install_element(VIEW_NODE, &vtysh_show_poll_cmd);
+	install_element(VIEW_NODE, &vtysh_show_thread_timer_cmd);
+
+	/* Logging */
+	install_element(VIEW_NODE, &vtysh_show_logging_cmd);
+
+	install_element(CONFIG_NODE, &vtysh_service_password_encrypt_cmd);
+	install_element(CONFIG_NODE, &no_vtysh_service_password_encrypt_cmd);
+
+	install_element(CONFIG_NODE, &vtysh_allow_reserved_ranges_cmd);
+	install_element(CONFIG_NODE, &no_vtysh_allow_reserved_ranges_cmd);
+
+	install_element(CONFIG_NODE, &vtysh_password_cmd);
+	install_element(CONFIG_NODE, &no_vtysh_password_cmd);
+	install_element(CONFIG_NODE, &vtysh_enable_password_cmd);
+	install_element(CONFIG_NODE, &no_vtysh_enable_password_cmd);
+}