Adding upstream version 9.1.upstream/9.1

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

1 files changed, 1864 insertions, 0 deletions

diff --git a/lib/if.c b/lib/if.c
new file mode 100644
index 0000000..48c01af
--- /dev/null
+++ b/lib/if.c
@@ -0,0 +1,1864 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Interface functions.
+ * Copyright (C) 1997, 98 Kunihiro Ishiguro
+ */
+
+#include <zebra.h>
+
+#include "linklist.h"
+#include "vector.h"
+#include "lib_errors.h"
+#include "vty.h"
+#include "command.h"
+#include "vrf.h"
+#include "if.h"
+#include "sockunion.h"
+#include "prefix.h"
+#include "memory.h"
+#include "table.h"
+#include "buffer.h"
+#include "log.h"
+#include "northbound_cli.h"
+#include "admin_group.h"
+#include "lib/if_clippy.c"
+
+DEFINE_MTYPE_STATIC(LIB, IF, "Interface");
+DEFINE_MTYPE_STATIC(LIB, IFDESC, "Intf Desc");
+DEFINE_MTYPE_STATIC(LIB, CONNECTED, "Connected");
+DEFINE_MTYPE_STATIC(LIB, NBR_CONNECTED, "Neighbor Connected");
+DEFINE_MTYPE(LIB, CONNECTED_LABEL, "Connected interface label");
+DEFINE_MTYPE_STATIC(LIB, IF_LINK_PARAMS, "Informational Link Parameters");
+
+static void if_set_name(struct interface *ifp, const char *name);
+static struct interface *if_lookup_by_ifindex(ifindex_t ifindex,
+					      vrf_id_t vrf_id);
+static struct interface *if_lookup_by_index_all_vrf(ifindex_t ifindex);
+static int if_cmp_func(const struct interface *, const struct interface *);
+static int if_cmp_index_func(const struct interface *ifp1,
+			     const struct interface *ifp2);
+RB_GENERATE(if_name_head, interface, name_entry, if_cmp_func);
+RB_GENERATE(if_index_head, interface, index_entry, if_cmp_index_func);
+
+DEFINE_QOBJ_TYPE(interface);
+
+DEFINE_HOOK(if_add, (struct interface * ifp), (ifp));
+DEFINE_KOOH(if_del, (struct interface * ifp), (ifp));
+
+static struct interface_master{
+	int (*create_hook)(struct interface *ifp);
+	int (*up_hook)(struct interface *ifp);
+	int (*down_hook)(struct interface *ifp);
+	int (*destroy_hook)(struct interface *ifp);
+} ifp_master = { 0, };
+
+/* Compare interface names, returning an integer greater than, equal to, or
+ * less than 0, (following the strcmp convention), according to the
+ * relationship between ifp1 and ifp2.  Interface names consist of an
+ * alphabetic prefix and a numeric suffix.  The primary sort key is
+ * lexicographic by name, and then numeric by number.  No number sorts
+ * before all numbers.  Examples: de0 < de1, de100 < fxp0 < xl0, devpty <
+ * devpty0, de0 < del0
+ */
+int if_cmp_name_func(const char *p1, const char *p2)
+{
+	unsigned int l1, l2;
+	long int x1, x2;
+	int res;
+
+	while (*p1 && *p2) {
+		char *tmp1, *tmp2;
+
+		/* look up to any number */
+		l1 = strcspn(p1, "0123456789");
+		l2 = strcspn(p2, "0123456789");
+
+		/* name lengths are different -> compare names */
+		if (l1 != l2)
+			return (strcmp(p1, p2));
+
+		/* Note that this relies on all numbers being less than all
+		 * letters, so
+		 * that de0 < del0.
+		 */
+		res = strncmp(p1, p2, l1);
+
+		/* names are different -> compare them */
+		if (res)
+			return res;
+
+		/* with identical name part, go to numeric part */
+		p1 += l1;
+		p2 += l1;
+
+		if (!*p1 && !*p2)
+			return 0;
+		if (!*p1)
+			return -1;
+		if (!*p2)
+			return 1;
+
+		x1 = strtol(p1, &tmp1, 10);
+		x2 = strtol(p2, &tmp2, 10);
+
+		/* let's compare numbers now */
+		if (x1 < x2)
+			return -1;
+		if (x1 > x2)
+			return 1;
+
+		/* Compare string if numbers are equal (distinguish foo-1 from foo-001) */
+		l1 = strspn(p1, "0123456789");
+		l2 = strspn(p2, "0123456789");
+		if (l1 != l2)
+			return (strcmp(p1, p2));
+
+		/* Continue to parse the rest of the string */
+		p1 = (const char *)tmp1;
+		p2 = (const char *)tmp2;
+
+		/* numbers were equal, lets do it again..
+		(it happens with name like "eth123.456:789") */
+	}
+	if (*p1)
+		return 1;
+	if (*p2)
+		return -1;
+	return 0;
+}
+
+static int if_cmp_func(const struct interface *ifp1,
+		       const struct interface *ifp2)
+{
+	return if_cmp_name_func(ifp1->name, ifp2->name);
+}
+
+static int if_cmp_index_func(const struct interface *ifp1,
+			     const struct interface *ifp2)
+{
+	if (ifp1->ifindex == ifp2->ifindex)
+		return 0;
+	else if (ifp1->ifindex > ifp2->ifindex)
+		return 1;
+	else
+		return -1;
+}
+
+static void ifp_connected_free(void *arg)
+{
+	struct connected *c = arg;
+
+	connected_free(&c);
+}
+
+/* Create new interface structure. */
+static struct interface *if_new(struct vrf *vrf)
+{
+	struct interface *ifp;
+
+	assert(vrf);
+
+	ifp = XCALLOC(MTYPE_IF, sizeof(struct interface));
+
+	ifp->ifindex = IFINDEX_INTERNAL;
+	ifp->name[0] = '\0';
+
+	ifp->vrf = vrf;
+
+	ifp->connected = list_new();
+	ifp->connected->del = ifp_connected_free;
+
+	ifp->nbr_connected = list_new();
+	ifp->nbr_connected->del = (void (*)(void *))nbr_connected_free;
+
+	/* Enable Link-detection by default */
+	SET_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION);
+
+	QOBJ_REG(ifp, interface);
+	return ifp;
+}
+
+void if_new_via_zapi(struct interface *ifp)
+{
+	if (ifp_master.create_hook)
+		(*ifp_master.create_hook)(ifp);
+}
+
+void if_destroy_via_zapi(struct interface *ifp)
+{
+	if (ifp_master.destroy_hook)
+		(*ifp_master.destroy_hook)(ifp);
+
+	ifp->oldifindex = ifp->ifindex;
+	if_set_index(ifp, IFINDEX_INTERNAL);
+
+	if (!ifp->configured)
+		if_delete(&ifp);
+}
+
+void if_up_via_zapi(struct interface *ifp)
+{
+	if (ifp_master.up_hook)
+		(*ifp_master.up_hook)(ifp);
+}
+
+void if_down_via_zapi(struct interface *ifp)
+{
+	if (ifp_master.down_hook)
+		(*ifp_master.down_hook)(ifp);
+}
+
+static struct interface *if_create_name(const char *name, struct vrf *vrf)
+{
+	struct interface *ifp;
+
+	ifp = if_new(vrf);
+
+	if_set_name(ifp, name);
+
+	hook_call(if_add, ifp);
+	return ifp;
+}
+
+/* Create new interface structure. */
+void if_update_to_new_vrf(struct interface *ifp, vrf_id_t vrf_id)
+{
+	struct vrf *old_vrf, *vrf;
+
+	/* remove interface from old master vrf list */
+	old_vrf = ifp->vrf;
+
+	if (ifp->name[0] != '\0')
+		IFNAME_RB_REMOVE(old_vrf, ifp);
+
+	if (ifp->ifindex != IFINDEX_INTERNAL)
+		IFINDEX_RB_REMOVE(old_vrf, ifp);
+
+	vrf = vrf_get(vrf_id, NULL);
+	ifp->vrf = vrf;
+
+	if (ifp->name[0] != '\0')
+		IFNAME_RB_INSERT(vrf, ifp);
+
+	if (ifp->ifindex != IFINDEX_INTERNAL)
+		IFINDEX_RB_INSERT(vrf, ifp);
+}
+
+
+/* Delete interface structure. */
+void if_delete_retain(struct interface *ifp)
+{
+	hook_call(if_del, ifp);
+	QOBJ_UNREG(ifp);
+
+	/* Free connected address list */
+	list_delete_all_node(ifp->connected);
+
+	/* Free connected nbr address list */
+	list_delete_all_node(ifp->nbr_connected);
+}
+
+/* Delete and free interface structure. */
+void if_delete(struct interface **ifp)
+{
+	struct interface *ptr = *ifp;
+	struct vrf *vrf = ptr->vrf;
+
+	IFNAME_RB_REMOVE(vrf, ptr);
+	if (ptr->ifindex != IFINDEX_INTERNAL)
+		IFINDEX_RB_REMOVE(vrf, ptr);
+
+	if_delete_retain(ptr);
+
+	list_delete(&ptr->connected);
+	list_delete(&ptr->nbr_connected);
+
+	if_link_params_free(ptr);
+
+	XFREE(MTYPE_IFDESC, ptr->desc);
+
+	XFREE(MTYPE_IF, ptr);
+	*ifp = NULL;
+}
+
+/* Used only internally to check within VRF only */
+static struct interface *if_lookup_by_ifindex(ifindex_t ifindex,
+					      vrf_id_t vrf_id)
+{
+	struct vrf *vrf;
+	struct interface if_tmp;
+
+	vrf = vrf_lookup_by_id(vrf_id);
+	if (!vrf)
+		return NULL;
+
+	if_tmp.ifindex = ifindex;
+	return RB_FIND(if_index_head, &vrf->ifaces_by_index, &if_tmp);
+}
+
+/* Interface existence check by index. */
+struct interface *if_lookup_by_index(ifindex_t ifindex, vrf_id_t vrf_id)
+{
+	switch (vrf_get_backend()) {
+	case VRF_BACKEND_UNKNOWN:
+	case VRF_BACKEND_NETNS:
+		return(if_lookup_by_ifindex(ifindex, vrf_id));
+	case VRF_BACKEND_VRF_LITE:
+		return(if_lookup_by_index_all_vrf(ifindex));
+	}
+	return NULL;
+}
+
+/* Interface existence check by index. */
+struct interface *if_vrf_lookup_by_index_next(ifindex_t ifindex,
+					      vrf_id_t vrf_id)
+{
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+	struct interface *tmp_ifp;
+	bool found = false;
+
+	if (!vrf)
+		return NULL;
+
+	if (ifindex == 0) {
+		tmp_ifp = RB_MIN(if_index_head, &vrf->ifaces_by_index);
+		/* skip the vrf interface */
+		if (tmp_ifp && if_is_vrf(tmp_ifp))
+			ifindex = tmp_ifp->ifindex;
+		else
+			return tmp_ifp;
+	}
+
+	RB_FOREACH (tmp_ifp, if_index_head, &vrf->ifaces_by_index) {
+		if (found) {
+			/* skip the vrf interface */
+			if (tmp_ifp && if_is_vrf(tmp_ifp))
+				continue;
+			else
+				return tmp_ifp;
+		}
+		if (tmp_ifp->ifindex == ifindex)
+			found = true;
+	}
+	return NULL;
+}
+
+const char *ifindex2ifname(ifindex_t ifindex, vrf_id_t vrf_id)
+{
+	struct interface *ifp;
+
+	return ((ifp = if_lookup_by_index(ifindex, vrf_id)) != NULL)
+		       ? ifp->name
+		       : "unknown";
+}
+
+ifindex_t ifname2ifindex(const char *name, vrf_id_t vrf_id)
+{
+	struct interface *ifp;
+
+	return ((ifp = if_lookup_by_name(name, vrf_id)) != NULL)
+		       ? ifp->ifindex
+		       : IFINDEX_INTERNAL;
+}
+
+/* Interface existence check by interface name. */
+struct interface *if_lookup_by_name(const char *name, vrf_id_t vrf_id)
+{
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+	struct interface if_tmp;
+
+	if (!vrf || !name
+	    || strnlen(name, INTERFACE_NAMSIZ) == INTERFACE_NAMSIZ)
+		return NULL;
+
+	strlcpy(if_tmp.name, name, sizeof(if_tmp.name));
+	return RB_FIND(if_name_head, &vrf->ifaces_by_name, &if_tmp);
+}
+
+struct interface *if_lookup_by_name_vrf(const char *name, struct vrf *vrf)
+{
+	struct interface if_tmp;
+
+	if (!name || strnlen(name, INTERFACE_NAMSIZ) == INTERFACE_NAMSIZ)
+		return NULL;
+
+	strlcpy(if_tmp.name, name, sizeof(if_tmp.name));
+	return RB_FIND(if_name_head, &vrf->ifaces_by_name, &if_tmp);
+}
+
+static struct interface *if_lookup_by_name_all_vrf(const char *name)
+{
+	struct vrf *vrf;
+	struct interface *ifp;
+
+	if (!name || strnlen(name, INTERFACE_NAMSIZ) == INTERFACE_NAMSIZ)
+		return NULL;
+
+	RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+		ifp = if_lookup_by_name_vrf(name, vrf);
+		if (ifp)
+			return ifp;
+	}
+
+	return NULL;
+}
+
+static struct interface *if_lookup_by_index_all_vrf(ifindex_t ifindex)
+{
+	struct vrf *vrf;
+	struct interface *ifp;
+
+	if (ifindex == IFINDEX_INTERNAL)
+		return NULL;
+
+	RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
+		ifp = if_lookup_by_ifindex(ifindex, vrf->vrf_id);
+		if (ifp)
+			return ifp;
+	}
+
+	return NULL;
+}
+
+/* Lookup interface by IP address.
+ *
+ * supersedes if_lookup_exact_address(), which didn't care about up/down
+ * state.  but all users we have either only care if the address is local
+ * (=> use if_address_is_local() please), or care about UP interfaces before
+ * anything else
+ *
+ * to accept only UP interfaces, check if_is_up() on the returned ifp.
+ */
+struct interface *if_lookup_address_local(const void *src, int family,
+					  vrf_id_t vrf_id)
+{
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+	struct listnode *cnode;
+	struct interface *ifp, *best_down = NULL;
+	struct prefix *p;
+	struct connected *c;
+
+	if (family != AF_INET && family != AF_INET6)
+		return NULL;
+
+	FOR_ALL_INTERFACES (vrf, ifp) {
+		for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, c)) {
+			p = c->address;
+
+			if (!p || p->family != family)
+				continue;
+
+			if (family == AF_INET) {
+				if (!IPV4_ADDR_SAME(&p->u.prefix4,
+						    (struct in_addr *)src))
+					continue;
+			} else if (family == AF_INET6) {
+				if (!IPV6_ADDR_SAME(&p->u.prefix6,
+						    (struct in6_addr *)src))
+					continue;
+			}
+
+			if (if_is_up(ifp))
+				return ifp;
+			if (!best_down)
+				best_down = ifp;
+		}
+	}
+	return best_down;
+}
+
+/* Lookup interface by IP address. */
+struct connected *if_lookup_address(const void *matchaddr, int family,
+				    vrf_id_t vrf_id)
+{
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+	struct prefix addr;
+	int bestlen = 0;
+	struct listnode *cnode;
+	struct interface *ifp;
+	struct connected *c;
+	struct connected *match;
+
+	if (family == AF_INET) {
+		addr.family = AF_INET;
+		addr.u.prefix4 = *((struct in_addr *)matchaddr);
+		addr.prefixlen = IPV4_MAX_BITLEN;
+	} else if (family == AF_INET6) {
+		addr.family = AF_INET6;
+		addr.u.prefix6 = *((struct in6_addr *)matchaddr);
+		addr.prefixlen = IPV6_MAX_BITLEN;
+	} else
+		assert(!"Attempted lookup of family not supported");
+
+	match = NULL;
+
+	FOR_ALL_INTERFACES (vrf, ifp) {
+		for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, c)) {
+			if (c->address && (c->address->family == AF_INET)
+			    && prefix_match(CONNECTED_PREFIX(c), &addr)
+			    && (c->address->prefixlen > bestlen)) {
+				bestlen = c->address->prefixlen;
+				match = c;
+			}
+		}
+	}
+	return match;
+}
+
+/* Lookup interface by prefix */
+struct interface *if_lookup_prefix(const struct prefix *prefix, vrf_id_t vrf_id)
+{
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+	struct listnode *cnode;
+	struct interface *ifp;
+	struct connected *c;
+
+	FOR_ALL_INTERFACES (vrf, ifp) {
+		for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, c)) {
+			if (prefix_cmp(c->address, prefix) == 0) {
+				return ifp;
+			}
+		}
+	}
+	return NULL;
+}
+
+size_t if_lookup_by_hwaddr(const uint8_t *hw_addr, size_t addrsz,
+			   struct interface ***result, vrf_id_t vrf_id)
+{
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+
+	struct list *rs = list_new();
+	struct interface *ifp;
+
+	FOR_ALL_INTERFACES (vrf, ifp) {
+		if (ifp->hw_addr_len == (int)addrsz
+		    && !memcmp(hw_addr, ifp->hw_addr, addrsz))
+			listnode_add(rs, ifp);
+	}
+
+	if (rs->count) {
+		*result = XCALLOC(MTYPE_TMP,
+				  sizeof(struct interface *) * rs->count);
+		list_to_array(rs, (void **)*result, rs->count);
+	}
+
+	int count = rs->count;
+
+	list_delete(&rs);
+
+	return count;
+}
+
+/* Get the VRF loopback interface, i.e. the loopback on the default VRF
+ * or the VRF interface.
+ */
+struct interface *if_get_vrf_loopback(vrf_id_t vrf_id)
+{
+	struct interface *ifp = NULL;
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+
+	FOR_ALL_INTERFACES (vrf, ifp)
+		if (if_is_loopback(ifp))
+			return ifp;
+
+	return NULL;
+}
+
+/* Get interface by name if given name interface doesn't exist create
+   one. */
+struct interface *if_get_by_name(const char *name, vrf_id_t vrf_id,
+				 const char *vrf_name)
+{
+	struct interface *ifp = NULL;
+	struct vrf *vrf;
+
+	switch (vrf_get_backend()) {
+	case VRF_BACKEND_UNKNOWN:
+	case VRF_BACKEND_NETNS:
+		vrf = vrf_get(vrf_id, vrf_name);
+		assert(vrf);
+
+		ifp = if_lookup_by_name_vrf(name, vrf);
+		if (ifp) {
+			/* If it came from the kernel or by way of zclient,
+			 * believe it and update the ifp accordingly.
+			 */
+			if (ifp->vrf->vrf_id != vrf_id && vrf_id != VRF_UNKNOWN)
+				if_update_to_new_vrf(ifp, vrf_id);
+
+			return ifp;
+		}
+
+		break;
+	case VRF_BACKEND_VRF_LITE:
+		ifp = if_lookup_by_name_all_vrf(name);
+		if (ifp) {
+			/* If it came from the kernel or by way of zclient,
+			 * believe it and update the ifp accordingly.
+			 */
+			if (ifp->vrf->vrf_id != vrf_id && vrf_id != VRF_UNKNOWN)
+				if_update_to_new_vrf(ifp, vrf_id);
+
+			return ifp;
+		}
+
+		vrf = vrf_get(vrf_id, vrf_name);
+		assert(vrf);
+
+		break;
+	default:
+		return NULL;
+	}
+
+	return if_create_name(name, vrf);
+}
+
+int if_set_index(struct interface *ifp, ifindex_t ifindex)
+{
+	if (ifp->ifindex == ifindex)
+		return 0;
+
+	/*
+	 * If there is already an interface with this ifindex, we will collide
+	 * on insertion, so don't even try.
+	 */
+	if (if_lookup_by_ifindex(ifindex, ifp->vrf->vrf_id))
+		return -1;
+
+	if (ifp->ifindex != IFINDEX_INTERNAL)
+		IFINDEX_RB_REMOVE(ifp->vrf, ifp);
+
+	ifp->ifindex = ifindex;
+
+	if (ifp->ifindex != IFINDEX_INTERNAL) {
+		/*
+		 * This should never happen, since we checked if there was
+		 * already an interface with the desired ifindex at the top of
+		 * the function. Nevertheless.
+		 */
+		if (IFINDEX_RB_INSERT(ifp->vrf, ifp))
+			return -1;
+	}
+
+	return 0;
+}
+
+static void if_set_name(struct interface *ifp, const char *name)
+{
+	if (if_cmp_name_func(ifp->name, name) == 0)
+		return;
+
+	if (ifp->name[0] != '\0')
+		IFNAME_RB_REMOVE(ifp->vrf, ifp);
+
+	strlcpy(ifp->name, name, sizeof(ifp->name));
+
+	if (ifp->name[0] != '\0')
+		IFNAME_RB_INSERT(ifp->vrf, ifp);
+}
+
+/* Does interface up ? */
+int if_is_up(const struct interface *ifp)
+{
+	return ifp->flags & IFF_UP;
+}
+
+/* Is interface running? */
+int if_is_running(const struct interface *ifp)
+{
+	return ifp->flags & IFF_RUNNING;
+}
+
+/* Is the interface operative, eg. either UP & RUNNING
+   or UP & !ZEBRA_INTERFACE_LINK_DETECTION and
+   if ptm checking is enabled, then ptm check has passed */
+int if_is_operative(const struct interface *ifp)
+{
+	return ((ifp->flags & IFF_UP)
+		&& (((ifp->flags & IFF_RUNNING)
+		     && (ifp->ptm_status || !ifp->ptm_enable))
+		    || !CHECK_FLAG(ifp->status,
+				   ZEBRA_INTERFACE_LINKDETECTION)));
+}
+
+/* Is the interface operative, eg. either UP & RUNNING
+   or UP & !ZEBRA_INTERFACE_LINK_DETECTION, without PTM check */
+int if_is_no_ptm_operative(const struct interface *ifp)
+{
+	return ((ifp->flags & IFF_UP)
+		&& ((ifp->flags & IFF_RUNNING)
+		    || !CHECK_FLAG(ifp->status,
+				   ZEBRA_INTERFACE_LINKDETECTION)));
+}
+
+/* Is this loopback interface ? */
+int if_is_loopback_exact(const struct interface *ifp)
+{
+	/* XXX: Do this better, eg what if IFF_WHATEVER means X on platform M
+	 * but Y on platform N?
+	 */
+	return (ifp->flags & (IFF_LOOPBACK | IFF_NOXMIT | IFF_VIRTUAL));
+}
+
+/* Check interface is VRF */
+int if_is_vrf(const struct interface *ifp)
+{
+	return CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
+}
+
+/* Should this interface be treated as a loopback? */
+bool if_is_loopback(const struct interface *ifp)
+{
+	if (if_is_loopback_exact(ifp) || if_is_vrf(ifp))
+		return true;
+
+	return false;
+}
+
+/* Does this interface support broadcast ? */
+int if_is_broadcast(const struct interface *ifp)
+{
+	return ifp->flags & IFF_BROADCAST;
+}
+
+/* Does this interface support pointopoint ? */
+int if_is_pointopoint(const struct interface *ifp)
+{
+	return ifp->flags & IFF_POINTOPOINT;
+}
+
+/* Does this interface support multicast ? */
+int if_is_multicast(const struct interface *ifp)
+{
+	return ifp->flags & IFF_MULTICAST;
+}
+
+/* Printout flag information into log */
+const char *if_flag_dump(unsigned long flag)
+{
+	int separator = 0;
+	static char logbuf[BUFSIZ];
+
+#define IFF_OUT_LOG(X, STR)                                                    \
+	if (flag & (X)) {                                                      \
+		if (separator)                                                 \
+			strlcat(logbuf, ",", sizeof(logbuf));                  \
+		else                                                           \
+			separator = 1;                                         \
+		strlcat(logbuf, STR, sizeof(logbuf));                          \
+	}
+
+	strlcpy(logbuf, "<", BUFSIZ);
+	IFF_OUT_LOG(IFF_UP, "UP");
+	IFF_OUT_LOG(IFF_BROADCAST, "BROADCAST");
+	IFF_OUT_LOG(IFF_DEBUG, "DEBUG");
+	IFF_OUT_LOG(IFF_LOOPBACK, "LOOPBACK");
+	IFF_OUT_LOG(IFF_POINTOPOINT, "POINTOPOINT");
+	IFF_OUT_LOG(IFF_NOTRAILERS, "NOTRAILERS");
+	IFF_OUT_LOG(IFF_RUNNING, "RUNNING");
+	IFF_OUT_LOG(IFF_NOARP, "NOARP");
+	IFF_OUT_LOG(IFF_PROMISC, "PROMISC");
+	IFF_OUT_LOG(IFF_ALLMULTI, "ALLMULTI");
+	IFF_OUT_LOG(IFF_OACTIVE, "OACTIVE");
+	IFF_OUT_LOG(IFF_SIMPLEX, "SIMPLEX");
+	IFF_OUT_LOG(IFF_LINK0, "LINK0");
+	IFF_OUT_LOG(IFF_LINK1, "LINK1");
+	IFF_OUT_LOG(IFF_LINK2, "LINK2");
+	IFF_OUT_LOG(IFF_MULTICAST, "MULTICAST");
+	IFF_OUT_LOG(IFF_NOXMIT, "NOXMIT");
+	IFF_OUT_LOG(IFF_NORTEXCH, "NORTEXCH");
+	IFF_OUT_LOG(IFF_VIRTUAL, "VIRTUAL");
+	IFF_OUT_LOG(IFF_IPV4, "IPv4");
+	IFF_OUT_LOG(IFF_IPV6, "IPv6");
+
+	strlcat(logbuf, ">", sizeof(logbuf));
+
+	return logbuf;
+#undef IFF_OUT_LOG
+}
+
+/* For debugging */
+static void if_dump(const struct interface *ifp)
+{
+	struct listnode *node;
+	struct connected *c __attribute__((unused));
+
+	for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, c))
+		zlog_info(
+			"Interface %s vrf %s(%u) index %d metric %d mtu %d mtu6 %d %s",
+			ifp->name, ifp->vrf->name, ifp->vrf->vrf_id,
+			ifp->ifindex, ifp->metric, ifp->mtu, ifp->mtu6,
+			if_flag_dump(ifp->flags));
+}
+
+/* Interface printing for all interface. */
+void if_dump_all(void)
+{
+	struct vrf *vrf;
+	void *ifp;
+
+	RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
+		FOR_ALL_INTERFACES (vrf, ifp)
+			if_dump(ifp);
+}
+
+/* Allocate connected structure. */
+struct connected *connected_new(void)
+{
+	return XCALLOC(MTYPE_CONNECTED, sizeof(struct connected));
+}
+
+/* Allocate nbr connected structure. */
+struct nbr_connected *nbr_connected_new(void)
+{
+	return XCALLOC(MTYPE_NBR_CONNECTED, sizeof(struct nbr_connected));
+}
+
+/* Free connected structure. */
+void connected_free(struct connected **connected)
+{
+	struct connected *ptr = *connected;
+
+	prefix_free(&ptr->address);
+	prefix_free(&ptr->destination);
+
+	XFREE(MTYPE_CONNECTED_LABEL, ptr->label);
+
+	XFREE(MTYPE_CONNECTED, ptr);
+	*connected = NULL;
+}
+
+/* Free nbr connected structure. */
+void nbr_connected_free(struct nbr_connected *connected)
+{
+	if (connected->address)
+		prefix_free(&connected->address);
+
+	XFREE(MTYPE_NBR_CONNECTED, connected);
+}
+
+/* If same interface nbr address already exists... */
+struct nbr_connected *nbr_connected_check(struct interface *ifp,
+					  struct prefix *p)
+{
+	struct nbr_connected *ifc;
+	struct listnode *node;
+
+	for (ALL_LIST_ELEMENTS_RO(ifp->nbr_connected, node, ifc))
+		if (prefix_same(ifc->address, p))
+			return ifc;
+
+	return NULL;
+}
+
+/* Print if_addr structure. */
+static void __attribute__((unused))
+connected_log(struct connected *connected, char *str)
+{
+	struct prefix *p;
+	struct interface *ifp;
+	char logbuf[BUFSIZ];
+	char buf[BUFSIZ];
+
+	ifp = connected->ifp;
+	p = connected->address;
+
+	snprintf(logbuf, sizeof(logbuf), "%s interface %s vrf %s(%u) %s %pFX ",
+		 str, ifp->name, ifp->vrf->name, ifp->vrf->vrf_id,
+		 prefix_family_str(p), p);
+
+	p = connected->destination;
+	if (p) {
+		strlcat(logbuf, inet_ntop(p->family, &p->u.prefix, buf, BUFSIZ),
+			BUFSIZ);
+	}
+	zlog_info("%s", logbuf);
+}
+
+/* Print if_addr structure. */
+static void __attribute__((unused))
+nbr_connected_log(struct nbr_connected *connected, char *str)
+{
+	struct prefix *p;
+	struct interface *ifp;
+	char logbuf[BUFSIZ];
+
+	ifp = connected->ifp;
+	p = connected->address;
+
+	snprintf(logbuf, sizeof(logbuf), "%s interface %s %s %pFX ", str,
+		 ifp->name, prefix_family_str(p), p);
+
+	zlog_info("%s", logbuf);
+}
+
+/* If two connected address has same prefix return 1. */
+static int connected_same_prefix(const struct prefix *p1,
+				 const struct prefix *p2)
+{
+	if (p1->family == p2->family) {
+		if (p1->family == AF_INET
+		    && IPV4_ADDR_SAME(&p1->u.prefix4, &p2->u.prefix4))
+			return 1;
+		if (p1->family == AF_INET6
+		    && IPV6_ADDR_SAME(&p1->u.prefix6, &p2->u.prefix6))
+			return 1;
+	}
+	return 0;
+}
+
+/* count the number of connected addresses that are in the given family */
+unsigned int connected_count_by_family(struct interface *ifp, int family)
+{
+	struct listnode *cnode;
+	struct connected *connected;
+	unsigned int cnt = 0;
+
+	for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected))
+		if (connected->address->family == family)
+			cnt++;
+
+	return cnt;
+}
+
+struct connected *connected_lookup_prefix_exact(struct interface *ifp,
+						const struct prefix *p)
+{
+	struct listnode *node;
+	struct listnode *next;
+	struct connected *ifc;
+
+	for (node = listhead(ifp->connected); node; node = next) {
+		ifc = listgetdata(node);
+		next = node->next;
+
+		if (connected_same_prefix(ifc->address, p))
+			return ifc;
+	}
+	return NULL;
+}
+
+struct connected *connected_delete_by_prefix(struct interface *ifp,
+					     struct prefix *p)
+{
+	struct listnode *node;
+	struct listnode *next;
+	struct connected *ifc;
+
+	/* In case of same prefix come, replace it with new one. */
+	for (node = listhead(ifp->connected); node; node = next) {
+		ifc = listgetdata(node);
+		next = node->next;
+
+		if (connected_same_prefix(ifc->address, p)) {
+			listnode_delete(ifp->connected, ifc);
+			return ifc;
+		}
+	}
+	return NULL;
+}
+
+/* Find the address on our side that will be used when packets
+   are sent to dst. */
+struct connected *connected_lookup_prefix(struct interface *ifp,
+					  const struct prefix *addr)
+{
+	struct listnode *cnode;
+	struct connected *c;
+	struct connected *match;
+
+	match = NULL;
+
+	for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, c)) {
+		if (c->address && (c->address->family == addr->family)
+		    && prefix_match(CONNECTED_PREFIX(c), addr)
+		    && (!match
+			|| (c->address->prefixlen > match->address->prefixlen)))
+			match = c;
+	}
+	return match;
+}
+
+struct connected *connected_add_by_prefix(struct interface *ifp,
+					  struct prefix *p,
+					  struct prefix *destination)
+{
+	struct connected *ifc;
+
+	/* Allocate new connected address. */
+	ifc = connected_new();
+	ifc->ifp = ifp;
+
+	/* Fetch interface address */
+	ifc->address = prefix_new();
+	memcpy(ifc->address, p, sizeof(struct prefix));
+
+	/* Fetch dest address */
+	if (destination) {
+		ifc->destination = prefix_new();
+		memcpy(ifc->destination, destination, sizeof(struct prefix));
+	}
+
+	/* Add connected address to the interface. */
+	listnode_add(ifp->connected, ifc);
+	return ifc;
+}
+
+struct connected *connected_get_linklocal(struct interface *ifp)
+{
+	struct listnode *n;
+	struct connected *c = NULL;
+
+	for (ALL_LIST_ELEMENTS_RO(ifp->connected, n, c)) {
+		if (c->address->family == AF_INET6
+		    && IN6_IS_ADDR_LINKLOCAL(&c->address->u.prefix6))
+			break;
+	}
+	return c;
+}
+
+void if_terminate(struct vrf *vrf)
+{
+	struct interface *ifp;
+
+	while (!RB_EMPTY(if_name_head, &vrf->ifaces_by_name)) {
+		ifp = RB_ROOT(if_name_head, &vrf->ifaces_by_name);
+
+		if (ifp->node) {
+			ifp->node->info = NULL;
+			route_unlock_node(ifp->node);
+			ifp->node = NULL;
+		}
+		if_delete(&ifp);
+	}
+}
+
+const char *if_link_type_str(enum zebra_link_type llt)
+{
+	switch (llt) {
+#define llts(T,S) case (T): return (S)
+		llts(ZEBRA_LLT_UNKNOWN, "Unknown");
+		llts(ZEBRA_LLT_ETHER, "Ethernet");
+		llts(ZEBRA_LLT_EETHER, "Experimental Ethernet");
+		llts(ZEBRA_LLT_AX25, "AX.25 Level 2");
+		llts(ZEBRA_LLT_PRONET, "PROnet token ring");
+		llts(ZEBRA_LLT_IEEE802, "IEEE 802.2 Ethernet/TR/TB");
+		llts(ZEBRA_LLT_ARCNET, "ARCnet");
+		llts(ZEBRA_LLT_APPLETLK, "AppleTalk");
+		llts(ZEBRA_LLT_DLCI, "Frame Relay DLCI");
+		llts(ZEBRA_LLT_ATM, "ATM");
+		llts(ZEBRA_LLT_METRICOM, "Metricom STRIP");
+		llts(ZEBRA_LLT_IEEE1394, "IEEE 1394 IPv4");
+		llts(ZEBRA_LLT_EUI64, "EUI-64");
+		llts(ZEBRA_LLT_INFINIBAND, "InfiniBand");
+		llts(ZEBRA_LLT_SLIP, "SLIP");
+		llts(ZEBRA_LLT_CSLIP, "Compressed SLIP");
+		llts(ZEBRA_LLT_SLIP6, "SLIPv6");
+		llts(ZEBRA_LLT_CSLIP6, "Compressed SLIPv6");
+		llts(ZEBRA_LLT_RSRVD, "Reserved");
+		llts(ZEBRA_LLT_ADAPT, "Adapt");
+		llts(ZEBRA_LLT_ROSE, "ROSE packet radio");
+		llts(ZEBRA_LLT_X25, "CCITT X.25");
+		llts(ZEBRA_LLT_PPP, "PPP");
+		llts(ZEBRA_LLT_CHDLC, "Cisco HDLC");
+		llts(ZEBRA_LLT_RAWHDLC, "Raw HDLC");
+		llts(ZEBRA_LLT_LAPB, "LAPB");
+		llts(ZEBRA_LLT_IPIP, "IPIP Tunnel");
+		llts(ZEBRA_LLT_IPIP6, "IPIP6 Tunnel");
+		llts(ZEBRA_LLT_FRAD, "FRAD");
+		llts(ZEBRA_LLT_SKIP, "SKIP vif");
+		llts(ZEBRA_LLT_LOOPBACK, "Loopback");
+		llts(ZEBRA_LLT_LOCALTLK, "Localtalk");
+		llts(ZEBRA_LLT_FDDI, "FDDI");
+		llts(ZEBRA_LLT_SIT, "IPv6-in-IPv4 SIT");
+		llts(ZEBRA_LLT_IPDDP, "IP-in-DDP tunnel");
+		llts(ZEBRA_LLT_IPGRE, "GRE over IP");
+		llts(ZEBRA_LLT_IP6GRE, "GRE over IPv6");
+		llts(ZEBRA_LLT_PIMREG, "PIMSM registration");
+		llts(ZEBRA_LLT_HIPPI, "HiPPI");
+		llts(ZEBRA_LLT_ECONET, "Acorn Econet");
+		llts(ZEBRA_LLT_IRDA, "IrDA");
+		llts(ZEBRA_LLT_FCPP, "Fibre-Channel PtP");
+		llts(ZEBRA_LLT_FCAL, "Fibre-Channel Arbitrated Loop");
+		llts(ZEBRA_LLT_FCPL, "Fibre-Channel Public Loop");
+		llts(ZEBRA_LLT_FCFABRIC, "Fibre-Channel Fabric");
+		llts(ZEBRA_LLT_IEEE802_TR, "IEEE 802.2 Token Ring");
+		llts(ZEBRA_LLT_IEEE80211, "IEEE 802.11");
+		llts(ZEBRA_LLT_IEEE80211_RADIOTAP, "IEEE 802.11 Radiotap");
+		llts(ZEBRA_LLT_IEEE802154, "IEEE 802.15.4");
+		llts(ZEBRA_LLT_IEEE802154_PHY, "IEEE 802.15.4 Phy");
+#undef llts
+	}
+	return NULL;
+}
+
+bool if_link_params_cmp(struct if_link_params *iflp1,
+			struct if_link_params *iflp2)
+{
+	struct if_link_params iflp1_copy, iflp2_copy;
+
+	/* Extended admin-groups in if_link_params contain pointers.
+	 * They cannot be compared with memcpy.
+	 * Make copies of if_link_params without ext. admin-groups
+	 * and compare separately the ext. admin-groups.
+	 */
+	memcpy(&iflp1_copy, iflp1, sizeof(struct if_link_params));
+	memset(&iflp1_copy.ext_admin_grp, 0, sizeof(struct admin_group));
+
+	memcpy(&iflp2_copy, iflp2, sizeof(struct if_link_params));
+	memset(&iflp2_copy.ext_admin_grp, 0, sizeof(struct admin_group));
+
+	if (memcmp(&iflp1_copy, &iflp2_copy, sizeof(struct if_link_params)))
+		return false;
+
+	if (!admin_group_cmp(&iflp1->ext_admin_grp, &iflp2->ext_admin_grp))
+		return false;
+
+	return true;
+}
+
+void if_link_params_copy(struct if_link_params *dst, struct if_link_params *src)
+{
+	struct admin_group dst_ag;
+
+	/* backup the admin_group structure that contains a pointer */
+	memcpy(&dst_ag, &dst->ext_admin_grp, sizeof(struct admin_group));
+	/* copy the if_link_params structure */
+	memcpy(dst, src, sizeof(struct if_link_params));
+	/* restore the admin_group structure */
+	memcpy(&dst->ext_admin_grp, &dst_ag, sizeof(struct admin_group));
+	/* copy src->ext_admin_grp data to dst->ext_admin_grp data memory */
+	admin_group_copy(&dst->ext_admin_grp, &src->ext_admin_grp);
+}
+
+struct if_link_params *if_link_params_get(struct interface *ifp)
+{
+	return ifp->link_params;
+}
+
+struct if_link_params *if_link_params_enable(struct interface *ifp)
+{
+	struct if_link_params *iflp;
+	int i;
+
+	iflp = if_link_params_init(ifp);
+
+	/* Compute default bandwidth based on interface */
+	iflp->default_bw =
+		((ifp->bandwidth ? ifp->bandwidth : DEFAULT_BANDWIDTH)
+		 * TE_MEGA_BIT / TE_BYTE);
+
+	/* Set Max, Reservable and Unreserved Bandwidth */
+	iflp->max_bw = iflp->default_bw;
+	iflp->max_rsv_bw = iflp->default_bw;
+	for (i = 0; i < MAX_CLASS_TYPE; i++)
+		iflp->unrsv_bw[i] = iflp->default_bw;
+
+	/* Update Link parameters status */
+	iflp->lp_status = LP_MAX_BW | LP_MAX_RSV_BW | LP_UNRSV_BW;
+
+	/* Set TE metric equal to standard metric only if it is set */
+	if (ifp->metric != 0) {
+		iflp->te_metric = ifp->metric;
+		iflp->lp_status |= LP_TE_METRIC;
+	}
+
+	/* Finally attach newly created Link Parameters */
+	ifp->link_params = iflp;
+
+	return iflp;
+}
+
+struct if_link_params *if_link_params_init(struct interface *ifp)
+{
+	struct if_link_params *iflp = if_link_params_get(ifp);
+
+	if (iflp)
+		return iflp;
+
+	iflp = XCALLOC(MTYPE_IF_LINK_PARAMS, sizeof(struct if_link_params));
+
+	admin_group_init(&iflp->ext_admin_grp);
+
+	ifp->link_params = iflp;
+
+	return iflp;
+}
+
+void if_link_params_free(struct interface *ifp)
+{
+	if (!ifp->link_params)
+		return;
+
+	admin_group_term(&ifp->link_params->ext_admin_grp);
+	XFREE(MTYPE_IF_LINK_PARAMS, ifp->link_params);
+}
+
+/* ----------- CLI commands ----------- */
+
+/* Guess the VRF of an interface. */
+static int vrfname_by_ifname(const char *ifname, const char **vrfname)
+{
+	struct vrf *vrf;
+	struct interface *ifp;
+	int count = 0;
+
+	RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+		FOR_ALL_INTERFACES (vrf, ifp) {
+			if (strmatch(ifp->name, ifname)) {
+				*vrfname = vrf->name;
+				count++;
+			}
+		}
+	}
+
+	return count;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface
+ */
+DEFPY_YANG_NOSH (interface,
+       interface_cmd,
+       "interface IFNAME [vrf NAME$vrf_name]",
+       "Select an interface to configure\n"
+       "Interface's name\n"
+       VRF_CMD_HELP_STR)
+{
+	char xpath_list[XPATH_MAXLEN];
+	struct interface *ifp;
+	struct vrf *vrf;
+	int ret, count;
+
+	if (vrf_is_backend_netns()) {
+		/*
+		 * For backward compatibility, if the VRF name is not specified
+		 * and there is exactly one interface with this name in the
+		 * system, use its VRF. Otherwise fallback to the default VRF.
+		 */
+		if (!vrf_name) {
+			count = vrfname_by_ifname(ifname, &vrf_name);
+			if (count != 1)
+				vrf_name = VRF_DEFAULT_NAME;
+		}
+
+		snprintf(xpath_list, XPATH_MAXLEN,
+			 "/frr-interface:lib/interface[name='%s:%s']", vrf_name,
+			 ifname);
+	} else {
+		snprintf(xpath_list, XPATH_MAXLEN,
+			 "/frr-interface:lib/interface[name='%s']", ifname);
+	}
+
+	nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, NULL);
+	ret = nb_cli_apply_changes_clear_pending(vty, "%s", xpath_list);
+	if (ret == CMD_SUCCESS) {
+		VTY_PUSH_XPATH(INTERFACE_NODE, xpath_list);
+
+		/*
+		 * For backward compatibility with old commands we still need
+		 * to use the qobj infrastructure. This can be removed once
+		 * all interface-level commands are converted to the new
+		 * northbound model.
+		 */
+		if (vrf_is_backend_netns()) {
+			vrf = vrf_lookup_by_name(vrf_name);
+			if (vrf)
+				ifp = if_lookup_by_name_vrf(ifname, vrf);
+			else
+				ifp = NULL;
+		} else {
+			ifp = if_lookup_by_name_all_vrf(ifname);
+		}
+		if (ifp)
+			VTY_PUSH_CONTEXT(INTERFACE_NODE, ifp);
+	}
+
+	return ret;
+}
+
+DEFPY_YANG (no_interface,
+       no_interface_cmd,
+       "no interface IFNAME [vrf NAME$vrf_name]",
+       NO_STR
+       "Delete a pseudo interface's configuration\n"
+       "Interface's name\n"
+       VRF_CMD_HELP_STR)
+{
+	char xpath_list[XPATH_MAXLEN];
+	int count;
+
+	if (vrf_is_backend_netns()) {
+		/*
+		 * For backward compatibility, if the VRF name is not specified
+		 * and there is exactly one interface with this name in the
+		 * system, use its VRF. Otherwise fallback to the default VRF.
+		 */
+		if (!vrf_name) {
+			count = vrfname_by_ifname(ifname, &vrf_name);
+			if (count != 1)
+				vrf_name = VRF_DEFAULT_NAME;
+		}
+
+		snprintf(xpath_list, XPATH_MAXLEN,
+			 "/frr-interface:lib/interface[name='%s:%s']", vrf_name,
+			 ifname);
+	} else {
+		snprintf(xpath_list, XPATH_MAXLEN,
+			 "/frr-interface:lib/interface[name='%s']", ifname);
+	}
+
+	nb_cli_enqueue_change(vty, ".", NB_OP_DESTROY, NULL);
+
+	return nb_cli_apply_changes(vty, "%s", xpath_list);
+}
+
+static void netns_ifname_split(const char *xpath, char *ifname, char *vrfname)
+{
+	char *delim;
+	int len;
+
+	assert(vrf_is_backend_netns());
+
+	delim = strchr(xpath, ':');
+	assert(delim);
+
+	len = delim - xpath;
+	memcpy(vrfname, xpath, len);
+	vrfname[len] = 0;
+
+	strlcpy(ifname, delim + 1, XPATH_MAXLEN);
+}
+
+static void cli_show_interface(struct vty *vty, const struct lyd_node *dnode,
+			       bool show_defaults)
+{
+	vty_out(vty, "!\n");
+
+	if (vrf_is_backend_netns()) {
+		char ifname[XPATH_MAXLEN];
+		char vrfname[XPATH_MAXLEN];
+
+		netns_ifname_split(yang_dnode_get_string(dnode, "./name"),
+				   ifname, vrfname);
+
+		vty_out(vty, "interface %s", ifname);
+		if (!strmatch(vrfname, VRF_DEFAULT_NAME))
+			vty_out(vty, " vrf %s", vrfname);
+	} else {
+		const char *ifname = yang_dnode_get_string(dnode, "./name");
+
+		vty_out(vty, "interface %s", ifname);
+	}
+
+	vty_out(vty, "\n");
+}
+
+static void cli_show_interface_end(struct vty *vty,
+				   const struct lyd_node *dnode)
+{
+	vty_out(vty, "exit\n");
+}
+
+void if_vty_config_start(struct vty *vty, struct interface *ifp)
+{
+	vty_frame(vty, "!\n");
+	vty_frame(vty, "interface %s", ifp->name);
+
+	if (vrf_is_backend_netns() && strcmp(ifp->vrf->name, VRF_DEFAULT_NAME))
+		vty_frame(vty, " vrf %s", ifp->vrf->name);
+
+	vty_frame(vty, "\n");
+}
+
+void if_vty_config_end(struct vty *vty)
+{
+	vty_endframe(vty, "exit\n!\n");
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/description
+ */
+DEFPY_YANG (interface_desc,
+       interface_desc_cmd,
+       "description LINE...",
+       "Interface specific description\n"
+       "Characters describing this interface\n")
+{
+	char *desc;
+	int ret;
+
+	desc = argv_concat(argv, argc, 1);
+	nb_cli_enqueue_change(vty, "./description", NB_OP_MODIFY, desc);
+	ret = nb_cli_apply_changes(vty, NULL);
+	XFREE(MTYPE_TMP, desc);
+
+	return ret;
+}
+
+DEFPY_YANG  (no_interface_desc,
+	no_interface_desc_cmd,
+	"no description",
+	NO_STR
+	"Interface specific description\n")
+{
+	nb_cli_enqueue_change(vty, "./description", NB_OP_DESTROY, NULL);
+
+	return nb_cli_apply_changes(vty, NULL);
+}
+
+static void cli_show_interface_desc(struct vty *vty,
+				    const struct lyd_node *dnode,
+				    bool show_defaults)
+{
+	vty_out(vty, " description %s\n", yang_dnode_get_string(dnode, NULL));
+}
+
+/* Interface autocomplete. */
+static void if_autocomplete(vector comps, struct cmd_token *token)
+{
+	struct interface *ifp;
+	struct vrf *vrf;
+
+	RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+		FOR_ALL_INTERFACES (vrf, ifp) {
+			vector_set(comps, XSTRDUP(MTYPE_COMPLETION, ifp->name));
+		}
+	}
+}
+
+static const struct cmd_variable_handler if_var_handlers[] = {
+	{/* "interface NAME" */
+	 .varname = "interface",
+	 .completions = if_autocomplete},
+	{.tokenname = "IFNAME", .completions = if_autocomplete},
+	{.tokenname = "INTERFACE", .completions = if_autocomplete},
+	{.completions = NULL}};
+
+static struct cmd_node interface_node = {
+	.name = "interface",
+	.node = INTERFACE_NODE,
+	.parent_node = CONFIG_NODE,
+	.prompt = "%s(config-if)# ",
+};
+
+static int if_config_write_single(const struct lyd_node *dnode, void *arg)
+{
+	nb_cli_show_dnode_cmds(arg, dnode, false);
+
+	return YANG_ITER_CONTINUE;
+}
+
+static int if_nb_config_write(struct vty *vty)
+{
+	yang_dnode_iterate(if_config_write_single, vty, running_config->dnode,
+			   "/frr-interface:lib/interface");
+	return 1;
+}
+
+void if_cmd_init(int (*config_write)(struct vty *))
+{
+	cmd_variable_handler_register(if_var_handlers);
+
+	interface_node.config_write = config_write;
+	install_node(&interface_node);
+
+	install_element(CONFIG_NODE, &interface_cmd);
+	install_element(CONFIG_NODE, &no_interface_cmd);
+
+	install_default(INTERFACE_NODE);
+	install_element(INTERFACE_NODE, &interface_desc_cmd);
+	install_element(INTERFACE_NODE, &no_interface_desc_cmd);
+}
+
+void if_cmd_init_default(void)
+{
+	if_cmd_init(if_nb_config_write);
+}
+
+void if_zapi_callbacks(int (*create)(struct interface *ifp),
+		       int (*up)(struct interface *ifp),
+		       int (*down)(struct interface *ifp),
+		       int (*destroy)(struct interface *ifp))
+{
+	ifp_master.create_hook = create;
+	ifp_master.up_hook = up;
+	ifp_master.down_hook = down;
+	ifp_master.destroy_hook = destroy;
+}
+
+/* ------- Northbound callbacks ------- */
+
+/*
+ * XPath: /frr-interface:lib/interface
+ */
+static int lib_interface_create(struct nb_cb_create_args *args)
+{
+	const char *ifname;
+	struct interface *ifp;
+
+	ifname = yang_dnode_get_string(args->dnode, "./name");
+
+	switch (args->event) {
+	case NB_EV_VALIDATE:
+		if (vrf_is_backend_netns()) {
+			char ifname_ns[XPATH_MAXLEN];
+			char vrfname_ns[XPATH_MAXLEN];
+
+			netns_ifname_split(ifname, ifname_ns, vrfname_ns);
+
+			if (strlen(ifname_ns) > 16) {
+				snprintf(
+					args->errmsg, args->errmsg_len,
+					"Maximum interface name length is 16 characters");
+				return NB_ERR_VALIDATION;
+			}
+			if (strlen(vrfname_ns) > 36) {
+				snprintf(
+					args->errmsg, args->errmsg_len,
+					"Maximum VRF name length is 36 characters");
+				return NB_ERR_VALIDATION;
+			}
+		} else {
+			if (strlen(ifname) > 16) {
+				snprintf(
+					args->errmsg, args->errmsg_len,
+					"Maximum interface name length is 16 characters");
+				return NB_ERR_VALIDATION;
+			}
+		}
+		break;
+	case NB_EV_PREPARE:
+	case NB_EV_ABORT:
+		break;
+	case NB_EV_APPLY:
+		if (vrf_is_backend_netns()) {
+			char ifname_ns[XPATH_MAXLEN];
+			char vrfname_ns[XPATH_MAXLEN];
+
+			netns_ifname_split(ifname, ifname_ns, vrfname_ns);
+
+			ifp = if_get_by_name(ifname_ns, VRF_UNKNOWN,
+					     vrfname_ns);
+		} else {
+			ifp = if_get_by_name(ifname, VRF_UNKNOWN,
+					     VRF_DEFAULT_NAME);
+		}
+
+		ifp->configured = true;
+		nb_running_set_entry(args->dnode, ifp);
+		break;
+	}
+
+	return NB_OK;
+}
+
+static int lib_interface_destroy(struct nb_cb_destroy_args *args)
+{
+	struct interface *ifp;
+	struct vrf *vrf;
+
+	switch (args->event) {
+	case NB_EV_VALIDATE:
+		ifp = nb_running_get_entry(args->dnode, NULL, true);
+		if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
+			snprintf(args->errmsg, args->errmsg_len,
+				 "only inactive interfaces can be deleted");
+			return NB_ERR_VALIDATION;
+		}
+		break;
+	case NB_EV_PREPARE:
+	case NB_EV_ABORT:
+		break;
+	case NB_EV_APPLY:
+		ifp = nb_running_unset_entry(args->dnode);
+		vrf = ifp->vrf;
+
+		ifp->configured = false;
+		if_delete(&ifp);
+
+		if (!vrf_is_enabled(vrf))
+			vrf_delete(vrf);
+		break;
+	}
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface
+ */
+static const void *lib_interface_get_next(struct nb_cb_get_next_args *args)
+{
+	struct vrf *vrf;
+	struct interface *pif = (struct interface *)args->list_entry;
+
+	if (args->list_entry == NULL) {
+		vrf = RB_MIN(vrf_name_head, &vrfs_by_name);
+		assert(vrf);
+		pif = RB_MIN(if_name_head, &vrf->ifaces_by_name);
+	} else {
+		vrf = pif->vrf;
+		pif = RB_NEXT(if_name_head, pif);
+		/* if no more interfaces, switch to next vrf */
+		while (pif == NULL) {
+			vrf = RB_NEXT(vrf_name_head, vrf);
+			if (!vrf)
+				return NULL;
+			pif = RB_MIN(if_name_head, &vrf->ifaces_by_name);
+		}
+	}
+
+	return pif;
+}
+
+static int lib_interface_get_keys(struct nb_cb_get_keys_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+
+	args->keys->num = 1;
+
+	if (vrf_is_backend_netns())
+		snprintf(args->keys->key[0], sizeof(args->keys->key[0]),
+			 "%s:%s", ifp->vrf->name, ifp->name);
+	else
+		snprintf(args->keys->key[0], sizeof(args->keys->key[0]), "%s",
+			 ifp->name);
+
+	return NB_OK;
+}
+
+static const void *
+lib_interface_lookup_entry(struct nb_cb_lookup_entry_args *args)
+{
+	if (vrf_is_backend_netns()) {
+		char ifname[XPATH_MAXLEN];
+		char vrfname[XPATH_MAXLEN];
+		struct vrf *vrf;
+
+		netns_ifname_split(args->keys->key[0], ifname, vrfname);
+
+		vrf = vrf_lookup_by_name(vrfname);
+
+		return vrf ? if_lookup_by_name(ifname, vrf->vrf_id) : NULL;
+	} else {
+		return if_lookup_by_name_all_vrf(args->keys->key[0]);
+	}
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/description
+ */
+static int lib_interface_description_modify(struct nb_cb_modify_args *args)
+{
+	struct interface *ifp;
+	const char *description;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	XFREE(MTYPE_IFDESC, ifp->desc);
+	description = yang_dnode_get_string(args->dnode, NULL);
+	ifp->desc = XSTRDUP(MTYPE_IFDESC, description);
+
+	return NB_OK;
+}
+
+static int lib_interface_description_destroy(struct nb_cb_destroy_args *args)
+{
+	struct interface *ifp;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	XFREE(MTYPE_IFDESC, ifp->desc);
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/vrf
+ */
+static struct yang_data *
+lib_interface_vrf_get_elem(struct nb_cb_get_elem_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+
+	return yang_data_new_string(args->xpath, ifp->vrf->name);
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/if-index
+ */
+static struct yang_data *
+lib_interface_state_if_index_get_elem(struct nb_cb_get_elem_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+
+	return yang_data_new_int32(args->xpath, ifp->ifindex);
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/mtu
+ */
+static struct yang_data *
+lib_interface_state_mtu_get_elem(struct nb_cb_get_elem_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+
+	return yang_data_new_uint16(args->xpath, ifp->mtu);
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/mtu6
+ */
+static struct yang_data *
+lib_interface_state_mtu6_get_elem(struct nb_cb_get_elem_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+
+	return yang_data_new_uint32(args->xpath, ifp->mtu6);
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/speed
+ */
+static struct yang_data *
+lib_interface_state_speed_get_elem(struct nb_cb_get_elem_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+
+	return yang_data_new_uint32(args->xpath, ifp->speed);
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/metric
+ */
+static struct yang_data *
+lib_interface_state_metric_get_elem(struct nb_cb_get_elem_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+
+	return yang_data_new_uint32(args->xpath, ifp->metric);
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/flags
+ */
+static struct yang_data *
+lib_interface_state_flags_get_elem(struct nb_cb_get_elem_args *args)
+{
+	/* TODO: implement me. */
+	return NULL;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/type
+ */
+static struct yang_data *
+lib_interface_state_type_get_elem(struct nb_cb_get_elem_args *args)
+{
+	/* TODO: implement me. */
+	return NULL;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/state/phy-address
+ */
+static struct yang_data *
+lib_interface_state_phy_address_get_elem(struct nb_cb_get_elem_args *args)
+{
+	const struct interface *ifp = args->list_entry;
+	struct ethaddr macaddr;
+
+	memcpy(&macaddr.octet, ifp->hw_addr, ETH_ALEN);
+
+	return yang_data_new_mac(args->xpath, &macaddr);
+}
+
+/* clang-format off */
+const struct frr_yang_module_info frr_interface_info = {
+	.name = "frr-interface",
+	.nodes = {
+		{
+			.xpath = "/frr-interface:lib/interface",
+			.cbs = {
+				.create = lib_interface_create,
+				.destroy = lib_interface_destroy,
+				.cli_show = cli_show_interface,
+				.cli_show_end = cli_show_interface_end,
+				.get_next = lib_interface_get_next,
+				.get_keys = lib_interface_get_keys,
+				.lookup_entry = lib_interface_lookup_entry,
+			},
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/description",
+			.cbs = {
+				.modify = lib_interface_description_modify,
+				.destroy = lib_interface_description_destroy,
+				.cli_show = cli_show_interface_desc,
+			},
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/vrf",
+			.cbs = {
+				.get_elem = lib_interface_vrf_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/if-index",
+			.cbs = {
+				.get_elem = lib_interface_state_if_index_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/mtu",
+			.cbs = {
+				.get_elem = lib_interface_state_mtu_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/mtu6",
+			.cbs = {
+				.get_elem = lib_interface_state_mtu6_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/speed",
+			.cbs = {
+				.get_elem = lib_interface_state_speed_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/metric",
+			.cbs = {
+				.get_elem = lib_interface_state_metric_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/flags",
+			.cbs = {
+				.get_elem = lib_interface_state_flags_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/type",
+			.cbs = {
+				.get_elem = lib_interface_state_type_get_elem,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/state/phy-address",
+			.cbs = {
+				.get_elem = lib_interface_state_phy_address_get_elem,
+			}
+		},
+		{
+			.xpath = NULL,
+		},
+	}
+};