ospfd: Add Link-State support

This patch allows to store Link State Information received through the various
LSAs into a dedicated Traffic Engineering Database (TED). This feature is
automatically activated once mpls-te is enabled.

A new CLI command `mpls-te export` permits to export the TED to other daemons
through the new ZAPI Opaque Link State messages. In complement, a new CLI
command `show ip ospf mpls-te database ...` output the contains of the TED to
the console.

Major modifications take place in ospf_te.[c, h]. File ospf_zebra.c has been
modified to handle TED synchronisation request.

Signed-off-by: Olivier Dugeon <olivier.dugeon@orange.com>

1 files changed, 1749 insertions, 27 deletions

diff --git a/ospfd/ospf_te.c b/ospfd/ospf_te.c
index a7cf4e954..f2842538a 100644
--- a/ospfd/ospf_te.c
+++ b/ospfd/ospf_te.c
@@ -43,6 +43,9 @@
 #include "hash.h"
 #include "sockunion.h" /* for inet_aton() */
 #include "network.h"
+#include "link_state.h"
+#include "zclient.h"
+#include "printfrr.h"
 
 #include "ospfd/ospfd.h"
 #include "ospfd/ospf_interface.h"
@@ -60,6 +63,9 @@
 #include "ospfd/ospf_ase.h"
 #include "ospfd/ospf_zebra.h"
 #include "ospfd/ospf_te.h"
+#include "ospfd/ospf_sr.h"
+#include "ospfd/ospf_ri.h"
+#include "ospfd/ospf_ext.h"
 #include "ospfd/ospf_vty.h"
 #include "ospfd/ospf_errors.h"
 
@@ -71,6 +77,7 @@ struct ospf_mpls_te OspfMplsTE;
 
 static const char *const mode2text[] = {"Off", "AS", "Area"};
 
+
 /*------------------------------------------------------------------------*
  * Followings are initialize/terminate functions for MPLS-TE handling.
  *------------------------------------------------------------------------*/
@@ -85,6 +92,8 @@ static int ospf_mpls_te_lsa_originate_area(void *arg);
 static int ospf_mpls_te_lsa_inter_as_as(void *arg);
 static int ospf_mpls_te_lsa_inter_as_area(void *arg);
 static struct ospf_lsa *ospf_mpls_te_lsa_refresh(struct ospf_lsa *lsa);
+static int ospf_mpls_te_lsa_update(struct ospf_lsa *lsa);
+static int ospf_mpls_te_lsa_delete(struct ospf_lsa *lsa);
 
 static void del_mpls_te_link(void *val);
 static void ospf_mpls_te_register_vty(void);
@@ -95,15 +104,19 @@ int ospf_mpls_te_init(void)
 
 	/* Register Opaque AREA LSA Type 1 for Traffic Engineering */
 	rc = ospf_register_opaque_functab(
-		OSPF_OPAQUE_AREA_LSA, OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA,
-		ospf_mpls_te_new_if, ospf_mpls_te_del_if,
-		ospf_mpls_te_ism_change, ospf_mpls_te_nsm_change,
+		OSPF_OPAQUE_AREA_LSA,
+		OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA,
+		ospf_mpls_te_new_if,
+		ospf_mpls_te_del_if,
+		ospf_mpls_te_ism_change,
+		ospf_mpls_te_nsm_change,
 		ospf_mpls_te_config_write_router,
-		NULL, /*ospf_mpls_te_config_write_if */
+		NULL, /* ospf_mpls_te_config_write_if */
 		NULL, /* ospf_mpls_te_config_write_debug */
 		ospf_mpls_te_show_info, ospf_mpls_te_lsa_originate_area,
-		ospf_mpls_te_lsa_refresh, NULL, /* ospf_mpls_te_new_lsa_hook */
-		NULL /* ospf_mpls_te_del_lsa_hook */);
+		ospf_mpls_te_lsa_refresh,
+		ospf_mpls_te_lsa_update, /* ospf_mpls_te_new_lsa_hook */
+		ospf_mpls_te_lsa_delete /* ospf_mpls_te_del_lsa_hook */);
 	if (rc != 0) {
 		flog_warn(
 			EC_OSPF_OPAQUE_REGISTRATION,
@@ -170,6 +183,7 @@ void ospf_mpls_te_term(void)
 
 	OspfMplsTE.enabled = false;
 	OspfMplsTE.inter_as = Off;
+	OspfMplsTE.export = false;
 
 	return;
 }
@@ -178,12 +192,12 @@ void ospf_mpls_te_finish(void)
 {
 	OspfMplsTE.enabled = false;
 	OspfMplsTE.inter_as = Off;
+	OspfMplsTE.export = false;
 }
 
 /*------------------------------------------------------------------------*
  * Followings are control functions for MPLS-TE parameters management.
  *------------------------------------------------------------------------*/
-
 static void del_mpls_te_link(void *val)
 {
 	XFREE(MTYPE_OSPF_MPLS_TE, val);
@@ -730,9 +744,8 @@ static void initialize_linkparams(struct mpls_te_link *lp)
 	struct ospf_interface *oi = NULL;
 	struct route_node *rn;
 
-	ote_debug(
-		"MPLS-TE (%s): Initialize Link Parameters for interface %s",
-		__func__, ifp->name);
+	ote_debug("MPLS-TE (%s): Initialize Link Parameters for interface %s",
+		  __func__, ifp->name);
 
 	/* Search OSPF Interface parameters for this interface */
 	for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
@@ -790,8 +803,8 @@ static int is_mandated_params_set(struct mpls_te_link *lp)
 	}
 
 	if (!IS_INTER_AS(lp->type) && (ntohs(lp->link_id.header.type) == 0)) {
-		flog_warn(EC_OSPF_TE_UNEXPECTED,
-			  "MPLS-TE (%s) Missing Link ID", __func__);
+		flog_warn(EC_OSPF_TE_UNEXPECTED, "MPLS-TE (%s) Missing Link ID",
+			  __func__);
 		return rc;
 	}
 
@@ -1039,15 +1052,14 @@ static void ospf_mpls_te_nsm_change(struct ospf_neighbor *nbr, int old_state)
 
 	case ISM_Down:
 		/* State goes Down: Flush LSA if engaged */
-		if (OspfMplsTE.enabled &&
-			CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
+		if (OspfMplsTE.enabled
+		    && CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
 			ote_debug(
 				"MPLS-TE (%s): Interface %s goes down: flush LSA",
 				__func__, IF_NAME(oi));
 			ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
 		}
 		return;
-		break;
 	default:
 		break;
 	}
@@ -1066,7 +1078,7 @@ static void ospf_mpls_te_nsm_change(struct ospf_neighbor *nbr, int old_state)
 }
 
 /*------------------------------------------------------------------------*
- * Followings are OSPF protocol processing functions for MPLS-TE.
+ * Followings are OSPF protocol processing functions for MPLS-TE LSA.
  *------------------------------------------------------------------------*/
 
 static void build_tlv_header(struct stream *s, struct tlv_header *tlvh)
@@ -1539,7 +1551,8 @@ void ospf_mpls_te_lsa_schedule(struct mpls_te_link *lp, enum lsa_opcode opcode)
 	if (!CHECK_FLAG(lp->flags, LPFLG_LSA_ACTIVE))
 		return;
 
-	ote_debug("MPLS-TE (%s): Schedule %s%s%s LSA for interface %s", __func__,
+	ote_debug("MPLS-TE (%s): Schedule %s%s%s LSA for interface %s",
+		  __func__,
 		  opcode == REORIGINATE_THIS_LSA ? "Re-Originate" : "",
 		  opcode == REFRESH_THIS_LSA ? "Refresh" : "",
 		  opcode == FLUSH_THIS_LSA ? "Flush" : "",
@@ -1606,8 +1619,1527 @@ void ospf_mpls_te_lsa_schedule(struct mpls_te_link *lp, enum lsa_opcode opcode)
 			  opcode);
 		break;
 	}
