Adding upstream version 8.4.4.upstream/8.4.4upstream

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

11 files changed, 7168 insertions, 0 deletions

diff --git a/vtysh/.gitignore b/vtysh/.gitignore
new file mode 100644
index 0000000..118b844
--- /dev/null
+++ b/vtysh/.gitignore
@@ -0,0 +1,4 @@
+vtysh
+vtysh_cmd.c
+extract.pl
+vtysh_daemons.h
diff --git a/vtysh/Makefile b/vtysh/Makefile
new file mode 100644
index 0000000..07e093b
--- /dev/null
+++ b/vtysh/Makefile
@@ -0,0 +1,10 @@
+all: ALWAYS
+	@$(MAKE) -s -C .. vtysh/vtysh
+%: ALWAYS
+	@$(MAKE) -s -C .. vtysh/$@
+
+Makefile:
+	#nothing
+ALWAYS:
+.PHONY: ALWAYS makefiles
+.SUFFIXES:
diff --git a/vtysh/daemons.pl b/vtysh/daemons.pl
new file mode 100755
index 0000000..fc95173
--- /dev/null
+++ b/vtysh/daemons.pl
@@ -0,0 +1,36 @@
+#!/usr/bin/perl
+##
+## generate daemons list and help strings
+##
+## Copyright (C) 2020 NFWare Inc.
+##
+## This file is part of FRR.
+##
+## FRR 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.
+##
+## FRR 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 FRR; see the file COPYING; if not, write to the Free
+## Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+## 02110-1301, USA.
+##
+
+use strict;
+
+my @daemons_list = ();
+my @daemons_str = ();
+
+foreach (@ARGV) {
+	push (@daemons_list, $_);
+	push (@daemons_str, "For the $_ daemon\\n");
+}
+
+print "#define DAEMONS_LIST \"<" . join('|', @daemons_list) . ">\"\n";
+print "#define DAEMONS_STR \"" . join('', @daemons_str) . "\"\n";
diff --git a/vtysh/extract.pl.in b/vtysh/extract.pl.in
new file mode 100755
index 0000000..228a136
--- /dev/null
+++ b/vtysh/extract.pl.in
@@ -0,0 +1,282 @@
+#! @PERL@
+##
+## @configure_input@
+##
+## Virtual terminal interface shell command extractor.
+## 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 GNU Zebra; see the file COPYING.  If not, write to the Free
+## Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+## 02111-1307, USA.  
+##
+
+use Getopt::Long;
+
+print <<EOF;
+#include <zebra.h>
+
+#include "command.h"
+#include "linklist.h"
+
+#include "vtysh/vtysh.h"
+
+EOF
+
+my $cli_stomp = 0;
+
+sub scan_file {
+    my ( $file, $fabricd) = @_;
+
+    $cppadd = $fabricd ? "-DFABRICD=1" : "";
+
+    $command_line = "@CPP@ -P -std=gnu11 -DHAVE_CONFIG_H -DVTYSH_EXTRACT_PL -Ivtysh/@top_builddir@ -Ivtysh/@top_srcdir@ -Ivtysh/@top_srcdir@/lib -Ivtysh/@top_builddir@/lib -Ivtysh/@top_srcdir@/bgpd -Ivtysh/@top_srcdir@/bgpd/rfapi @LUA_INCLUDE@ @CPPFLAGS@ @LIBYANG_CFLAGS@ $cppadd $file |";
+    open (FH, $command_line)
+	|| die "Open to the pipeline failed: $!\n\nCommand Issued:\n$command_line";
+    local $/; undef $/;
+    $line = <FH>;
+    if (!close (FH)) {
+	die "File: $file failed to compile:\n$!\nwhen extracting cli from it please inspect\n"
+    }
+
+    # ?: makes a group non-capturing
+    @defun = ($line =~ /((?:DEFUN|DEFUN_HIDDEN|DEFUN_YANG|ALIAS|ALIAS_HIDDEN|ALIAS_YANG|DEFPY|DEFPY_HIDDEN|DEFPY_YANG)\s*\(.+?\));?\s?\s?\n/sg);
+    @install = ($line =~ /install_element\s*\(\s*[0-9A-Z_]+,\s*&[^;]*;\s*\n/sg);
+
+    # DEFUN process
+    foreach (@defun) {
+        # $_ will contain the entire string including the DEFUN, ALIAS, etc.
+        # We need to extract the DEFUN/ALIAS from everything in ()s.
+        # The /s at the end tells the regex to allow . to match newlines.
+        $_ =~ /^(.*?)\s*\((.*)\)$/s;
+
+        my (@defun_array);
+        $defun_or_alias = $1;
+        @defun_array = split (/,/, $2);
+
+        if ($defun_or_alias =~ /_HIDDEN/) {
+            $hidden = 1;
+        } else {
+            $hidden = 0;
+        }
+
+        $defun_array[0] = '';
+
+        # Actual input command string.
+        $str = "$defun_array[2]";
+        $str =~ s/^\s+//g;
+        $str =~ s/\s+$//g;
+
+        # Get VTY command structure.  This is needed for searching
+        # install_element() command.
+        $cmd = "$defun_array[1]";
+        $cmd =~ s/^\s+//g;
+        $cmd =~ s/\s+$//g;
+
+        if ($fabricd) {
+            $cmd = "fabricd_" . $cmd;
+        }
+
+        # $protocol is VTYSH_PROTO format for redirection of user input
+        if ($file =~ /lib\/keychain\.c$/) {
+            $protocol = "VTYSH_RIPD|VTYSH_EIGRPD|VTYSH_OSPF6D";
+        }
+        elsif ($file =~ /lib\/routemap\.c$/ || $file =~ /lib\/routemap_cli\.c$/) {
+            $protocol = "VTYSH_RMAP";
+        }
+        elsif ($file =~ /lib\/vrf\.c$/) {
+            $protocol = "VTYSH_VRF";
+        }
+        elsif ($file =~ /lib\/if\.c$/) {
+            $protocol = "VTYSH_INTERFACE";
+        }
+        elsif ($file =~ /lib\/(filter|filter_cli)\.c$/) {
+            $protocol = "VTYSH_ACL";
+        }
+        elsif ($file =~ /lib\/(lib|log)_vty\.c$/) {
+            $protocol = "VTYSH_ALL";
+        }
+	elsif ($file =~ /lib\/agentx\.c$/) {
+	    $protocol = "VTYSH_ISISD|VTYSH_RIPD|VTYSH_OSPFD|VTYSH_OSPF6D|VTYSH_BGPD|VTYSH_ZEBRA";
+	}
+	elsif ($file =~ /lib\/nexthop_group\.c$/) {
+	    $protocol = "VTYSH_NH_GROUP";
+	}
+        elsif ($file =~ /lib\/plist\.c$/) {
+            if ($defun_array[1] =~ m/ipv6/) {
+                $protocol = "VTYSH_RIPNGD|VTYSH_OSPF6D|VTYSH_BGPD|VTYSH_ZEBRA|VTYSH_PIM6D|VTYSH_BABELD|VTYSH_ISISD|VTYSH_FABRICD";
+            } else {
+                $protocol = "VTYSH_RIPD|VTYSH_OSPFD|VTYSH_BGPD|VTYSH_ZEBRA|VTYSH_PIMD|VTYSH_EIGRPD|VTYSH_BABELD|VTYSH_ISISD|VTYSH_FABRICD";
+            }
+        }
+        elsif ($file =~ /lib\/if_rmap\.c$/) {
+            if ($defun_array[1] =~ m/ipv6/) {
+                $protocol = "VTYSH_RIPNGD";
+            } else {
+                $protocol = "VTYSH_RIPD";
+            }
+        }
+	elsif ($file =~ /lib\/resolver\.c$/) {
+	    $protocol = "VTYSH_NHRPD|VTYSH_BGPD";
+	}
+	elsif ($file =~ /lib\/spf_backoff\.c$/) {
+	    $protocol = "VTYSH_ISISD";
+	}
+        elsif ($file =~ /lib\/(vty|thread)\.c$/) {
+           $protocol = "VTYSH_ALL";
+        }
+        elsif ($file =~ /librfp\/.*\.c$/ || $file =~ /rfapi\/.*\.c$/) {
+           $protocol = "VTYSH_BGPD";
+        }
+        elsif ($fabricd) {
+           $protocol = "VTYSH_FABRICD";
+        }
+        elsif ($file =~ /pimd\/pim6_.*\.c$/) {
+           $protocol = "VTYSH_PIM6D";
+        }
+        else {
+           ($protocol) = ($file =~ /^(?:.*\/)?([a-z0-9]+)\/[a-zA-Z0-9_\-]+\.c$/);
+           $protocol = "VTYSH_" . uc $protocol;
+        }
+
+        # Append _vtysh to structure then build DEFUN again
+        $defun_array[1] = $cmd . "_vtysh";
+        $defun_body = join (", ", @defun_array);
+
+	# $cmd -> $str hash for lookup
+	if (exists($cmd2str{$cmd})) {
+	    warn "Duplicate CLI Function: $cmd\n";
+	    warn "\tFrom cli: $cmd2str{$cmd} to New cli: $str\n";
+	    warn "\tOriginal Protocol: $cmd2proto{$cmd} to New Protocol: $protocol\n";
+	    $cli_stomp++;
+	}
+        $cmd2str{$cmd} = $str;
+        $cmd2defun{$cmd} = $defun_body;
+        $cmd2proto{$cmd} = $protocol;
+        $cmd2hidden{$cmd} = $hidden;
+    }
+
+    # install_element() process
+    foreach (@install) {
+        my (@element_array);
+        @element_array = split (/,/);
+
+        # Install node
+        $enode = $element_array[0];
+        $enode =~ s/^\s+//g;
+        $enode =~ s/\s+$//g;
+        ($enode) = ($enode =~ /([0-9A-Z_]+)$/);
+
+        # VTY command structure.
+        ($ecmd) = ($element_array[1] =~ /&([^\)]+)/);
+        $ecmd =~ s/^\s+//g;
+        $ecmd =~ s/\s+$//g;
+
+        if ($fabricd) {
+            $ecmd = "fabricd_" . $ecmd;
+        }
+
+        # Register $ecmd
+        if (defined ($cmd2str{$ecmd})) {
+            my ($key);
+            $key = $enode . "," . $cmd2str{$ecmd};
+            $ocmd{$key} = $ecmd;
+            $odefun{$key} = $cmd2defun{$ecmd};
+
+            if ($cmd2hidden{$ecmd}) {
+                $defsh{$key} = "DEFSH_HIDDEN"
+            } else {
+                $defsh{$key} = "DEFSH"
+            }
+            push (@{$oproto{$key}}, $cmd2proto{$ecmd});
+        }
+    }
+}
+
+my $have_isisd = 0;
+my $have_fabricd = 0;
+
+GetOptions('have-isisd' => \$have_isisd, 'have-fabricd' => \$have_fabricd);
+
+foreach (@ARGV) {
+    if (/(^|\/)isisd\//) {
+        # We scan all the IS-IS files twice, once for isisd,
+        # once for fabricd. Exceptions are made for the files
+        # that are not shared between the two.
+        if (/isis_vty_isisd.c/) {
+            if ( $have_isisd ) {
+                scan_file($_, 0);
+            }
+        } elsif (/isis_vty_fabricd.c/) {
+            if ( $have_fabricd ) {
+                scan_file($_, 1);
+            }
+        } else {
+            if ( $have_isisd ) {
+                scan_file($_, 0);
+            }
+            if ( $have_fabricd ) {
+                scan_file($_, 1);
+            }
+        }
+    } else {
+        scan_file($_, 0);
+    }
+}
+
+# When we have cli commands that map to the same function name, we
+# can introduce subtle bugs due to code not being called when
+# we think it is.
+#
+# If extract.pl fails with a error message and you've been
+# modifying the cli, then go back and fix your code to
+# not have cli command function collisions.
+# please fix your code before submittal
+if ($cli_stomp) {
+    warn "There are $cli_stomp command line stomps\n";
+}
+
+# Check finaly alive $cmd;
+foreach (keys %odefun) {
+    my ($node, $str) = (split (/,/));
+    my ($cmd) = $ocmd{$_};
+    $live{$cmd} = $_;
+}
+
+# Output DEFSH
+foreach (sort keys %live) {
+    my ($proto);
+    my ($key);
+    $key = $live{$_};
+    $proto = join ("|", @{$oproto{$key}});
+    printf "$defsh{$key} ($proto$odefun{$key})\n\n";
+}
+
+# Output install_element
+print <<EOF;
+void vtysh_init_cmd(void)
+{
+EOF
+
+foreach (sort keys %odefun) {
+    my ($node, $str) = (split (/,/));
+    $cmd = $ocmd{$_};
+    $cmd =~ s/_cmd$/_cmd_vtysh/;
+    printf "  install_element ($node, &$cmd);\n";
+}
+
+print <<EOF
+}
+EOF
diff --git a/vtysh/subdir.am b/vtysh/subdir.am
new file mode 100644
index 0000000..6243616
--- /dev/null
+++ b/vtysh/subdir.am
@@ -0,0 +1,61 @@
+#
+# vtysh
+#
+
+if VTYSH
+bin_PROGRAMS += vtysh/vtysh
+man1 += $(MANBUILD)/vtysh.1
+endif
+
+clippy_scan += \
+	vtysh/vtysh.c \
+	# end
+
+vtysh_vtysh_SOURCES = \
+	vtysh/vtysh_main.c \
+	vtysh/vtysh.c \
+	vtysh/vtysh_user.c \
+	vtysh/vtysh_config.c \
+	# end
+nodist_vtysh_vtysh_SOURCES = \
+	vtysh/vtysh_cmd.c \
+	# end
+CLEANFILES += vtysh/vtysh_cmd.c
+
+noinst_HEADERS += \
+	vtysh/vtysh.h \
+	vtysh/vtysh_user.h \
+	# end
+
+vtysh_vtysh_LDADD = lib/libfrr.la $(LIBCAP) $(LIBREADLINE) $(LIBS) $(LIBPAM)
+
+EXTRA_DIST += vtysh/daemons.pl
+
+BUILT_SOURCES += vtysh/vtysh_daemons.h
+
+# force vtysh_daemons.h
+$(vtysh_vtysh_OBJECTS): vtysh/vtysh_daemons.h
+
+CLEANFILES += vtysh/vtysh_daemons.h
+vtysh/vtysh_daemons.h:
+	$(PERL) $(top_srcdir)/vtysh/daemons.pl $(vtysh_daemons) > vtysh/vtysh_daemons.h
+
+AM_V_EXTRACT = $(am__v_EXTRACT_$(V))
+am__v_EXTRACT_ = $(am__v_EXTRACT_$(AM_DEFAULT_VERBOSITY))
+am__v_EXTRACT_0 = @echo "  EXTRACT " $@;
+am__v_EXTRACT_1 =
+
+if ISISD
+HAVE_ISISD = --have-isisd
+else
+HAVE_ISISD =
+endif
+
+if FABRICD
+HAVE_FABRICD = --have-fabricd
+else
+HAVE_FABRICD =
+endif
+
+vtysh/vtysh_cmd.c: vtysh/extract.pl $(vtysh_scan)
+	$(AM_V_EXTRACT) $^ $(HAVE_ISISD) $(HAVE_FABRICD) > vtysh/vtysh_cmd.c
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);
+}
diff --git a/vtysh/vtysh.h b/vtysh/vtysh.h
new file mode 100644
index 0000000..1de4ab0
--- /dev/null
+++ b/vtysh/vtysh.h
@@ -0,0 +1,130 @@
+/* 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
+ */
+
+#ifndef VTYSH_H
+#define VTYSH_H
+
+#include "memory.h"
+DECLARE_MGROUP(MVTYSH);
+
+struct thread_master;
+
+extern struct thread_master *master;
+
+#define VTYSH_ZEBRA     0x00001
+#define VTYSH_RIPD      0x00002
+#define VTYSH_RIPNGD    0x00004
+#define VTYSH_OSPFD     0x00008
+#define VTYSH_OSPF6D    0x00010
+#define VTYSH_BGPD      0x00020
+#define VTYSH_ISISD     0x00040
+#define VTYSH_PIMD      0x00080
+#define VTYSH_LDPD      0x00100
+#define VTYSH_WATCHFRR  0x00200
+#define VTYSH_NHRPD     0x00400
+#define VTYSH_EIGRPD    0x00800
+#define VTYSH_BABELD    0x01000
+#define VTYSH_SHARPD    0x02000
+#define VTYSH_PBRD      0x04000
+#define VTYSH_STATICD   0x08000
+#define VTYSH_BFDD      0x10000
+#define VTYSH_FABRICD   0x20000
+#define VTYSH_VRRPD     0x40000
+#define VTYSH_PATHD     0x80000
+#define VTYSH_PIM6D     0x100000
+
+#define VTYSH_WAS_ACTIVE (-2)
+
+/* commands in REALLYALL are crucial to correct vtysh operation */
+#define VTYSH_REALLYALL	  ~0U
+/* watchfrr is not in ALL since library CLI functions should not be
+ * run on it (logging & co. should stay in a fixed/frozen config, and
+ * things like prefix lists are not even initialised) */
+#define VTYSH_ALL        VTYSH_ZEBRA|VTYSH_RIPD|VTYSH_RIPNGD|VTYSH_OSPFD|VTYSH_OSPF6D|VTYSH_LDPD|VTYSH_BGPD|VTYSH_ISISD|VTYSH_PIMD|VTYSH_PIM6D|VTYSH_NHRPD|VTYSH_EIGRPD|VTYSH_BABELD|VTYSH_SHARPD|VTYSH_PBRD|VTYSH_STATICD|VTYSH_BFDD|VTYSH_FABRICD|VTYSH_VRRPD|VTYSH_PATHD
+#define VTYSH_ACL         VTYSH_BFDD|VTYSH_BABELD|VTYSH_BGPD|VTYSH_EIGRPD|VTYSH_ISISD|VTYSH_FABRICD|VTYSH_LDPD|VTYSH_NHRPD|VTYSH_OSPF6D|VTYSH_OSPFD|VTYSH_PBRD|VTYSH_PIMD|VTYSH_PIM6D|VTYSH_RIPD|VTYSH_RIPNGD|VTYSH_VRRPD|VTYSH_ZEBRA
+#define VTYSH_RMAP       VTYSH_ZEBRA|VTYSH_RIPD|VTYSH_RIPNGD|VTYSH_OSPFD|VTYSH_OSPF6D|VTYSH_BGPD|VTYSH_ISISD|VTYSH_PIMD|VTYSH_EIGRPD|VTYSH_FABRICD
+#define VTYSH_INTERFACE_SUBSET                                                 \
+	VTYSH_ZEBRA | VTYSH_RIPD | VTYSH_RIPNGD | VTYSH_OSPFD | VTYSH_OSPF6D | \
+		VTYSH_ISISD | VTYSH_PIMD | VTYSH_PIM6D | VTYSH_NHRPD |         \
+		VTYSH_EIGRPD | VTYSH_BABELD | VTYSH_PBRD | VTYSH_FABRICD |     \
+		VTYSH_VRRPD
+#define VTYSH_INTERFACE VTYSH_INTERFACE_SUBSET | VTYSH_BGPD
+#define VTYSH_VRF VTYSH_INTERFACE_SUBSET | VTYSH_STATICD
+#define VTYSH_KEYS VTYSH_RIPD | VTYSH_EIGRPD | VTYSH_OSPF6D
+/* Daemons who can process nexthop-group configs */
+#define VTYSH_NH_GROUP    VTYSH_PBRD|VTYSH_SHARPD
+#define VTYSH_SR          VTYSH_ZEBRA|VTYSH_PATHD
+#define VTYSH_DPDK VTYSH_ZEBRA
+
+enum vtysh_write_integrated {
+	WRITE_INTEGRATED_UNSPECIFIED,
+	WRITE_INTEGRATED_NO,
+	WRITE_INTEGRATED_YES
+};
+
+extern enum vtysh_write_integrated vtysh_write_integrated;
+
+extern char frr_config[];
+extern char vtydir[];
+extern bool vtysh_loop_exited;
+
+void vtysh_init_vty(void);
+void vtysh_uninit(void);
+void vtysh_init_cmd(void);
+extern int vtysh_connect_all(const char *optional_daemon_name);
+void vtysh_readline_init(void);
+void vtysh_user_init(void);
+
+int vtysh_execute(const char *);
+int vtysh_execute_no_pager(const char *);
+int vtysh_execute_command_questionmark(char *input);
+
+char *vtysh_prompt(void);
+
+void vtysh_config_write(void);
+
+int vtysh_config_from_file(struct vty *, FILE *);
+
+void config_add_line(struct list *, const char *);
+
+int vtysh_mark_file(const char *filename);
+
+int vtysh_read_config(const char *filename, bool dry_run);
+int vtysh_write_config_integrated(void);
+
+void vtysh_config_parse_line(void *, const char *);
+
+void vtysh_config_dump(void);
+
+void vtysh_config_init(void);
+
+void suid_on(void);
+void suid_off(void);
+
+/* Child process execution flag. */
+extern int execute_flag;
+
+extern struct vty *vty;
+
+extern int user_mode;
+
+extern bool vtysh_add_timestamp;
+
+#endif /* VTYSH_H */
diff --git a/vtysh/vtysh_config.c b/vtysh/vtysh_config.c
new file mode 100644
index 0000000..d98f83d
--- /dev/null
+++ b/vtysh/vtysh_config.c
@@ -0,0 +1,682 @@
+/* Configuration generator.
+ * 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 "command.h"
+#include "linklist.h"
+#include "memory.h"
+#include "typesafe.h"
+
+#include "vtysh/vtysh.h"
+#include "vtysh/vtysh_user.h"
+
+DEFINE_MGROUP(MVTYSH, "vtysh");
+DEFINE_MTYPE_STATIC(MVTYSH, VTYSH_CONFIG, "Vtysh configuration");
+DEFINE_MTYPE_STATIC(MVTYSH, VTYSH_CONFIG_LINE, "Vtysh configuration line");
+
+vector configvec;
+
+PREDECL_LIST(config_master);
+PREDECL_HASH(config_master_hash);
+
+struct config {
+	/* Configuration node name. */
+	char *name;
+
+	/* Configuration string line. */
+	struct list *line;
+
+	/* Configuration can be nested. */
+	struct config *parent;
+	vector nested;
+
+	/* Exit command. */
+	char *exit;
+
+	/* Index of this config. */
+	uint32_t index;
+
+	/* Node entry for the typed Red-black tree */
+	struct config_master_item rbt_item;
+	struct config_master_hash_item hash_item;
+};
+
+struct list *config_top;
+
+static int line_cmp(char *c1, char *c2)
+{
+	return strcmp(c1, c2);
+}
+
+static void line_del(char *line)
+{
+	XFREE(MTYPE_VTYSH_CONFIG_LINE, line);
+}
+
+static struct config *config_new(void)
+{
+	struct config *config;
+	config = XCALLOC(MTYPE_VTYSH_CONFIG, sizeof(struct config));
+	return config;
+}
+
+static void config_del(struct config *config)
+{
+	vector_free(config->nested);
+	list_delete(&config->line);
+	if (config->exit)
+		XFREE(MTYPE_VTYSH_CONFIG_LINE, config->exit);
+	XFREE(MTYPE_VTYSH_CONFIG_LINE, config->name);
+	XFREE(MTYPE_VTYSH_CONFIG, config);
+}
+
+static int config_cmp(const struct config *c1, const struct config *c2)
+{
+	return strcmp(c1->name, c2->name);
+}
+
+static uint32_t config_hash(const struct config *c)
+{
+	return string_hash_make(c->name);
+}
+
+DECLARE_LIST(config_master, struct config, rbt_item);
+DECLARE_HASH(config_master_hash, struct config, hash_item, config_cmp,
+	     config_hash);
+
+/*
+ * The config_master_head is a list for order of receipt
+ * The hash is for quick lookup under this NODE
+ */
+struct configuration {
+	struct config_master_head master;
+	struct config_master_hash_head hash_master;
+};
+
+static struct config *config_get_vec(vector vec, int index, const char *line)
+{
+	struct config *config, *config_loop;
+	struct configuration *configuration;
+	struct config lookup;
+
+	config = config_loop = NULL;
+
+	configuration = vector_lookup_ensure(vec, index);
+
+	if (!configuration) {
+		configuration = XMALLOC(MTYPE_VTYSH_CONFIG,
+					sizeof(struct configuration));
+		config_master_init(&configuration->master);
+		config_master_hash_init(&configuration->hash_master);
+		vector_set_index(vec, index, configuration);
+	}
+
+	lookup.name = (char *)line;
+	config = config_master_hash_find(&configuration->hash_master, &lookup);
+
+	if (!config) {
+		config = config_new();
+		config->line = list_new();
+		config->line->del = (void (*)(void *))line_del;
+		config->line->cmp = (int (*)(void *, void *))line_cmp;
+		config->name = XSTRDUP(MTYPE_VTYSH_CONFIG_LINE, line);
+		config->exit = NULL;
+		config->index = index;
+		config->nested = vector_init(1);
+		config_master_add_tail(&configuration->master, config);
+		config_master_hash_add(&configuration->hash_master, config);
+	}
+	return config;
+}
+
+static struct config *config_get(int index, const char *line)
+{
+	return config_get_vec(configvec, index, line);
+}
+
+static struct config *config_get_nested(struct config *parent, int index,
+					const char *line)
+{
+	struct config *config;
+
+	config = config_get_vec(parent->nested, index, line);
+	config->parent = parent;
+
+	return config;
+}
+
+void config_add_line(struct list *config, const char *line)
+{
+	listnode_add(config, XSTRDUP(MTYPE_VTYSH_CONFIG_LINE, line));
+}
+
+static void config_add_line_uniq(struct list *config, const char *line)
+{
+	struct listnode *node, *nnode;
+	char *pnt;
+
+	for (ALL_LIST_ELEMENTS(config, node, nnode, pnt)) {
+		if (strcmp(pnt, line) == 0)
+			return;
+	}
+	listnode_add_sort(config, XSTRDUP(MTYPE_VTYSH_CONFIG_LINE, line));
+}
+
+/*
+ * Add a line that should only be shown once, and always show at the end of the
+ * config block.
+ *
+ * If the line already exists, it will be moved to the end of the block. If it
+ * does not exist, it will be added at the end of the block.
+ *
+ * Note that this only makes sense when there is just one such line that should
+ * show up at the very end of a config block. Furthermore, if the same block
+ * can show up from multiple daemons, all of them must make sure to print the
+ * line at the end of their config, otherwise the line will show at the end of
+ * the config for the last daemon that printed it.
+ *
+ * Here is a motivating example with the 'exit-vrf' command. Suppose we receive
+ * a config from Zebra like so:
+ *
+ * vrf BLUE
+ *    ip route A
+ *    ip route B
+ *    exit-vrf
+ *
+ * Then suppose we later receive this config from PIM:
+ *
+ * vrf BLUE
+ *    ip msdp mesh-group MyGroup member 1.2.3.4
+ *    exit-vrf
+ *
+ * Then we will combine them into one config block like so:
+ *
+ * vrf BLUE
+ *    ip route A
+ *    ip route B
+ *    ip msdp mesh-group MyGroup member 1.2.3.4
+ *    exit-vrf
+ *
+ * Because PIM also sent us an 'exit-vrf', we noticed that we already had one
+ * under the 'vrf BLUE' config block and so we moved it to the end of the
+ * config block again. If PIM had neglected to send us 'exit-vrf', the result
+ * would be this:
+ *
+ * vrf BLUE
+ *    ip route A
+ *    ip route B
+ *    exit-vrf
+ *    ip msdp mesh-group MyGroup member 1.2.3.4
+ *
+ * Therefore, daemons that share config blocks must take care to consistently
+ * print the same block terminators.
+ *
+ * Ideally this would be solved by adding a string to struct config that is
+ * always printed at the end when dumping a config. However, this would only
+ * work when the user is using integrated config. In the non-integrated config
+ * case, daemons are responsible for writing their own config files, and so the
+ * must be able to print these blocks correctly independently of vtysh, which
+ * means they are the ones that need to handle printing the block terminators
+ * and VTYSH needs to be smart enough to combine them properly.
+ *
+ * ---
+ *
+ * config
+ *    The config to add the line to
+ *
+ * line
+ *    The line to add to the end of the config
+ */
+static void config_add_line_uniq_end(struct list *config, const char *line)
+{
+	struct listnode *node;
+	char *pnt;
+
+	for (ALL_LIST_ELEMENTS_RO(config, node, pnt)) {
+		if (strcmp(pnt, line) == 0)
+			break;
+	}
+
+	if (!node)
+		config_add_line(config, line);
+	else
+		listnode_move_to_tail(config, node);
+}
+
+void vtysh_config_parse_line(void *arg, const char *line)
+{
+	char c;
+	static struct config *config = NULL;
+
+	if (!line)
+		return;
+
+	c = line[0];
+
+	if (c == '\0')
+		return;
+
+	switch (c) {
+	/* Suppress exclamation points ! and commented lines. The !s are
+	 * generated
+	 * dynamically in vtysh_config_dump() */
+	case '!':
+	case '#':
+		break;
+	case ' ':
+		/* Store line to current configuration. */
+		if (config) {
+			if (config->index == KEYCHAIN_NODE
+			    && strncmp(line, " key", strlen(" key")) == 0) {
+				config = config_get_nested(
+					config, KEYCHAIN_KEY_NODE, line);
+			} else if (config->index == KEYCHAIN_KEY_NODE) {
+				if (strncmp(line, " exit", strlen(" exit"))
+				    == 0) {
+					config_add_line_uniq_end(config->line,
+								 line);
+					config = config->parent;
+				} else {
+					config_add_line_uniq(config->line,
+							     line);
+				}
+			} else if (strncmp(line, " link-params",
+					   strlen(" link-params"))
+				   == 0) {
+				config_add_line(config->line, line);
+				config->index = LINK_PARAMS_NODE;
+			} else if (strncmp(line, " ip multicast boundary",
+					   strlen(" ip multicast boundary"))
+				   == 0) {
+				config_add_line_uniq_end(config->line, line);
+			} else if (strncmp(line, " ip igmp query-interval",
+					   strlen(" ip igmp query-interval"))
+				   == 0) {
+				config_add_line_uniq_end(config->line, line);
+			} else if (config->index == LINK_PARAMS_NODE
+				   && strncmp(line, " exit-link-params",
+					      strlen(" exit"))
+					      == 0) {
+				config_add_line(config->line, line);
+				config->index = INTERFACE_NODE;
+			} else if (!strncmp(line, " vrrp", strlen(" vrrp"))
+				   || !strncmp(line, " no vrrp",
+					       strlen(" no vrrp"))) {
+				config_add_line(config->line, line);
+			} else if (!strncmp(line, " ip mroute",
+					    strlen(" ip mroute"))) {
+				config_add_line_uniq_end(config->line, line);
+			} else if (config->index == RMAP_NODE
+				   || config->index == INTERFACE_NODE
+				   || config->index == VTY_NODE
+				   || config->index == NH_GROUP_NODE)
+				config_add_line_uniq(config->line, line);
+			else
+				config_add_line(config->line, line);
+		} else
+			config_add_line(config_top, line);
+		break;
+	default:
+		if (strncmp(line, "exit", strlen("exit")) == 0) {
+			if (config)
+				config->exit =
+					XSTRDUP(MTYPE_VTYSH_CONFIG_LINE, line);
+		} else if (strncmp(line, "interface", strlen("interface")) == 0)
+			config = config_get(INTERFACE_NODE, line);
+		else if (strncmp(line, "pseudowire", strlen("pseudowire")) == 0)
+			config = config_get(PW_NODE, line);
+		else if (strncmp(line, "vrf", strlen("vrf")) == 0)
+			config = config_get(VRF_NODE, line);
+		else if (strncmp(line, "nexthop-group", strlen("nexthop-group"))
+			 == 0)
+			config = config_get(NH_GROUP_NODE, line);
+		else if (strncmp(line, "router-id", strlen("router-id")) == 0)
+			config = config_get(ZEBRA_NODE, line);
+		else if (strncmp(line, "router rip", strlen("router rip")) == 0)
+			config = config_get(RIP_NODE, line);
+		else if (strncmp(line, "router ripng", strlen("router ripng"))
+			 == 0)
+			config = config_get(RIPNG_NODE, line);
+		else if (strncmp(line, "router eigrp", strlen("router eigrp"))
+			 == 0)
+			config = config_get(EIGRP_NODE, line);
+		else if (strncmp(line, "router babel", strlen("router babel"))
+			 == 0)
+			config = config_get(BABEL_NODE, line);
+		else if (strncmp(line, "router ospf", strlen("router ospf"))
+			 == 0)
+			config = config_get(OSPF_NODE, line);
+		else if (strncmp(line, "router ospf6", strlen("router ospf6"))
+			 == 0)
+			config = config_get(OSPF6_NODE, line);
+		else if (strncmp(line, "mpls ldp", strlen("mpls ldp")) == 0)
+			config = config_get(LDP_NODE, line);
+		else if (strncmp(line, "l2vpn", strlen("l2vpn")) == 0)
+			config = config_get(LDP_L2VPN_NODE, line);
+		else if (strncmp(line, "router bgp", strlen("router bgp")) == 0)
+			config = config_get(BGP_NODE, line);
+		else if (strncmp(line, "router isis", strlen("router isis"))
+			 == 0)
+			config = config_get(ISIS_NODE, line);
+		else if (strncmp(line, "router openfabric", strlen("router openfabric"))
+			 == 0)
+			config = config_get(OPENFABRIC_NODE, line);
+		else if (strncmp(line, "route-map", strlen("route-map")) == 0)
+			config = config_get(RMAP_NODE, line);
+		else if (strncmp(line, "no route-map", strlen("no route-map"))
+			 == 0)
+			config = config_get(RMAP_NODE, line);
+		else if (strncmp(line, "pbr-map", strlen("pbr-map")) == 0)
+			config = config_get(PBRMAP_NODE, line);
+		else if (strncmp(line, "access-list", strlen("access-list"))
+			 == 0)
+			config = config_get(ACCESS_NODE, line);
+		else if (strncmp(line, "ipv6 access-list",
+				 strlen("ipv6 access-list"))
+			 == 0)
+			config = config_get(ACCESS_IPV6_NODE, line);
+		else if (strncmp(line, "mac access-list",
+				 strlen("mac access-list"))
+			 == 0)
+			config = config_get(ACCESS_MAC_NODE, line);
+		else if (strncmp(line, "ip prefix-list",
+				 strlen("ip prefix-list"))
+			 == 0)
+			config = config_get(PREFIX_NODE, line);
+		else if (strncmp(line, "ipv6 prefix-list",
+				 strlen("ipv6 prefix-list"))
+			 == 0)
+			config = config_get(PREFIX_IPV6_NODE, line);
+		else if (strncmp(line, "bgp as-path access-list",
+				 strlen("bgp as-path access-list"))
+			 == 0)
+			config = config_get(AS_LIST_NODE, line);
+		else if (strncmp(line, "bgp community-list",
+				 strlen("bgp community-list"))
+				 == 0
+			 || strncmp(line, "bgp extcommunity-list",
+				    strlen("bgp extcommunity-list"))
+				    == 0
+			 || strncmp(line, "bgp large-community-list",
+				    strlen("bgp large-community-list"))
+				    == 0)
+			config = config_get(COMMUNITY_LIST_NODE, line);
+		else if (strncmp(line, "bgp community alias",
+				 strlen("bgp community alias")) == 0)
+			config = config_get(COMMUNITY_ALIAS_NODE, line);
+		else if (strncmp(line, "ip route", strlen("ip route")) == 0)
+			config = config_get(IP_NODE, line);
+		else if (strncmp(line, "ipv6 route", strlen("ipv6 route")) == 0)
+			config = config_get(IP_NODE, line);
+		else if (strncmp(line, "key", strlen("key")) == 0)
+			config = config_get(KEYCHAIN_NODE, line);
+		else if (strncmp(line, "line", strlen("line")) == 0)
+			config = config_get(VTY_NODE, line);
+		else if ((strncmp(line, "ipv6 forwarding",
+				  strlen("ipv6 forwarding"))
+			  == 0)
+			 || (strncmp(line, "ip forwarding",
+				     strlen("ip forwarding"))
+			     == 0))
+			config = config_get(FORWARDING_NODE, line);
+		else if (strncmp(line, "debug vrf", strlen("debug vrf")) == 0)
+			config = config_get(VRF_DEBUG_NODE, line);
+		else if (strncmp(line, "debug northbound",
+				 strlen("debug northbound"))
+			 == 0)
+			config = config_get(NORTHBOUND_DEBUG_NODE, line);
+		else if (strncmp(line, "debug route-map",
+				 strlen("debug route-map"))
+			 == 0)
+			config = config_get(RMAP_DEBUG_NODE, line);
+		else if (strncmp(line, "debug resolver",
+				 strlen("debug resolver")) == 0)
+			config = config_get(RESOLVER_DEBUG_NODE, line);
+		else if (strncmp(line, "debug", strlen("debug")) == 0)
+			config = config_get(DEBUG_NODE, line);
+		else if (strncmp(line, "password", strlen("password")) == 0
+			 || strncmp(line, "enable password",
+				    strlen("enable password"))
+				    == 0)
+			config = config_get(AAA_NODE, line);
+		else if (strncmp(line, "ip protocol", strlen("ip protocol"))
+			 == 0)
+			config = config_get(PROTOCOL_NODE, line);
+		else if (strncmp(line, "ipv6 protocol", strlen("ipv6 protocol"))
+			 == 0)
+			config = config_get(PROTOCOL_NODE, line);
+		else if (strncmp(line, "ip nht", strlen("ip nht")) == 0)
+			config = config_get(PROTOCOL_NODE, line);
+		else if (strncmp(line, "ipv6 nht", strlen("ipv6 nht")) == 0)
+			config = config_get(PROTOCOL_NODE, line);
+		else if (strncmp(line, "mpls", strlen("mpls")) == 0)
+			config = config_get(MPLS_NODE, line);
+		else if (strncmp(line, "segment-routing",
+				 strlen("segment-routing"))
+			 == 0)
+			config = config_get(SEGMENT_ROUTING_NODE, line);
+		else if (strncmp(line, "bfd", strlen("bfd")) == 0)
+			config = config_get(BFD_NODE, line);
+		else if (strncmp(line, "rpki", strlen("rpki")) == 0)
+			config = config_get(RPKI_NODE, line);
+		else {
+			if (strncmp(line, "log", strlen("log")) == 0 ||
+			    strncmp(line, "hostname", strlen("hostname")) ==
+				    0 ||
+			    strncmp(line, "domainname", strlen("domainname")) ==
+				    0 ||
+			    strncmp(line, "allow-reserved-ranges",
+				    strlen("allow-reserved-ranges")) == 0 ||
+			    strncmp(line, "frr", strlen("frr")) == 0 ||
+			    strncmp(line, "agentx", strlen("agentx")) == 0 ||
+			    strncmp(line, "no log", strlen("no log")) == 0 ||
+			    strncmp(line, "no ip prefix-list",
+				    strlen("no ip prefix-list")) == 0 ||
+			    strncmp(line, "no ipv6 prefix-list",
+				    strlen("no ipv6 prefix-list")) == 0 ||
+			    strncmp(line, "service cputime-stats",
+				    strlen("service cputime-stats")) == 0 ||
+			    strncmp(line, "no service cputime-stats",
+				    strlen("no service cputime-stats")) == 0 ||
+			    strncmp(line, "service cputime-warning",
+				    strlen("service cputime-warning")) == 0)
+				config_add_line_uniq(config_top, line);
+			else
+				config_add_line(config_top, line);
+			config = NULL;
+		}
+		break;
+	}
+}
+
+/* Macro to check delimiter is needed between each configuration line
+ * or not. */
+#define NO_DELIMITER(I)                                                        \
+	((I) == ACCESS_NODE || (I) == PREFIX_NODE || (I) == IP_NODE            \
+	 || (I) == AS_LIST_NODE || (I) == COMMUNITY_LIST_NODE                  \
+	 || (I) == COMMUNITY_ALIAS_NODE || (I) == ACCESS_IPV6_NODE             \
+	 || (I) == ACCESS_MAC_NODE || (I) == PREFIX_IPV6_NODE                  \
+	 || (I) == FORWARDING_NODE || (I) == DEBUG_NODE || (I) == AAA_NODE     \
+	 || (I) == VRF_DEBUG_NODE || (I) == NORTHBOUND_DEBUG_NODE              \
+	 || (I) == RMAP_DEBUG_NODE || (I) == RESOLVER_DEBUG_NODE               \
+	 || (I) == MPLS_NODE || (I) == KEYCHAIN_KEY_NODE)
+
+static void configvec_dump(vector vec, bool nested)
+{
+	struct listnode *mnode, *mnnode;
+	struct config *config;
+	struct configuration *configuration;
+	char *line;
+	unsigned int i;
+
+	for (i = 0; i < vector_active(vec); i++)
+		if ((configuration = vector_slot(vec, i)) != NULL) {
+			while ((config = config_master_pop(
+					&configuration->master))) {
+				config_master_hash_del(
+					&configuration->hash_master, config);
+				/* Don't print empty sections for interface.
+				 * Route maps on the
+				 * other hand could have a legitimate empty
+				 * section at the end.
+				 * VRF is handled in the backend, we could have
+				 * "configured" VRFs with static routes which
+				 * are not under the VRF node.
+				 */
+				if (config->index == INTERFACE_NODE
+				    && (listcount(config->line) == 1)
+				    && (line = listnode_head(config->line))
+				    && strmatch(line, "exit")) {
+					config_del(config);
+					continue;
+				}
+
+				vty_out(vty, "%s\n", config->name);
+
+				for (ALL_LIST_ELEMENTS(config->line, mnode,
+						       mnnode, line))
+					vty_out(vty, "%s\n", line);
+
+				configvec_dump(config->nested, true);
+
+				if (config->exit)
+					vty_out(vty, "%s\n", config->exit);
+
+				if (!NO_DELIMITER(i))
+					vty_out(vty, "!\n");
+
+				config_del(config);
+			}
+			config_master_fini(&configuration->master);
+			config_master_hash_fini(&configuration->hash_master);
+			XFREE(MTYPE_VTYSH_CONFIG, configuration);
+			vector_slot(vec, i) = NULL;
+			if (!nested && NO_DELIMITER(i))
+				vty_out(vty, "!\n");
+		}
+}
+
+void vtysh_config_dump(void)
+{
+	struct listnode *node, *nnode;
+	char *line;
+
+	for (ALL_LIST_ELEMENTS(config_top, node, nnode, line))
+		vty_out(vty, "%s\n", line);
+
+	list_delete_all_node(config_top);
+
+	vty_out(vty, "!\n");
+
+	configvec_dump(configvec, false);
+}
+
+/* Read up configuration file from file_name. */
+static int vtysh_read_file(FILE *confp, bool dry_run)
+{
+	struct vty *vty;
+	int ret;
+
+	vty = vty_new();
+	vty->wfd = STDERR_FILENO;
+	vty->type = VTY_TERM;
+	vty->node = CONFIG_NODE;
+
+	vtysh_execute_no_pager("enable");
+	vtysh_execute_no_pager("configure terminal");
+
+	if (!dry_run)
+		vtysh_execute_no_pager("XFRR_start_configuration");
+
+	/* Execute configuration file. */
+	ret = vtysh_config_from_file(vty, confp);
+
+	if (!dry_run)
+		vtysh_execute_no_pager("XFRR_end_configuration");
+
+	vtysh_execute_no_pager("end");
+	vtysh_execute_no_pager("disable");
+
+	vty_close(vty);
+
+	return (ret);
+}
+
+/* Read up configuration file from config_default_dir. */
+int vtysh_read_config(const char *config_default_dir, bool dry_run)
+{
+	FILE *confp = NULL;
+	bool save;
+	int ret;
+
+	confp = fopen(config_default_dir, "r");
+	if (confp == NULL) {
+		fprintf(stderr,
+			"%% Can't open configuration file %s due to '%s'.\n",
+			config_default_dir, safe_strerror(errno));
+		return CMD_ERR_NO_FILE;
+	}
+
+	save = vtysh_add_timestamp;
+	vtysh_add_timestamp = false;
+
+	ret = vtysh_read_file(confp, dry_run);
+	fclose(confp);
+
+	vtysh_add_timestamp = save;
+
+	return (ret);
+}
+
+/* We don't write vtysh specific into file from vtysh. vtysh.conf should
+ * be edited by hand. So, we handle only "write terminal" case here and
+ * integrate vtysh specific conf with conf from daemons.
+ */
+void vtysh_config_write(void)
+{
+	char line[512];
+
+	if (cmd_hostname_get()) {
+		snprintf(line, sizeof(line), "hostname %s", cmd_hostname_get());
+		vtysh_config_parse_line(NULL, line);
+	}
+
+	if (cmd_domainname_get()) {
+		snprintf(line, sizeof(line), "domainname %s",
+			 cmd_domainname_get());
+		vtysh_config_parse_line(NULL, line);
+	}
+	if (vtysh_write_integrated == WRITE_INTEGRATED_NO)
+		vtysh_config_parse_line(NULL,
+					"no service integrated-vtysh-config");
+	if (vtysh_write_integrated == WRITE_INTEGRATED_YES)
+		vtysh_config_parse_line(NULL,
+					"service integrated-vtysh-config");
+
+	user_config_write();
+}
+
+void vtysh_config_init(void)
+{
+	config_top = list_new();
+	config_top->del = (void (*)(void *))line_del;
+	configvec = vector_init(1);
+}
diff --git a/vtysh/vtysh_main.c b/vtysh/vtysh_main.c
new file mode 100644
index 0000000..8149d62
--- /dev/null
+++ b/vtysh/vtysh_main.c
@@ -0,0 +1,756 @@
+/* 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 <pwd.h>
+#include <sys/file.h>
+#include <unistd.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
+
+/*
+ * The append_history function only appears in newer versions
+ * of the readline library it appears like.  Since we don't
+ * need this just silently ignore the code on these
+ * ancient platforms.
+ */
+#if !defined HAVE_APPEND_HISTORY
+#define append_history(A, B)
+#endif
+
+#include <lib/version.h>
+#include "getopt.h"
+#include "command.h"
+#include "memory.h"
+#include "linklist.h"
+#include "libfrr.h"
+#include "ferr.h"
+#include "lib_errors.h"
+
+#include "vtysh/vtysh.h"
+#include "vtysh/vtysh_user.h"
+
+/* VTY shell program name. */
+char *progname;
+
+/* SUID mode */
+static uid_t elevuid, realuid;
+static gid_t elevgid, realgid;
+
+#define VTYSH_CONFIG_NAME "vtysh.conf"
+#define FRR_CONFIG_NAME "frr.conf"
+
+/* Configuration file name and directory. */
+static char vtysh_config[MAXPATHLEN * 3];
+char frr_config[MAXPATHLEN * 3];
+char vtydir[MAXPATHLEN];
+static char history_file[MAXPATHLEN];
+
+/* Flag for indicate executing child command. */
+int execute_flag = 0;
+
+/* Flag to indicate if in user/unprivileged mode. */
+int user_mode;
+
+/* Master of threads. */
+struct thread_master *master;
+
+/* Command logging */
+FILE *logfile;
+
+static void vtysh_rl_callback(char *line_read)
+{
+	HIST_ENTRY *last;
+
+	rl_callback_handler_remove();
+
+	if (!line_read) {
+		vtysh_loop_exited = true;
+		return;
+	}
+
+	/* If the line has any text in it, save it on the history. But only if
+	 * last command in history isn't the same one.
+	 */
+	if (*line_read) {
+		using_history();
+		last = previous_history();
+		if (!last || strcmp(last->line, line_read) != 0) {
+			add_history(line_read);
+			append_history(1, history_file);
+		}
+	}
+
+	vtysh_execute(line_read);
+
+	if (!vtysh_loop_exited)
+		rl_callback_handler_install(vtysh_prompt(), vtysh_rl_callback);
+}
+
+/* SIGTSTP handler.  This function care user's ^Z input. */
+static void sigtstp(int sig)
+{
+	rl_callback_handler_remove();
+
+	/* Execute "end" command. */
+	vtysh_execute("end");
+
+	if (!vtysh_loop_exited)
+		rl_callback_handler_install(vtysh_prompt(), vtysh_rl_callback);
+
+	/* Initialize readline. */
+	rl_initialize();
+	printf("\n");
+	rl_forced_update_display();
+}
+
+/* SIGINT handler.  This function care user's ^Z input.  */
+static void sigint(int sig)
+{
+	/* Check this process is not child process. */
+	if (!execute_flag) {
+		rl_initialize();
+		printf("\n");
+		rl_forced_update_display();
+	}
+}
+
+/* Signale wrapper for vtysh. We don't use sigevent because
+ * vtysh doesn't use threads. TODO */
+static void vtysh_signal_set(int signo, void (*func)(int))
+{
+	struct sigaction sig;
+	struct sigaction osig;
+
+	sig.sa_handler = func;
+	sigemptyset(&sig.sa_mask);
+	sig.sa_flags = 0;
+#ifdef SA_RESTART
+	sig.sa_flags |= SA_RESTART;
+#endif /* SA_RESTART */
+
+	sigaction(signo, &sig, &osig);
+}
+
+/* Initialization of signal handles. */
+static void vtysh_signal_init(void)
+{
+	vtysh_signal_set(SIGINT, sigint);
+	vtysh_signal_set(SIGTSTP, sigtstp);
+	vtysh_signal_set(SIGPIPE, SIG_IGN);
+}
+
+/* Help information display. */
+static void usage(int status)
+{
+	if (status != 0)
+		fprintf(stderr, "Try `%s --help' for more information.\n",
+			progname);
+	else
+		printf("Usage : %s [OPTION...]\n\n"
+		       "Integrated shell for FRR (version " FRR_VERSION
+		       "). \n"
+		       "Configured with:\n    " FRR_CONFIG_ARGS
+		       "\n\n"
+		       "-b, --boot               Execute boot startup configuration\n"
+		       "-c, --command            Execute argument as command\n"
+		       "-d, --daemon             Connect only to the specified daemon\n"
+		       "-f, --inputfile          Execute commands from specific file and exit\n"
+		       "-E, --echo               Echo prompt and command in -c mode\n"
+		       "-C, --dryrun             Check configuration for validity and exit\n"
+		       "-m, --markfile           Mark input file with context end\n"
+		       "    --vty_socket         Override vty socket path\n"
+		       "    --config_dir         Override config directory path\n"
+		       "-N  --pathspace          Insert prefix into config & socket paths\n"
+		       "-u  --user               Run as an unprivileged user\n"
+		       "-w, --writeconfig        Write integrated config (frr.conf) and exit\n"
+		       "-H, --histfile           Override history file\n"
+		       "-h, --help               Display this help and exit\n\n"
+		       "Note that multiple commands may be executed from the command\n"
+		       "line by passing multiple -c args, or by embedding linefeed\n"
+		       "characters in one or more of the commands.\n\n"
+		       "Report bugs to %s\n",
+		       progname, FRR_BUG_ADDRESS);
+
+	exit(status);
+}
+
+/* VTY shell options, we use GNU getopt library. */
+#define OPTION_VTYSOCK 1000
+#define OPTION_CONFDIR 1001
+struct option longopts[] = {
+	{"boot", no_argument, NULL, 'b'},
+	/* For compatibility with older zebra/quagga versions */
+	{"eval", required_argument, NULL, 'e'},
+	{"command", required_argument, NULL, 'c'},
+	{"daemon", required_argument, NULL, 'd'},
+	{"vty_socket", required_argument, NULL, OPTION_VTYSOCK},
+	{"config_dir", required_argument, NULL, OPTION_CONFDIR},
+	{"inputfile", required_argument, NULL, 'f'},
+	{"histfile", required_argument, NULL, 'H'},
+	{"echo", no_argument, NULL, 'E'},
+	{"dryrun", no_argument, NULL, 'C'},
+	{"help", no_argument, NULL, 'h'},
+	{"noerror", no_argument, NULL, 'n'},
+	{"mark", no_argument, NULL, 'm'},
+	{"writeconfig", no_argument, NULL, 'w'},
+	{"pathspace", required_argument, NULL, 'N'},
+	{"user", no_argument, NULL, 'u'},
+	{"timestamp", no_argument, NULL, 't'},
+	{0}};
+
+bool vtysh_loop_exited;
+
+static struct thread *vtysh_rl_read_thread;
+
+static void vtysh_rl_read(struct thread *thread)
+{
+	thread_add_read(master, vtysh_rl_read, NULL, STDIN_FILENO,
+			&vtysh_rl_read_thread);
+	rl_callback_read_char();
+}
+
+/* Read a string, and return a pointer to it.  Returns NULL on EOF. */
+static void vtysh_rl_run(void)
+{
+	struct thread thread;
+
+	master = thread_master_create(NULL);
+
+	rl_callback_handler_install(vtysh_prompt(), vtysh_rl_callback);
+	thread_add_read(master, vtysh_rl_read, NULL, STDIN_FILENO,
+			&vtysh_rl_read_thread);
+
+	while (!vtysh_loop_exited && thread_fetch(master, &thread))
+		thread_call(&thread);
+
+	if (!vtysh_loop_exited)
+		rl_callback_handler_remove();
+
+	thread_master_free(master);
+}
+
+static void log_it(const char *line)
+{
+	time_t t = time(NULL);
+	struct tm tmp;
+	const char *user = getenv("USER");
+	char tod[64];
+
+	localtime_r(&t, &tmp);
+	if (!user)
+		user = "boot";
+
+	strftime(tod, sizeof(tod), "%Y%m%d-%H:%M.%S", &tmp);
+
+	fprintf(logfile, "%s:%s %s\n", tod, user, line);
+}
+
+static int flock_fd;
+
+static void vtysh_flock_config(const char *flock_file)
+{
+	int count = 0;
+
+	flock_fd = open(flock_file, O_RDONLY, 0644);
+	if (flock_fd < 0) {
+		fprintf(stderr, "Unable to create lock file: %s, %s\n",
+			flock_file, safe_strerror(errno));
+		return;
+	}
+
+	while (count < 400 && (flock(flock_fd, LOCK_EX | LOCK_NB) < 0)) {
+		count++;
+		usleep(500000);
+	}
+
+	if (count >= 400)
+		fprintf(stderr,
+			"Flock of %s failed, continuing this may cause issues\n",
+			flock_file);
+}
+
+static void vtysh_unflock_config(void)
+{
+	flock(flock_fd, LOCK_UN);
+	close(flock_fd);
+}
+
+void suid_on(void)
+{
+	if (elevuid != realuid && seteuid(elevuid)) {
+		perror("seteuid(on)");
+		exit(1);
+	}
+	if (elevgid != realgid && setegid(elevgid)) {
+		perror("setegid(on)");
+		exit(1);
+	}
+}
+
+void suid_off(void)
+{
+	if (elevuid != realuid && seteuid(realuid)) {
+		perror("seteuid(off)");
+		exit(1);
+	}
+	if (elevgid != realgid && setegid(realgid)) {
+		perror("setegid(off)");
+		exit(1);
+	}
+}
+
+/* VTY shell main routine. */
+int main(int argc, char **argv, char **env)
+{
+	char *p;
+	int opt;
+	int dryrun = 0;
+	int boot_flag = 0;
+	bool ts_flag = false;
+	const char *daemon_name = NULL;
+	const char *inputfile = NULL;
+	struct cmd_rec {
+		char *line;
+		struct cmd_rec *next;
+	} *cmd = NULL;
+	struct cmd_rec *tail = NULL;
+	int echo_command = 0;
+	int no_error = 0;
+	int markfile = 0;
+	int writeconfig = 0;
+	int ret = 0;
+	char *homedir = NULL;
+	int ditch_suid = 0;
+	char sysconfdir[MAXPATHLEN];
+	const char *pathspace_arg = NULL;
+	char pathspace[MAXPATHLEN] = "";
+	const char *histfile = NULL;
+	const char *histfile_env = getenv("VTYSH_HISTFILE");
+
+	/* SUID: drop down to calling user & go back up when needed */
+	elevuid = geteuid();
+	elevgid = getegid();
+	realuid = getuid();
+	realgid = getgid();
+	suid_off();
+
+	user_mode = 0;		/* may be set in options processing */
+
+	/* Preserve name of myself. */
+	progname = ((p = strrchr(argv[0], '/')) ? ++p : argv[0]);
+
+	strlcpy(sysconfdir, frr_sysconfdir, sizeof(sysconfdir));
+
+	frr_init_vtydir();
+	strlcpy(vtydir, frr_vtydir, sizeof(vtydir));
+
+	/* Option handling. */
+	while (1) {
+		opt = getopt_long(argc, argv, "be:c:d:nf:H:mEhCwN:ut", longopts,
+				  0);
+
+		if (opt == EOF)
+			break;
+
+		switch (opt) {
+		case 0:
+			break;
+		case 'b':
+			boot_flag = 1;
+			break;
+		case 'e':
+		case 'c': {
+			struct cmd_rec *cr;
+			cr = XMALLOC(MTYPE_TMP, sizeof(*cr));
+			cr->line = optarg;
+			cr->next = NULL;
+			if (tail)
+				tail->next = cr;
+			else
+				cmd = cr;
+			tail = cr;
+		} break;
+		case OPTION_VTYSOCK:
+			ditch_suid = 1; /* option disables SUID */
+			strlcpy(vtydir, optarg, sizeof(vtydir));
+			break;
+		case OPTION_CONFDIR:
+			ditch_suid = 1; /* option disables SUID */
+			snprintf(sysconfdir, sizeof(sysconfdir), "%s/", optarg);
+			break;
+		case 'N':
+			if (strchr(optarg, '/') || strchr(optarg, '.')) {
+				fprintf(stderr,
+					"slashes or dots are not permitted in the --pathspace option.\n");
+				exit(1);
+			}
+			pathspace_arg = optarg;
+			snprintf(pathspace, sizeof(pathspace), "%s/", optarg);
+			break;
+		case 'd':
+			daemon_name = optarg;
+			break;
+		case 'f':
+			inputfile = optarg;
+			break;
+		case 'm':
+			markfile = 1;
+			break;
+		case 'n':
+			no_error = 1;
+			break;
+		case 'E':
+			echo_command = 1;
+			break;
+		case 'C':
+			dryrun = 1;
+			break;
+		case 'u':
+			user_mode = 1;
+			break;
+		case 't':
+			ts_flag = true;
+			break;
+		case 'w':
+			writeconfig = 1;
+			break;
+		case 'h':
+			usage(0);
+			break;
+		case 'H':
+			histfile = optarg;
+			break;
+		default:
+			usage(1);
+			break;
+		}
+	}
+
+	if (ditch_suid) {
+		elevuid = realuid;
+		elevgid = realgid;
+	}
+
+	if (markfile + writeconfig + dryrun + boot_flag > 1) {
+		fprintf(stderr,
+			"Invalid combination of arguments.  Please specify at most one of:\n\t-b, -C, -m, -w\n");
+		return 1;
+	}
+	if (inputfile && (writeconfig || boot_flag)) {
+		fprintf(stderr,
+			"WARNING: Combinining the -f option with -b or -w is NOT SUPPORTED since its\nresults are inconsistent!\n");
+	}
+
+	snprintf(vtysh_config, sizeof(vtysh_config), "%s%s%s", sysconfdir,
+		 pathspace, VTYSH_CONFIG_NAME);
+	snprintf(frr_config, sizeof(frr_config), "%s%s%s", sysconfdir,
+		 pathspace, FRR_CONFIG_NAME);
+
+	if (pathspace_arg) {
+		strlcat(vtydir, "/", sizeof(vtydir));
+		strlcat(vtydir, pathspace_arg, sizeof(vtydir));
+	}
+
+	/* Initialize user input buffer. */
+	setlinebuf(stdout);
+
+	/* Signal and others. */
+	vtysh_signal_init();
+
+	/* Make vty structure and register commands. */
+	vtysh_init_vty();
+	vtysh_init_cmd();
+	vtysh_user_init();
+	vtysh_config_init();
+
+	vty_init_vtysh();
+
+	if (!user_mode) {
+		/* Read vtysh configuration file before connecting to daemons.
+		 * (file may not be readable to calling user in SUID mode) */
+		suid_on();
+		vtysh_read_config(vtysh_config, dryrun);
+		suid_off();
+	}
+	/* Error code library system */
+	log_ref_init();
+	lib_error_init();
+
+	if (markfile) {
+		if (!inputfile) {
+			fprintf(stderr,
+				"-f option MUST be specified with -m option\n");
+			return 1;
+		}
+		return (vtysh_mark_file(inputfile));
+	}
+
+	/* Start execution only if not in dry-run mode */
+	if (dryrun && !cmd) {
+		if (inputfile) {
+			ret = vtysh_read_config(inputfile, dryrun);
+		} else {
+			ret = vtysh_read_config(frr_config, dryrun);
+		}
+
+		exit(ret);
+	}
+
+	if (dryrun && cmd && cmd->line) {
+		if (!user_mode)
+			vtysh_execute("enable");
+		while (cmd) {
+			struct cmd_rec *cr;
+			char *cmdnow = cmd->line, *next;
+			do {
+				next = strchr(cmdnow, '\n');
+				if (next)
+					*next++ = '\0';
+
+				if (echo_command)
+					printf("%s%s\n", vtysh_prompt(),
+					       cmdnow);
+
+				ret = vtysh_execute_no_pager(cmdnow);
+				if (!no_error
+				    && !(ret == CMD_SUCCESS
+					 || ret == CMD_SUCCESS_DAEMON
+					 || ret == CMD_WARNING))
+					exit(1);
+			} while ((cmdnow = next) != NULL);
+
+			cr = cmd;
+			cmd = cmd->next;
+			XFREE(MTYPE_TMP, cr);
+		}
+		exit(ret);
+	}
+
+	/* Ignore error messages */
+	if (no_error) {
+		if (freopen("/dev/null", "w", stdout) == NULL) {
+			fprintf(stderr,
+				"Exiting: Failed to duplicate stdout with -n option");
+			exit(1);
+		}
+	}
+
+	/* SUID: go back up elevated privs */
+	suid_on();
+
+	/* Make sure we pass authentication before proceeding. */
+	vtysh_auth();
+
+	/* Do not connect until we have passed authentication. */
+	if (vtysh_connect_all(daemon_name) <= 0) {
+		fprintf(stderr, "Exiting: failed to connect to any daemons.\n");
+		if (geteuid() != 0)
+			fprintf(stderr,
+				"Hint: if this seems wrong, try running me as a privileged user!\n");
+		if (no_error)
+			exit(0);
+		else
+			exit(1);
+	}
+
+	/* SUID: back down, don't need privs further on */
+	suid_off();
+
+	if (writeconfig) {
+		if (user_mode) {
+			fprintf(stderr,
+				"writeconfig cannot be used when running as an unprivileged user.\n");
+			if (no_error)
+				exit(0);
+			else
+				exit(1);
+		}
+		vtysh_execute("enable");
+		return vtysh_write_config_integrated();
+	}
+
+	if (inputfile) {
+		vtysh_flock_config(inputfile);
+		ret = vtysh_read_config(inputfile, dryrun);
+		vtysh_unflock_config();
+		exit(ret);
+	}
+
+	/*
+	 * Setup history file for use by both -c and regular input
+	 * If we can't find the home directory, then don't store
+	 * the history information.
+	 * VTYSH_HISTFILE is preferred over command line
+	 * argument (-H/--histfile).
+	 */
+	if (histfile_env) {
+		strlcpy(history_file, histfile_env, sizeof(history_file));
+	} else if (histfile) {
+		strlcpy(history_file, histfile, sizeof(history_file));
+	} else {
+		homedir = vtysh_get_home();
+		if (homedir)
+			snprintf(history_file, sizeof(history_file),
+				 "%s/.history_frr", homedir);
+	}
+
+	if (strlen(history_file) > 0) {
+		if (read_history(history_file) != 0) {
+			int fp;
+
+			fp = open(history_file, O_CREAT | O_EXCL,
+				  S_IRUSR | S_IWUSR);
+			if (fp != -1)
+				close(fp);
+
+			read_history(history_file);
+		}
+	}
+
+	if (getenv("VTYSH_LOG")) {
+		const char *logpath = getenv("VTYSH_LOG");
+
+		logfile = fopen(logpath, "a");
+		if (!logfile) {
+			fprintf(stderr, "Failed to open logfile (%s): %s\n",
+				logpath, strerror(errno));
+			exit(1);
+		}
+	}
+
+	/* If eval mode. */
+	if (cmd && cmd->line) {
+		/* Enter into enable node. */
+		if (!user_mode)
+			vtysh_execute("enable");
+
+		vtysh_add_timestamp = ts_flag;
+
+		while (cmd != NULL) {
+			char *eol;
+
+			while ((eol = strchr(cmd->line, '\n')) != NULL) {
+				*eol = '\0';
+
+				add_history(cmd->line);
+				append_history(1, history_file);
+
+				if (echo_command)
+					printf("%s%s\n", vtysh_prompt(),
+					       cmd->line);
+
+				if (logfile)
+					log_it(cmd->line);
+
+				ret = vtysh_execute_no_pager(cmd->line);
+				if (!no_error
+				    && !(ret == CMD_SUCCESS
+					 || ret == CMD_SUCCESS_DAEMON
+					 || ret == CMD_WARNING))
+					exit(1);
+
+				cmd->line = eol + 1;
+			}
+
+			add_history(cmd->line);
+			append_history(1, history_file);
+
+			if (echo_command)
+				printf("%s%s\n", vtysh_prompt(), cmd->line);
+
+			if (logfile)
+				log_it(cmd->line);
+
+			/*
+			 * Parsing logic for regular commands will be different
+			 * than for those commands requiring further
+			 * processing, such as cli instructions terminating
+			 * with question-mark character.
+			 */
+			if (!vtysh_execute_command_questionmark(cmd->line))
+				ret = CMD_SUCCESS;
+			else
+				ret = vtysh_execute_no_pager(cmd->line);
+
+			if (!no_error
+			    && !(ret == CMD_SUCCESS || ret == CMD_SUCCESS_DAEMON
+				 || ret == CMD_WARNING))
+				exit(1);
+
+			{
+				struct cmd_rec *cr;
+				cr = cmd;
+				cmd = cmd->next;
+				XFREE(MTYPE_TMP, cr);
+			}
+		}
+
+		history_truncate_file(history_file, 1000);
+		exit(0);
+	}
+
+	/* Boot startup configuration file. */
+	if (boot_flag) {
+		vtysh_flock_config(frr_config);
+		ret = vtysh_read_config(frr_config, dryrun);
+		vtysh_unflock_config();
+		if (ret) {
+			fprintf(stderr,
+				"Configuration file[%s] processing failure: %d\n",
+				frr_config, ret);
+			if (no_error)
+				exit(0);
+			else
+				exit(ret);
+		} else
+			exit(0);
+	}
+
+	vtysh_readline_init();
+
+	vty_hello(vty);
+
+	/* Enter into enable node. */
+	if (!user_mode)
+		vtysh_execute("enable");
+
+	vtysh_add_timestamp = ts_flag;
+
+	/* Main command loop. */
+	vtysh_rl_run();
+
+	vtysh_uninit();
+
+	history_truncate_file(history_file, 1000);
+	printf("\n");
+
+	/* Rest in peace. */
+	exit(0);
+}
diff --git a/vtysh/vtysh_user.c b/vtysh/vtysh_user.c
new file mode 100644
index 0000000..50b32de
--- /dev/null
+++ b/vtysh/vtysh_user.c
@@ -0,0 +1,235 @@
+/* User authentication for vtysh.
+ * 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 <lib/version.h>
+
+#include <pwd.h>
+
+#ifdef USE_PAM
+#include <security/pam_appl.h>
+#ifdef HAVE_PAM_MISC_H
+#include <security/pam_misc.h>
+#endif
+#ifdef HAVE_OPENPAM_H
+#include <security/openpam.h>
+#endif
+#endif /* USE_PAM */
+
+#include "memory.h"
+#include "linklist.h"
+#include "command.h"
+#include "vtysh/vtysh_user.h"
+
+/*
+ * Compiler is warning about prototypes not being declared.
+ * The DEFUNSH and DEFUN macro's are messing with the
+ * compiler I believe.  This is just to make it happy.
+ */
+#ifdef USE_PAM
+static int vtysh_pam(const char *);
+#endif
+int vtysh_auth(void);
+void vtysh_user_init(void);
+
+extern struct list *config_top;
+extern void config_add_line(struct list *config, const char *line);
+
+#ifdef USE_PAM
+static struct pam_conv conv = {PAM_CONV_FUNC, NULL};
+
+static int vtysh_pam(const char *user)
+{
+	int ret, second_ret;
+	pam_handle_t *pamh = NULL;
+
+	/* Start PAM. */
+	ret = pam_start(FRR_PAM_NAME, user, &conv, &pamh);
+
+	/* Is user really user? */
+	if (ret == PAM_SUCCESS)
+		ret = pam_authenticate(pamh, 0);
+
+	if (ret != PAM_SUCCESS)
+		fprintf(stderr, "vtysh_pam: Failure to initialize pam: %s(%d)",
+			pam_strerror(pamh, ret), ret);
+
+	second_ret = pam_acct_mgmt(pamh, 0);
+	if (second_ret != PAM_SUCCESS)
+		fprintf(stderr, "%s: Failed in account validation: %s(%d)",
+			__func__, pam_strerror(pamh, second_ret), second_ret);
+
+	/* close Linux-PAM */
+	second_ret = pam_end(pamh, ret);
+	if (second_ret != PAM_SUCCESS) {
+		pamh = NULL;
+		fprintf(stderr,
+			"vtysh_pam: failed to release authenticator: %s(%d)\n",
+			pam_strerror(pamh, second_ret), second_ret);
+		exit(1);
+	}
+
+	return ret == PAM_SUCCESS ? 0 : 1;
+}
+#endif /* USE_PAM */
+
+struct vtysh_user {
+	char *name;
+	uint8_t nopassword;
+};
+
+struct list *userlist;
+
+static struct vtysh_user *user_new(void)
+{
+	return XCALLOC(MTYPE_TMP, sizeof(struct vtysh_user));
+}
+
+static struct vtysh_user *user_lookup(const char *name)
+{
+	struct listnode *node, *nnode;
+	struct vtysh_user *user;
+
+	for (ALL_LIST_ELEMENTS(userlist, node, nnode, user)) {
+		if (strcmp(user->name, name) == 0)
+			return user;
+	}
+	return NULL;
+}
+
+void user_config_write(void)
+{
+	struct listnode *node, *nnode;
+	struct vtysh_user *user;
+	char line[128];
+
+	for (ALL_LIST_ELEMENTS(userlist, node, nnode, user)) {
+		if (user->nopassword) {
+			snprintf(line, sizeof(line), "username %s nopassword",
+				 user->name);
+			config_add_line(config_top, line);
+		}
+	}
+}
+
+static struct vtysh_user *user_get(const char *name)
+{
+	struct vtysh_user *user;
+	user = user_lookup(name);
+	if (user)
+		return user;
+
+	user = user_new();
+	user->name = strdup(name);
+	listnode_add(userlist, user);
+
+	return user;
+}
+
+DEFUN (vtysh_banner_motd_file,
+       vtysh_banner_motd_file_cmd,
+       "banner motd file FILE",
+       "Set banner\n"
+       "Banner for motd\n"
+       "Banner from a file\n"
+       "Filename\n")
+{
+	int idx_file = 3;
+	return cmd_banner_motd_file(argv[idx_file]->arg);
+}
+
+DEFUN (vtysh_banner_motd_line,
+       vtysh_banner_motd_line_cmd,
+       "banner motd line LINE...",
+       "Set banner\n"
+       "Banner for motd\n"
+       "Banner from an input\n"
+       "Text\n")
+{
+	int idx = 0;
+	char *motd;
+
+	argv_find(argv, argc, "LINE", &idx);
+	motd = argv_concat(argv, argc, idx);
+
+	cmd_banner_motd_line(motd);
+	XFREE(MTYPE_TMP, motd);
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (username_nopassword,
+       username_nopassword_cmd,
+       "username WORD nopassword",
+       "\n"
+       "\n"
+       "\n")
+{
+	int idx_word = 1;
+	struct vtysh_user *user;
+	user = user_get(argv[idx_word]->arg);
+	user->nopassword = 1;
+	return CMD_SUCCESS;
+}
+
+int vtysh_auth(void)
+{
+	struct vtysh_user *user;
+	struct passwd *passwd;
+
+	if ((passwd = getpwuid(geteuid())) == NULL) {
+		fprintf(stderr, "could not lookup user ID %d\n",
+			(int)geteuid());
+		exit(1);
+	}
+
+	user = user_lookup(passwd->pw_name);
+	if (user && user->nopassword)
+		/* Pass through */;
+	else {
+#ifdef USE_PAM
+		if (vtysh_pam(passwd->pw_name))
+			exit(0);
+#endif /* USE_PAM */
+	}
+	return 0;
+}
+
+char *vtysh_get_home(void)
+{
+	struct passwd *passwd;
+	char *homedir;
+
+	if ((homedir = getenv("HOME")) != NULL)
+		return homedir;
+
+	/* Fallback if HOME is undefined */
+	passwd = getpwuid(getuid());
+
+	return passwd ? passwd->pw_dir : NULL;
+}
+
+void vtysh_user_init(void)
+{
+	userlist = list_new();
+	install_element(CONFIG_NODE, &username_nopassword_cmd);
+	install_element(CONFIG_NODE, &vtysh_banner_motd_file_cmd);
+	install_element(CONFIG_NODE, &vtysh_banner_motd_line_cmd);
+}
diff --git a/vtysh/vtysh_user.h b/vtysh/vtysh_user.h
new file mode 100644
index 0000000..2b31589
--- /dev/null
+++ b/vtysh/vtysh_user.h
@@ -0,0 +1,30 @@
+/* User authentication for vtysh.
+ * 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
+ */
+
+#ifndef _VTYSH_USER_H
+#define _VTYSH_USER_H
+
+int vtysh_auth(void);
+void vtysh_user_init(void);
+void user_config_write(void);
+
+char *vtysh_get_home(void);
+
+#endif /* _VTYSH_USER_H */