Adding upstream version 9.1.upstream/9.1

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

1 files changed, 847 insertions, 0 deletions

diff --git a/isisd/isis_redist.c b/isisd/isis_redist.c
new file mode 100644
index 0000000..2cb08db
--- /dev/null
+++ b/isisd/isis_redist.c
@@ -0,0 +1,847 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * IS-IS Rout(e)ing protocol - isis_redist.c
+ *
+ * Copyright (C) 2013-2015 Christian Franke <chris@opensourcerouting.org>
+ */
+
+#include <zebra.h>
+
+#include "command.h"
+#include "if.h"
+#include "linklist.h"
+#include "memory.h"
+#include "prefix.h"
+#include "routemap.h"
+#include "stream.h"
+#include "table.h"
+#include "vty.h"
+#include "srcdest_table.h"
+
+#include "isisd/isis_constants.h"
+#include "isisd/isis_common.h"
+#include "isisd/isis_flags.h"
+#include "isisd/isis_misc.h"
+#include "isisd/isis_circuit.h"
+#include "isisd/isisd.h"
+#include "isisd/isis_lsp.h"
+#include "isisd/isis_route.h"
+#include "isisd/isis_zebra.h"
+
+DEFINE_MTYPE_STATIC(ISISD, ISIS_EXT_ROUTE, "ISIS redistributed route");
+DEFINE_MTYPE_STATIC(ISISD, ISIS_EXT_INFO,  "ISIS redistributed route info");
+DEFINE_MTYPE_STATIC(ISISD, ISIS_RMAP_NAME, "ISIS redistribute route-map name");
+DEFINE_MTYPE_STATIC(ISISD, ISIS_REDISTRIBUTE, "ISIS redistribute");
+
+static int redist_protocol(int family)
+{
+	if (family == AF_INET)
+		return 0;
+	if (family == AF_INET6)
+		return 1;
+
+	assert(!"Unsupported address family!");
+	return 0;
+}
+
+afi_t afi_for_redist_protocol(int protocol)
+{
+	if (protocol == 0)
+		return AFI_IP;
+	if (protocol == 1)
+		return AFI_IP6;
+
+	assert(!"Unknown redist protocol!");
+	return AFI_IP;
+}
+
+static struct route_table *get_ext_info(struct isis *i, int family)
+{
+	int protocol = redist_protocol(family);
+
+	return i->ext_info[protocol];
+}
+
+static struct isis_redist *isis_redist_lookup(struct isis_area *area,
+					      int family, int type, int level,
+					      uint16_t table)
+{
+	int protocol = redist_protocol(family);
+	struct listnode *node;
+	struct isis_redist *red;
+
+	if (area->redist_settings[protocol][type][level - 1]) {
+		for (ALL_LIST_ELEMENTS_RO(area->redist_settings[protocol][type]
+							       [level - 1],
+					  node, red))
+			if (red->table == table)
+				return red;
+	}
+	return NULL;
+}
+
+static struct isis_redist *isis_redist_get(struct isis_area *area, int family,
+					   int type, int level, uint16_t table)
+{
+	struct isis_redist *red;
+	int protocol;
+
+	red = isis_redist_lookup(area, family, type, level, table);
+	if (red)
+		return red;
+
+	protocol = redist_protocol(family);
+	if (area->redist_settings[protocol][type][level - 1] == NULL)
+		area->redist_settings[protocol][type][level - 1] = list_new();
+
+	red = XCALLOC(MTYPE_ISIS_REDISTRIBUTE, sizeof(struct isis_redist));
+	red->table = table;
+
+	listnode_add(area->redist_settings[protocol][type][level - 1], red);
+	return red;
+}
+
+struct route_table *get_ext_reach(struct isis_area *area, int family, int level)
+{
+	int protocol = redist_protocol(family);
+
+	return area->ext_reach[protocol][level - 1];
+}
+
+/* Install external reachability information into a
+ * specific area for a specific level.
+ * Schedule an lsp regenerate if necessary */
+static void isis_redist_install(struct isis_area *area, int level,
+				const struct prefix *p,
+				const struct prefix_ipv6 *src_p,
+				struct isis_ext_info *info)
+{
+	int family = p->family;
+	struct route_table *er_table = get_ext_reach(area, family, level);
+	struct route_node *er_node;
+
+	if (!er_table) {
+		zlog_warn(
+			"%s: External reachability table of area %s is not initialized.",
+			__func__, area->area_tag);
+		return;
+	}
+
+	er_node = srcdest_rnode_get(er_table, p, src_p);
+	if (er_node->info) {
+		route_unlock_node(er_node);
+
+		/* Don't update/reschedule lsp generation if nothing changed. */
+		if (!memcmp(er_node->info, info, sizeof(*info)))
+			return;
+	} else {
+		er_node->info = XMALLOC(MTYPE_ISIS_EXT_INFO, sizeof(*info));
+	}
+
+	memcpy(er_node->info, info, sizeof(*info));
+	lsp_regenerate_schedule(area, level, 0);
+}
+
+/* Remove external reachability information from a
+ * specific area for a specific level.
+ * Schedule an lsp regenerate if necessary. */
+static void isis_redist_uninstall(struct isis_area *area, int level,
+				  const struct prefix *p,
+				  const struct prefix_ipv6 *src_p)
+{
+	int family = p->family;
+	struct route_table *er_table = get_ext_reach(area, family, level);
+	struct route_node *er_node;
+
+	if (!er_table) {
+		zlog_warn(
+			"%s: External reachability table of area %s is not initialized.",
+			__func__, area->area_tag);
+		return;
+	}
+
+	er_node = srcdest_rnode_lookup(er_table, p, src_p);
+	if (!er_node)
+		return;
+	else
+		route_unlock_node(er_node);
+
+	if (!er_node->info)
+		return;
+
+	XFREE(MTYPE_ISIS_EXT_INFO, er_node->info);
+	route_unlock_node(er_node);
+	lsp_regenerate_schedule(area, level, 0);
+}
+
+/* Update external reachability info of area for a given level
+ * and prefix, using the given redistribution settings. */
+static void isis_redist_update_ext_reach(struct isis_area *area, int level,
+					 struct isis_redist *redist,
+					 const struct prefix *p,
+					 const struct prefix_ipv6 *src_p,
+					 struct isis_ext_info *info)
+{
+	struct isis_ext_info area_info;
+	route_map_result_t map_ret;
+
+	memcpy(&area_info, info, sizeof(area_info));
+	area_info.metric = redist->metric;
+
+	if (redist->map_name) {
+		map_ret = route_map_apply(redist->map, p, &area_info);
+		if (map_ret == RMAP_DENYMATCH)
+			area_info.distance = 255;
+	}
+
+	/* Allow synthesized default routes only on always orignate */
+	if (area_info.origin == DEFAULT_ROUTE
+	    && redist->redist != DEFAULT_ORIGINATE_ALWAYS)
+		area_info.distance = 255;
+
+	if (area_info.distance < 255)
+		isis_redist_install(area, level, p, src_p, &area_info);
+	else
+		isis_redist_uninstall(area, level, p, src_p);
+}
+
+static void isis_redist_ensure_default(struct isis *isis, int family)
+{
+	struct prefix p;
+	struct route_table *ei_table = get_ext_info(isis, family);
+	struct route_node *ei_node;
+	struct isis_ext_info *info;
+
+	if (family == AF_INET) {
+		p.family = AF_INET;
+		p.prefixlen = 0;
+		memset(&p.u.prefix4, 0, sizeof(p.u.prefix4));
+	} else if (family == AF_INET6) {
+		p.family = AF_INET6;
+		p.prefixlen = 0;
+		memset(&p.u.prefix6, 0, sizeof(p.u.prefix6));
+	} else
+		assert(!"Unknown family!");
+
+	ei_node = srcdest_rnode_get(ei_table, &p, NULL);
+	if (ei_node->info) {
+		route_unlock_node(ei_node);
+		return;
+	}
+
+	ei_node->info =
+		XCALLOC(MTYPE_ISIS_EXT_INFO, sizeof(struct isis_ext_info));
+
+	info = ei_node->info;
+	info->origin = DEFAULT_ROUTE;
+	info->distance = 254;
+	info->metric = MAX_WIDE_PATH_METRIC;
+}
+
+static int _isis_redist_table_is_present(const struct lyd_node *dnode, void *arg)
+{
+	struct isis_redist_table_present_args *rtda = arg;
+
+	/* This entry is the caller, so skip it. */
+	if (yang_dnode_get_uint16(dnode, "table") !=
+	    (uint16_t)atoi(rtda->rtda_table))
+		return YANG_ITER_CONTINUE;
+
+	/* found */
+	rtda->rtda_found = true;
+	return YANG_ITER_CONTINUE;
+}
+
+static int _isis_redist_table_get_first_cb(const struct lyd_node *dnode,
+					   void *arg)
+{
+	uint16_t *table = arg;
+
+	*table = yang_dnode_get_uint16(dnode, "table");
+	return YANG_ITER_STOP;
+}
+
+uint16_t isis_redist_table_get_first(const struct vty *vty,
+				     struct isis_redist_table_present_args *rtda)
+{
+	uint16_t table = 0;
+
+	yang_dnode_iterate(_isis_redist_table_get_first_cb, &table,
+			   vty->candidate_config->dnode,
+			   "%s/redistribute/%s[protocol='table'][level='%s']/table",
+			   VTY_CURR_XPATH, rtda->rtda_ip, rtda->rtda_level);
+	return table;
+}
+
+bool isis_redist_table_is_present(const struct vty *vty,
+				  struct isis_redist_table_present_args *rtda)
+{
+	rtda->rtda_found = false;
+	yang_dnode_iterate(_isis_redist_table_is_present, rtda,
+			   vty->candidate_config->dnode,
+			   "%s/redistribute/%s[protocol='table'][level='%s']/table",
+			   VTY_CURR_XPATH, rtda->rtda_ip, rtda->rtda_level);
+
+	return rtda->rtda_found;
+}
+
+/* Handle notification about route being added */
+void isis_redist_add(struct isis *isis, int type, struct prefix *p,
+		     struct prefix_ipv6 *src_p, uint8_t distance,
+		     uint32_t metric, const route_tag_t tag, uint16_t table)
+{
+	int family = p->family;
+	struct route_table *ei_table = get_ext_info(isis, family);
+	struct route_node *ei_node;
+	struct isis_ext_info *info;
+	struct listnode *node;
+	struct isis_area *area;
+	int level;
+	struct isis_redist *redist;
+
+	zlog_debug("%s: New route %pFX from %s: distance %d.", __func__, p,
+		   zebra_route_string(type), distance);
+
+	if (!ei_table) {
+		zlog_warn("%s: External information table not initialized.",
+			  __func__);
+		return;
+	}
+
+	ei_node = srcdest_rnode_get(ei_table, p, src_p);
+	if (ei_node->info)
+		route_unlock_node(ei_node);
+	else
+		ei_node->info = XCALLOC(MTYPE_ISIS_EXT_INFO,
+					sizeof(struct isis_ext_info));
+
+	info = ei_node->info;
+	info->origin = type;
+	info->distance = distance;
+	info->metric = metric;
+	info->tag = tag;
+
+	if (is_default_prefix(p)
+	    && (!src_p || !src_p->prefixlen)) {
+		type = DEFAULT_ROUTE;
+	}
+
+	for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
+		for (level = 1; level <= ISIS_LEVELS; level++) {
+			redist = isis_redist_lookup(area, family, type, level,
+						    table);
+			if (!redist || !redist->redist)
+				continue;
+
+			isis_redist_update_ext_reach(area, level, redist, p,
+						     src_p, info);
+		}
+}
+
+void isis_redist_delete(struct isis *isis, int type, struct prefix *p,
+			struct prefix_ipv6 *src_p, uint16_t table)
+{
+	int family = p->family;
+	struct route_table *ei_table = get_ext_info(isis, family);
+	struct route_node *ei_node;
+	struct listnode *node;
+	struct isis_area *area;
+	int level;
+	struct isis_redist *redist;
+
+	zlog_debug("%s: Removing route %pFX from %s.", __func__, p,
+		   zebra_route_string(type));
+
+	if (is_default_prefix(p)
+	    && (!src_p || !src_p->prefixlen)) {
+		/* Don't remove default route but add synthetic route for use
+		 * by "default-information originate always". Areas without the
+		 * "always" setting will ignore routes with origin
+		 * DEFAULT_ROUTE. */
+		isis_redist_add(isis, DEFAULT_ROUTE, p, NULL, 254,
+				MAX_WIDE_PATH_METRIC, 0, table);
+		return;
+	}
+
+	if (!ei_table) {
+		zlog_warn("%s: External information table not initialized.",
+			  __func__);
+		return;
+	}
+
+	ei_node = srcdest_rnode_lookup(ei_table, p, src_p);
+	if (!ei_node || !ei_node->info) {
+		zlog_warn(
+			"%s: Got a delete for %s route %pFX, but that route was never added.",
+			__func__, zebra_route_string(type), p);
+		if (ei_node)
+			route_unlock_node(ei_node);
+		return;
+	}
+	route_unlock_node(ei_node);
+
+	for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
+		for (level = ISIS_LEVEL1; level <= ISIS_LEVEL2; level++) {
+			redist = isis_redist_lookup(area, family, type, level,
+						    table);
+			if (!redist || !redist->redist)
+				continue;
+
+			isis_redist_uninstall(area, level, p, src_p);
+		}
+
+	XFREE(MTYPE_ISIS_EXT_INFO, ei_node->info);
+	route_unlock_node(ei_node);
+}
+
+static void isis_redist_routemap_set(struct isis_redist *redist,
+				     const char *routemap)
+{
+	if (redist->map_name) {
+		XFREE(MTYPE_ISIS_RMAP_NAME, redist->map_name);
+		route_map_counter_decrement(redist->map);
+		redist->map = NULL;
+	}
+
+	if (routemap && strlen(routemap)) {
+		redist->map_name = XSTRDUP(MTYPE_ISIS_RMAP_NAME, routemap);
+		redist->map = route_map_lookup_by_name(routemap);
+		route_map_counter_increment(redist->map);
+	}
+}
+
+void isis_redist_free(struct isis *isis)
+{
+	struct route_node *rn;
+	int i;
+
+	for (i = 0; i < REDIST_PROTOCOL_COUNT; i++) {
+		if (!isis->ext_info[i])
+			continue;
+
+		for (rn = route_top(isis->ext_info[i]); rn;
+		     rn = srcdest_route_next(rn)) {
+			if (rn->info)
+				XFREE(MTYPE_ISIS_EXT_INFO, rn->info);
+		}
+
+		route_table_finish(isis->ext_info[i]);
+		isis->ext_info[i] = NULL;
+	}
+}
+
+void isis_redist_set(struct isis_area *area, int level, int family, int type,
+		     uint32_t metric, const char *routemap, int originate_type,
+		     uint16_t table)
+{
+	int protocol = redist_protocol(family);
+	struct isis_redist *redist = isis_redist_get(area, family, type, level,
+						     table);
+	int i;
+	struct route_table *ei_table;
+	struct route_node *rn;
+	struct isis_ext_info *info;
+
+	redist->redist = (type == DEFAULT_ROUTE) ? originate_type : 1;
+	redist->metric = metric;
+	isis_redist_routemap_set(redist, routemap);
+
+	if (!area->ext_reach[protocol][level - 1]) {
+		area->ext_reach[protocol][level - 1] = srcdest_table_init();
+	}
+
+	for (i = 0; i < REDIST_PROTOCOL_COUNT; i++) {
+		if (!area->isis->ext_info[i]) {
+			area->isis->ext_info[i] = srcdest_table_init();
+		}
+	}
+
+	isis_zebra_redistribute_set(afi_for_redist_protocol(protocol), type,
+				    area->isis->vrf_id, redist->table);
+
+	if (type == DEFAULT_ROUTE && originate_type == DEFAULT_ORIGINATE_ALWAYS)
+		isis_redist_ensure_default(area->isis, family);
+
+	ei_table = get_ext_info(area->isis, family);
+	for (rn = route_top(ei_table); rn; rn = srcdest_route_next(rn)) {
+		if (!rn->info)
+			continue;
+		info = rn->info;
+
+		const struct prefix *p, *src_p;
+
+		srcdest_rnode_prefixes(rn, &p, &src_p);
+
+		if (type == DEFAULT_ROUTE) {
+			if (!is_default_prefix(p)
+			    || (src_p && src_p->prefixlen)) {
+				continue;
+			}
+		} else {
+			if (info->origin != type)
+				continue;
+		}
+
+		isis_redist_update_ext_reach(area, level, redist, p,
+					     (const struct prefix_ipv6 *)src_p,
+					     info);
+	}
+}
+
+void isis_redist_unset(struct isis_area *area, int level, int family, int type,
+		       uint16_t table)
+{
+	struct isis_redist *redist = isis_redist_lookup(area, family, type,
+							level, table);
+	struct route_table *er_table = get_ext_reach(area, family, level);
+	struct route_node *rn;
+	struct isis_ext_info *info;
+	struct list *redist_list;
+	int protocol = redist_protocol(family);
+
+	if (!redist || !redist->redist)
+		return;
+
+	redist->redist = 0;
+
+	redist_list = area->redist_settings[protocol][type][level - 1];
+	listnode_delete(redist_list, redist);
+	XFREE(MTYPE_ISIS_REDISTRIBUTE, redist);
+
+	if (!er_table) {
+		zlog_warn("%s: External reachability table uninitialized.",
+			  __func__);
+		return;
+	}
+
+	for (rn = route_top(er_table); rn; rn = srcdest_route_next(rn)) {
+		if (!rn->info)
+			continue;
+		info = rn->info;
+
+		const struct prefix *p, *src_p;
+		srcdest_rnode_prefixes(rn, &p, &src_p);
+
+		if (type == DEFAULT_ROUTE) {
+			if (!is_default_prefix(p)
+			    || (src_p && src_p->prefixlen)) {
+				continue;
+			}
+		} else {
+			if (info->origin != type)
+				continue;
+		}
+
+		XFREE(MTYPE_ISIS_EXT_INFO, rn->info);
+		route_unlock_node(rn);
+	}
+
+	lsp_regenerate_schedule(area, level, 0);
+	isis_zebra_redistribute_unset(afi_for_redist_protocol(protocol), type,
+				      area->isis->vrf_id, table);
+}
+
+void isis_redist_area_finish(struct isis_area *area)
+{
+	struct route_node *rn;
+	int protocol;
+	int level;
+	int type;
+	struct isis_redist *redist;
+	struct listnode *node, *nnode;
+	struct list *redist_list;
+
+	for (protocol = 0; protocol < REDIST_PROTOCOL_COUNT; protocol++)
+		for (level = 0; level < ISIS_LEVELS; level++) {
+			for (type = 0; type < ZEBRA_ROUTE_MAX + 1; type++) {
+				redist_list = area->redist_settings[protocol]
+								   [type][level];
+				if (!redist_list)
+					continue;
+				for (ALL_LIST_ELEMENTS(redist_list, node, nnode,
+						       redist)) {
+					redist->redist = 0;
+					XFREE(MTYPE_ISIS_RMAP_NAME,
+					      redist->map_name);
+					isis_zebra_redistribute_unset(
+						afi_for_redist_protocol(protocol),
+						type, area->isis->vrf_id,
+						redist->table);
+					listnode_delete(redist_list, redist);
+					XFREE(MTYPE_ISIS_REDISTRIBUTE, redist);
+				}
+				list_delete(&redist_list);
+			}
+			if (!area->ext_reach[protocol][level])
+				continue;
+			for (rn = route_top(area->ext_reach[protocol][level]);
+			     rn; rn = srcdest_route_next(rn)) {
+				if (rn->info)
+					XFREE(MTYPE_ISIS_EXT_INFO, rn->info);
+			}
+			route_table_finish(area->ext_reach[protocol][level]);
+			area->ext_reach[protocol][level] = NULL;
+		}
+}
+
+#ifdef FABRICD
+DEFUN (isis_redistribute,
+       isis_redistribute_cmd,
+       "redistribute <ipv4 " PROTO_IP_REDIST_STR "|ipv6 " PROTO_IP6_REDIST_STR ">"
+       " [{metric (0-16777215)|route-map RMAP_NAME}]",
+       REDIST_STR
+       "Redistribute IPv4 routes\n"
+       PROTO_IP_REDIST_HELP
+       "Redistribute IPv6 routes\n"
+       PROTO_IP6_REDIST_HELP
+       "Metric for redistributed routes\n"
+       "ISIS default metric\n"
+       "Route map reference\n"
+       "Pointer to route-map entries\n")
+{
+	int idx_afi = 1;
+	int idx_protocol = 2;
+	int idx_metric_rmap = 1;
+	VTY_DECLVAR_CONTEXT(isis_area, area);
+	int family;
+	int afi;
+	int type;
+	int level;
+	unsigned long metric = 0;
+	const char *routemap = NULL;
+
+	family = str2family(argv[idx_afi]->text);
+	if (family < 0)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	afi = family2afi(family);
+	if (!afi)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	type = proto_redistnum(afi, argv[idx_protocol]->text);
+	if (type < 0)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	level = 2;
+
+	if ((area->is_type & level) != level) {
+		vty_out(vty, "Node is not a level-%d IS\n", level);
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	if (argv_find(argv, argc, "metric", &idx_metric_rmap)) {
+		metric = strtoul(argv[idx_metric_rmap + 1]->arg, NULL, 10);
+	}
+
+	idx_metric_rmap = 1;
+	if (argv_find(argv, argc, "route-map", &idx_metric_rmap)) {
+		routemap = argv[idx_metric_rmap + 1]->arg;
+	}
+
+	isis_redist_set(area, level, family, type, metric, routemap, 0, 0);
+	return 0;
+}
+
+DEFUN (no_isis_redistribute,
+       no_isis_redistribute_cmd,
+       "no redistribute <ipv4 " PROTO_IP_REDIST_STR "|ipv6 " PROTO_IP6_REDIST_STR ">",
+       NO_STR
+       REDIST_STR
+       "Redistribute IPv4 routes\n"
+       PROTO_IP_REDIST_HELP
+       "Redistribute IPv6 routes\n"
+       PROTO_IP6_REDIST_HELP)
+{
+	int idx_afi = 2;
+	int idx_protocol = 3;
+	VTY_DECLVAR_CONTEXT(isis_area, area);
+	int type;
+	int level;
+	int family;
+	int afi;
+
+	family = str2family(argv[idx_afi]->arg);
+	if (family < 0)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	afi = family2afi(family);
+	if (!afi)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	type = proto_redistnum(afi, argv[idx_protocol]->text);
+	if (type < 0)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	level = 2;
+
+	isis_redist_unset(area, level, family, type, 0);
+	return 0;
+}
+
+DEFUN (isis_default_originate,
+       isis_default_originate_cmd,
+       "default-information originate <ipv4|ipv6> [always] [{metric (0-16777215)|route-map RMAP_NAME}]",
+       "Control distribution of default information\n"
+       "Distribute a default route\n"
+       "Distribute default route for IPv4\n"
+       "Distribute default route for IPv6\n"
+       "Always advertise default route\n"
+       "Metric for default route\n"
+       "ISIS default metric\n"
+       "Route map reference\n"
+       "Pointer to route-map entries\n")
+{
+	int idx_afi = 2;
+	int idx_always = fabricd ? 3 : 4;
+	int idx_metric_rmap = 1;
+	VTY_DECLVAR_CONTEXT(isis_area, area);
+	int family;
+	int originate_type = DEFAULT_ORIGINATE;
+	int level;
+	unsigned long metric = 0;
+	const char *routemap = NULL;
+
+	family = str2family(argv[idx_afi]->text);
+	if (family < 0)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	level = 2;
+
+	if ((area->is_type & level) != level) {
+		vty_out(vty, "Node is not a level-%d IS\n", level);
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	if (argc > idx_always && strmatch(argv[idx_always]->text, "always")) {
+		originate_type = DEFAULT_ORIGINATE_ALWAYS;
+		idx_metric_rmap++;
+	}
+
+	if (argv_find(argv, argc, "metric", &idx_metric_rmap)) {
+		metric = strtoul(argv[idx_metric_rmap + 1]->arg, NULL, 10);
+	}
+
+	idx_metric_rmap = 1;
+	if (argv_find(argv, argc, "route-map", &idx_metric_rmap)) {
+		routemap = argv[idx_metric_rmap + 1]->arg;
+	}
+
+	if (family == AF_INET6 && originate_type != DEFAULT_ORIGINATE_ALWAYS) {
+		vty_out(vty,
+			"Zebra doesn't implement default-originate for IPv6 yet\n");
+		vty_out(vty,
+			"so use with care or use default-originate always.\n");
+	}
+
+	isis_redist_set(area, level, family, DEFAULT_ROUTE, metric, routemap,
+			originate_type, 0);
+	return 0;
+}
+
+DEFUN (no_isis_default_originate,
+       no_isis_default_originate_cmd,
+       "no default-information originate <ipv4|ipv6>",
+       NO_STR
+       "Control distribution of default information\n"
+       "Distribute a default route\n"
+       "Distribute default route for IPv4\n"
+       "Distribute default route for IPv6\n")
+{
+	int idx_afi = 3;
+	VTY_DECLVAR_CONTEXT(isis_area, area);
+	int family;
+	int level;
+
+	family = str2family(argv[idx_afi]->text);
+	if (family < 0)
+		return CMD_WARNING_CONFIG_FAILED;
+
+	level = 2;
+
+	isis_redist_unset(area, level, family, DEFAULT_ROUTE, 0);
+	return 0;
+}
+#endif /* ifdef FABRICD */
+
+int isis_redist_config_write(struct vty *vty, struct isis_area *area,
+			     int family)
+{
+	int type;
+	int level;
+	int write = 0;
+	struct isis_redist *redist;
+	struct list *redist_list;
+	const char *family_str;
+	struct listnode *node;
+
+	if (family == AF_INET)
+		family_str = "ipv4";
+	else if (family == AF_INET6)
+		family_str = "ipv6";
+	else
+		return 0;
+
+	for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
+		if (type == PROTO_TYPE)
+			continue;
+
+		for (level = 1; level <= ISIS_LEVELS; level++) {
+			redist_list = area->redist_settings[redist_protocol(
+				family)][type][level - 1];
+			if (!redist_list)
+				continue;
+			for (ALL_LIST_ELEMENTS_RO(redist_list, node, redist)) {
+				if (!redist->redist)
+					continue;
+				vty_out(vty, " redistribute %s %s", family_str,
+					zebra_route_string(type));
+				if (type == ZEBRA_ROUTE_TABLE)
+					vty_out(vty, " %u", redist->table);
+				if (!fabricd)
+					vty_out(vty, " level-%d", level);
+				if (redist->metric)
+					vty_out(vty, " metric %u",
+						redist->metric);
+				if (redist->map_name)
+					vty_out(vty, " route-map %s",
+						redist->map_name);
+				vty_out(vty, "\n");
+				write++;
+			}
+		}
+	}
+
+	for (level = 1; level <= ISIS_LEVELS; level++) {
+		redist = isis_redist_lookup(area, family, DEFAULT_ROUTE, level,
+					    0);
+		if (!redist)
+			continue;
+		if (!redist->redist)
+			continue;
+		vty_out(vty, " default-information originate %s",
+			family_str);
+		if (!fabricd)
+			vty_out(vty, " level-%d", level);
+		if (redist->redist == DEFAULT_ORIGINATE_ALWAYS)
+			vty_out(vty, " always");
+		if (redist->metric)
+			vty_out(vty, " metric %u", redist->metric);
+		if (redist->map_name)
+			vty_out(vty, " route-map %s", redist->map_name);
+		vty_out(vty, "\n");
+		write++;
+	}
+
+	return write;
+}
+
+void isis_redist_init(void)
+{
+#ifdef FABRICD
+	install_element(ROUTER_NODE, &isis_redistribute_cmd);
+	install_element(ROUTER_NODE, &no_isis_redistribute_cmd);
+
+	install_element(ROUTER_NODE, &isis_default_originate_cmd);
+	install_element(ROUTER_NODE, &no_isis_default_originate_cmd);
+#endif /* ifdef FABRICD */
+}