+}
+
+/**
+ * ------------------------------------------------------
+ * Followings are Link State Data Base control functions.
+ * ------------------------------------------------------
+ */
+
+/**
+ * Get Vertex from TED by the router which advertised the LSA. A new Vertex and
+ * associated Link State Node are created if Vertex is not found.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	Link State Vertex
+ */
+static struct ls_vertex *get_vertex(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_node_id lnid;
+	struct ls_node *lnode;
+	struct ls_vertex *vertex;
+
+	/* Sanity Check */
+	if (!ted || !lsa || !lsa->data || !lsa->area)
+		return NULL;
+
+	/* Search if a Link State Vertex already exist */
+	lnid.origin = OSPFv2;
+	lnid.id.ip.addr = lsa->data->adv_router;
+	lnid.id.ip.area_id = lsa->area->area_id;
+	vertex = ls_find_vertex_by_id(ted, lnid);
+
+	/* Create Node & Vertex in the Link State Date Base if not found */
+	if (!vertex) {
+		const struct in_addr inaddr_any = {.s_addr = INADDR_ANY};
+
+		lnode = ls_node_new(lnid, inaddr_any, in6addr_any);
+		snprintfrr(lnode->name, MAX_NAME_LENGTH, "%pI4",
+			   &lnid.id.ip.addr);
+		vertex = ls_vertex_add(ted, lnode);
+	}
+
+	if (IS_LSA_SELF(lsa))
+		ted->self = vertex;
+
+	return vertex;
+}
+
+/**
+ * Get Edge from TED by Link State Attribute ID. A new Edge and associated Link
+ * State Attributes are created if not found.
+ *
+ * @param ted		Link State Traffic Engineering Database
+ * @param adv		Link State Node ID of router which advertised Edge
+ * @param link_id	Link State Attribute ID
+ *
+ * @return		Link State Edge
+ */
+static struct ls_edge *get_edge(struct ls_ted *ted, struct ls_node_id adv,
+				struct in_addr link_id)
+{
+	uint64_t key;
+	struct ls_edge *edge;
+	struct ls_attributes *attr;
+
+	/* Search Edge that corresponds to the Link ID */
+	key = ((uint64_t)ntohl(link_id.s_addr)) & 0xffffffff;
+	edge = ls_find_edge_by_key(ted, key);
+
+	/* Create new one if not exist */
+	if (!edge) {
+		attr = ls_attributes_new(adv, link_id, in6addr_any, 0);
+		edge = ls_edge_add(ted, attr);
+	}
+
+	return edge;
+}
+
+/**
+ * Export Link State information to consumer daemon through ZAPI Link State
+ * Opaque Message.
+ *
+ * @param type		Type of Link State Element i.e. Vertex, Edge or Subnet
+ * @param link_state	Pointer to Link State Vertex, Edge or Subnet
+ *
+ * @return		0 if success, -1 otherwise
+ */
+static int ospf_te_export(uint8_t type, void *link_state)
+{
+	struct ls_message msg = {};
+	int rc = 0;
+
+	if (!OspfMplsTE.export)
+		return rc;
+
+	switch (type) {
+	case LS_MSG_TYPE_NODE:
+		ls_vertex2msg(&msg, (struct ls_vertex *)link_state);
+		rc = ls_send_msg(zclient, &msg, NULL);
+		break;
+	case LS_MSG_TYPE_ATTRIBUTES:
+		ls_edge2msg(&msg, (struct ls_edge *)link_state);
+		rc = ls_send_msg(zclient, &msg, NULL);
+		break;
+	case LS_MSG_TYPE_PREFIX:
+		ls_subnet2msg(&msg, (struct ls_subnet *)link_state);
+		rc = ls_send_msg(zclient, &msg, NULL);
+		break;
+	default:
+		rc = -1;
+		break;
+	}
+
+	return rc;
+}
+
+/**
+ * Update Link State Edge & Attributes from the given Link State Attributes ID
+ * and metric. This function is called when parsing Router LSA.
+ *
+ * @param ted		Link State Traffic Engineering Database
+ * @param vertex	Vertex where the Edge is attached as source
+ * @param link_data	Link State Edge ID
+ * @param metric	Standard metric attached to this Edge
+ */
+static void ospf_te_update_link(struct ls_ted *ted, struct ls_vertex *vertex,
+				struct in_addr link_data, uint8_t metric)
+{
+	struct ls_edge *edge;
+	struct ls_attributes *attr;
+
+	/* Sanity check */
+	if (!ted || !vertex || !vertex->node)
+		return;
+
+	/* Get Corresponding Edge from Link State Data Base */
+	edge = get_edge(ted, vertex->node->adv, link_data);
+	attr = edge->attributes;
+
+	/* re-attached edge to vertex if needed */
+	if (!edge->source)
+		edge->source = vertex;
+
+	/* Check if it is just an LSA refresh */
+	if ((CHECK_FLAG(attr->flags, LS_ATTR_METRIC)
+	     && (attr->metric == metric))) {
+		edge->status = SYNC;
+		return;
+	}
+
+	/* Update metric value */
+	attr->metric = metric;
+	SET_FLAG(attr->flags, LS_ATTR_METRIC);
+	if (edge->status != NEW)
+		edge->status = UPDATE;
+
+	ote_debug("    |- %s Edge %pI4 with metric %d",
+		  edge->status == NEW ? "Add" : "Update", &attr->standard.local,
+		  attr->metric);
+
+	/* Export Link State Edge */
+	ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
+	edge->status = SYNC;
+}
+
+/**
+ * Update Link State Subnet & Prefix from the given prefix and metric. This
+ * function is called when parsing Router LSA.
+ *
+ * @param ted		Link State Traffic Engineering Database
+ * @param vertex	Vertex where the Edge is attached as source
+ * @param p		Prefix associated to the Subnet
+ * @param metric	Standard metric attached to this Edge
+ */
+static void ospf_te_update_subnet(struct ls_ted *ted, struct ls_vertex *vertex,
+				  struct prefix p, uint8_t metric)
+{
+	struct ls_subnet *subnet;
+	struct ls_prefix *ls_pref;
+
+	/* Search if there is a Subnet for this prefix */
+	subnet = ls_find_subnet(ted, p);
+
+	/* If found a Subnet, check if it is attached to this Vertex */
+	if (subnet) {
+		/* Re-attach the subnet to the vertex if necessary */
+		if (subnet->vertex != vertex) {
+			subnet->vertex = vertex;
+			listnode_add_sort_nodup(vertex->prefixes, subnet);
+		}
+		/* Check if it is a simple refresh */
+		ls_pref = subnet->ls_pref;
+		if ((CHECK_FLAG(ls_pref->flags, LS_PREF_METRIC))
+		    && (ls_pref->metric == metric)) {
+			subnet->status = SYNC;
+			return;
+		}
+		ls_pref->metric = metric;
+		SET_FLAG(ls_pref->flags, LS_PREF_METRIC);
+		subnet->status = UPDATE;
+	} else {
+		/* Create new Link State Prefix  */
+		ls_pref = ls_prefix_new(vertex->node->adv, p);
+		ls_pref->metric = metric;
+		SET_FLAG(ls_pref->flags, LS_PREF_METRIC);
+		/* and add it to the TED */
+		subnet = ls_subnet_add(ted, ls_pref);
+	}
+
+	ote_debug("    |- %s subnet %pFX with metric %d",
+		  subnet->status == NEW ? "Add" : "Update", &subnet->key,
+		  ls_pref->metric);
+
+	/* Export Link State Subnet */
+	ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
+	subnet->status = SYNC;
+}
+
+/**
+ * Delete Subnet that correspond to the given IPv4 address and export deletion
+ * information before removal. Prefix length is fixed to IPV4_MAX_PREFIXLEN.
+ *
+ * @param ted	Links State Database
+ * @param addr	IPv4 address
+ */
+static void ospf_te_delete_subnet(struct ls_ted *ted, struct in_addr addr)
+{
+	struct prefix p;
+	struct ls_subnet *subnet;
+
+	/* Search subnet that correspond to the address/32 as prefix */
+	p.family = AF_INET;
+	p.prefixlen = IPV4_MAX_PREFIXLEN;
+	p.u.prefix4 = addr;
+	subnet = ls_find_subnet(ted, p);
+
+	/* Remove subnet if found */
+	if (subnet) {
+		subnet->status = DELETE;
+		ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
+		ls_subnet_del_all(ted, subnet);
+	}
+}
+
+/**
+ * Parse Router LSA. This function will create or update corresponding Vertex,
+ * Edge and Subnet. It also remove Edge and Subnet if they are marked as Orphan
+ * once Router LSA is parsed.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_parse_router_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct router_lsa *rl;
+	enum ls_node_type type;
+	struct ls_vertex *vertex;
+	struct ls_edge *edge;
+	struct ls_subnet *subnet;
+	struct listnode *node;
+	int len;
+
+	/* Sanity Check */
+	if (!ted || !lsa || !lsa->data)
+		return -1;
+
+	ote_debug("MPLS-TE (%s): Parse Router LSA[%pI4] from Router[%pI4]",
+		  __func__, &lsa->data->id, &lsa->data->adv_router);
+
+	/* Get vertex from LSA Advertise Router ID */
+	vertex = get_vertex(ted, lsa);
+
+	/* Set Node type information if it has changed */
+	rl = (struct router_lsa *)lsa->data;
+	if (IS_ROUTER_LSA_VIRTUAL(rl))
+		type = PSEUDO;
+	else if (IS_ROUTER_LSA_EXTERNAL(rl))
+		type = ASBR;
+	else if (IS_ROUTER_LSA_BORDER(rl))
+		type = ABR;
+	else
+		type = STANDARD;
+
+	if (vertex->status == NEW) {
+		vertex->node->type = type;
+		SET_FLAG(vertex->node->flags, LS_NODE_TYPE);
+	} else if (vertex->node->type != type) {
+		vertex->node->type = type;
+		vertex->status = UPDATE;
+	}
+
+	/* Check if Vertex has been modified */
+	if (vertex->status != SYNC) {
+		ote_debug("  |- %s Vertex %pI4",
+			  vertex->status == NEW ? "Add" : "Update",
+			  &vertex->node->router_id);
+
+		/* Vertex is out of sync: export it */
+		ospf_te_export(LS_MSG_TYPE_NODE, vertex);
+		vertex->status = SYNC;
+	}
+
+	/* Mark outgoing Edge and Subnet as ORPHAN to detect deletion */
+	for (ALL_LIST_ELEMENTS_RO(vertex->outgoing_edges, node, edge))
+		edge->status = ORPHAN;
+
+	for (ALL_LIST_ELEMENTS_RO(vertex->prefixes, node, subnet))
+		subnet->status = ORPHAN;
+
+	/* Then, process Link Information */
+	len = ntohs(rl->header.length) - 4;
+	for (int i = 0; i < ntohs(rl->links) && len > 0; len -= 12, i++) {
+		struct prefix p;
+		uint32_t metric;
+
+		switch (rl->link[i].type) {
+		case LSA_LINK_TYPE_POINTOPOINT:
+			ospf_te_update_link(ted, vertex, rl->link[i].link_data,
+					    ntohs(rl->link[i].metric));
+			/* Add corresponding subnet */
+			p.family = AF_INET;
+			p.prefixlen = IPV4_MAX_PREFIXLEN;
+			p.u.prefix4 = rl->link[i].link_data;
+			metric = ntohs(rl->link[i].metric);
+			ospf_te_update_subnet(ted, vertex, p, metric);
+			break;
+		case LSA_LINK_TYPE_STUB:
+			/* Keep only /32 prefix */
+			p.prefixlen = ip_masklen(rl->link[i].link_data);
+			if (p.prefixlen == IPV4_MAX_PREFIXLEN) {
+				p.family = AF_INET;
+				p.u.prefix4 = rl->link[i].link_id;
+				metric = ntohs(rl->link[i].metric);
+				ospf_te_update_subnet(ted, vertex, p, metric);
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	/* Clean remaining Orphan Edges or Subnets */
+	if (OspfMplsTE.export)
+		ls_vertex_clean(ted, vertex, zclient);
+	else
+		ls_vertex_clean(ted, vertex, NULL);
+
+	return 0;
+}
+
+/**
+ * Delete Vertex, Edge and Subnet associated to this Router LSA. This function
+ * is called when the router received such LSA with MAX_AGE (Flush) or when the
+ * router stop OSPF.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_delete_router_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_node_id lnid;
+	struct ls_vertex *vertex;
+
+	/* Sanity Check */
+	if (!ted || !lsa || !lsa->data)
+		return -1;
+
+	/* Search Vertex that corresponds to this LSA */
+	lnid.origin = OSPFv2;
+	lnid.id.ip.addr = lsa->data->adv_router;
+	lnid.id.ip.area_id = lsa->area->area_id;
+	vertex = ls_find_vertex_by_id(ted, lnid);
+	if (!vertex)
+		return -1;
+
+	ote_debug("MPLS-TE (%s): Delete Vertex %pI4 from Router LSA[%pI4]",
+		  __func__, &vertex->node->router_id, &lsa->data->id);
+
+	/* Export deleted vertex ... */
+	vertex->status = DELETE;
+	ospf_te_export(LS_MSG_TYPE_NODE, vertex);
+
+	/* ... and remove Node & Vertex from Link State Date Base */
+	ls_vertex_del_all(ted, vertex);
+
+	return 0;
+}
+
+/**
+ * Create or update Remote Vertex that corresponds to the remote ASBR of the
+ * foreign network if Edge is associated to an Inter-AS LSA (Type 6).
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param edge	Link State Edge
+ */
+static void ospf_te_update_remote_asbr(struct ls_ted *ted, struct ls_edge *edge)
+{
+	struct ls_node_id lnid;
+	struct ls_vertex *vertex;
+	struct ls_node *lnode;
+	struct ls_attributes *attr;
+	struct prefix p;
+
+	/* Sanity Check */
+	if (!ted || !edge)
+		return;
+
+	/* Search if a Link State Vertex already exist */
+	attr = edge->attributes;
+	lnid.origin = OSPFv2;
+	lnid.id.ip.addr = attr->standard.remote_addr;
+	lnid.id.ip.area_id = attr->adv.id.ip.area_id;
+	vertex = ls_find_vertex_by_id(ted, lnid);
+
+	/* Create Node & Vertex in the Link State Date Base if not found */
+	if (!vertex) {
+		const struct in_addr inaddr_any = {.s_addr = INADDR_ANY};
+
+		lnode = ls_node_new(lnid, inaddr_any, in6addr_any);
+		snprintfrr(lnode->name, MAX_NAME_LENGTH, "%pI4",
+			   &lnid.id.ip.addr);
+		vertex = ls_vertex_add(ted, lnode);
+	}
+
+	/* Update Node information */
+	lnode = vertex->node;
+	if (CHECK_FLAG(lnode->flags, LS_NODE_TYPE)) {
+		if (lnode->type != RMT_ASBR) {
+			lnode->type = RMT_ASBR;
+			if (vertex->status != NEW)
+				vertex->status = UPDATE;
+		}
+	} else {
+		lnode->type = RMT_ASBR;
+		SET_FLAG(lnode->flags, LS_NODE_TYPE);
+		if (vertex->status != NEW)
+			vertex->status = UPDATE;
+	}
+	if (CHECK_FLAG(lnode->flags, LS_NODE_AS_NUMBER)) {
+		if (lnode->as_number != attr->standard.remote_as) {
+			lnode->as_number = attr->standard.remote_as;
+			if (vertex->status != NEW)
+				vertex->status = UPDATE;
+		}
+	} else {
+		lnode->as_number = attr->standard.remote_as;
+		SET_FLAG(lnode->flags, LS_NODE_AS_NUMBER);
+		if (vertex->status != NEW)
+			vertex->status = UPDATE;
+	}
+
+	/* Export Link State Vertex if needed */
+	if (vertex->status == NEW  || vertex->status == UPDATE) {
+		ote_debug("  |- %s Remote Vertex %pI4 for AS %u",
+			  vertex->status == NEW ? "Add" : "Update",
+			  &lnode->router_id, lnode->as_number);
+		ospf_te_export(LS_MSG_TYPE_NODE, vertex);
+		vertex->status = SYNC;
+	}
+
+	/* Update corresponding Subnets */
+	p.family = AF_INET;
+	p.prefixlen = IPV4_MAX_PREFIXLEN;
+	p.u.prefix4 = attr->standard.local;
+	ospf_te_update_subnet(ted, edge->source, p, attr->standard.te_metric);
+
+	p.family = AF_INET;
+	p.prefixlen = IPV4_MAX_PREFIXLEN;
+	p.u.prefix4 = attr->standard.remote_addr;
+	ospf_te_update_subnet(ted, vertex, p, attr->standard.te_metric);
+
+	/* Connect Edge to the remote Vertex */
+	if (edge->destination == NULL) {
+		edge->destination = vertex;
+		listnode_add_sort_nodup(vertex->incoming_edges, edge);
+	}
+
+	/* Finally set type to ASBR the node that advertised this Edge ... */
+	vertex = edge->source;
+	lnode = vertex->node;
+	if (CHECK_FLAG(lnode->flags, LS_NODE_TYPE)) {
+		if (lnode->type != ASBR) {
+			lnode->type = ASBR;
+			if (vertex->status != NEW)
+				vertex->status = UPDATE;
+		}
+	} else {
+		lnode->type = ASBR;
+		SET_FLAG(lnode->flags, LS_NODE_TYPE);
+		if (vertex->status != NEW)
+			vertex->status = UPDATE;
+	}
+
+	/* ... and Export it if needed */
+	if (vertex->status == NEW  || vertex->status == UPDATE) {
+		ospf_te_export(LS_MSG_TYPE_NODE, vertex);
+		vertex->status = SYNC;
+	}
+}
+
+/**
+ * Parse Opaque Traffic Engineering LSA (Type 1) TLVs and create or update the
+ * corresponding Link State Edge and Attributes. Vertex connections are also
+ * updated if needed based on the remote IP address of the Edge and existing
+ * reverse Edge.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_parse_te(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_edge *edge;
+	struct ls_vertex *vertex;
+	struct ls_attributes *old, attr = {};
+	struct tlv_header *tlvh;
+	void *value;
+	uint16_t len, sum;
+	uint8_t lsa_id;
+
+	/* Initialize Attribute */
+	attr.adv.origin = OSPFv2;
+	attr.adv.id.ip.addr = lsa->data->adv_router;
+	if (lsa->data->type != OSPF_OPAQUE_AS_LSA)
+		attr.adv.id.ip.area_id = lsa->area->area_id;
+
+	/* Initialize TLV browsing */
+	tlvh = TLV_HDR_TOP(lsa->data);
+
+	/* Skip TE Router-ID if present */
+	if (ntohs(tlvh->type) == TE_TLV_ROUTER_ADDR)
+		tlvh = TLV_HDR_NEXT(tlvh);
+
+	/* Check if we have a TE Link TLV */
+	len = TLV_BODY_SIZE(tlvh);
+	if ((len == 0) || (ntohs(tlvh->type) != TE_TLV_LINK))
+		return 0;
+
+	sum = 0;
+	/* Browse sub-TLV and fulfill Link State Attributes */
+	for (tlvh = TLV_DATA(tlvh); sum < len; tlvh = TLV_HDR_NEXT(tlvh)) {
+		uint32_t val32, tab32[2];
+		float valf, tabf[8];
+		struct in_addr addr;
+
+		value = TLV_DATA(tlvh);
+		switch (ntohs(tlvh->type)) {
+		case TE_LINK_SUBTLV_LCLIF_IPADDR:
+			memcpy(&addr, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.local = addr;
+			SET_FLAG(attr.flags, LS_ATTR_LOCAL_ADDR);
+			break;
+		case TE_LINK_SUBTLV_RMTIF_IPADDR:
+			memcpy(&addr, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.remote = addr;
+			SET_FLAG(attr.flags, LS_ATTR_NEIGH_ADDR);
+			break;
+		case TE_LINK_SUBTLV_TE_METRIC:
+			memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.te_metric = ntohl(val32);
+			SET_FLAG(attr.flags, LS_ATTR_TE_METRIC);
+			break;
+		case TE_LINK_SUBTLV_MAX_BW:
+			memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.max_bw = ntohf(valf);
+			SET_FLAG(attr.flags, LS_ATTR_MAX_BW);
+			break;
+		case TE_LINK_SUBTLV_MAX_RSV_BW:
+			memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.max_rsv_bw = ntohf(valf);
+			SET_FLAG(attr.flags, LS_ATTR_MAX_RSV_BW);
+			break;
+		case TE_LINK_SUBTLV_UNRSV_BW:
+			memcpy(tabf, value, TE_LINK_SUBTLV_UNRSV_SIZE);
+			for (int i = 0; i < MAX_CLASS_TYPE; i++)
+				attr.standard.unrsv_bw[i] = ntohf(tabf[i]);
+			SET_FLAG(attr.flags, LS_ATTR_UNRSV_BW);
+			break;
+		case TE_LINK_SUBTLV_RSC_CLSCLR:
+			memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.admin_group = ntohl(val32);
+			SET_FLAG(attr.flags, LS_ATTR_ADM_GRP);
+			break;
+		case TE_LINK_SUBTLV_LLRI:
+			memcpy(tab32, value, TE_LINK_SUBTLV_LLRI_SIZE);
+			attr.standard.local_id = ntohl(tab32[0]);
+			attr.standard.remote_id = ntohl(tab32[1]);
+			SET_FLAG(attr.flags, LS_ATTR_LOCAL_ID);
+			SET_FLAG(attr.flags, LS_ATTR_NEIGH_ID);
+			break;
+		case TE_LINK_SUBTLV_RIP:
+			memcpy(&addr, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.remote_addr = addr;
+			SET_FLAG(attr.flags, LS_ATTR_REMOTE_ADDR);
+			break;
+		case TE_LINK_SUBTLV_RAS:
+			memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.standard.remote_as = ntohl(val32);
+			SET_FLAG(attr.flags, LS_ATTR_REMOTE_AS);
+			break;
+		case TE_LINK_SUBTLV_AV_DELAY:
+			memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.extended.delay = ntohl(val32);
+			SET_FLAG(attr.flags, LS_ATTR_DELAY);
+			break;
+		case TE_LINK_SUBTLV_MM_DELAY:
+			memcpy(tab32, value, TE_LINK_SUBTLV_MM_DELAY_SIZE);
+			attr.extended.min_delay = ntohl(tab32[0]);
+			attr.extended.max_delay = ntohl(tab32[1]);
+			SET_FLAG(attr.flags, LS_ATTR_MIN_MAX_DELAY);
+			break;
+		case TE_LINK_SUBTLV_DELAY_VAR:
+			memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.extended.jitter = ntohl(val32);
+			SET_FLAG(attr.flags, LS_ATTR_JITTER);
+			break;
+		case TE_LINK_SUBTLV_PKT_LOSS:
+			memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.extended.pkt_loss = ntohl(val32);
+			SET_FLAG(attr.flags, LS_ATTR_PACKET_LOSS);
+			break;
+		case TE_LINK_SUBTLV_RES_BW:
+			memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.extended.rsv_bw = ntohf(valf);
+			SET_FLAG(attr.flags, LS_ATTR_RSV_BW);
+			break;
+		case TE_LINK_SUBTLV_AVA_BW:
+			memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.extended.ava_bw = ntohf(valf);
+			SET_FLAG(attr.flags, LS_ATTR_AVA_BW);
+			break;
+		case TE_LINK_SUBTLV_USE_BW:
+			memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
+			attr.extended.used_bw = ntohf(valf);
+			SET_FLAG(attr.flags, LS_ATTR_USE_BW);
+			break;
+		default:
+			break;
+		}
+		sum += TLV_SIZE(tlvh);
+	}
+
+	/* Get corresponding Edge from Link State Data Base */
+	edge = get_edge(ted, attr.adv, attr.standard.local);
+	old = edge->attributes;
+
+	ote_debug("  |- Process Traffic Engineering LSA %pI4 for Edge %pI4",
+		  &lsa->data->id, &attr.standard.local);
+
+	/* Update standard fields */
+	len = sizeof(struct ls_standard);
+	if ((attr.flags & 0x0FFFF) == (old->flags & 0x0FFFF)) {
+		if (memcmp(&attr.standard, &old->standard, len) != 0) {
+			memcpy(&old->standard, &attr.standard, len);
+			if (edge->status != NEW)
+				edge->status = UPDATE;
+		}
+	} else {
+		memcpy(&old->standard, &attr.standard, len);
+		old->flags |= attr.flags & 0x0FFFF;
+		if (edge->status != NEW)
+			edge->status = UPDATE;
+	}
+	/* Update extended fields */
+	len = sizeof(struct ls_extended);
+	if ((attr.flags & 0x0FF0000) == (old->flags & 0x0FF0000)) {
+		if (memcmp(&attr.extended, &old->extended, len) != 0) {
+			memcpy(&old->extended, &attr.extended, len);
+			if (edge->status != NEW)
+				edge->status = UPDATE;
+		}
+	} else {
+		memcpy(&old->extended, &attr.extended, len);
+		old->flags |= attr.flags & 0x0FF0000;
+		if (edge->status != NEW)
+			edge->status = UPDATE;
+	}
+
+	/* If LSA is an Opaque Inter-AS, Add Node and Subnet */
+	lsa_id = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
+	if (lsa_id ==  OPAQUE_TYPE_INTER_AS_LSA)
+		ospf_te_update_remote_asbr(ted, edge);
+
+	/* Update remote Link if remote IP addr is known */
+	if (CHECK_FLAG(old->flags, LS_ATTR_NEIGH_ADDR)) {
+		struct ls_edge *dst;
+
+		dst = ls_find_edge_by_destination(ted, old);
+		/* Attach remote link if not set */
+		if (dst && edge->source && dst->destination == NULL) {
+			vertex = edge->source;
+			if (vertex->incoming_edges)
+				listnode_add_sort_nodup(vertex->incoming_edges,
+							dst);
+			dst->destination = vertex;
+		}
+		/* and destination vertex to this edge */
+		if (dst && dst->source && edge->destination == NULL) {
+			vertex = dst->source;
+			if (vertex->incoming_edges)
+				listnode_add_sort_nodup(vertex->incoming_edges,
+							edge);
+			edge->destination = vertex;
+		}
+	}
+
+	/* Export Link State Edge if needed */
+	if (edge->status == NEW || edge->status == UPDATE) {
+		ote_debug("  |- %s TE info. for Edge %pI4",
+			  edge->status == NEW ? "Add" : "Update",
+			  &edge->attributes->standard.local);
+
+		ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
+		edge->status = SYNC;
+	}
+
+	return 0;
+}
+
+/**
+ * Delete Link State Attributes information that correspond to the Opaque
+ * Traffic Engineering LSA (Type 1) TLVs. Note that the Edge is not removed.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_delete_te(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_edge *edge;
+	struct ls_attributes *attr;
+	struct tlv_header *tlvh;
+	struct in_addr addr;
+	uint64_t key = 0;
+	uint16_t len, sum;
+	uint8_t lsa_id;
+
+	/* Initialize TLV browsing */
+	tlvh = TLV_HDR_TOP(lsa->data);
+	/* Skip Router TE ID if present */
+	if (ntohs(tlvh->type) == TE_TLV_ROUTER_ADDR)
+		tlvh = TLV_HDR_NEXT(tlvh);
+	len = TLV_BODY_SIZE(tlvh);
+	sum = 0;
+
+	/* Browse sub-TLV to find Link ID */
+	for (tlvh = TLV_DATA(tlvh); sum < len; tlvh = TLV_HDR_NEXT(tlvh)) {
+		if (ntohs(tlvh->type) == TE_LINK_SUBTLV_LCLIF_IPADDR) {
+			memcpy(&addr, TLV_DATA(tlvh), TE_LINK_SUBTLV_DEF_SIZE);
+			key = ((uint64_t)ntohl(addr.s_addr)) & 0xffffffff;
+			break;
+		}
+		sum += TLV_SIZE(tlvh);
+	}
+	if (key == 0)
+		return 0;
+
+	/* Search Edge that corresponds to the Link ID */
+	edge = ls_find_edge_by_key(ted, key);
+	if (!edge || !edge->attributes)
+		return 0;
+	attr = edge->attributes;
+
+	/* First, remove Remote ASBR and associated Edge & Subnet if any */
+	lsa_id = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
+	if (lsa_id ==  OPAQUE_TYPE_INTER_AS_LSA) {
+		ote_debug("  |- Delete remote ASBR, Edge and Subnet");
+
+		if (edge->destination) {
+			edge->destination->status = DELETE;
+			ospf_te_export(LS_MSG_TYPE_NODE, edge->destination);
+			ls_vertex_del_all(ted, edge->destination);
+		}
+
+		ospf_te_delete_subnet(ted, attr->standard.local);
+
+		edge->status = DELETE;
+		ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
+		ls_edge_del_all(ted, edge);
+
+		return 0;
+	}
+
+	ote_debug("  |- Delete TE info. for Edge %pI4",
+		  &edge->attributes->standard.local);
+
+	/* Remove Link State Attributes TE information */
+	memset(&attr->standard, 0, sizeof(struct ls_standard));
+	attr->flags &= 0x0FFFF;
+	memset(&attr->extended, 0, sizeof(struct ls_extended));
+	attr->flags &= 0x0FF0000;
+	ls_attributes_srlg_del(attr);
+
+	/* Export Edge that has been updated */
+	if (CHECK_FLAG(attr->flags, LS_ATTR_ADJ_SID)
+	    || CHECK_FLAG(attr->flags, LS_ATTR_BCK_ADJ_SID)) {
+		edge->status = UPDATE;
+		ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
+		edge->status = SYNC;
+	} else {
+		/* Remove completely the Edge if Segment Routing is not set */
+		ospf_te_delete_subnet(ted, attr->standard.local);
+		edge->status = DELETE;
+		ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
+		ls_edge_del_all(ted, edge);
+	}
+
+	return 0;
+}
+
+/**
+ * Parse Opaque Router Information LSA (Type 4) TLVs and update the
+ * corresponding Link State Vertex with these information (Segment Routing).
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_parse_ri(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_vertex *vertex;
+	struct ls_node *node;
+	struct lsa_header *lsah = lsa->data;
+	struct tlv_header *tlvh;
+	uint16_t len = 0, sum = 0;
+
+	/* Get vertex / Node from LSA Advertised Router ID */
+	vertex = get_vertex(ted, lsa);
+	node = vertex->node;
+
+	ote_debug("  |- Process Router Information LSA %pI4 for Vertex %pI4",
+		  &lsa->data->id, &node->router_id);
+
+	/* Initialize TLV browsing */
+	len = ntohs(lsah->length) - OSPF_LSA_HEADER_SIZE;
+	for (tlvh = TLV_HDR_TOP(lsah); sum < len; tlvh = TLV_HDR_NEXT(tlvh)) {
+		struct ri_sr_tlv_sr_algorithm *algo;
+		struct ri_sr_tlv_sid_label_range *range;
+		struct ri_sr_tlv_node_msd *msd;
+		uint32_t size, lower;
+
+		switch (ntohs(tlvh->type)) {
+		case RI_SR_TLV_SR_ALGORITHM:
+			algo = (struct ri_sr_tlv_sr_algorithm *)tlvh;
+
+			for (int i = 0; i < ntohs(algo->header.length); i++) {
+				if (CHECK_FLAG(node->flags, LS_NODE_SR)
+				    && (node->algo[i] == algo->value[i]))
+					continue;
+
+				node->algo[i] = algo->value[i];
+				SET_FLAG(node->flags, LS_NODE_SR);
+				if (vertex->status != NEW)
+					vertex->status = UPDATE;
+			}
+
+			/* Reset other Algorithms */
+			for (int i = ntohs(algo->header.length); i < 2; i++) {
+				if (vertex->status != NEW
+				    && node->algo[i] != SR_ALGORITHM_UNSET)
+					vertex->status = UPDATE;
+				node->algo[i] = SR_ALGORITHM_UNSET;
+			}
+
+			break;
+
+		case RI_SR_TLV_SRGB_LABEL_RANGE:
+			range = (struct ri_sr_tlv_sid_label_range *)tlvh;
+			size = GET_RANGE_SIZE(ntohl(range->size));
+			lower = GET_LABEL(ntohl(range->lower.value));
+			if ((CHECK_FLAG(node->flags, LS_NODE_SR))
+			    && ((node->srgb.range_size == size)
+				&& (node->srgb.lower_bound == lower)))
+				break;
+
+			node->srgb.range_size = size;
+			node->srgb.lower_bound = lower;
+			SET_FLAG(node->flags, LS_NODE_SR);
+			if (vertex->status != NEW)
+				vertex->status = UPDATE;
+
+			break;
+
+		case RI_SR_TLV_SRLB_LABEL_RANGE:
+			range = (struct ri_sr_tlv_sid_label_range *)tlvh;
+			size = GET_RANGE_SIZE(ntohl(range->size));
+			lower = GET_LABEL(ntohl(range->lower.value));
+			if ((CHECK_FLAG(node->flags, LS_NODE_SRLB))
+			    && ((node->srlb.range_size == size)
+				&& (node->srlb.lower_bound == lower)))
+				break;
+
+			node->srlb.range_size = size;
+			node->srlb.lower_bound = lower;
+			SET_FLAG(node->flags, LS_NODE_SRLB);
+			if (vertex->status != NEW)
+				vertex->status = UPDATE;
+
+			break;
+
+		case RI_SR_TLV_NODE_MSD:
+			msd = (struct ri_sr_tlv_node_msd *)tlvh;
+			if ((CHECK_FLAG(node->flags, LS_NODE_MSD))
+			    && (node->msd == msd->value))
+				break;
+
+			node->msd = msd->value;
+			SET_FLAG(node->flags, LS_NODE_MSD);
+			if (vertex->status != NEW)
+				vertex->status = UPDATE;
+
+			break;
+
+		default:
+			break;
+		}
+		sum += TLV_SIZE(tlvh);
+	}
+
+	/* Vertex has been created or updated: export it */
+	if (vertex->status == NEW || vertex->status == UPDATE) {
+		ote_debug("  |- %s SR info - SRGB[%d/%d] for Vertex %pI4",
+			  vertex->status == NEW ? "Add" : "Update",
+			  vertex->node->srgb.lower_bound,
+			  vertex->node->srgb.range_size,
+			  &vertex->node->router_id);
+
+		ospf_te_export(LS_MSG_TYPE_NODE, vertex);
+		vertex->status = SYNC;
+	}
+
+	return 0;
+}
+
+/**
+ * Delete Link State Node information (Segment Routing) that correspond to the
+ * Opaque Router Information LSA (Type 4) TLVs. Note that the Vertex is not
+ * removed.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_delete_ri(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_node_id lnid;
+	struct ls_vertex *vertex;
+	struct ls_node *node;
+
+	/* Search if a Link State Vertex already exist */
+	lnid.origin = OSPFv2;
+	lnid.id.ip.addr = lsa->data->adv_router;
+	lnid.id.ip.area_id = lsa->area->area_id;
+	vertex = ls_find_vertex_by_id(ted, lnid);
+	if (!vertex)
+		return -1;
+
+	/* Remove Segment Routing Information if any */
+	node = vertex->node;
+	UNSET_FLAG(node->flags, LS_NODE_SR);
+	memset(&node->srgb, 0, sizeof(struct ls_srgb));
+	node->algo[0] = SR_ALGORITHM_UNSET;
+	node->algo[1] = SR_ALGORITHM_UNSET;
+	UNSET_FLAG(node->flags, LS_NODE_SRLB);
+	memset(&node->srlb, 0, sizeof(struct ls_srlb));
+	UNSET_FLAG(node->flags, LS_NODE_MSD);
+	node->msd = 0;
+	vertex->status = UPDATE;
+
+	ote_debug("  |- Delete SR info. for Vertex %pI4",
+		  &vertex->node->router_id);
+
+	/* Vertex has been updated: export it */
+	ospf_te_export(LS_MSG_TYPE_NODE, vertex);
+	vertex->status = SYNC;
+
+	return 0;
+}
+
+/**
+ * Parse Opaque Extended Prefix LSA (Type 7) TLVs and update the corresponding
+ * Link State Subnet with these information (Segment Routing ID).
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_parse_ext_pref(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_node_id lnid;
+	struct ls_subnet *subnet;
+	struct ls_prefix *ls_pref;
+	struct prefix pref;
+	struct ext_tlv_prefix *ext;
+	struct ext_subtlv_prefix_sid *pref_sid;
+	uint32_t label;
+
+	/* Get corresponding Subnet from Link State Data Base */
+	ext = (struct ext_tlv_prefix *)TLV_HDR_TOP(lsa->data);
+	pref.family = AF_INET;
+	pref.prefixlen = ext->pref_length;
+	pref.u.prefix4 = ext->address;
+	subnet = ls_find_subnet(ted, pref);
+
+	/* Create new Link State Prefix if not found */
+	if (!subnet) {
+		lnid.origin = OSPFv2;
+		lnid.id.ip.addr = lsa->data->adv_router;
+		lnid.id.ip.area_id = lsa->area->area_id;
+		ls_pref = ls_prefix_new(lnid, pref);
+		/* and add it to the TED */
+		subnet = ls_subnet_add(ted, ls_pref);
+	}
+
+	ote_debug("  |- Process Extended Prefix LSA %pI4 for subnet %pFX",
+		  &lsa->data->id, &pref);
+
+	/* Initialize TLV browsing */
+	ls_pref = subnet->ls_pref;
+	pref_sid = (struct ext_subtlv_prefix_sid *)((char *)(ext) + TLV_HDR_SIZE
+						    + EXT_TLV_PREFIX_SIZE);
+	label = CHECK_FLAG(pref_sid->flags, EXT_SUBTLV_PREFIX_SID_VFLG)
+			? GET_LABEL(ntohl(pref_sid->value))
+			: ntohl(pref_sid->value);
+
+	/* Check if it is a simple refresh */
+	if (CHECK_FLAG(ls_pref->flags, LS_PREF_SR)
+	    && ls_pref->sr.algo == pref_sid->algorithm
+	    && ls_pref->sr.sid_flag == pref_sid->flags
+	    && ls_pref->sr.sid == label)
+		return 0;
+
+	/* Fulfill SR information */
+	ls_pref->sr.algo = pref_sid->algorithm;
+	ls_pref->sr.sid_flag = pref_sid->flags;
+	ls_pref->sr.sid = label;
+	SET_FLAG(ls_pref->flags, LS_PREF_SR);
+	if (subnet->status != NEW)
+		subnet->status = UPDATE;
+
+	/* Export Subnet if needed */
+	if (subnet->status == NEW || subnet->status == UPDATE) {
+		ote_debug("  |- %s SID %d to subnet %pFX",
+			  subnet->status == NEW ? "Add" : "Update",
+			  ls_pref->sr.sid, &ls_pref->pref);
+
+		ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
+		subnet->status = SYNC;
+	}
+
+	return 0;
+}
+
+/**
+ * Delete Link State Subnet information (Segment Routing ID) that correspond to
+ * the Opaque Extended Prefix LSA (Type 7) TLVs. Note that the Subnet is not
+ * removed.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_delete_ext_pref(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_subnet *subnet;
+	struct ls_prefix *ls_pref;
+	struct prefix pref;
+	struct ext_tlv_prefix *ext;
+
+	/* Get corresponding Subnet from Link State Data Base */
+	ext = (struct ext_tlv_prefix *)TLV_HDR_TOP(lsa->data);
+	pref.family = AF_INET;
+	pref.prefixlen = ext->pref_length;
+	pref.u.prefix4 = ext->address;
+	subnet = ls_find_subnet(ted, pref);
+
+	/* Check if there is a corresponding subnet */
+	if (!subnet)
+		return -1;
+
+	ote_debug("  |- Delete SID %d to subnet %pFX", subnet->ls_pref->sr.sid,
+		  &subnet->ls_pref->pref);
+
+	/* Remove Segment Routing information */
+	ls_pref = subnet->ls_pref;
+	UNSET_FLAG(ls_pref->flags, LS_PREF_SR);
+	memset(&ls_pref->sr, 0, sizeof(struct ls_sid));
+	subnet->status = UPDATE;
+
+	/* Subnet has been updated: export it */
+	ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
+	subnet->status = SYNC;
+
+	return 0;
+}
+
+/**
+ * Parse Opaque Extended Link LSA (Type 8) TLVs and update the corresponding
+ * Link State Edge with these information (Segment Routing Adjacency).
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_parse_ext_link(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_node_id lnid;
+	struct tlv_header *tlvh;
+	struct ext_tlv_link *ext;
+	struct ls_edge *edge;
+	struct ls_attributes *atr;
+	uint16_t len = 0, sum = 0, i;
+	uint32_t label;
+
+	/* Get corresponding Edge from Link State Data Base */
+	lnid.origin = OSPFv2;
+	lnid.id.ip.addr = lsa->data->adv_router;
+	lnid.id.ip.area_id = lsa->area->area_id;
+	ext = (struct ext_tlv_link *)TLV_HDR_TOP(lsa->data);
+	edge = get_edge(ted, lnid, ext->link_data);
+	atr = edge->attributes;
+
+	ote_debug("  |- Process Extended Link LSA %pI4 for edge %pI4",
+		  &lsa->data->id, &edge->attributes->standard.local);
+
+	/* Initialize TLV browsing */
+	len = TLV_BODY_SIZE(&ext->header);
+	tlvh = (struct tlv_header *)((char *)(ext) + TLV_HDR_SIZE
+				     + EXT_TLV_LINK_SIZE);
+	for (; sum < len; tlvh = TLV_HDR_NEXT(tlvh)) {
+		struct ext_subtlv_adj_sid *adj;
+		struct ext_subtlv_lan_adj_sid *ladj;
+		struct ext_subtlv_rmt_itf_addr *rmt;
+
+		switch (ntohs(tlvh->type)) {
+		case EXT_SUBTLV_ADJ_SID:
+			adj = (struct ext_subtlv_adj_sid *)tlvh;
+			label = CHECK_FLAG(adj->flags,
+					   EXT_SUBTLV_LINK_ADJ_SID_VFLG)
+					? GET_LABEL(ntohl(adj->value))
+					: ntohl(adj->value);
+			i = CHECK_FLAG(adj->flags,
+				       EXT_SUBTLV_LINK_ADJ_SID_BFLG) ? 1 : 0;
+			if (((i && CHECK_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID))
+			     || (!i && CHECK_FLAG(atr->flags, LS_ATTR_ADJ_SID)))
+			    && atr->adj_sid[i].flags == adj->flags
+			    && atr->adj_sid[i].sid == label
+			    && atr->adj_sid[i].weight == adj->weight)
+				break;
+
+			atr->adj_sid[i].flags = adj->flags;
+			atr->adj_sid[i].sid = label;
+			atr->adj_sid[i].weight = adj->weight;
+			if (i == 0)
+				SET_FLAG(atr->flags, LS_ATTR_ADJ_SID);
+			else
+				SET_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID);
+			if (edge->status != NEW)
+				edge->status = UPDATE;
+
+			break;
+		case EXT_SUBTLV_LAN_ADJ_SID:
+			ladj = (struct ext_subtlv_lan_adj_sid *)tlvh;
+			label = CHECK_FLAG(ladj->flags,
+					   EXT_SUBTLV_LINK_ADJ_SID_VFLG)
+					? GET_LABEL(ntohl(ladj->value))
+					: ntohl(ladj->value);
+			i = CHECK_FLAG(ladj->flags,
+				       EXT_SUBTLV_LINK_ADJ_SID_BFLG) ? 1 : 0;
+			if (((i && CHECK_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID))
+			     || (!i && CHECK_FLAG(atr->flags, LS_ATTR_ADJ_SID)))
+			    && atr->adj_sid[i].flags == ladj->flags
+			    && atr->adj_sid[i].sid == label
+			    && atr->adj_sid[i].weight == ladj->weight
+			    && IPV4_ADDR_SAME(&atr->adj_sid[1].neighbor.addr,
+					      &ladj->neighbor_id))
+				break;
+
+			atr->adj_sid[i].flags = ladj->flags;
+			atr->adj_sid[i].sid = label;
+			atr->adj_sid[i].weight = ladj->weight;
+			atr->adj_sid[i].neighbor.addr = ladj->neighbor_id;
+			if (i == 0)
+				SET_FLAG(atr->flags, LS_ATTR_ADJ_SID);
+			else
+				SET_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID);
+			if (edge->status != NEW)
+				edge->status = UPDATE;
+
+			break;
+		case EXT_SUBTLV_RMT_ITF_ADDR:
+			rmt = (struct ext_subtlv_rmt_itf_addr *)tlvh;
+			if (CHECK_FLAG(atr->flags, LS_ATTR_NEIGH_ADDR)
+			    && IPV4_ADDR_SAME(&atr->standard.remote,
+					      &rmt->value))
+				break;
+
+			atr->standard.remote = rmt->value;
+			SET_FLAG(atr->flags, LS_ATTR_NEIGH_ADDR);
+			if (edge->status != NEW)
+				edge->status = UPDATE;
+
+			break;
+		default:
+			break;
+		}
+		sum += TLV_SIZE(tlvh);
+	}
+
+	/* Export Link State Edge if needed */
+	if (edge->status == NEW || edge->status == UPDATE) {
+		ote_debug("  |- %s Adj-SID %d & %d to edge %pI4",
+			  edge->status == NEW ? "Add" : "Update",
+			  edge->attributes->adj_sid[0].sid,
+			  edge->attributes->adj_sid[1].sid,
+			  &edge->attributes->standard.local);
+
+		ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
+		edge->status = SYNC;
+	}
+
+	return 0;
+}
+
+/**
+ * Delete Link State Edge information (Segment Routing Adjacency) that
+ * correspond to the Opaque Extended Link LSA (Type 8) TLVs. Note that the Edge
+ * is not removed.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_delete_ext_link(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	struct ls_edge *edge;
+	struct ls_attributes *atr;
+	struct ext_tlv_link *ext;
+	uint64_t key;
+
+	/* Search for corresponding Edge from Link State Data Base */
+	ext = (struct ext_tlv_link *)TLV_HDR_TOP(lsa->data);
+	key = ((uint64_t)ntohl(ext->link_data.s_addr)) & 0xffffffff;
+	edge = ls_find_edge_by_key(ted, key);
+
+	/* Check if there is a corresponding Edge */
+	if (!edge)
+		return -1;
+
+	ote_debug("  |- Delete Adj-SID %d to edge %pI4",
+		  edge->attributes->adj_sid[0].sid,
+		  &edge->attributes->standard.local);
+
+	/* Remove Segment Routing information */
+	atr = edge->attributes;
+	UNSET_FLAG(atr->flags, LS_ATTR_ADJ_SID);
+	UNSET_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID);
+	memset(atr->adj_sid, 0, 2 * sizeof(struct ls_sid));
+	edge->status = UPDATE;
+
+	/* Edge has been updated: export it */
+	ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
+	edge->status = SYNC;
+
+	return 0;
+}
+
+/**
+ * Parse Opaque LSA Type and call corresponding parser.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_parse_opaque_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	uint8_t key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
+	int rc = -1;
+
+	ote_debug("MPLS-TE (%s): Parse Opaque LSA[%pI4] from Router[%pI4]",
+		  __func__, &lsa->data->id, &lsa->data->adv_router);
+
+	switch (key) {
+	case OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA:
+	case OPAQUE_TYPE_INTER_AS_LSA:
+		rc = ospf_te_parse_te(ted, lsa);
+		break;
+	case OPAQUE_TYPE_ROUTER_INFORMATION_LSA:
+		rc = ospf_te_parse_ri(ted, lsa);
+		break;
+	case OPAQUE_TYPE_EXTENDED_PREFIX_LSA:
+		rc = ospf_te_parse_ext_pref(ted, lsa);
+		break;
+	case OPAQUE_TYPE_EXTENDED_LINK_LSA:
+		rc = ospf_te_parse_ext_link(ted, lsa);
+		break;
+	default:
+		break;
+	}
+
+	return rc;
+}
+
+/**
+ * Parse Opaque LSA Type and call corresponding deletion function.
+ *
+ * @param ted	Link State Traffic Engineering Database
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_te_delete_opaque_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
+{
+	uint8_t key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
+	int rc = -1;
+
+	ote_debug("MPLS-TE (%s): Parse Opaque LSA[%pI4] from Router[%pI4]",
+		  __func__, &lsa->data->id, &lsa->data->adv_router);
+
+	switch (key) {
+	case OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA:
+	case OPAQUE_TYPE_INTER_AS_LSA:
+		rc = ospf_te_delete_te(ted, lsa);
+		break;
+	case OPAQUE_TYPE_ROUTER_INFORMATION_LSA:
+		rc = ospf_te_delete_ri(ted, lsa);
+		break;
+	case OPAQUE_TYPE_EXTENDED_PREFIX_LSA:
+		rc = ospf_te_delete_ext_pref(ted, lsa);
+		break;
+	case OPAQUE_TYPE_EXTENDED_LINK_LSA:
+		rc = ospf_te_delete_ext_link(ted, lsa);
+		break;
+	default:
+		break;
+	}
+
+	return rc;
+}
+
+/**
+ * Update Traffic Engineering Database Elements that correspond to the received
+ * OSPF LSA. If LSA age is equal to MAX_AGE, call deletion function instead.
+ *
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_mpls_te_lsa_update(struct ospf_lsa *lsa)
+{
+
+	uint8_t rc;
+
+	/* Check that MPLS-TE is active */
+	if (!OspfMplsTE.enabled || !OspfMplsTE.ted)
+		return 0;
+
+	/* Sanity Check */
+	if (lsa == NULL) {
+		flog_warn(EC_OSPF_LSA_NULL, "TE (%s): Abort! LSA is NULL",
+			  __func__);
+		return -1;
+	}
+
+	/* If LSA is MAX_AGE, remove corresponding Link State element */
+	if (IS_LSA_MAXAGE(lsa)) {
+		switch (lsa->data->type) {
+		case OSPF_ROUTER_LSA:
+			rc = ospf_te_delete_router_lsa(OspfMplsTE.ted, lsa);
+			break;
+		case OSPF_OPAQUE_AREA_LSA:
+		case OSPF_OPAQUE_AS_LSA:
+			rc = ospf_te_delete_opaque_lsa(OspfMplsTE.ted, lsa);
+			break;
+		default:
+			rc = 0;
+			break;
+		}
+	} else {
+		/* Parse LSA to Update corresponding Link State element */
+		switch (lsa->data->type) {
+		case OSPF_ROUTER_LSA:
+			rc = ospf_te_parse_router_lsa(OspfMplsTE.ted, lsa);
+			break;
+		case OSPF_OPAQUE_AREA_LSA:
+		case OSPF_OPAQUE_AS_LSA:
+			rc = ospf_te_parse_opaque_lsa(OspfMplsTE.ted, lsa);
+			break;
+		default:
+			rc = 0;
+			break;
+		}
+	}
+
+	return rc;
+}
+
+/**
+ * Delete Traffic Engineering Database element from OSPF LSA. This function
+ * process only self LSA (i.e. advertised by the router) which reach MAX_AGE
+ * as LSA deleted by neighbor routers are Flushed (i.e. advertised with
+ * age == MAX_AGE) and processed by ospf_mpls_te_lsa_update() function.
+ *
+ * @param lsa	OSPF Link State Advertisement
+ *
+ * @return	0 if success, -1 otherwise
+ */
+static int ospf_mpls_te_lsa_delete(struct ospf_lsa *lsa)
+{
+
+	uint8_t rc;
+
+	/* Check that MPLS-TE is active */
+	if (!OspfMplsTE.enabled || !OspfMplsTE.ted)
+		return 0;
+
+	/* Sanity Check */
+	if (lsa == NULL) {
+		flog_warn(EC_OSPF_LSA_NULL, "TE (%s): Abort! LSA is NULL",
+			  __func__);
+		return -1;
+	}
+
+	/*
+	 * Process only self LSAs that reach MAX_AGE. Indeed, when the router
+	 * need to update or refresh an LSA, it first removes the old LSA from
+	 * the LSDB and then insert the new one. Thus, to avoid removing
+	 * corresponding Link State element and loosing some parameters
+	 * instead of just updating it, only self LSAs that reach MAX_AGE are
+	 * processed here. Other LSAs are processed by ospf_mpls_te_lsa_update()
+	 * and eventually removed when LSA age is MAX_AGE i.e. LSA is flushed
+	 * by the originator.
+	 */
+	if (!IS_LSA_SELF(lsa) || !IS_LSA_MAXAGE(lsa))
+		return 0;
+
+	/* Parse Link State information */
+	switch (lsa->data->type) {
+	case OSPF_ROUTER_LSA:
+		rc = ospf_te_delete_router_lsa(OspfMplsTE.ted, lsa);
+		break;
+	case OSPF_OPAQUE_AREA_LSA:
+	case OSPF_OPAQUE_AS_LSA:
+		rc = ospf_te_delete_opaque_lsa(OspfMplsTE.ted, lsa);
+		break;
+	default:
+		rc = 0;
+		break;
+	}
+
+	return rc;
+}
+
+/**
+ * Send the whole Link State Traffic Engineering Database to the consumer that
+ * request it through a ZAPI Link State Synchronous Opaque Message.
+ *
+ * @param info	ZAPI Opaque message
+ *
+ * @return	0 if success, -1 otherwise
+ */
+int ospf_te_sync_ted(struct zapi_opaque_reg_info dst)
+{
+	int rc = -1;
+
+	/* Check that MPLS-TE and TE distribution are enabled */
+	if (!OspfMplsTE.enabled || !OspfMplsTE.export)
+		return rc;
+
+	rc = ls_sync_ted(OspfMplsTE.ted, zclient, &dst);
+
+	return rc;
+}
+
+/**
+ * Initialize Traffic Engineering Database from the various OSPF Link State
+ * Database (LSDB).
+ *
+ * @param ted	Link State Traffice Engineering Database
+ * @param ospf	OSPF main structure
+ */
+static void ospf_te_init_ted(struct ls_ted *ted, struct ospf *ospf)
+{
+	struct listnode *node, *nnode;
+	struct route_node *rn;
+	struct ospf_area *area;
+	struct ospf_lsa *lsa;
+
+	/* Iterate over all areas. */
+	for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area)) {
+		if (!area->lsdb)
+			continue;
+
+		/* Parse all Router LSAs from the area LSDB */
+		LSDB_LOOP (ROUTER_LSDB(area), rn, lsa)
+			ospf_te_parse_router_lsa(ted, lsa);
+
+		/* Parse all Opaque LSAs from the area LSDB */
+		LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
+			ospf_te_parse_opaque_lsa(ted, lsa);
+	}
+
+	/* Parse AS-external opaque LSAs from OSPF LSDB */
+	if (ospf->lsdb) {
+		LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
+			ospf_te_parse_opaque_lsa(ted, lsa);
+	}
 
-	return;
 }
 
 /*------------------------------------------------------------------------*
@@ -2184,14 +3716,15 @@ static void ospf_mpls_te_config_write_router(struct vty *vty)
 		vty_out(vty, " mpls-te on\n");
 		vty_out(vty, " mpls-te router-address %pI4\n",
 			&OspfMplsTE.router_addr.value);
-	}
-
-	if (OspfMplsTE.inter_as == AS)
-		vty_out(vty, "  mpls-te inter-as as\n");
-	if (OspfMplsTE.inter_as == Area)
-		vty_out(vty, "  mpls-te inter-as area %pI4 \n",
-			&OspfMplsTE.interas_areaid);
 
+		if (OspfMplsTE.inter_as == AS)
+			vty_out(vty, " mpls-te inter-as as\n");
+		if (OspfMplsTE.inter_as == Area)
+			vty_out(vty, " mpls-te inter-as area %pI4 \n",
+				&OspfMplsTE.interas_areaid);
+		if (OspfMplsTE.export)
+			vty_out(vty, " mpls-te export\n");
+	}
 	return;
 }
 
@@ -2230,6 +3763,14 @@ DEFUN (ospf_mpls_te_on,
 		}
 	}
 
+	/* Create TED and initialize it */
+	OspfMplsTE.ted = ls_ted_new(1, "OSPF", 0);
+	if (!OspfMplsTE.ted) {
+		vty_out(vty, "Unable to create Link State Data Base\n");
+		return CMD_WARNING;
+	}
+	ospf_te_init_ted(OspfMplsTE.ted, ospf);
+
 	return CMD_SUCCESS;
 }
 
@@ -2249,8 +3790,11 @@ DEFUN (no_ospf_mpls_te,
 
 	ote_debug("MPLS-TE: ON -> OFF");
 
+	/* Remove TED */
+	ls_ted_del_all(OspfMplsTE.ted);
 	OspfMplsTE.enabled = false;
 
+	/* Flush all TE Opaque LSAs */
 	for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp))
 		if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
 			ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
@@ -2265,7 +3809,6 @@ DEFUN (no_ospf_mpls_te,
 	return CMD_SUCCESS;
 }
 
-
 DEFUN (ospf_mpls_te_router_addr,
        ospf_mpls_te_router_addr_cmd,
        "mpls-te router-address A.B.C.D",
@@ -2430,6 +3973,49 @@ DEFUN (no_ospf_mpls_te_inter_as,
 	return CMD_SUCCESS;
 }
 
+DEFUN (ospf_mpls_te_export,
+       ospf_mpls_te_export_cmd,
+       "mpls-te export",
+       MPLS_TE_STR
+       "Export the MPLS-TE information as Link State\n")
+{
+
+	VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
+
+	if (OspfMplsTE.enabled) {
+		if (ls_register(zclient, true) != 0) {
+			vty_out(vty, "Unable to register Link State\n");
+			return CMD_WARNING;
+		}
+		OspfMplsTE.export = true;
+	} else {
+		vty_out(vty, "mpls-te has not been turned on\n");
+		return CMD_WARNING;
+	}
+	return CMD_SUCCESS;
+}
+
+
+DEFUN (no_ospf_mpls_te_export,
+       no_ospf_mpls_te_export_cmd,
+       "no mpls-te export",
+       NO_STR
+       MPLS_TE_STR
+       "Stop export of the MPLS-TE information as Link State\n")
+{
+
+	VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
+
+	if (OspfMplsTE.export) {
+		if (ls_unregister(zclient, true) != 0) {
+			vty_out(vty, "Unable to unregister Link State\n");
+			return CMD_WARNING;
+		}
+		OspfMplsTE.export = false;
+	}
+	return CMD_SUCCESS;
+}
+
 DEFUN (show_ip_ospf_mpls_te_router,
        show_ip_ospf_mpls_te_router_cmd,
        "show ip ospf mpls-te router",
@@ -2446,7 +4032,9 @@ DEFUN (show_ip_ospf_mpls_te_router,
 			show_vty_router_addr(vty,
 					     &OspfMplsTE.router_addr.header);
 		else
-			vty_out(vty, "  N/A\n");
+			vty_out(vty, "  Router address is not set\n");
+		vty_out(vty, "  Link State distribution is %s\n",
+			OspfMplsTE.export ? "Active" : "Inactive");
 	}
 	return CMD_SUCCESS;
 }
@@ -2603,10 +4191,142 @@ DEFUN (show_ip_ospf_mpls_te_link,
 	return CMD_SUCCESS;
 }
 
+DEFUN (show_ip_ospf_mpls_te_db,
+       show_ip_ospf_mpls_te_db_cmd,
+       "show ip ospf mpls-te database [<vertex [<self-originate|adv-router A.B.C.D>]|edge [A.B.C.D]|subnet [A.B.C.D/M]>] [verbose|json]",
+       SHOW_STR
+       IP_STR
+       OSPF_STR
+       "MPLS-TE information\n"
+       "MPLS-TE database\n"
+       "MPLS-TE Vertex\n"
+       "Self-originated MPLS-TE router\n"
+       "Advertised MPLS-TE router\n"
+       "MPLS-TE router ID (as an IP address)\n"
+       "MPLS-TE Edge\n"
+       "MPLS-TE Edge ID (as an IP address)\n"
+       "MPLS-TE Subnet\n"
+       "MPLS-TE Subnet ID (as an IP prefix)\n"
+       "Verbose output\n"
+       JSON_STR)
+{
+	int idx = 0;
+	struct in_addr ip_addr;
+	struct prefix pref;
+	struct ls_vertex *vertex;
+	struct ls_edge *edge;
+	struct ls_subnet *subnet;
+	uint64_t key;
+	bool verbose = false;
+	bool uj = use_json(argc, argv);
+	json_object *json = NULL;
+
+	if (!OspfMplsTE.enabled || !OspfMplsTE.ted) {
+		vty_out(vty, "MPLS-TE database is not enabled\n");
+		return CMD_WARNING;
+	}
+
+	if (uj)
+		json = json_object_new_object();
+
+	if (argv[argc - 1]->arg && strmatch(argv[argc - 1]->text, "verbose"))
+		verbose = true;
+
+	idx = 5;
+	if (argv_find(argv, argc, "vertex", &idx)) {
+		/* Show Vertex */
+		if (argv_find(argv, argc, "self-originate", &idx))
+			vertex = OspfMplsTE.ted->self;
+		else if (argv_find(argv, argc, "adv-router", &idx)) {
+			if (!inet_aton(argv[idx + 1]->arg, &ip_addr)) {
+				vty_out(vty,
+					"Specified Router ID %s is invalid\n",
+					argv[idx + 1]->arg);
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+			/* Get the Vertex from the Link State Database */
+			key = ((uint64_t)ntohl(ip_addr.s_addr)) & 0xffffffff;
+			vertex = ls_find_vertex_by_key(OspfMplsTE.ted, key);
+			if (!vertex) {
+				vty_out(vty, "No vertex found for ID %pI4\n",
+					&ip_addr);
+				return CMD_WARNING;
+			}
+		} else
+			vertex = NULL;
+
+		if (vertex)
+			ls_show_vertex(vertex, vty, json, verbose);
+		else
+			ls_show_vertices(OspfMplsTE.ted, vty, json, verbose);
+
+	} else if (argv_find(argv, argc, "edge", &idx)) {
+		/* Show Edge */
+		if (argv_find(argv, argc, "A.B.C.D", &idx)) {
+			if (!inet_aton(argv[idx]->arg, &ip_addr)) {
+				vty_out(vty,
+					"Specified Edge ID %s is invalid\n",
+					argv[idx]->arg);
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+			/* Get the Edge from the Link State Database */
+			key = ((uint64_t)ntohl(ip_addr.s_addr)) & 0xffffffff;
+			edge = ls_find_edge_by_key(OspfMplsTE.ted, key);
+			if (!edge) {
+				vty_out(vty, "No edge found for ID %pI4\n",
+					&ip_addr);
+				return CMD_WARNING;
+			}
+		} else
+			edge = NULL;
+
+		if (edge)
+			ls_show_edge(edge, vty, json, verbose);
+		else
+			ls_show_edges(OspfMplsTE.ted, vty, json, verbose);
+
+	} else if (argv_find(argv, argc, "subnet", &idx)) {
+		/* Show Subnet */
+		if (argv_find(argv, argc, "A.B.C.D/M", &idx)) {
+			if (!str2prefix(argv[idx]->arg, &pref)) {
+				vty_out(vty, "Invalid prefix format %s\n",
+					argv[idx]->arg);
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+			/* Get the Subnet from the Link State Database */
+			subnet = ls_find_subnet(OspfMplsTE.ted, pref);
+			if (!subnet) {
+				vty_out(vty, "No subnet found for ID %pFX\n",
+					&pref);
+				return CMD_WARNING;
+			}
+		} else
+			subnet = NULL;
+
+		if (subnet)
+			ls_show_subnet(subnet, vty, json, verbose);
+		else
+			ls_show_subnets(OspfMplsTE.ted, vty, json, verbose);
+
+	} else {
+		/* Show the complete TED */
+		ls_show_ted(OspfMplsTE.ted, vty, json, verbose);
+	}
+
+	if (uj) {
+		vty_out(vty, "%s\n",
+			json_object_to_json_string_ext(
+				json, JSON_C_TO_STRING_PRETTY));
+		json_object_free(json);
+	}
+	return CMD_SUCCESS;
+}
+
 static void ospf_mpls_te_register_vty(void)
 {
 	install_element(VIEW_NODE, &show_ip_ospf_mpls_te_router_cmd);
 	install_element(VIEW_NODE, &show_ip_ospf_mpls_te_link_cmd);
+	install_element(VIEW_NODE, &show_ip_ospf_mpls_te_db_cmd);
 
 	install_element(OSPF_NODE, &ospf_mpls_te_on_cmd);
 	install_element(OSPF_NODE, &no_ospf_mpls_te_cmd);
@@ -2614,6 +4334,8 @@ static void ospf_mpls_te_register_vty(void)
 	install_element(OSPF_NODE, &ospf_mpls_te_inter_as_cmd);
 	install_element(OSPF_NODE, &ospf_mpls_te_inter_as_area_cmd);
 	install_element(OSPF_NODE, &no_ospf_mpls_te_inter_as_cmd);
+	install_element(OSPF_NODE, &ospf_mpls_te_export_cmd);
+	install_element(OSPF_NODE, &no_ospf_mpls_te_export_cmd);
 
 	return;
 }