MPLS infrastructure improvments

- deprecate MPLSoEth and MPLSoGRE; replace with generic MPLS tunnel.
- deprecates CLI 'mpls encap ..'; replace with addition of MPLS out label to a route/tunnel.
- support for MPLS 'routes', e.g. MPLS x-connects.
 - deprecates CLI 'mpls decap ..'; replace with 'mpls route .. '

Change-Id: Ibda46544912f880d0200f22bf9ff9b52828fcc2f
Signed-off-by: Neale Ranns <nranns@cisco.com>

46 files changed, 2694 insertions, 2596 deletions

diff --git a/vnet/Makefile.am b/vnet/Makefile.am
index 0ba07bac5bd..7d6abc60840 100644
--- a/vnet/Makefile.am
+++ b/vnet/Makefile.am
@@ -452,12 +452,13 @@ libvnet_la_SOURCES +=				\
  vnet/mpls/mpls_features.c			\
  vnet/mpls/node.c				\
  vnet/mpls/interface.c			        \
- vnet/mpls/policy_encap.c			\
+ vnet/mpls/mpls_tunnel.c		        \
  vnet/mpls/pg.c
  
 nobase_include_HEADERS +=			\
  vnet/mpls/mpls.h				\
  vnet/mpls/mpls_types.h			        \
+ vnet/mpls/mpls_tunnel.h		        \
  vnet/mpls/packet.h				\
  vnet/mpls/error.def
 
@@ -801,6 +802,7 @@ libvnet_la_SOURCES +=				\
   vnet/fib/fib_entry_src_mpls.c                 \
   vnet/fib/fib_entry_src_lisp.c                 \
   vnet/fib/fib_entry_cover.c                    \
+  vnet/fib/fib_entry_delegate.c                 \
   vnet/fib/fib_path_list.c                      \
   vnet/fib/fib_path.c				\
   vnet/fib/fib_path_ext.c			\
@@ -815,7 +817,8 @@ nobase_include_HEADERS +=			\
   vnet/fib/fib_table.h				\
   vnet/fib/fib_node.h				\
   vnet/fib/fib_node_list.h			\
-  vnet/fib/fib_entry.h				
+  vnet/fib/fib_entry.h				\
+  vnet/fib/fib_entry_delegate.h
 
 ########################################
 # ADJ
diff --git a/vnet/etc/scripts/mpls-tunnel b/vnet/etc/scripts/mpls-tunnel
new file mode 100644
index 00000000000..d04b29702e7
--- /dev/null
+++ b/vnet/etc/scripts/mpls-tunnel
@@ -0,0 +1,87 @@
+packet-generator new {
+  name x0
+  limit 1
+  node ip4-input
+  size 64-64
+  no-recycle
+  data {
+    ICMP: 1.0.0.2 -> 2.0.0.2
+    ICMP echo_request
+    incrementing 100
+  }
+}
+packet-generator new {
+  name x1
+  limit 1
+  node ip4-input
+  size 64-64
+  no-recycle
+  data {
+    ICMP: 1.0.0.2 -> 2.0.1.2
+    ICMP echo_request
+    incrementing 100
+  }
+}
+packet-generator new {
+  name x2
+  limit 1
+  node ip4-input
+  size 64-64
+  no-recycle
+  data {
+    ICMP: 1.0.0.2 -> 2.0.2.2
+    ICMP echo_request
+    incrementing 100
+  }
+}
+packet-generator new {
+  name x3
+  limit 1
+  node ip4-input
+  size 64-64
+  no-recycle
+  data {
+    ICMP: 1.0.0.2 -> 2.0.3.2
+    ICMP echo_request
+    incrementing 100
+  }
+}
+
+
+
+trace add pg-input 100
+
+loop create
+set int state loop0 up
+
+set int ip address loop0 10.0.0.1/24
+set ip arp loop0 10.0.0.2 00:00:11:aa:bb:cc
+
+mpls tunnel add via 10.0.0.2 loop0 out-label 33 out-label 34 out-label 35 out-label 36
+set int state mpls-tunnel0 up
+set int ip addr  mpls-tunnel0 192.168.0.1/32
+ip route add 2.0.0.2/32 via 192.168.0.2 mpls-tunnel0
+
+
+mpls tunnel add via 10.0.0.2 out-label 33
+set int state mpls-tunnel1 up
+set int ip addr  mpls-tunnel1 192.168.1.1/32
+ip route add 2.0.1.2/32 via 192.168.1.2 mpls-tunnel1 out-label 99
+
+mpls tunnel add via 10.0.0.2 loop0 out-label 3
+set int state mpls-tunnel2 up
+set int ip addr  mpls-tunnel2 192.168.2.1/32
+ip route add 2.0.2.2/32 via 192.168.2.2 mpls-tunnel2
+
+
+mpls tunnel add l2-only via 10.0.0.2 loop0 out-label 234 out-label 0
+set int state mpls-tunnel3 up
+set int l2 bridge mpls-tunnel3 1
+
+loop create
+set int ip addr loop1 6.0.1.44/24
+set int l2 bridge loop1 1 bvi
+set int l2 learn loop1 disable
+set int state loop1 up
+
+ip route add 2.0.3.2/32 via 6.0.1.45 loop1
diff --git a/vnet/vnet/buffer.h b/vnet/vnet/buffer.h
index 2ae4f1ccb70..b3c71c127cc 100644
--- a/vnet/vnet/buffer.h
+++ b/vnet/vnet/buffer.h
@@ -143,6 +143,18 @@ typedef struct
       };
     } ip;
 
+    /*
+     * MPLS:
+     * data copied from the MPLS header that was popped from the packet
+     * during the look-up.
+     */
+    struct
+    {
+      u8 ttl;
+      u8 exp;
+      u8 first;
+    } mpls;
+
     /* Multicast replication */
     struct
     {
@@ -331,6 +343,14 @@ typedef struct
   };
 } vnet_buffer_opaque_t;
 
+/*
+ * The opaque field of the vlib_buffer_t is intepreted as a
+ * vnet_buffer_opaque_t. Hence it should be big enough to accommodate one.
+ */
+STATIC_ASSERT (sizeof (vnet_buffer_opaque_t) <= STRUCT_SIZE_OF (vlib_buffer_t,
+								opaque),
+	       "VNET buffer meta-data too large for vlib_buffer");
+
 #define vnet_buffer(b) ((vnet_buffer_opaque_t *) (b)->opaque)
 
 /* Full cache line (64 bytes) of additional space */
diff --git a/vnet/vnet/dhcp/client.c b/vnet/vnet/dhcp/client.c
index f555f19ef12..c352e3109ee 100644
--- a/vnet/vnet/dhcp/client.c
+++ b/vnet/vnet/dhcp/client.c
@@ -224,7 +224,7 @@ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b,
 					c->sw_if_index,
 					~0,
 					1,
-					MPLS_LABEL_INVALID,
+					NULL, // no label stack
 					FIB_ROUTE_PATH_FLAG_NONE);
 	    }
 
diff --git a/vnet/vnet/dpo/mpls_label_dpo.c b/vnet/vnet/dpo/mpls_label_dpo.c
index 48c03be57fc..606b7ba3911 100644
--- a/vnet/vnet/dpo/mpls_label_dpo.c
+++ b/vnet/vnet/dpo/mpls_label_dpo.c
@@ -42,29 +42,55 @@ mpls_label_dpo_get_index (mpls_label_dpo_t *mld)
 }
 
 index_t
-mpls_label_dpo_create (mpls_label_t label,
+mpls_label_dpo_create (mpls_label_t *label_stack,
                        mpls_eos_bit_t eos,
                        u8 ttl,
                        u8 exp,
+                       dpo_proto_t payload_proto,
 		       const dpo_id_t *dpo)
 {
     mpls_label_dpo_t *mld;
+    u32 ii;
 
     mld = mpls_label_dpo_alloc();
-
-    vnet_mpls_uc_set_label(&mld->mld_hdr.label_exp_s_ttl, label);
-    vnet_mpls_uc_set_ttl(&mld->mld_hdr.label_exp_s_ttl, ttl);
-    vnet_mpls_uc_set_exp(&mld->mld_hdr.label_exp_s_ttl, exp);
-    vnet_mpls_uc_set_s(&mld->mld_hdr.label_exp_s_ttl, eos);
+    mld->mld_n_labels = vec_len(label_stack);
+    mld->mld_payload_proto = payload_proto;
 
     /*
+     * construct label rewrite headers for each value value passed.
      * get the header in network byte order since we will paint it
      * on a packet in the data-plane
      */
-    mld->mld_hdr.label_exp_s_ttl =
-        clib_host_to_net_u32(mld->mld_hdr.label_exp_s_ttl);
 
-    dpo_stack(DPO_MPLS_LABEL, DPO_PROTO_MPLS, &mld->mld_dpo, dpo);
+    for (ii = 0; ii < mld->mld_n_labels-1; ii++)
+    {
+	vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl, label_stack[ii]);
+	vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl, 255);
+	vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl, 0);
+	vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl, MPLS_NON_EOS);
+	mld->mld_hdr[ii].label_exp_s_ttl =
+	    clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
+    }
+
+    /*
+     * the inner most label
+     */
+    ii = mld->mld_n_labels-1;
+
+    vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl, label_stack[ii]);
+    vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl, ttl);
+    vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl, exp);
+    vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl, eos);
+    mld->mld_hdr[ii].label_exp_s_ttl =
+	clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
+
+    /*
+     * stack this label objct on its parent.
+     */
+    dpo_stack(DPO_MPLS_LABEL,
+              mld->mld_payload_proto,
+              &mld->mld_dpo,
+              dpo);
 
     return (mpls_label_dpo_get_index(mld));
 }
@@ -76,15 +102,20 @@ format_mpls_label_dpo (u8 *s, va_list *args)
     u32 indent = va_arg (*args, u32);
     mpls_unicast_header_t hdr;
     mpls_label_dpo_t *mld;
+    u32 ii;
 
     mld = mpls_label_dpo_get(index);
 
-    hdr.label_exp_s_ttl =
-        clib_net_to_host_u32(mld->mld_hdr.label_exp_s_ttl);
-
     s = format(s, "mpls-label:[%d]:", index);
-    s = format(s, "%U\n", format_mpls_header, hdr);
-    s = format(s, "%U", format_white_space, indent);
+
+    for (ii = 0; ii < mld->mld_n_labels; ii++)
+    {
+	hdr.label_exp_s_ttl =
+	    clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl);
+	s = format(s, "%U", format_mpls_header, hdr);
+    }
+
+    s = format(s, "\n%U", format_white_space, indent);
     s = format(s, "%U", format_dpo_id, &mld->mld_dpo, indent+2);
 
     return (s);
@@ -129,9 +160,11 @@ typedef struct mpls_label_imposition_trace_t_
 } mpls_label_imposition_trace_t;
 
 always_inline uword
-mpls_label_imposition (vlib_main_t * vm,
-                       vlib_node_runtime_t * node,
-                       vlib_frame_t * from_frame)
+mpls_label_imposition_inline (vlib_main_t * vm,
+                              vlib_node_runtime_t * node,
+                              vlib_frame_t * from_frame,
+                              u8 payload_is_ip4,
+                              u8 payload_is_ip6)
 {
     u32 n_left_from, next_index, * from, * to_next;
 
@@ -153,6 +186,7 @@ mpls_label_imposition (vlib_main_t * vm,
             vlib_buffer_t * b0;
             u32 bi0, mldi0;
             u32 next0;
+            u8 ttl;
 
             bi0 = from[0];
             to_next[0] = bi0;
@@ -167,16 +201,69 @@ mpls_label_imposition (vlib_main_t * vm,
             mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
             mld0 = mpls_label_dpo_get(mldi0);
 
+            if (payload_is_ip4)
+            {
+                /*
+                 * decrement the TTL on ingress to the LSP
+                 */
+                ip4_header_t * ip0 = vlib_buffer_get_current(b0);
+                u32 checksum0;
+
+                checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
+                checksum0 += checksum0 >= 0xffff;
+
+                ip0->checksum = checksum0;
+                ip0->ttl -= 1;
+                ttl = ip0->ttl;
+            }
+            else if (payload_is_ip6)
+            {
+                /*
+                 * decrement the TTL on ingress to the LSP
+                 */
+                ip6_header_t * ip0 = vlib_buffer_get_current(b0);
+
+                ip0->hop_limit -= 1;
+                ttl = ip0->hop_limit;
+            }
+            else
+            {
+                /*
+                 * else, the packet to be encapped is an MPLS packet
+                 */
+                if (vnet_buffer(b0)->mpls.first)
+                {
+                    /*
+                     * The first label to be imposed on the packet. this is a label swap.
+                     * in which case we stashed the TTL and EXP bits in the
+                     * packet in the lookup node
+                     */
+                    ASSERT(0 != vnet_buffer (b0)->mpls.ttl);
+
+                    ttl = vnet_buffer(b0)->mpls.ttl - 1;
+                }
+                else
+                {
+                    /*
+                     * not the first label. implying we are recusring down a chain of
+                     * output labels.
+                     * Each layer is considered a new LSP - hence the TTL is reset.
+                     */
+                    ttl = 255;
+                }
+            }
+            vnet_buffer(b0)->mpls.first = 0;
+
             /* Paint the MPLS header */
-            vlib_buffer_advance(b0, -sizeof(*hdr0));
+            vlib_buffer_advance(b0, -(sizeof(*hdr0) * mld0->mld_n_labels));
             hdr0 = vlib_buffer_get_current(b0);
 
-            // FIXME.
-            // need to copy the TTL from the correct place.
-            // for IPvX imposition from the IP header
-            // so we need a deidcated ipx-to-mpls-label-imp-node
-            // for mpls switch and stack another solution is required.
-            *hdr0 = mld0->mld_hdr;
+            clib_memcpy(hdr0, mld0->mld_hdr,
+                        sizeof(*hdr0) * mld0->mld_n_labels);
+
+            /* fixup the TTL for the inner most label */
+            hdr0 = hdr0 + (mld0->mld_n_labels - 1);
+            ((char*)hdr0)[3] = ttl;
 
             next0 = mld0->mld_dpo.dpoi_next_node;
             vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index;
@@ -215,6 +302,14 @@ format_mpls_label_imposition_trace (u8 * s, va_list * args)
     return (s);
 }
 
+static uword
+mpls_label_imposition (vlib_main_t * vm,
+                       vlib_node_runtime_t * node,
+                       vlib_frame_t * frame)
+{
+    return (mpls_label_imposition_inline(vm, node, frame, 0, 0));
+}
+
 VLIB_REGISTER_NODE (mpls_label_imposition_node) = {
     .function = mpls_label_imposition,
     .name = "mpls-label-imposition",
@@ -226,7 +321,52 @@ VLIB_REGISTER_NODE (mpls_label_imposition_node) = {
         [0] = "error-drop",
     }
 };
-VLIB_NODE_FUNCTION_MULTIARCH (mpls_label_imposition_node, mpls_label_imposition)
+VLIB_NODE_FUNCTION_MULTIARCH (mpls_label_imposition_node,
+                              mpls_label_imposition)
+
+static uword
+ip4_mpls_label_imposition (vlib_main_t * vm,
+                           vlib_node_runtime_t * node,
+                           vlib_frame_t * frame)
+{
+    return (mpls_label_imposition_inline(vm, node, frame, 1, 0));
+}
+
+VLIB_REGISTER_NODE (ip4_mpls_label_imposition_node) = {
+    .function = ip4_mpls_label_imposition,
+    .name = "ip4-mpls-label-imposition",
+    .vector_size = sizeof (u32),
+
+    .format_trace = format_mpls_label_imposition_trace,
+    .n_next_nodes = 1,
+    .next_nodes = {
+        [0] = "error-drop",
+    }
+};
+VLIB_NODE_FUNCTION_MULTIARCH (ip4_mpls_label_imposition_node,
+                              ip4_mpls_label_imposition)
+
+static uword
+ip6_mpls_label_imposition (vlib_main_t * vm,
+                           vlib_node_runtime_t * node,
+                           vlib_frame_t * frame)
+{
+    return (mpls_label_imposition_inline(vm, node, frame, 0, 1));
+}
+
+VLIB_REGISTER_NODE (ip6_mpls_label_imposition_node) = {
+    .function = ip6_mpls_label_imposition,
+    .name = "ip6-mpls-label-imposition",
+    .vector_size = sizeof (u32),
+
+    .format_trace = format_mpls_label_imposition_trace,
+    .n_next_nodes = 1,
+    .next_nodes = {
+        [0] = "error-drop",
+    }
+};
+VLIB_NODE_FUNCTION_MULTIARCH (ip6_mpls_label_imposition_node,
+                              ip6_mpls_label_imposition)
 
 static void
 mpls_label_dpo_mem_show (void)
@@ -246,12 +386,12 @@ const static dpo_vft_t mld_vft = {
 
 const static char* const mpls_label_imp_ip4_nodes[] =
 {
-    "mpls-label-imposition",
+    "ip4-mpls-label-imposition",
     NULL,
 };
 const static char* const mpls_label_imp_ip6_nodes[] =
 {
-    "mpls-label-imposition",
+    "ip6-mpls-label-imposition",
     NULL,
 };
 const static char* const mpls_label_imp_mpls_nodes[] =
diff --git a/vnet/vnet/dpo/mpls_label_dpo.h b/vnet/vnet/dpo/mpls_label_dpo.h
index 47ee344933f..6580c47d7cc 100644
--- a/vnet/vnet/dpo/mpls_label_dpo.h
+++ b/vnet/vnet/dpo/mpls_label_dpo.h
@@ -26,9 +26,9 @@
 typedef struct mpls_label_dpo_t
 {
     /**
-     * The MPLS label header to impose
+     * The MPLS label header to impose. Outer most label first.
      */
-    mpls_unicast_header_t mld_hdr;
+    mpls_unicast_header_t mld_hdr[8];
 
     /**
      * Next DPO in the graph
@@ -36,15 +36,45 @@ typedef struct mpls_label_dpo_t
     dpo_id_t mld_dpo;
 
     /**
+     * The protocol of the payload/packets that are being encapped
+     */
+    dpo_proto_t mld_payload_proto;
+
+    /**
+     * Size of the label stack
+     */
+    u16 mld_n_labels;
+
+    /**
      * Number of locks/users of the label
      */
     u16 mld_locks;
 } mpls_label_dpo_t;
 
-extern index_t mpls_label_dpo_create(mpls_label_t label,
+/**
+ * @brief Assert that the MPLS label object is less than a cache line in size.
+ * Should this get any bigger then we will need to reconsider how many labels
+ * can be pushed in one object.
+ */
+_Static_assert((sizeof(mpls_label_dpo_t) <= CLIB_CACHE_LINE_BYTES),
+	       "MPLS label DPO is larger than one cache line.");
+
+/**
+ * @brief Create an MPLS label object
+ *
+ * @param label_stack The stack if labels to impose, outer most label first
+ * @param eos The inner most label's EOS bit
+ * @param ttl The inner most label's TTL bit
+ * @param exp The inner most label's EXP bit
+ * @param payload_proto The ptocool of the payload packets that will
+ *                      be imposed with this label header.
+ * @param dpo The parent of the created MPLS label object
+ */
+extern index_t mpls_label_dpo_create(mpls_label_t *label_stack,
                                      mpls_eos_bit_t eos,
                                      u8 ttl,
                                      u8 exp,
+                                     dpo_proto_t payload_proto,
 				     const dpo_id_t *dpo);
 
 extern u8* format_mpls_label_dpo(u8 *s, va_list *args);
diff --git a/vnet/vnet/ethernet/arp.c b/vnet/vnet/ethernet/arp.c
index d0b7132ef74..4968d7b780d 100644
--- a/vnet/vnet/ethernet/arp.c
+++ b/vnet/vnet/ethernet/arp.c
@@ -557,9 +557,7 @@ vnet_arp_set_ip4_over_ethernet_internal (vnet_main_t * vnm,
 					 &pfx.fp_addr,
 					 e->sw_if_index,
 					 ~0,
-					 1,
-					 MPLS_LABEL_INVALID,
-					 FIB_ROUTE_PATH_FLAG_NONE);
+					 1, NULL, FIB_ROUTE_PATH_FLAG_NONE);
     }
   else
     {
diff --git a/vnet/vnet/fib/fib_attached_export.c b/vnet/vnet/fib/fib_attached_export.c
index afc953a4ac5..07bce5548cc 100644
--- a/vnet/vnet/fib/fib_attached_export.c
+++ b/vnet/vnet/fib/fib_attached_export.c
@@ -16,9 +16,10 @@
 #include <vnet/fib/fib_entry.h>
 #include <vnet/fib/fib_table.h>
 
-#include "fib_attached_export.h"
-#include "fib_entry_cover.h"
-#include "fib_entry_src.h"
+#include <vnet/fib/fib_attached_export.h>
+#include <vnet/fib/fib_entry_cover.h>
+#include <vnet/fib/fib_entry_src.h>
+#include <vnet/fib/fib_entry_delegate.h>
 
 /**
  * A description of the need to import routes from the export table
@@ -92,22 +93,27 @@ static fib_ae_export_t *fib_ae_export_pool;
 static fib_ae_export_t *
 fib_entry_ae_add_or_lock (fib_node_index_t connected)
 {
+    fib_entry_delegate_t *fed;
     fib_ae_export_t *export;
     fib_entry_t *entry;
 
     entry = fib_entry_get(connected);
+    fed = fib_entry_delegate_get(entry,
+                                 FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
 
-    if (FIB_NODE_INDEX_INVALID == entry->fe_export)
+    if (NULL == fed)
     {
+        fed = fib_entry_delegate_find_or_add(entry,
+                                             FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
 	pool_get(fib_ae_export_pool, export);
 	memset(export, 0, sizeof(*export));
 
-	entry->fe_export = (export - fib_ae_export_pool);
+	fed->fd_index = (export - fib_ae_export_pool);
 	export->faee_ei = connected;
     }
     else
     {
-	export = pool_elt_at_index(fib_ae_export_pool, entry->fe_export);
+	export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index);
     }
 
     export->faee_locks++;
@@ -235,6 +241,7 @@ void
 fib_attached_export_import (fib_entry_t *fib_entry,
 			    fib_node_index_t export_fib)
 {
+    fib_entry_delegate_t *fed;
     fib_ae_import_t *import;
 
     pool_get(fib_ae_import_pool, import);
@@ -290,7 +297,9 @@ fib_attached_export_import (fib_entry_t *fib_entry,
 	fib_entry_cover_track(fib_entry_get(import->faei_export_entry),
 			      fib_entry_get_index(fib_entry));
 
-    fib_entry->fe_import = (import - fib_ae_import_pool);
+    fed = fib_entry_delegate_find_or_add(fib_entry,
+                                         FIB_ENTRY_DELEGATE_ATTACHED_IMPORT);
+    fed->fd_index = (import - fib_ae_import_pool);
 }
 
 /**
@@ -299,15 +308,19 @@ fib_attached_export_import (fib_entry_t *fib_entry,
 void
 fib_attached_export_purge (fib_entry_t *fib_entry)
 {
-    if (FIB_NODE_INDEX_INVALID != fib_entry->fe_import)
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(fib_entry,
+                                 FIB_ENTRY_DELEGATE_ATTACHED_IMPORT);
+
+    if (NULL != fed)
     {
  	fib_node_index_t *import_index;
 	fib_entry_t *export_entry;
 	fib_ae_import_t *import;
 	fib_ae_export_t *export;
 
-	import = pool_elt_at_index(fib_ae_import_pool,
-				   fib_entry->fe_import);
+	import = pool_elt_at_index(fib_ae_import_pool, fed->fd_index);
 
 	/*
 	 * remove each imported entry
@@ -342,9 +355,15 @@ fib_attached_export_purge (fib_entry_t *fib_entry)
 	 */
 	if (FIB_NODE_INDEX_INVALID != import->faei_exporter)
 	{
+            fib_entry_delegate_t *fed;
+
 	    export_entry = fib_entry_get(import->faei_export_entry);
-	    ASSERT(FIB_NODE_INDEX_INVALID != export_entry->fe_export);
-	    export = pool_elt_at_index(fib_ae_export_pool, export_entry->fe_export);
+
+            fed = fib_entry_delegate_get(export_entry,
+                                         FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
+            ASSERT(NULL != fed);
+
+	    export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index);
 
 	    u32 index = vec_search(export->faee_importers,
 				   (import - fib_ae_import_pool));
@@ -358,7 +377,8 @@ fib_attached_export_purge (fib_entry_t *fib_entry)
 	    if (0 == --export->faee_locks)
 	    {
 		pool_put(fib_ae_export_pool, export);
-		export_entry->fe_export = FIB_NODE_INDEX_INVALID;
+                fib_entry_delegate_remove(export_entry,
+                                          FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
 	    }
 	}
 
@@ -366,7 +386,8 @@ fib_attached_export_purge (fib_entry_t *fib_entry)
 	 * free the import tracker
 	 */
 	pool_put(fib_ae_import_pool, import);
-	fib_entry->fe_import = FIB_NODE_INDEX_INVALID;
+        fib_entry_delegate_remove(fib_entry,
+                                  FIB_ENTRY_DELEGATE_ATTACHED_IMPORT);
     }	
 }
 
@@ -374,7 +395,12 @@ void
 fib_attached_export_covered_added (fib_entry_t *cover,
 				   fib_node_index_t covered)
 {
-    if (FIB_NODE_INDEX_INVALID != cover->fe_export)
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(cover,
+                                 FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
+
+    if (NULL != fed)
     {
 	/*
 	 * the covering prefix is exporting to other tables
@@ -383,7 +409,7 @@ fib_attached_export_covered_added (fib_entry_t *cover,
 	fib_ae_import_t *import;
 	fib_ae_export_t *export;
 
-	export = pool_elt_at_index(fib_ae_export_pool, cover->fe_export);
+	export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index);
 
 	/*
 	 * export the covered entry to each of the importers
@@ -401,7 +427,12 @@ void
 fib_attached_export_covered_removed (fib_entry_t *cover,
 				     fib_node_index_t covered)
 {
-    if (FIB_NODE_INDEX_INVALID != cover->fe_export)
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(cover,
+                                 FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
+
+    if (NULL != fed)
     {
 	/*
 	 * the covering prefix is exporting to other tables
@@ -410,7 +441,7 @@ fib_attached_export_covered_removed (fib_entry_t *cover,
 	fib_ae_import_t *import;
 	fib_ae_export_t *export;
 
-	export = pool_elt_at_index(fib_ae_export_pool, cover->fe_export);
+	export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index);
 
 	/*
 	 * remove the covered entry from each of the importers
@@ -427,7 +458,12 @@ fib_attached_export_covered_removed (fib_entry_t *cover,
 static void
 fib_attached_export_cover_modified_i (fib_entry_t *fib_entry)
 {
-    if (FIB_NODE_INDEX_INVALID != fib_entry->fe_import)
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(fib_entry,
+                                 FIB_ENTRY_DELEGATE_ATTACHED_IMPORT);
+
+    if (NULL != fed)
     {
 	fib_ae_import_t *import;
 	u32 export_fib;
@@ -436,7 +472,7 @@ fib_attached_export_cover_modified_i (fib_entry_t *fib_entry)
 	 * safe the temporaries we need from the existing import
 	 * since it will be toast after the purge.
 	 */
-	import = pool_elt_at_index(fib_ae_import_pool, fib_entry->fe_import);
+	import = pool_elt_at_index(fib_ae_import_pool, fed->fd_index);
 	export_fib = import->faei_export_fib;
 
 	/*
@@ -469,15 +505,20 @@ fib_attached_export_cover_update (fib_entry_t *fib_entry)
 }
 
 u8*
-fib_ae_import_format (fib_node_index_t import_index,
+fib_ae_import_format (fib_entry_t *fib_entry,
 		      u8* s)
 {
-    if (FIB_NODE_INDEX_INVALID != import_index)
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(fib_entry,
+                                 FIB_ENTRY_DELEGATE_ATTACHED_IMPORT);
+
+    if (NULL != fed)
     {
 	fib_node_index_t *index;
 	fib_ae_import_t *import;
 
-	import = pool_elt_at_index(fib_ae_import_pool, import_index);
+	import = pool_elt_at_index(fib_ae_import_pool, fed->fd_index);
 
 	s = format(s, "\n  Attached-Import:%d:[", (import - fib_ae_import_pool));
 	s = format(s, "export-prefix:%U ", format_fib_prefix, &import->faei_prefix);
@@ -501,14 +542,20 @@ fib_ae_import_format (fib_node_index_t import_index,
 }
 
 u8*
-fib_ae_export_format (fib_node_index_t export_index, u8*s)
+fib_ae_export_format (fib_entry_t *fib_entry,
+		      u8* s)
 {
-    if (FIB_NODE_INDEX_INVALID != export_index)
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(fib_entry,
+                                 FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
+
+    if (NULL != fed)
     {
-	fib_node_index_t *index;
+        fib_node_index_t *index;
 	fib_ae_export_t *export;
 
-	export = pool_elt_at_index(fib_ae_export_pool, export_index);
+	export = pool_elt_at_index(fib_ae_export_pool, fed->fd_list);
     
 	s = format(s, "\n  Attached-Export:%d:[", (export - fib_ae_export_pool));
 	s = format(s, "export-entry:%d ", export->faee_ei);
diff --git a/vnet/vnet/fib/fib_attached_export.h b/vnet/vnet/fib/fib_attached_export.h
index ee68481187c..fa28a6e13b8 100644
--- a/vnet/vnet/fib/fib_attached_export.h
+++ b/vnet/vnet/fib/fib_attached_export.h
@@ -51,7 +51,7 @@ extern void fib_attached_export_covered_removed(fib_entry_t *cover,
 extern void fib_attached_export_cover_change(fib_entry_t *fib_entry);
 extern void fib_attached_export_cover_update(fib_entry_t *fib_entry);
 
-extern u8* fib_ae_import_format(fib_node_index_t import_index, u8*s);
-extern u8* fib_ae_export_format(fib_node_index_t export_index, u8*s);
+extern u8* fib_ae_import_format(fib_entry_t *fib_entry, u8*s);
+extern u8* fib_ae_export_format(fib_entry_t *fib_entry, u8*s);
 
 #endif
diff --git a/vnet/vnet/fib/fib_entry.c b/vnet/vnet/fib/fib_entry.c
index da2656e35aa..24b506379ac 100644
--- a/vnet/vnet/fib/fib_entry.c
+++ b/vnet/vnet/fib/fib_entry.c
@@ -64,47 +64,6 @@ fib_entry_get_proto (const fib_entry_t * fib_entry)
     return (fib_entry->fe_prefix.fp_proto);
 }
 
-/**
- * @brief Turn the chain type requested by the client into the one they
- * really wanted
- */
-static fib_forward_chain_type_t
-fib_entry_chain_type_fixup (const fib_entry_t *entry,
-			    fib_forward_chain_type_t fct)
-{
-    if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == fct)
-    {
-	/*
-	 * The EOS chain is a tricky since one cannot know the adjacency
-	 * to link to without knowing what the packets payload protocol
-	 * will be once the label is popped.
-	 */
-	fib_forward_chain_type_t dfct;
-
-	dfct = fib_entry_get_default_chain_type(entry);
-
-	if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct)
-	{
-	    /*
-	     * If the entry being asked is a eos-MPLS label entry,
-	     * then use the payload-protocol field, that we stashed there
-	     * for just this purpose
-	     */
-	    return (fib_forw_chain_type_from_dpo_proto(
-			entry->fe_prefix.fp_payload_proto));
-	}
-	/*
-	 * else give them what this entry would be by default. i.e. if it's a v6
-	 * entry, then the label its local labelled should be carrying v6 traffic.
-	 * If it's a non-EOS label entry, then there are more labels and we want
-	 * a non-eos chain.
-	 */
-	return (dfct);
-    }
-
-    return (fct);
-}
-
 fib_forward_chain_type_t
 fib_entry_get_default_chain_type (const fib_entry_t *fib_entry)
 {
@@ -189,8 +148,8 @@ format_fib_entry (u8 * s, va_list * args)
 	    s = format(s, "\n tracking %d covered: ", n_covered);
 	    s = fib_entry_cover_list_format(fib_entry, s);
 	}
-	s = fib_ae_import_format(fib_entry->fe_import, s);
-	s = fib_ae_export_format(fib_entry->fe_export, s);
+	s = fib_ae_import_format(fib_entry, s);
+	s = fib_ae_export_format(fib_entry, s);
 
 	s = format (s, "\n forwarding: ");
     }
@@ -201,34 +160,33 @@ format_fib_entry (u8 * s, va_list * args)
 
     fct = fib_entry_get_default_chain_type(fib_entry);
 
-    if (!dpo_id_is_valid(&fib_entry->fe_lb[fct]))
+    if (!dpo_id_is_valid(&fib_entry->fe_lb))
     {
 	s = format (s, "  UNRESOLVED\n");
 	return (s);
     }
     else
     {
+        s = format(s, "  %U-chain\n  %U",
+                   format_fib_forw_chain_type, fct,
+                   format_dpo_id,
+                   &fib_entry->fe_lb,
+                   2);
+        s = format(s, "\n");
+
         if (level >= FIB_ENTRY_FORMAT_DETAIL2)
         {
+            fib_entry_delegate_type_t fdt;
+            fib_entry_delegate_t *fed;
 
-            FOR_EACH_FIB_FORW_MPLS_CHAIN(fct)
+            FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
             {
                 s = format(s, "  %U-chain\n  %U",
-                           format_fib_forw_chain_type, fct,
-                           format_dpo_id,
-                           &fib_entry->fe_lb[fct],
-                           2);
+                           format_fib_forw_chain_type,
+                           fib_entry_delegate_type_to_chain_type(fdt),
+                           format_dpo_id, &fed->fd_dpo, 2);
                 s = format(s, "\n");
-            }
-        }
-        else
-        {
-	    s = format(s, "  %U-chain\n  %U",
-		       format_fib_forw_chain_type, fct,
-                       format_dpo_id,
-                       &fib_entry->fe_lb[fct],
-                       2);
-            s = format(s, "\n");
+            });
         }
     }
 
@@ -238,68 +196,6 @@ format_fib_entry (u8 * s, va_list * args)
         s = fib_node_children_format(fib_entry->fe_node.fn_children, s);
     }
 
-    /* adj = adj_get(fib_entry->fe_prefix.fp_proto, fib_entry->fe_adj_index); */
-
-    /* ip_multipath_next_hop_t * nhs, tmp_nhs[1]; */
-    /* u32 i, j, n_left, n_nhs; */
-    /* vlib_counter_t c, sum; */
-    /* ip_lookup_main_t *lm = fib_get_lookup_main(fib_entry->fe_prefix.fp_proto); */
-
-    /* if (adj->n_adj == 1) */
-    /* { */
-    /* 	nhs = &tmp_nhs[0]; */
-    /* 	nhs[0].next_hop_adj_index = ~0; /\* not used *\/ */
-    /* 	nhs[0].weight = 1; */
-    /* 	n_nhs = 1; */
-    /* } */
-    /* else */
-    /* { */
-    /* 	ip_multipath_adjacency_t * madj; */
-    /* 	madj = vec_elt_at_index (lm->multipath_adjacencies, adj->heap_handle); */
-    /* 	nhs = heap_elt_at_index (lm->next_hop_heap, madj->normalized_next_hops.heap_offset); */
-    /* 	n_nhs = madj->normalized_next_hops.count; */
-    /* } */
-
-    /* n_left = nhs[0].weight; */
-    /* vlib_counter_zero (&sum); */
-    /* for (i = j = 0; i < adj->n_adj; i++) */
-    /* { */
-    /* 	n_left -= 1; */
-    /* 	vlib_get_combined_counter(&lm->adjacency_counters,  */
-    /* 				  fib_entry->fe_adj_index + i, */
-    /* 				  &c); */
-    /* 	/\* if (clear) *\/ */
-    /* 	/\*     vlib_zero_combined_counter (&lm->adjacency_counters,  *\/ */
-    /* 	/\* 				fib_entry->fe_adj_index + i); *\/ */
-
-    /* 	vlib_counter_add (&sum, &c); */
-    /* 	if (n_left == 0) */
-    /* 	{ */
-    /* 	    s = format (s, "%16Ld%16Ld ", sum.packets, sum.bytes); */
-    /* 	    s = format (s, "weight %d, index %d", */
-    /* 			  nhs[j].weight, fib_entry->fe_adj_index + i); */
-
-    /* 	    if (adj->n_adj > 1) */
-    /* 		s = format (s, ", multipath"); */
-
-    /* 	    s = format (s, "\n%U", */
-    /* 			format_ip_adjacency, */
-    /* 			vnet_get_main(), lm, fib_entry->fe_adj_index + i); */
-
-    /* 	    //   vlib_cli_output (vm, "%v", msg); */
-    /* 	    //vec_free (msg); */
-    /* 	} */
-    /* 	else */
-    /* 	{ */
-    /* 	    j++; */
-    /* 	    if (j < n_nhs) */
-    /* 	    { */
-    /* 		n_left = nhs[j].weight; */
-    /* 		vlib_counter_zero (&sum); */
-    /* 	    } */
-    /* 	} */
-    /* } */
-
     return (s);
 }
 
@@ -315,20 +211,25 @@ fib_entry_from_fib_node (fib_node_t *node)
 static void
 fib_entry_last_lock_gone (fib_node_t *node)
 {
-    fib_forward_chain_type_t fct;
+    fib_entry_delegate_type_t fdt;
+    fib_entry_delegate_t *fed;
     fib_entry_t *fib_entry;
 
     fib_entry = fib_entry_from_fib_node(node);
 
-    FOR_EACH_FIB_FORW_MPLS_CHAIN(fct)
+    FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
     {
-	dpo_reset(&fib_entry->fe_lb[fct]);
-    }
+	dpo_reset(&fed->fd_dpo);
+        fib_entry_delegate_remove(fib_entry, fdt);
+    });
 
     FIB_ENTRY_DBG(fib_entry, "last-lock");
 
     fib_node_deinit(&fib_entry->fe_node);
     // FIXME -RR Backwalk
+
+    ASSERT(0 == vec_len(fib_entry->fe_delegates));
+    vec_free(fib_entry->fe_delegates);
     pool_put(fib_entry_pool, fib_entry);
 }
 
@@ -487,44 +388,58 @@ fib_entry_contribute_urpf (fib_node_index_t entry_index,
  */
 void
 fib_entry_contribute_forwarding (fib_node_index_t fib_entry_index,
-				 fib_forward_chain_type_t type,
+				 fib_forward_chain_type_t fct,
 				 dpo_id_t *dpo)
 {
+    fib_entry_delegate_t *fed;
     fib_entry_t *fib_entry;
 
     fib_entry = fib_entry_get(fib_entry_index);
 
-    /*
-     * these are not the droids you are looking for...
-     */
-    type = fib_entry_chain_type_fixup(fib_entry, type);
-
-    if (!dpo_id_is_valid(&fib_entry->fe_lb[type]))
+    if (fct == fib_entry_get_default_chain_type(fib_entry))
     {
-	/*
-	 * on-demand create eos/non-eos.
-	 * There is no on-demand delete because:
-	 *   - memory versus complexity & reliability:
-	 *      leaving unrequired [n]eos LB arounds wastes memory, cleaning
-	 *      then up on the right trigger is more code. i favour the latter.
-	 */
-	fib_entry_src_mk_lb(fib_entry,
-			    fib_entry_get_best_src_i(fib_entry),
-			    type,
-			    &fib_entry->fe_lb[type]);
+        dpo_copy(dpo, &fib_entry->fe_lb);
     }
+    else
+    {
+        fed = fib_entry_delegate_get(fib_entry,
+                                     fib_entry_chain_type_to_delegate_type(fct));
+
+        if (NULL == fed)
+        {
+            fed = fib_entry_delegate_find_or_add(
+                      fib_entry,
+                      fib_entry_chain_type_to_delegate_type(fct));
+            /*
+             * on-demand create eos/non-eos.
+             * There is no on-demand delete because:
+             *   - memory versus complexity & reliability:
+             *      leaving unrequired [n]eos LB arounds wastes memory, cleaning
+             *      then up on the right trigger is more code. i favour the latter.
+             */
+            fib_entry_src_mk_lb(fib_entry,
+                                fib_entry_get_best_src_i(fib_entry),
+                                fct,
+                                &fed->fd_dpo);
+        }
 
-    dpo_copy(dpo, &fib_entry->fe_lb[type]);
+        dpo_copy(dpo, &fed->fd_dpo);
+    }
 }
 
 const dpo_id_t *
 fib_entry_contribute_ip_forwarding (fib_node_index_t fib_entry_index)
 {
+    fib_forward_chain_type_t fct;
     fib_entry_t *fib_entry;
 
     fib_entry = fib_entry_get(fib_entry_index);
+    fct = fib_entry_get_default_chain_type(fib_entry);
+
+    ASSERT((fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP4 ||
+            fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP6));
 
-    return (&fib_entry->fe_lb[fib_entry_get_default_chain_type(fib_entry)]);
+    return (&fib_entry->fe_lb);
 }
 
 adj_index_t
@@ -570,6 +485,27 @@ fib_entry_child_remove (fib_node_index_t fib_entry_index,
     fib_node_child_remove(FIB_NODE_TYPE_ENTRY,
                           fib_entry_index,
                           sibling_index);
+
+    if (0 == fib_node_get_n_children(FIB_NODE_TYPE_ENTRY,
+                                     fib_entry_index))
+    {
+        /*
+         * if there are no children left then there is no reason to keep
+         * the non-default forwarding chains. those chains are built only
+         * because the children want them.
+         */
+        fib_entry_delegate_type_t fdt;
+        fib_entry_delegate_t *fed;
+        fib_entry_t *fib_entry;
+
+        fib_entry = fib_entry_get(fib_entry_index);
+
+        FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
+        {
+            dpo_reset(&fed->fd_dpo);
+            fib_entry_delegate_remove(fib_entry, fdt);
+        });
+    }
 }
 
 static fib_entry_t *
@@ -577,8 +513,8 @@ fib_entry_alloc (u32 fib_index,
 		 const fib_prefix_t *prefix,
 		 fib_node_index_t *fib_entry_index)
 {
-    fib_forward_chain_type_t fct;
     fib_entry_t *fib_entry;
+    fib_prefix_t *fep;
 
     pool_get(fib_entry_pool, fib_entry);
     memset(fib_entry, 0, sizeof(*fib_entry));
@@ -587,20 +523,25 @@ fib_entry_alloc (u32 fib_index,
 		  FIB_NODE_TYPE_ENTRY);
 
     fib_entry->fe_fib_index = fib_index;
-    fib_entry->fe_prefix = *prefix;
+
+    /*
+     * the one time we need to update the const prefix is when
+     * the entry is first created
+     */
+    fep = (fib_prefix_t*)&(fib_entry->fe_prefix);
+    *fep = *prefix;
+
     if (FIB_PROTOCOL_MPLS == fib_entry->fe_prefix.fp_proto)
     {
-	fib_entry->fe_prefix.fp_len = 21;
+	fep->fp_len = 21;
+	if (MPLS_NON_EOS == fep->fp_eos)
+	{
+	    fep->fp_payload_proto = DPO_PROTO_MPLS;
+	}
     	ASSERT(DPO_PROTO_NONE != fib_entry->fe_prefix.fp_payload_proto);
     }
 
-    fib_entry->fe_export = FIB_NODE_INDEX_INVALID;
-    fib_entry->fe_import = FIB_NODE_INDEX_INVALID;
-    fib_entry->fe_covered = FIB_NODE_INDEX_INVALID;
-    FOR_EACH_FIB_FORW_MPLS_CHAIN(fct)
-    {
-	dpo_reset(&fib_entry->fe_lb[fct]);
-    }
+    dpo_reset(&fib_entry->fe_lb);
 
     *fib_entry_index = fib_entry_get_index(fib_entry);
 
@@ -1316,7 +1257,6 @@ fib_entry_recursive_loop_detect (fib_node_index_t entry_index,
     if (FIB_NODE_INDEX_INVALID != fib_entry->fe_parent)
     {
 	fib_node_index_t *entries = *entry_indicies;
-	fib_forward_chain_type_t fct;
 
 	vec_add1(entries, entry_index);
 	was_looped = fib_path_list_is_looped(fib_entry->fe_parent);
@@ -1331,16 +1271,16 @@ fib_entry_recursive_loop_detect (fib_node_index_t entry_index,
 	     * re-evaluate all the entry's forwarding
 	     * NOTE: this is an inplace modify
 	     */
-	    FOR_EACH_FIB_FORW_MPLS_CHAIN(fct)
-	    {
-		if (dpo_id_is_valid(&fib_entry->fe_lb[fct]))
-		{
-		    fib_entry_src_mk_lb(fib_entry,
-					fib_entry_get_best_src_i(fib_entry),
-					fct,
-					&fib_entry->fe_lb[fct]);
-		}
-	    }
+            fib_entry_delegate_type_t fdt;
+            fib_entry_delegate_t *fed;
+
+            FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
+            {
+                fib_entry_src_mk_lb(fib_entry,
+                                    fib_entry_get_best_src_i(fib_entry),
+                                    fib_entry_delegate_type_to_chain_type(fdt),
+                                    &fed->fd_dpo);
+	    });
 	}
     }
     else
@@ -1379,8 +1319,8 @@ fib_entry_get_best_source (fib_node_index_t entry_index)
 }
 
 static int
-fib_ip4_address_compare (ip4_address_t * a1,
-                         ip4_address_t * a2)
+fib_ip4_address_compare (const ip4_address_t * a1,
+                         const ip4_address_t * a2)
 {
     /*
      * IP addresses are unsiged ints. the return value here needs to be signed
@@ -1393,8 +1333,8 @@ fib_ip4_address_compare (ip4_address_t * a1,
 }
 
 static int
-fib_ip6_address_compare (ip6_address_t * a1,
-                         ip6_address_t * a2)
+fib_ip6_address_compare (const ip6_address_t * a1,
+                         const ip6_address_t * a2)
 {
   int i;
   for (i = 0; i < ARRAY_LEN (a1->as_u16); i++)
diff --git a/vnet/vnet/fib/fib_entry.h b/vnet/vnet/fib/fib_entry.h
index d62a94043b3..44a5f2e6d7f 100644
--- a/vnet/vnet/fib/fib_entry.h
+++ b/vnet/vnet/fib/fib_entry.h
@@ -17,6 +17,7 @@
 #define __FIB_ENTRY_H__
 
 #include <vnet/fib/fib_node.h>
+#include <vnet/fib/fib_entry_delegate.h>
 #include <vnet/adj/adj.h>
 #include <vnet/ip/ip.h>
 #include <vnet/dpo/dpo.h>
@@ -363,9 +364,10 @@ typedef struct fib_entry_t_ {
      */
     fib_node_t fe_node;
     /**
-     * The prefix of the route
+     * The prefix of the route. this is const just to be sure.
+     * It is the entry's key/identity and so should never change.
      */
-    fib_prefix_t fe_prefix;
+    const fib_prefix_t fe_prefix;
     /**
      * The index of the FIB table this entry is in
      */
@@ -382,7 +384,7 @@ typedef struct fib_entry_t_ {
      *     paint the header straight on without the need to check the packet
      *     type to derive the EOS bit value.
      */
-    dpo_id_t fe_lb[FIB_FORW_CHAIN_MPLS_NUM];
+    dpo_id_t fe_lb; // [FIB_FORW_CHAIN_MPLS_NUM];
     /**
      * Vector of source infos.
      * Most entries will only have 1 source. So we optimise for memory usage,
@@ -400,17 +402,11 @@ typedef struct fib_entry_t_ {
      * be changed by the parent as it manages its list.
      */
     u32 fe_sibling;
+
     /**
-     * Dependency list of covered entries.
-     * these are more specific entries that are interested in changes
-     * to their respective cover
-     */
-    fib_node_list_t fe_covered;
-    /**
-     * exporter
+     * A vector of delegates.
      */
-    fib_node_index_t fe_export;
-    fib_node_index_t fe_import;
+    fib_entry_delegate_t *fe_delegates;
 } fib_entry_t;
 
 #define FOR_EACH_FIB_ENTRY_FLAG(_item) \
diff --git a/vnet/vnet/fib/fib_entry_cover.c b/vnet/vnet/fib/fib_entry_cover.c
index 06b5b918abc..147c5daa4fd 100644
--- a/vnet/vnet/fib/fib_entry_cover.c
+++ b/vnet/vnet/fib/fib_entry_cover.c
@@ -21,16 +21,21 @@ u32
 fib_entry_cover_track (fib_entry_t* cover,
 		       fib_node_index_t covered)
 {
+    fib_entry_delegate_t *fed;
+
     FIB_ENTRY_DBG(cover, "cover-track %d", covered);
 
     ASSERT(fib_entry_get_index(cover) != covered);
 
-    if (FIB_NODE_INDEX_INVALID == cover->fe_covered)
+    fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED);
+
+    if (NULL == fed)
     {
-        cover->fe_covered = fib_node_list_create();
+        fed = fib_entry_delegate_find_or_add(cover, FIB_ENTRY_DELEGATE_COVERED);
+        fed->fd_list = fib_node_list_create();
     }
 
-    return (fib_node_list_push_front(cover->fe_covered,
+    return (fib_node_list_push_front(fed->fd_list,
                                      0, FIB_NODE_TYPE_ENTRY,
                                      covered));
 }
@@ -39,16 +44,21 @@ void
 fib_entry_cover_untrack (fib_entry_t* cover,
 			 u32 tracked_index)
 {
+    fib_entry_delegate_t *fed;
+
     FIB_ENTRY_DBG(cover, "cover-untrack @ %d", tracked_index);
 
-    if (FIB_NODE_INDEX_INVALID == cover->fe_covered)
+    fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED);
+
+    if (NULL == fed)
         return;
 
-    fib_node_list_remove(cover->fe_covered, tracked_index);
+    fib_node_list_remove(fed->fd_list, tracked_index);
 
-    if (0 == fib_node_list_get_size(cover->fe_covered))
+    if (0 == fib_node_list_get_size(fed->fd_list))
     {
-        fib_node_list_destroy(&cover->fe_covered);
+        fib_node_list_destroy(&fed->fd_list);
+        fib_entry_delegate_remove(cover, FIB_ENTRY_DELEGATE_COVERED);        
     }
 }
 
@@ -78,26 +88,35 @@ fib_entry_cover_walk (fib_entry_t *cover,
 		      fib_entry_covered_walk_t walk,
 		      void *args)
 {
-    if (FIB_NODE_INDEX_INVALID != cover->fe_covered)
-    {
-        fib_enty_cover_walk_ctx_t ctx = {
-            .cover = cover,
-            .walk = walk,
-            .ctx = args,
-        };
-
-        fib_node_list_walk(cover->fe_covered,
-                           fib_entry_cover_walk_node_ptr,
-                           &ctx);
-    }
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED);
+
+    if (NULL == fed)
+        return;
+
+    fib_enty_cover_walk_ctx_t ctx = {
+        .cover = cover,
+        .walk = walk,
+        .ctx = args,
+    };
+
+    fib_node_list_walk(fed->fd_list,
+                       fib_entry_cover_walk_node_ptr,
+                       &ctx);
 }
 
 u32
 fib_entry_cover_get_size (fib_entry_t *cover)
 {
-    if (FIB_NODE_INDEX_INVALID != cover->fe_covered)
-        return (fib_node_list_get_size(cover->fe_covered));
-    return (0);
+    fib_entry_delegate_t *fed;
+
+    fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED);
+
+    if (NULL == fed)
+        return (0);
+
+    return (fib_node_list_get_size(fed->fd_list));
 }
 
 typedef struct fib_entry_cover_list_format_ctx_t_ {
diff --git a/vnet/vnet/fib/fib_entry_delegate.c b/vnet/vnet/fib/fib_entry_delegate.c
new file mode 100644
index 00000000000..a0d45f970b3
--- /dev/null
+++ b/vnet/vnet/fib/fib_entry_delegate.c
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vnet/fib/fib_entry_delegate.h>
+#include <vnet/fib/fib_entry.h>
+
+static fib_entry_delegate_t *
+fib_entry_delegate_find_i (const fib_entry_t *fib_entry,
+                           fib_entry_delegate_type_t type,
+                           u32 *index)
+{
+    fib_entry_delegate_t *delegate;
+    int ii;
+
+    ii = 0;
+    vec_foreach(delegate, fib_entry->fe_delegates)
+    {
+	if (delegate->fd_type == type)
+	{
+            if (NULL != index)
+                *index = ii;
+
+	    return (delegate);
+	}
+	else
+	{
+	    ii++;
+	}
+    }
+
+    return (NULL);
+}
+
+fib_entry_delegate_t *
+fib_entry_delegate_get (const fib_entry_t *fib_entry,
+                        fib_entry_delegate_type_t type)
+{
+    return (fib_entry_delegate_find_i(fib_entry, type, NULL));
+}
+
+void
+fib_entry_delegate_remove (fib_entry_t *fib_entry,
+                           fib_entry_delegate_type_t type)
+{
+    fib_entry_delegate_t *fed;
+    u32 index = ~0;
+
+    fed = fib_entry_delegate_find_i(fib_entry, type, &index);
+
+    ASSERT(NULL != fed);
+
+    vec_del1(fib_entry->fe_delegates, index);
+}
+
+static int
+fib_entry_delegate_cmp_for_sort (void * v1,
+                                 void * v2)
+{
+    fib_entry_delegate_t *delegate1 = v1, *delegate2 = v2;
+
+    return (delegate1->fd_type - delegate2->fd_type);
+}
+
+static void
+fib_entry_delegate_init (fib_entry_t *fib_entry,
+                         fib_entry_delegate_type_t type)
+
+{
+    fib_entry_delegate_t delegate = {
+	.fd_entry_index = fib_entry_get_index(fib_entry),
+	.fd_type = type,
+    };
+
+    vec_add1(fib_entry->fe_delegates, delegate);
+    vec_sort_with_function(fib_entry->fe_delegates,
+			   fib_entry_delegate_cmp_for_sort);
+}
+
+fib_entry_delegate_t *
+fib_entry_delegate_find_or_add (fib_entry_t *fib_entry,
+                                fib_entry_delegate_type_t fdt)
+{
+    fib_entry_delegate_t *delegate;
+
+    delegate = fib_entry_delegate_get(fib_entry, fdt);
+
+    if (NULL == delegate)
+    {
+	fib_entry_delegate_init(fib_entry, fdt);
+    }
+
+    return (fib_entry_delegate_get(fib_entry, fdt));
+}
+
+fib_entry_delegate_type_t
+fib_entry_chain_type_to_delegate_type (fib_forward_chain_type_t fct)
+{
+    switch (fct)
+    {
+    case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
+        return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4);
+    case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
+        return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6);
+    case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
+        return (FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS);
+    case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
+        return (FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS);
+    case FIB_FORW_CHAIN_TYPE_ETHERNET:
+        return (FIB_ENTRY_DELEGATE_CHAIN_ETHERNET);
+    }
+    ASSERT(0);
+    return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4);
+}
+
+fib_forward_chain_type_t
+fib_entry_delegate_type_to_chain_type (fib_entry_delegate_type_t fdt)
+{
+    switch (fdt)
+    {
+    case FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4:
+        return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
+    case FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6:
+        return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6);
+    case FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS:
+        return (FIB_FORW_CHAIN_TYPE_MPLS_EOS);
+    case FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS:
+        return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS);
+    case FIB_ENTRY_DELEGATE_CHAIN_ETHERNET:
+        return (FIB_FORW_CHAIN_TYPE_ETHERNET);
+    case FIB_ENTRY_DELEGATE_COVERED:
+    case FIB_ENTRY_DELEGATE_ATTACHED_IMPORT:
+    case FIB_ENTRY_DELEGATE_ATTACHED_EXPORT:
+        break;
+    }
+    ASSERT(0);
+    return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
+}
diff --git a/vnet/vnet/fib/fib_entry_delegate.h b/vnet/vnet/fib/fib_entry_delegate.h
new file mode 100644
index 00000000000..6d3a6549f32
--- /dev/null
+++ b/vnet/vnet/fib/fib_entry_delegate.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __FIB_ENTRY_DELEGATE_T__
+#define __FIB_ENTRY_DELEGATE_T__
+
+#include <vnet/fib/fib_node.h>
+
+/**
+ * Delegate types
+ */
+typedef enum fib_entry_delegate_type_t_ {
+    /**
+     * Forwarding chain types:
+     * for the vast majority of FIB entries only one chain is required - the
+     * one that forwards traffic matching the fib_entry_t's fib_prefix_t. For those
+     * fib_entry_t that are a resolution target for other fib_entry_t's they will also
+     * need the chain to provide forwarding for those children. We store these additional
+     * chains in delegates to save memory in the common case.
+     */
+    FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4 = FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+    FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6 = FIB_FORW_CHAIN_TYPE_UNICAST_IP6,
+    FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS = FIB_FORW_CHAIN_TYPE_MPLS_EOS,
+    FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
+    FIB_ENTRY_DELEGATE_CHAIN_ETHERNET = FIB_FORW_CHAIN_TYPE_ETHERNET,
+    /**
+     * Dependency list of covered entries.
+     * these are more specific entries that are interested in changes
+     * to their respective cover
+     */
+    FIB_ENTRY_DELEGATE_COVERED,
+    /**
+     * Attached import/export functionality
+     */
+    FIB_ENTRY_DELEGATE_ATTACHED_IMPORT,
+    FIB_ENTRY_DELEGATE_ATTACHED_EXPORT,
+} fib_entry_delegate_type_t;
+
+#define FOR_EACH_DELEGATE_CHAIN(_entry, _fdt, _fed, _body)    \
+{                                                             \
+    for (_fdt = FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4;         \
+         _fdt <= FIB_ENTRY_DELEGATE_CHAIN_ETHERNET;           \
+         _fdt++)                                              \
+    {                                                         \
+        _fed = fib_entry_delegate_get(_entry, _fdt);          \
+        if (NULL != _fed) {                                   \
+            _body;                                            \
+        }                                                     \
+    }                                                         \
+}
+
+/**
+ * A Delagate is a means to implmenet the Delagation design pattern; the extension of an
+ * objects functionality through the composition of, and delgation to, other objects.
+ * These 'other' objects are delegates. Delagates are thus attached to other FIB objects
+ * to extend their functionality.
+ */
+typedef struct fib_entry_delegate_t_
+{
+    /**
+     * The FIB entry object to which the delagate is attached
+     */
+    fib_node_index_t fd_entry_index;
+
+    /**
+     * The delagate type
+     */
+    fib_entry_delegate_type_t fd_type;
+
+    /**
+     * A union of data for the different delegate types
+     * These delegates are stored in a sparse vector on the entry, so they
+     * must all be of the same size. We could use indirection here for all types,
+     * i.e. store an index, that's ok for large delegates, like the attached export
+     * but for the chain delegates it's excessive
+     */
+    union
+    {
+        /**
+         * Valid for the forwarding chain delegates. The LB that is built.
+         */
+        dpo_id_t fd_dpo;
+
+        /**
+         * Valid for the attached import cases. An index of the importer/exporter
+         */
+        fib_node_index_t fd_index;
+
+        /**
+         * For the cover tracking. The node list;
+         */
+        fib_node_list_t fd_list;
+    };
+} fib_entry_delegate_t;
+
+struct fib_entry_t_;
+
+extern void fib_entry_delegate_remove(struct fib_entry_t_ *fib_entry,
+                                      fib_entry_delegate_type_t type);
+
+extern fib_entry_delegate_t *fib_entry_delegate_find_or_add(struct fib_entry_t_ *fib_entry,
+                                                            fib_entry_delegate_type_t fdt);
+extern fib_entry_delegate_t *fib_entry_delegate_get(const struct fib_entry_t_ *fib_entry,
+                                                    fib_entry_delegate_type_t type);
+
+extern fib_forward_chain_type_t fib_entry_delegate_type_to_chain_type(
+    fib_entry_delegate_type_t type);
+
+extern fib_entry_delegate_type_t fib_entry_chain_type_to_delegate_type(
+     fib_forward_chain_type_t type);
+
+#endif
diff --git a/vnet/vnet/fib/fib_entry_src.c b/vnet/vnet/fib/fib_entry_src.c
index 6fb2e64c287..060fac941d2 100644
--- a/vnet/vnet/fib/fib_entry_src.c
+++ b/vnet/vnet/fib/fib_entry_src.c
@@ -221,6 +221,44 @@ fib_entry_src_valid_out_label (mpls_label_t label)
              MPLS_IETF_IMPLICIT_NULL_LABEL == label));
 }
 
+/**
+ * @brief Turn the chain type requested by the client into the one they
+ * really wanted
+ */
+fib_forward_chain_type_t
+fib_entry_chain_type_fixup (const fib_entry_t *entry,
+			    fib_forward_chain_type_t fct)
+{
+    ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS == fct);
+
+    /*
+     * The EOS chain is a tricky since one cannot know the adjacency
+     * to link to without knowing what the packets payload protocol
+     * will be once the label is popped.
+     */
+    fib_forward_chain_type_t dfct;
+
+    dfct = fib_entry_get_default_chain_type(entry);
+
+    if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct)
+    {
+        /*
+         * If the entry being asked is a eos-MPLS label entry,
+         * then use the payload-protocol field, that we stashed there
+         * for just this purpose
+         */
+        return (fib_forw_chain_type_from_dpo_proto(
+                    entry->fe_prefix.fp_payload_proto));
+    }
+    /*
+     * else give them what this entry would be by default. i.e. if it's a v6
+     * entry, then the label its local labelled should be carrying v6 traffic.
+     * If it's a non-EOS label entry, then there are more labels and we want
+     * a non-eos chain.
+     */
+    return (dfct);
+}
+
 static int
 fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
                                   fib_node_index_t path_index,
@@ -255,13 +293,13 @@ fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
     
     if (NULL != path_ext &&
         path_ext->fpe_path_index == path_index &&
-        fib_entry_src_valid_out_label(path_ext->fpe_label))
+        fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0]))
     {
         /*
          * found a matching extension. stack it to obtain the forwarding
          * info for this path.
          */
-        ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fct, ctx->next_hops);
+        ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fib_entry, ctx->fct, ctx->next_hops);
     }
     else
     {
@@ -299,6 +337,21 @@ fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
 	    }
             break;
         case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
+        {
+            /*
+             * no label. we need a chain based on the payload. fixup.
+             */
+            vec_add2(ctx->next_hops, nh, 1);
+
+            nh->path_index = path_index;
+            nh->path_weight = fib_path_get_weight(path_index);
+            fib_path_contribute_forwarding(path_index,
+                                           fib_entry_chain_type_fixup(ctx->fib_entry,
+                                                                      ctx->fct),
+                                           &nh->path_dpo);
+
+            break;
+        }
         case FIB_FORW_CHAIN_TYPE_ETHERNET:
 	    ASSERT(0);
 	    break;
@@ -420,12 +473,12 @@ fib_entry_src_action_install (fib_entry_t *fib_entry,
      * the load-balance object only needs to be added to the forwarding
      * DB once, when it is created.
      */
-    insert = !dpo_id_is_valid(&fib_entry->fe_lb[fct]);
+    insert = !dpo_id_is_valid(&fib_entry->fe_lb);
 
-    fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb[fct]);
+    fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb);
 
-    ASSERT(dpo_id_is_valid(&fib_entry->fe_lb[fct]));
-    FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb[fct]);
+    ASSERT(dpo_id_is_valid(&fib_entry->fe_lb));
+    FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb);
 
     /*
      * insert the adj into the data-plane forwarding trie
@@ -434,51 +487,41 @@ fib_entry_src_action_install (fib_entry_t *fib_entry,
     {
        fib_table_fwding_dpo_update(fib_entry->fe_fib_index,
                                    &fib_entry->fe_prefix,
-                                   &fib_entry->fe_lb[fct]);
+                                   &fib_entry->fe_lb);
     }
 
-    if (FIB_FORW_CHAIN_TYPE_UNICAST_IP4 == fct ||
-	FIB_FORW_CHAIN_TYPE_UNICAST_IP6 == fct)
+    /*
+     * if any of the other chain types are already created they will need
+     * updating too
+     */
+    fib_entry_delegate_type_t fdt;
+    fib_entry_delegate_t *fed;
+
+    FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
     {
-	for (fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS;
-	     fct <= FIB_FORW_CHAIN_TYPE_MPLS_EOS;
-	     fct++)
-	{
-	    /*
-	     * if any of the other chain types are already created they will need
-	     * updating too
-	     */
-	    if (dpo_id_is_valid(&fib_entry->fe_lb[fct]))
-	    {
-		fib_entry_src_mk_lb(fib_entry,
-				    esrc,
-				    fct,
-				    &fib_entry->fe_lb[fct]);
-	    }
-	}
-    }
+        fib_entry_src_mk_lb(fib_entry, esrc,
+                            fib_entry_delegate_type_to_chain_type(fdt),
+                            &fed->fd_dpo);
+    });
 }
 
 void
 fib_entry_src_action_uninstall (fib_entry_t *fib_entry)
 {
-    fib_forward_chain_type_t fct;
-
-    fct = fib_entry_get_default_chain_type(fib_entry);
     /*
      * uninstall the forwarding chain from the forwarding tables
      */
     FIB_ENTRY_DBG(fib_entry, "uninstall: %d",
 		  fib_entry->fe_adj_index);
 
-    if (dpo_id_is_valid(&fib_entry->fe_lb[fct]))
+    if (dpo_id_is_valid(&fib_entry->fe_lb))
     {
 	fib_table_fwding_dpo_remove(
 	    fib_entry->fe_fib_index,
 	    &fib_entry->fe_prefix,
-	    &fib_entry->fe_lb[fct]);
+	    &fib_entry->fe_lb);
 
-	dpo_reset(&fib_entry->fe_lb[fct]);
+	dpo_reset(&fib_entry->fe_lb);
     }
 }
 
@@ -965,7 +1008,7 @@ static void
 fib_entry_src_path_ext_append (fib_entry_src_t *esrc,
 			       const fib_route_path_t *rpath)
 {
-    if (MPLS_LABEL_INVALID != rpath->frp_label)
+    if (NULL != rpath->frp_label_stack)
     {
 	fib_path_ext_t *path_ext;
 
@@ -991,7 +1034,7 @@ fib_entry_src_path_ext_insert (fib_entry_src_t *esrc,
     if (0 == vec_len(esrc->fes_path_exts))
 	return (fib_entry_src_path_ext_append(esrc, rpath));
 
-    if (MPLS_LABEL_INVALID != rpath->frp_label)
+    if (NULL != rpath->frp_label_stack)
     {
 	fib_path_ext_t path_ext;
 	int i = 0;
@@ -1097,6 +1140,7 @@ fib_entry_src_action_path_swap (fib_entry_t *fib_entry,
     fib_node_index_t old_path_list, fib_entry_index;
     fib_path_list_flags_t pl_flags;
     const fib_route_path_t *rpath;
+    fib_path_ext_t *path_ext;
     fib_entry_src_t *esrc;
 
     esrc = fib_entry_src_find(fib_entry, source, NULL);
@@ -1138,7 +1182,12 @@ fib_entry_src_action_path_swap (fib_entry_t *fib_entry,
 					     pl_flags,
 					     rpaths);
 
+    vec_foreach(path_ext, esrc->fes_path_exts)
+    {
+	vec_free(path_ext->fpe_label_stack);
+    }
     vec_free(esrc->fes_path_exts);
+
     vec_foreach(rpath, rpaths)
     {
 	fib_entry_src_path_ext_append(esrc, rpath);
@@ -1192,6 +1241,7 @@ fib_entry_src_action_path_remove (fib_entry_t *fib_entry,
 	     * delete the element moving the remaining elements down 1 position.
 	     * this preserves the sorted order.
 	     */
+	    vec_free(path_ext->fpe_label_stack);
 	    vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts));
 	    break;
 	}
diff --git a/vnet/vnet/fib/fib_entry_src.h b/vnet/vnet/fib/fib_entry_src.h
index 0b98c1c35c0..640c174db47 100644
--- a/vnet/vnet/fib/fib_entry_src.h
+++ b/vnet/vnet/fib/fib_entry_src.h
@@ -269,6 +269,9 @@ extern fib_entry_flag_t fib_entry_get_flags_i(const fib_entry_t *fib_entry);
 extern fib_path_list_flags_t fib_entry_src_flags_2_path_list_flags(
     fib_entry_flag_t eflags);
 
+extern fib_forward_chain_type_t fib_entry_chain_type_fixup(const fib_entry_t *entry,
+                                                           fib_forward_chain_type_t fct);
+
 extern void fib_entry_src_mk_lb (fib_entry_t *fib_entry,
 				 const fib_entry_src_t *esrc,
 				 fib_forward_chain_type_t fct,
diff --git a/vnet/vnet/fib/fib_entry_src_rr.c b/vnet/vnet/fib/fib_entry_src_rr.c
index 6d56541dec2..ff15c54e281 100644
--- a/vnet/vnet/fib/fib_entry_src_rr.c
+++ b/vnet/vnet/fib/fib_entry_src_rr.c
@@ -58,6 +58,7 @@ fib_entry_src_rr_resolve_via_connected (fib_entry_src_t *src,
     vec_free(paths);
 }
 
+
 /**
  * Source initialisation Function 
  */
@@ -79,8 +80,18 @@ fib_entry_src_rr_activate (fib_entry_src_t *src,
 
     /*
      * find the covering prefix. become a dependent thereof.
-     * there should always be a cover, though it may be the default route.
+     * for IP there should always be a cover, though it may be the default route.
+     * For MPLS there is never a cover.
      */
+    if (FIB_PROTOCOL_MPLS == fib_entry->fe_prefix.fp_proto)
+    {
+	src->fes_pl = fib_path_list_create_special(FIB_PROTOCOL_MPLS,
+						   FIB_PATH_LIST_FLAG_DROP,
+						   NULL);
+	fib_path_list_lock(src->fes_pl);
+	return (!0);
+    }
+
     src->rr.fesr_cover = fib_table_get_less_specific(fib_entry->fe_fib_index,
 						     &fib_entry->fe_prefix);
 
@@ -157,12 +168,12 @@ fib_entry_src_rr_deactivate (fib_entry_src_t *src,
     /*
      * remove the depednecy on the covering entry
      */
-    ASSERT(FIB_NODE_INDEX_INVALID != src->rr.fesr_cover);
-    cover = fib_entry_get(src->rr.fesr_cover);
-
-    fib_entry_cover_untrack(cover, src->rr.fesr_sibling);
-
-    src->rr.fesr_cover = FIB_NODE_INDEX_INVALID;
+    if (FIB_NODE_INDEX_INVALID != src->rr.fesr_cover)
+    {
+	cover = fib_entry_get(src->rr.fesr_cover);
+	fib_entry_cover_untrack(cover, src->rr.fesr_sibling);
+	src->rr.fesr_cover = FIB_NODE_INDEX_INVALID;
+    }
 
     fib_path_list_unlock(src->fes_pl);
     src->fes_pl = FIB_NODE_INDEX_INVALID;
diff --git a/vnet/vnet/fib/fib_internal.h b/vnet/vnet/fib/fib_internal.h
index a0238ac3cdb..2d980bcce0a 100644
--- a/vnet/vnet/fib/fib_internal.h
+++ b/vnet/vnet/fib/fib_internal.h
@@ -24,6 +24,9 @@
  */
 #undef FIB_DEBUG
 
+extern void fib_prefix_from_mpls_label(mpls_label_t label,
+				       fib_prefix_t *prf);
+
 extern int fib_route_path_cmp(const fib_route_path_t *rpath1,
 			      const fib_route_path_t *rpath2);
 
diff --git a/vnet/vnet/fib/fib_node.c b/vnet/vnet/fib/fib_node.c
index 35dc874effb..db3e22bb3b8 100644
--- a/vnet/vnet/fib/fib_node.c
+++ b/vnet/vnet/fib/fib_node.c
@@ -117,22 +117,6 @@ fib_node_child_add (fib_node_type_t parent_type,
                                      index));
 }
 
-u32
-fib_node_child_get_n_children (fib_node_type_t parent_type,
-                               fib_node_index_t parent_index)
-{
-    fib_node_t *parent;
-
-    parent = fn_vfts[parent_type].fnv_get(parent_index);
-
-    if (FIB_NODE_INDEX_INVALID == parent->fn_children)
-    {
-        return (0);
-    }
-
-    return (fib_node_list_get_size(parent->fn_children));
-}
-
 void
 fib_node_child_remove (fib_node_type_t parent_type,
                        fib_node_index_t parent_index,
@@ -152,6 +136,17 @@ fib_node_child_remove (fib_node_type_t parent_type,
     fib_node_unlock(parent);
 }
 
+u32
+fib_node_get_n_children (fib_node_type_t parent_type,
+                         fib_node_index_t parent_index)
+{
+    fib_node_t *parent;
+
+    parent = fn_vfts[parent_type].fnv_get(parent_index);
+
+    return (fib_node_list_get_size(parent->fn_children));
+}
+
 
 fib_node_back_walk_rc_t
 fib_node_back_walk_one (fib_node_ptr_t *ptr,
diff --git a/vnet/vnet/fib/fib_node.h b/vnet/vnet/fib/fib_node.h
index 4aabc64e288..3ad8ee95b64 100644
--- a/vnet/vnet/fib/fib_node.h
+++ b/vnet/vnet/fib/fib_node.h
@@ -35,6 +35,7 @@ typedef enum fib_node_type_t_ {
     FIB_NODE_TYPE_PATH,
     FIB_NODE_TYPE_ADJ,
     FIB_NODE_TYPE_MPLS_ENTRY,
+    FIB_NODE_TYPE_MPLS_TUNNEL,
     FIB_NODE_TYPE_LISP_GPE_FWD_ENTRY,
     FIB_NODE_TYPE_LISP_ADJ,
     FIB_NODE_TYPE_GRE_TUNNEL,
@@ -54,6 +55,7 @@ typedef enum fib_node_type_t_ {
     [FIB_NODE_TYPE_PATH_LIST] = "path-list",      \
     [FIB_NODE_TYPE_PATH]      = "path",           \
     [FIB_NODE_TYPE_MPLS_ENTRY] = "mpls-entry",    \
+    [FIB_NODE_TYPE_MPLS_TUNNEL] = "mpls-tunnel",  \
     [FIB_NODE_TYPE_ADJ] = "adj",                  \
     [FIB_NODE_TYPE_LISP_GPE_FWD_ENTRY] = "lisp-gpe-fwd-entry", \
     [FIB_NODE_TYPE_LISP_ADJ] = "lisp-adj", \
@@ -341,8 +343,8 @@ extern void fib_node_deinit(fib_node_t *node);
 extern void fib_node_lock(fib_node_t *node);
 extern void fib_node_unlock(fib_node_t *node);
 
-extern u32 fib_node_child_get_n_children(fib_node_type_t parent_type,
-                                         fib_node_index_t parent_index);
+extern u32 fib_node_get_n_children(fib_node_type_t parent_type,
+                                   fib_node_index_t parent_index);
 extern u32 fib_node_child_add(fib_node_type_t parent_type,
 			      fib_node_index_t parent_index,
 			      fib_node_type_t child_type,
diff --git a/vnet/vnet/fib/fib_path.c b/vnet/vnet/fib/fib_path.c
index 988f689b102..809e3e166da 100644
--- a/vnet/vnet/fib/fib_path.c
+++ b/vnet/vnet/fib/fib_path.c
@@ -207,10 +207,17 @@ typedef struct fib_path_t_ {
 	    u32 fp_interface;
 	} attached;
 	struct {
-	    /**
-	     * The next-hop
-	     */
-	    ip46_address_t fp_nh;
+	    union
+	    {
+		/**
+		 * The next-hop
+		 */
+		ip46_address_t fp_ip;
+		/**
+		 * The local label to resolve through.
+		 */
+		mpls_label_t fp_local_label;
+	    } fp_nh;
 	    /**
 	     * The FIB table index in which to find the next-hop.
 	     * This needs to be fixed. We should lookup the adjacencies in
@@ -237,7 +244,7 @@ typedef struct fib_path_t_ {
 	} recursive;
 	struct {
 	    /**
-	     * The FIN index in which to perfom the next lookup
+	     * The FIB index in which to perfom the next lookup
 	     */
 	    fib_node_index_t fp_tbl_id;
 	} deag;
@@ -428,11 +435,22 @@ format_fib_path (u8 * s, va_list * args)
 	}
 	break;
     case FIB_PATH_TYPE_RECURSIVE:
-	s = format (s, "via %U",
-		    format_ip46_address,
-		    &path->recursive.fp_nh,
-		    IP46_TYPE_ANY);
-	s = format (s, " in fib:%d", path->recursive.fp_tbl_id, path->fp_via_fib); 
+	if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+	{
+	    s = format (s, "via %U",
+			format_mpls_unicast_label,
+			path->recursive.fp_nh.fp_local_label);
+	}
+	else
+	{
+	    s = format (s, "via %U",
+			format_ip46_address,
+			&path->recursive.fp_nh.fp_ip,
+			IP46_TYPE_ANY);
+	}
+	s = format (s, " in fib:%d",
+		    path->recursive.fp_tbl_id,
+		    path->fp_via_fib); 
 	s = format (s, " via-fib:%d", path->fp_via_fib); 
 	s = format (s, " via-dpo:[%U:%d]",
 		    format_dpo_type, path->fp_dpo.dpoi_type, 
@@ -677,7 +695,7 @@ fib_path_unresolve (fib_path_t *path)
 	{
 	    fib_prefix_t pfx;
 
-	    fib_prefix_from_ip46_addr(&path->recursive.fp_nh, &pfx);
+	    fib_entry_get_prefix(path->fp_via_fib, &pfx);
 	    fib_entry_child_remove(path->fp_via_fib,
 				   path->fp_sibling);
 	    fib_table_entry_special_remove(path->recursive.fp_tbl_id,
@@ -1025,7 +1043,14 @@ fib_path_create (fib_node_index_t pl_index,
 	else
 	{
 	    path->fp_type = FIB_PATH_TYPE_RECURSIVE;
-	    path->recursive.fp_nh = rpath->frp_addr;
+	    if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+	    {
+		path->recursive.fp_nh.fp_local_label = rpath->frp_local_label;
+	    }
+	    else
+	    {
+		path->recursive.fp_nh.fp_ip = rpath->frp_addr;
+	    }
 	    path->recursive.fp_tbl_id = rpath->frp_fib_index;
 	}
     }
@@ -1301,13 +1326,20 @@ fib_path_cmp_w_route_path (fib_node_index_t path_index,
 		      rpath->frp_sw_if_index);
 	    break;
 	case FIB_PATH_TYPE_RECURSIVE:
-	    res = ip46_address_cmp(&path->recursive.fp_nh,
-				   &rpath->frp_addr);
- 
-	    if (0 == res)
-	    {
-		res = (path->recursive.fp_tbl_id - rpath->frp_fib_index);
-	    }
+            if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+            {
+                res = path->recursive.fp_nh.fp_local_label - rpath->frp_local_label;
+            }
+            else
+            {
+                res = ip46_address_cmp(&path->recursive.fp_nh.fp_ip,
+                                       &rpath->frp_addr);
+            }
+
+            if (0 == res)
+            {
+                res = (path->recursive.fp_tbl_id - rpath->frp_fib_index);
+            }
 	    break;
 	case FIB_PATH_TYPE_DEAG:
 	    res = (path->deag.fp_tbl_id - rpath->frp_fib_index);
@@ -1506,7 +1538,14 @@ fib_path_resolve (fib_node_index_t path_index)
 
 	ASSERT(FIB_NODE_INDEX_INVALID == path->fp_via_fib);
 
-	fib_prefix_from_ip46_addr(&path->recursive.fp_nh, &pfx);
+	if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+	{
+	    fib_prefix_from_mpls_label(path->recursive.fp_nh.fp_local_label, &pfx);
+	}
+	else
+	{
+	    fib_prefix_from_ip46_addr(&path->recursive.fp_nh.fp_ip, &pfx);
+	}
 
 	fei = fib_table_entry_special_add(path->recursive.fp_tbl_id,
 					  &pfx,
@@ -1720,7 +1759,7 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
 		adj_index_t ai;
 
 		/*
-		 * get a MPLS link type adj.
+		 * get a appropriate link type adj.
 		 */
 		ai = fib_path_attached_next_hop_get_adj(
 		         path,
@@ -1739,12 +1778,6 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
 	    case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
 	    case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
 	    case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
-		/*
-		 * Assume that EOS and IP forwarding is the same.
-		 * revisit for ieBGP
-		 */
-		dpo_copy(dpo, &path->fp_dpo);
-		break;
 	    case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
 		fib_path_recursive_adj_update(path, fct, dpo);
 		break;
@@ -1898,7 +1931,7 @@ fib_path_encode (fib_node_index_t path_list_index,
       case FIB_PATH_TYPE_DEAG:
         break;
       case FIB_PATH_TYPE_RECURSIVE:
-        api_rpath->rpath.frp_addr = path->recursive.fp_nh;
+        api_rpath->rpath.frp_addr = path->recursive.fp_nh.fp_ip;
         break;
       default:
         break;
@@ -1906,6 +1939,16 @@ fib_path_encode (fib_node_index_t path_list_index,
     return (1);
 }
 
+fib_protocol_t
+fib_path_get_proto (fib_node_index_t path_index)
+{
+    fib_path_t *path;
+
+    path = fib_path_get(path_index);
+
+    return (path->fp_nh_proto);
+}
+
 void
 fib_path_module_init (void)
 {
diff --git a/vnet/vnet/fib/fib_path.h b/vnet/vnet/fib/fib_path.h
index 4151c578aed..91f49d09234 100644
--- a/vnet/vnet/fib/fib_path.h
+++ b/vnet/vnet/fib/fib_path.h
@@ -132,6 +132,7 @@ extern int fib_path_is_recursive(fib_node_index_t path_index);
 extern int fib_path_is_exclusive(fib_node_index_t path_index);
 extern int fib_path_is_deag(fib_node_index_t path_index);
 extern int fib_path_is_looped(fib_node_index_t path_index);
+extern fib_protocol_t fib_path_get_proto(fib_node_index_t path_index);
 extern void fib_path_destroy(fib_node_index_t path_index);
 extern uword fib_path_hash(fib_node_index_t path_index);
 extern load_balance_path_t * fib_path_append_nh_for_multipath_hash(
diff --git a/vnet/vnet/fib/fib_path_ext.c b/vnet/vnet/fib/fib_path_ext.c
index 6603b64f02f..f75b5626c04 100644
--- a/vnet/vnet/fib/fib_path_ext.c
+++ b/vnet/vnet/fib/fib_path_ext.c
@@ -18,23 +18,28 @@
 #include <vnet/dpo/load_balance.h>
 #include <vnet/dpo/drop_dpo.h>
 
-#include "fib_path_ext.h"
-#include "fib_path.h"
-#include "fib_path_list.h"
-#include "fib_internal.h"
+#include <vnet/fib/fib_path_ext.h>
+#include <vnet/fib/fib_entry_src.h>
+#include <vnet/fib/fib_path.h>
+#include <vnet/fib/fib_path_list.h>
+#include <vnet/fib/fib_internal.h>
 
 u8 *
 format_fib_path_ext (u8 * s, va_list * args)
 {
     fib_path_ext_t *path_ext;
+    u32 ii;
 
     path_ext = va_arg (*args, fib_path_ext_t *);
 
-    s = format(s, "path:%d label:%U",
-	       path_ext->fpe_path_index,
-	       format_mpls_unicast_label,
-	       path_ext->fpe_path.frp_label);
-
+    s = format(s, "path:%d labels:",
+	       path_ext->fpe_path_index);
+    for (ii = 0; ii < vec_len(path_ext->fpe_path.frp_label_stack); ii++)
+    {
+	s = format(s, "%U ",
+		   format_mpls_unicast_label,
+		   path_ext->fpe_path.frp_label_stack[ii]);
+    }
     return (s);
 }
 
@@ -86,12 +91,23 @@ fib_path_ext_init (fib_path_ext_t *path_ext,
     fib_path_ext_resolve(path_ext, path_list_index);
 }
 
+/**
+ * @brief Return true if the label stack is implicit null
+ */
+static int
+fib_path_ext_is_imp_null (fib_path_ext_t *path_ext)
+{
+    return ((1 == vec_len(path_ext->fpe_label_stack)) &&
+	    (MPLS_IETF_IMPLICIT_NULL_LABEL == path_ext->fpe_label_stack[0]));
+}
+
 load_balance_path_t *
 fib_path_ext_stack (fib_path_ext_t *path_ext,
-		    fib_forward_chain_type_t parent_fct,
+		    const fib_entry_t *entry,
+                    fib_forward_chain_type_t child_fct,
 		    load_balance_path_t *nhs)
 {
-    fib_forward_chain_type_t child_fct;
+    fib_forward_chain_type_t parent_fct;
     load_balance_path_t *nh;
 
     if (!fib_path_is_resolved(path_ext->fpe_path_index))
@@ -102,33 +118,50 @@ fib_path_ext_stack (fib_path_ext_t *path_ext,
      * label. From the chain type request by the child, determine what
      * chain type we will request from the parent.
      */
-    switch (parent_fct)
+    switch (child_fct)
     {
     case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
-	ASSERT(0);
-        return (nhs);
+    {
+	/*
+	 * The EOS chain is a tricky since, when the path has an imp NULL one cannot know
+         * the adjacency to link to without knowing what the packets payload protocol
+	 * will be once the label is popped.
+	 */
+	if (fib_path_ext_is_imp_null(path_ext))
+	{
+            parent_fct = fib_entry_chain_type_fixup(entry, child_fct);
+        }
+        else
+        {
+            /*
+             * we have a label to stack. packets will thus be labelled when
+             * they encounter the child, ergo, non-eos.
+             */
+	    parent_fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS;
+        }
 	break;
+    }
     case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
     case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
-	if (MPLS_IETF_IMPLICIT_NULL_LABEL == path_ext->fpe_label)
+	if (fib_path_ext_is_imp_null(path_ext))
 	{
             /*
              * implicit-null label for the eos or IP chain, need to pick up
              * the IP adj
              */
-	    child_fct = parent_fct;
+	    parent_fct = child_fct;
 	}
         else
         {
             /*
              * we have a label to stack. packets will thus be labelled when
-             * they encounter th child, ergo, non-eos.
+             * they encounter the child, ergo, non-eos.
              */
-	    child_fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS;
+	    parent_fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS;
         }
 	break;
     case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
-        child_fct = parent_fct;
+        parent_fct = child_fct;
 	break;
     default:
         return (nhs);
@@ -143,7 +176,7 @@ fib_path_ext_stack (fib_path_ext_t *path_ext,
      * are to be sent. We stack the MPLS Label DPO on this path DPO
      */
     fib_path_contribute_forwarding(path_ext->fpe_path_index,
-				   child_fct,
+				   parent_fct,
 				   &via_dpo);
 
     if (dpo_is_drop(&via_dpo) ||
@@ -165,17 +198,31 @@ fib_path_ext_stack (fib_path_ext_t *path_ext,
 	 * The label is stackable for this chain type
 	 * construct the mpls header that will be imposed in the data-path
 	 */
-	if (MPLS_IETF_IMPLICIT_NULL_LABEL != path_ext->fpe_label)
+	if (!fib_path_ext_is_imp_null(path_ext))
 	{
+            /*
+             * we use the parent protocol for the label so that
+             * we pickup the correct MPLS imposition nodes to do
+             * ip[46] processing.
+             */
+            dpo_proto_t chain_proto;
+            mpls_eos_bit_t eos;
+            index_t mldi;
+
+            eos = (child_fct == FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS ?
+                   MPLS_NON_EOS :
+                   MPLS_EOS);
+            chain_proto = fib_forw_chain_type_to_dpo_proto(child_fct);
+
+            mldi = mpls_label_dpo_create(path_ext->fpe_label_stack,
+                                         eos, 255, 0,
+                                         chain_proto,
+                                         &nh->path_dpo);
+
 	    dpo_set(&nh->path_dpo,
 		    DPO_MPLS_LABEL,
-		    DPO_PROTO_MPLS,
-		    mpls_label_dpo_create(path_ext->fpe_label,
-                                          (parent_fct == FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS ?
-                                           MPLS_NON_EOS :
-                                           MPLS_EOS),
-                                          255, 0,
-                                          &nh->path_dpo));
+                    chain_proto,
+                    mldi);
 	}
     }
     dpo_reset(&via_dpo);
diff --git a/vnet/vnet/fib/fib_path_ext.h b/vnet/vnet/fib/fib_path_ext.h
index 6cb7f507ff4..cf8f8df00c6 100644
--- a/vnet/vnet/fib/fib_path_ext.h
+++ b/vnet/vnet/fib/fib_path_ext.h
@@ -24,10 +24,10 @@
  * when packets are sent for that entry over that path.
  *
  * For example:
- *    ip route add 1.1.1.1/32 via 10.10.10.10 mpls-label 100
+ *    ip route add 1.1.1.1/32 via 10.10.10.10 out-label 100
  *
  * The out-going MPLS label value 100 is a path-extension. It is a value sepcific
- * to the entry 1.1.1.1/32 and valid only went packets are sent via 10.10.10.10.
+ * to the entry 1.1.1.1/32 and valid only when packets are sent via 10.10.10.10.
  */
 typedef struct fib_path_ext_t_
 {
@@ -37,7 +37,7 @@ typedef struct fib_path_ext_t_
      * instance of a fib_path_t that is extended
      */
     fib_route_path_t fpe_path;
-#define fpe_label fpe_path.frp_label
+#define fpe_label_stack fpe_path.frp_label_stack
 
     /**
      * The index of the path. This is the global index, not the path's
@@ -46,6 +46,7 @@ typedef struct fib_path_ext_t_
     fib_node_index_t fpe_path_index;
 } fib_path_ext_t;
 
+struct fib_entry_t_;
 
 extern u8 * format_fib_path_ext(u8 * s, va_list * args);
 
@@ -60,6 +61,7 @@ extern void fib_path_ext_resolve(fib_path_ext_t *path_ext,
 				 fib_node_index_t path_list_index);
 
 extern load_balance_path_t *fib_path_ext_stack(fib_path_ext_t *path_ext,
+                                               const struct fib_entry_t_ *entry,
                                                fib_forward_chain_type_t fct,
                                                load_balance_path_t *nhs);
 
diff --git a/vnet/vnet/fib/fib_path_list.c b/vnet/vnet/fib/fib_path_list.c
index 4d695d63d51..5b35e9b87e7 100644
--- a/vnet/vnet/fib/fib_path_list.c
+++ b/vnet/vnet/fib/fib_path_list.c
@@ -613,6 +613,20 @@ fib_path_list_get_resolving_interface (fib_node_index_t path_list_index)
     return (sw_if_index);
 }
 
+fib_protocol_t
+fib_path_list_get_proto (fib_node_index_t path_list_index)
+{
+    fib_path_list_t *path_list;
+
+    path_list = fib_path_list_get(path_list_index);
+
+    /*
+     * we don't support a mix of path protocols, so we can return the proto
+     * of the first
+     */
+    return (fib_path_get_proto(path_list->fpl_paths[0]));
+}
+
 int
 fib_path_list_is_looped (fib_node_index_t path_list_index)
 {
diff --git a/vnet/vnet/fib/fib_path_list.h b/vnet/vnet/fib/fib_path_list.h
index 852f07d427d..8bc1b20b6bf 100644
--- a/vnet/vnet/fib/fib_path_list.h
+++ b/vnet/vnet/fib/fib_path_list.h
@@ -126,6 +126,7 @@ extern int fib_path_list_recursive_loop_detect(fib_node_index_t path_list_index,
 					       fib_node_index_t **entry_indicies);
 extern u32 fib_path_list_get_resolving_interface(fib_node_index_t path_list_index);
 extern int fib_path_list_is_looped(fib_node_index_t path_list_index);
+extern fib_protocol_t fib_path_list_get_proto(fib_node_index_t path_list_index);
 extern u8 * fib_path_list_format(fib_node_index_t pl_index,
 				 u8 * s);
 extern u8 * fib_path_list_adjs_format(fib_node_index_t pl_index,
diff --git a/vnet/vnet/fib/fib_table.c b/vnet/vnet/fib/fib_table.c
index 54bc8081993..76db42d0ec7 100644
--- a/vnet/vnet/fib/fib_table.c
+++ b/vnet/vnet/fib/fib_table.c
@@ -493,7 +493,7 @@ fib_table_entry_path_add (u32 fib_index,
 			  u32 next_hop_sw_if_index,
 			  u32 next_hop_fib_index,
 			  u32 next_hop_weight,
-			  mpls_label_t next_hop_label,
+			  mpls_label_t *next_hop_labels,
 			  fib_route_path_flags_t path_flags)
 {
     fib_route_path_t path = {
@@ -503,12 +503,11 @@ fib_table_entry_path_add (u32 fib_index,
 	.frp_fib_index = next_hop_fib_index,
 	.frp_weight = next_hop_weight,
 	.frp_flags = path_flags,
-	.frp_label = next_hop_label,
+	.frp_label_stack = next_hop_labels,
     };
     fib_node_index_t fib_entry_index;
     fib_route_path_t *paths = NULL;
 
-    fib_table_route_path_fixup(prefix, &path);
     vec_add1(paths, path);
 
     fib_entry_index = fib_table_entry_path_add2(fib_index, prefix,
@@ -523,14 +522,20 @@ fib_table_entry_path_add2 (u32 fib_index,
 			   const fib_prefix_t *prefix,
 			   fib_source_t source,
 			   fib_entry_flag_t flags,
-			   const fib_route_path_t *rpath)
+			   fib_route_path_t *rpath)
 {
     fib_node_index_t fib_entry_index;
     fib_table_t *fib_table;
+    u32 ii;
 
     fib_table = fib_table_get(fib_index, prefix->fp_proto);
     fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
 
+    for (ii = 0; ii < vec_len(rpath); ii++)
+    {
+	fib_table_route_path_fixup(prefix, &rpath[ii]);
+    }
+
     if (FIB_NODE_INDEX_INVALID == fib_entry_index)
     {
 	fib_entry_index = fib_entry_create(fib_index, prefix,
@@ -558,9 +563,9 @@ fib_table_entry_path_add2 (u32 fib_index,
 
 void
 fib_table_entry_path_remove2 (u32 fib_index,
-			     const fib_prefix_t *prefix,
-			     fib_source_t source,
-			      const fib_route_path_t *rpath)
+			      const fib_prefix_t *prefix,
+			      fib_source_t source,
+			      fib_route_path_t *rpath)
 {
     /*
      * 1 is it present
@@ -570,10 +575,16 @@ fib_table_entry_path_remove2 (u32 fib_index,
      */
     fib_node_index_t fib_entry_index;
     fib_table_t *fib_table;
+    u32 ii;
 
     fib_table = fib_table_get(fib_index, prefix->fp_proto);
     fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
 
+    for (ii = 0; ii < vec_len(rpath); ii++)
+    {
+	fib_table_route_path_fixup(prefix, &rpath[ii]);
+    }
+
     if (FIB_NODE_INDEX_INVALID == fib_entry_index)
     {
 	/*
@@ -667,20 +678,24 @@ fib_table_entry_update (u32 fib_index,
 			const fib_prefix_t *prefix,
 			fib_source_t source,
 			fib_entry_flag_t flags,
-			const fib_route_path_t *paths)
+			fib_route_path_t *paths)
 {
     fib_node_index_t fib_entry_index;
     fib_table_t *fib_table;
+    u32 ii;
 
     fib_table = fib_table_get(fib_index, prefix->fp_proto);
     fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
 
+    for (ii = 0; ii < vec_len(paths); ii++)
+    {
+	fib_table_route_path_fixup(prefix, &paths[ii]);
+    }
     /*
      * sort the paths provided by the control plane. this means
      * the paths and the extension on the entry will be sorted.
      */
-    vec_sort_with_function(((fib_route_path_t*)paths), // const cast
-			   fib_route_path_cmp_for_sort);
+    vec_sort_with_function(paths, fib_route_path_cmp_for_sort);
 
     if (FIB_NODE_INDEX_INVALID == fib_entry_index)
     {
@@ -717,7 +732,7 @@ fib_table_entry_update_one_path (u32 fib_index,
 				 u32 next_hop_sw_if_index,
 				 u32 next_hop_fib_index,
 				 u32 next_hop_weight,
-				 mpls_label_t next_hop_label,
+				 mpls_label_t *next_hop_labels,
 				 fib_route_path_flags_t path_flags)
 {
     fib_node_index_t fib_entry_index;
@@ -728,7 +743,7 @@ fib_table_entry_update_one_path (u32 fib_index,
 	.frp_fib_index = next_hop_fib_index,
 	.frp_weight = next_hop_weight,
 	.frp_flags = path_flags,
-	.frp_label = next_hop_label,
+	.frp_label_stack = next_hop_labels,
     };
     fib_route_path_t *paths = NULL;
 
diff --git a/vnet/vnet/fib/fib_table.h b/vnet/vnet/fib/fib_table.h
index ef7599a7bf5..cfec516de1a 100644
--- a/vnet/vnet/fib/fib_table.h
+++ b/vnet/vnet/fib/fib_table.h
@@ -289,8 +289,8 @@ extern void fib_table_entry_special_remove(u32 fib_index,
  * @param next_hop_weight
  *  [un]equal cost path weight
  *
- * @param  next_hop_label
- *  The path's out-going label. INVALID is there is none.
+ * @param  next_hop_label_stack
+ *  The path's out-going label stack. NULL is there is none.
  *
  * @param  pf
  *  Flags for the path
@@ -307,7 +307,7 @@ extern fib_node_index_t fib_table_entry_path_add(u32 fib_index,
 						 u32 next_hop_sw_if_index,
 						 u32 next_hop_fib_index,
 						 u32 next_hop_weight,
-						 mpls_label_t next_hop_label,
+						 mpls_label_t *next_hop_label_stack,
 						 fib_route_path_flags_t pf);
 /**
  * @brief
@@ -329,7 +329,7 @@ extern fib_node_index_t fib_table_entry_path_add(u32 fib_index,
  *  Flags for the entry.
  *
  * @param rpaths
- *  A vector of paths.
+ *  A vector of paths. Not const since they may be modified.
  *
  * @return
  *  the index of the fib_entry_t that is created (or existed already).
@@ -338,7 +338,7 @@ extern fib_node_index_t fib_table_entry_path_add2(u32 fib_index,
 						  const fib_prefix_t *prefix,
 						  fib_source_t source,
 						  fib_entry_flag_t flags,
-						  const fib_route_path_t *rpath);
+						  fib_route_path_t *rpath);
 
 /**
  * @brief
@@ -407,7 +407,7 @@ extern void fib_table_entry_path_remove(u32 fib_index,
 extern void fib_table_entry_path_remove2(u32 fib_index,
 					 const fib_prefix_t *prefix,
 					 fib_source_t source,
-					 const fib_route_path_t *paths);
+					 fib_route_path_t *paths);
 
 /**
  * @brief
@@ -426,7 +426,7 @@ extern void fib_table_entry_path_remove2(u32 fib_index,
  *  The ID of the client/source adding the entry.
  *
  * @param rpaths
- *  A vector of paths.
+ *  A vector of paths. Not const since they may be modified.
  *
  * @return
  *  the index of the fib_entry_t that is created (or existed already).
@@ -435,7 +435,7 @@ extern fib_node_index_t fib_table_entry_update(u32 fib_index,
 					       const fib_prefix_t *prefix,
 					       fib_source_t source,
 					       fib_entry_flag_t flags,
-					       const fib_route_path_t *paths);
+					       fib_route_path_t *paths);
 
 /**
  * @brief
@@ -472,8 +472,8 @@ extern fib_node_index_t fib_table_entry_update(u32 fib_index,
  * @param next_hop_weight
  *  [un]equal cost path weight
  *
- * @param  next_hop_label
- *  The path's out-going label. INVALID is there is none.
+ * @param  next_hop_label_stack
+ *  The path's out-going label stack. NULL is there is none.
  *
  * @param  pf
  *  Flags for the path
@@ -490,7 +490,7 @@ extern fib_node_index_t fib_table_entry_update_one_path(u32 fib_index,
 							u32 next_hop_sw_if_index,
 							u32 next_hop_fib_index,
 							u32 next_hop_weight,
-							mpls_label_t next_hop_label,
+							mpls_label_t *next_hop_label_stack,
 							fib_route_path_flags_t pf);
 
 /**
diff --git a/vnet/vnet/fib/fib_test.c b/vnet/vnet/fib/fib_test.c
index eb5253d06da..a28026c13c1 100644
--- a/vnet/vnet/fib/fib_test.c
+++ b/vnet/vnet/fib/fib_test.c
@@ -28,6 +28,7 @@
 #include <vnet/mpls/mpls.h>
 
 #include <vnet/fib/fib_path_list.h>
+#include <vnet/fib/fib_entry_src.h>
 #include <vnet/fib/fib_walk.h>
 #include <vnet/fib/fib_node_list.h>
 #include <vnet/fib/fib_urpf_list.h>
@@ -256,6 +257,7 @@ fib_test_build_rewrite (u8 *eth_addr)
 
 typedef enum fib_test_lb_bucket_type_t_ {
     FT_LB_LABEL_O_ADJ,
+    FT_LB_LABEL_STACK_O_ADJ,
     FT_LB_LABEL_O_LB,
     FT_LB_O_LB,
     FT_LB_SPECIAL,
@@ -277,6 +279,14 @@ typedef struct fib_test_lb_bucket_t_ {
 	struct
 	{
 	    mpls_eos_bit_t eos;
+	    mpls_label_t label_stack[8];
+	    u8 label_stack_size;
+	    u8 ttl;
+	    adj_index_t adj;
+	} label_stack_o_adj;
+	struct
+	{
+	    mpls_eos_bit_t eos;
 	    mpls_label_t label;
 	    u8 ttl;
 	    index_t lb;
@@ -322,6 +332,63 @@ fib_test_validate_lb_v (const load_balance_t *lb,
 
 	switch (exp->type)
 	{
+	case FT_LB_LABEL_STACK_O_ADJ:
+	    {
+		const mpls_label_dpo_t *mld;
+                mpls_label_t hdr;
+		u32 ii;
+
+		FIB_TEST_LB((DPO_MPLS_LABEL == dpo->dpoi_type),
+			   "bucket %d stacks on %U",
+			   bucket,
+			   format_dpo_type, dpo->dpoi_type);
+	    
+		mld = mpls_label_dpo_get(dpo->dpoi_index);
+
+		FIB_TEST_LB(exp->label_stack_o_adj.label_stack_size == mld->mld_n_labels,
+			    "label stack size",
+			    mld->mld_n_labels);
+
+		for (ii = 0; ii < mld->mld_n_labels; ii++)
+		{
+		    hdr = clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl);
+		    FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
+				 exp->label_stack_o_adj.label_stack[ii]),
+				"bucket %d stacks on label %d",
+				bucket,
+				exp->label_stack_o_adj.label_stack[ii]);
+
+		    if (ii == mld->mld_n_labels-1)
+		    {
+			FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
+				     exp->label_o_adj.eos),
+				    "bucket %d stacks on label %d %U!=%U",
+				    bucket,
+				    exp->label_stack_o_adj.label_stack[ii],
+				    format_mpls_eos_bit, exp->label_o_adj.eos,
+				    format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr));
+		    }
+		    else
+		    {
+			FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) == MPLS_NON_EOS),
+				    "bucket %d stacks on label %d %U",
+				    bucket,
+				    exp->label_stack_o_adj.label_stack[ii],
+				    format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr));
+		    }
+		}
+
+		FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type),
+			    "bucket %d label stacks on %U",
+			    bucket,
+			    format_dpo_type, mld->mld_dpo.dpoi_type);
+
+		FIB_TEST_LB((exp->label_stack_o_adj.adj == mld->mld_dpo.dpoi_index),
+			    "bucket %d label stacks on adj %d",
+			    bucket,
+			    exp->label_stack_o_adj.adj);
+	    }
+	    break;
 	case FT_LB_LABEL_O_ADJ:
 	    {
 		const mpls_label_dpo_t *mld;
@@ -332,7 +399,7 @@ fib_test_validate_lb_v (const load_balance_t *lb,
 			   format_dpo_type, dpo->dpoi_type);
 	    
 		mld = mpls_label_dpo_get(dpo->dpoi_index);
-                hdr = clib_net_to_host_u32(mld->mld_hdr.label_exp_s_ttl);
+                hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
 
 		FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
 			     exp->label_o_adj.label),
@@ -367,10 +434,12 @@ fib_test_validate_lb_v (const load_balance_t *lb,
 			   "bucket %d stacks on %U",
 			   bucket,
 			   format_dpo_type, dpo->dpoi_type);
-
+	    
 		mld = mpls_label_dpo_get(dpo->dpoi_index);
-                hdr = clib_net_to_host_u32(mld->mld_hdr.label_exp_s_ttl);
+                hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
 
+		FIB_TEST_LB(1 == mld->mld_n_labels, "label stack size",
+			    mld->mld_n_labels);
 		FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
 			     exp->label_o_lb.label),
 			    "bucket %d stacks on label %d",
@@ -437,8 +506,8 @@ fib_test_validate_entry (fib_node_index_t fei,
 			 u16 n_buckets,
 			 ...)
 {
-    const load_balance_t *lb;
     dpo_id_t dpo = DPO_INVALID;
+    const load_balance_t *lb;
     fib_prefix_t pfx;
     index_t fw_lbi;
     u32 fib_index;
@@ -462,34 +531,37 @@ fib_test_validate_entry (fib_node_index_t fei,
      * ensure that the LB contributed by the entry is the
      * same as the LB in the forwarding tables
      */
-    switch (pfx.fp_proto)
+    if (fct == fib_entry_get_default_chain_type(fib_entry_get(fei)))
     {
-    case FIB_PROTOCOL_IP4:
-	fw_lbi = ip4_fib_forwarding_lookup(fib_index, &pfx.fp_addr.ip4);
-	break;
-    case FIB_PROTOCOL_IP6:
-	fw_lbi = ip6_fib_table_fwding_lookup(&ip6_main, fib_index, &pfx.fp_addr.ip6);
-	break;
-    case FIB_PROTOCOL_MPLS:
-	{
-	    mpls_unicast_header_t hdr = {
-		.label_exp_s_ttl = 0,
-	    };
-
-	    vnet_mpls_uc_set_label(&hdr.label_exp_s_ttl, pfx.fp_label);
-	    vnet_mpls_uc_set_s(&hdr.label_exp_s_ttl, pfx.fp_eos);
-	    hdr.label_exp_s_ttl = clib_host_to_net_u32(hdr.label_exp_s_ttl);
-
-	    fw_lbi = mpls_fib_table_forwarding_lookup(fib_index, &hdr);
-	    break;
-	}
-    default:
-	fw_lbi = 0;
+        switch (pfx.fp_proto)
+        {
+        case FIB_PROTOCOL_IP4:
+            fw_lbi = ip4_fib_forwarding_lookup(fib_index, &pfx.fp_addr.ip4);
+            break;
+        case FIB_PROTOCOL_IP6:
+            fw_lbi = ip6_fib_table_fwding_lookup(&ip6_main, fib_index, &pfx.fp_addr.ip6);
+            break;
+        case FIB_PROTOCOL_MPLS:
+            {
+                mpls_unicast_header_t hdr = {
+                    .label_exp_s_ttl = 0,
+                };
+
+                vnet_mpls_uc_set_label(&hdr.label_exp_s_ttl, pfx.fp_label);
+                vnet_mpls_uc_set_s(&hdr.label_exp_s_ttl, pfx.fp_eos);
+                hdr.label_exp_s_ttl = clib_host_to_net_u32(hdr.label_exp_s_ttl);
+
+                fw_lbi = mpls_fib_table_forwarding_lookup(fib_index, &hdr);
+                break;
+            }
+        default:
+            fw_lbi = 0;
+        }
+        FIB_TEST_LB((fw_lbi == dpo.dpoi_index),
+                    "Contributed LB = FW LB: %U\n %U",
+                    format_load_balance, fw_lbi, 0,
+                    format_load_balance, dpo.dpoi_index, 0);
     }
-    FIB_TEST_LB((fw_lbi == dpo.dpoi_index),
-		"Contributed LB = FW LB: %U\n %U",
-		format_load_balance, fw_lbi, 0,
-		format_load_balance, dpo.dpoi_index, 0);
 
     dpo_reset(&dpo);
 
@@ -623,7 +695,7 @@ fib_test_v4 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1, // weight
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &local_pfx);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
@@ -650,7 +722,7 @@ fib_test_v4 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1, // weight
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &local_pfx);
     FIB_TEST(((FIB_ENTRY_FLAG_LOCAL | FIB_ENTRY_FLAG_CONNECTED) ==
@@ -700,7 +772,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx);
     FIB_TEST((FIB_ENTRY_FLAG_NONE == fib_entry_get_flags(fei)),
@@ -818,7 +890,7 @@ fib_test_v4 (void)
                                           tm->hw[0]->sw_if_index,
                                           ~0, // invalid fib index
                                           1,
-                                          MPLS_LABEL_INVALID,
+                                          NULL,
                                           FIB_ROUTE_PATH_FLAG_NONE);
 
     dpo = fib_entry_contribute_ip_forwarding(fei);
@@ -884,7 +956,7 @@ fib_test_v4 (void)
                                           tm->hw[0]->sw_if_index,
                                           ~0, // invalid fib index
                                           1,
-                                          MPLS_LABEL_INVALID,
+                                          NULL,
                                           FIB_ROUTE_PATH_FLAG_NONE);
     FIB_TEST((FIB_ENTRY_FLAG_ATTACHED  == fib_entry_get_flags(fei)),
 	     "Flags set on adj-fib");
@@ -933,7 +1005,7 @@ fib_test_v4 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_10_10_10_2_s_32);
@@ -970,7 +1042,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
     ai = fib_entry_get_adj(fei);
@@ -1003,7 +1075,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
     ai = fib_entry_get_adj(fei);
@@ -1030,7 +1102,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
     dpo = fib_entry_contribute_ip_forwarding(fei);
@@ -1116,7 +1188,7 @@ fib_test_v4 (void)
 				   ~0, // no index provided.
 				   fib_index, // nexthop in same fib as route
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST_REC_FORW(&bgp_100_pfx, &pfx_1_1_1_1_s_32, 0);
@@ -1152,7 +1224,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index, // nexthop in same fib as route
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST_REC_FORW(&bgp_101_pfx, &pfx_1_1_1_1_s_32, 0);
@@ -1274,7 +1346,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index, // nexthop in same fib as route
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
@@ -1320,7 +1392,7 @@ fib_test_v4 (void)
                              tm->hw[0]->sw_if_index,
                              ~0,
                              1,
-                             MPLS_LABEL_INVALID,
+                             NULL,
                              FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_entry_path_add(fib_index,
                                    &pfx_1_2_3_4_s_32,
@@ -1331,7 +1403,7 @@ fib_test_v4 (void)
                                    tm->hw[1]->sw_if_index,
                                    ~0,
                                    3,
-                                   MPLS_LABEL_INVALID,
+                                   NULL,
                                    FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.4/32 presnet");
@@ -1372,7 +1444,7 @@ fib_test_v4 (void)
                              tm->hw[1]->sw_if_index,
                              ~0,
                              1,
-                             MPLS_LABEL_INVALID,
+                             NULL,
                              FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_entry_path_add(fib_index,
                                    &pfx_1_2_3_5_s_32,
@@ -1383,7 +1455,7 @@ fib_test_v4 (void)
                                    tm->hw[0]->sw_if_index,
                                    ~0,
                                    4,
-                                   MPLS_LABEL_INVALID,
+                                   NULL,
                                    FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.5/32 presnet");
@@ -1455,7 +1527,7 @@ fib_test_v4 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    0,  // zero weigth
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
@@ -1474,7 +1546,7 @@ fib_test_v4 (void)
                              tm->hw[0]->sw_if_index,
                              ~0, // invalid fib index
                              100,
-                             MPLS_LABEL_INVALID,
+                             NULL,
                              FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
@@ -1556,7 +1628,7 @@ fib_test_v4 (void)
                              tm->hw[1]->sw_if_index,
                              ~0, // invalid fib index
                              100,
-                             MPLS_LABEL_INVALID,
+                             NULL,
                              FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
@@ -1812,7 +1884,7 @@ fib_test_v4 (void)
                                    ~0,
                                    fib_index,
                                    1,
-                                   MPLS_LABEL_INVALID,
+                                   NULL,
                                    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_entry_path_add(fib_index,
                                    &bgp_44_s_32,
@@ -1823,7 +1895,7 @@ fib_test_v4 (void)
                                    ~0,
                                    fib_index,
                                    1,
-                                   MPLS_LABEL_INVALID,
+                                   NULL,
                                    FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST_REC_FORW(&bgp_44_s_32, &pfx_1_2_3_4_s_32, 0);
@@ -1893,7 +1965,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index, // nexthop in same fib as route
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0);
@@ -1936,7 +2008,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_24);
     dpo1 = fib_entry_contribute_ip_forwarding(fei);
@@ -1994,7 +2066,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_28);
     dpo2 = fib_entry_contribute_ip_forwarding(fei);
@@ -2097,7 +2169,7 @@ fib_test_v4 (void)
 				   tm->hw[0]->sw_if_index,
 				   ~0, // invalid fib index
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
     dpo1 = fib_entry_contribute_ip_forwarding(fei);
     ai = fib_entry_get_adj(fei);
@@ -2198,7 +2270,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index, // same as route
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fib_table_entry_path_add(fib_index,
 			     &bgp_102,
@@ -2209,7 +2281,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index, // same as route's FIB
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &bgp_102);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "100.100.100.102/32 presnet");
@@ -2298,7 +2370,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index, // Same as route's FIB
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     /*
@@ -2345,7 +2417,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     /*
@@ -2459,7 +2531,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fib_table_entry_path_add(fib_index,
 			     &pfx_5_5_5_6_s_32,
@@ -2470,7 +2542,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fib_table_entry_path_add(fib_index,
 			     &pfx_5_5_5_7_s_32,
@@ -2481,7 +2553,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     /*
      * +3 entries, +3 shared path-list
@@ -2520,7 +2592,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
 
@@ -2579,7 +2651,7 @@ fib_test_v4 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
@@ -2621,7 +2693,7 @@ fib_test_v4 (void)
 				    ~0, // no index provided.
 				    fib_index,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
@@ -2696,7 +2768,7 @@ fib_test_v4 (void)
 			     ~0, // no index provided.
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
     FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
@@ -2744,7 +2816,7 @@ fib_test_v4 (void)
 				   ~0, // recursive
 				   fib_index,
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
     dpo = fib_entry_contribute_ip_forwarding(fei);
     FIB_TEST(load_balance_is_drop(dpo),
@@ -2774,7 +2846,7 @@ fib_test_v4 (void)
 			     ~0,
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
 
     fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32);
@@ -2804,7 +2876,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28);
     ai = fib_entry_get_adj(fei);
@@ -2839,7 +2911,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)),
 	     "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1");
@@ -2863,7 +2935,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     fib_table_entry_path_add(fib_index,
@@ -2875,7 +2947,7 @@ fib_test_v4 (void)
 			     ~0,
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
 
     fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
@@ -2960,7 +3032,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket_i(lb, 0)),
@@ -2987,7 +3059,7 @@ fib_test_v4 (void)
 			     ~0,
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
 
     fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
@@ -3055,7 +3127,7 @@ fib_test_v4 (void)
                              tm->hw[0]->sw_if_index,
                              ~0,
                              1,
-                             MPLS_LABEL_INVALID,
+                             NULL,
                              FIB_ROUTE_PATH_FLAG_NONE);
 
     fib_table_entry_path_remove(fib_index,
@@ -3133,7 +3205,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fib_table_entry_path_add(fib_index,
 			     &pfx_4_4_4_4_s_32,
@@ -3144,7 +3216,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fib_table_entry_path_add(fib_index,
 			     &pfx_4_4_4_4_s_32,
@@ -3155,7 +3227,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     FIB_TEST(FIB_NODE_INDEX_INVALID !=
 	     fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
@@ -3240,7 +3312,7 @@ fib_test_v4 (void)
 			     ~0,
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32);
@@ -3300,7 +3372,7 @@ fib_test_v4 (void)
                                    ~0,
                                    fib_index,
                                    1,
-                                   MPLS_LABEL_INVALID,
+                                   NULL,
                                    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_entry_path_add(fib_index,
                                    &pfx_34_1_1_1_s_32,
@@ -3311,7 +3383,7 @@ fib_test_v4 (void)
                                    ~0,
                                    fib_index,
                                    1,
-                                   MPLS_LABEL_INVALID,
+                                   NULL,
                                    FIB_ROUTE_PATH_FLAG_NONE);
     FIB_TEST_REC_FORW(&pfx_34_1_1_1_s_32, &pfx_34_34_1_1_s_32, 0);
     fib_table_entry_delete_index(fei, FIB_SOURCE_API);
@@ -3389,7 +3461,7 @@ fib_test_v4 (void)
 			     tm->hw[0]->sw_if_index,
 			     fib_index,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup_exact_match(fib_index, &pfx_4_1_1_1_s_32);
@@ -3443,7 +3515,7 @@ fib_test_v4 (void)
 				   tm->hw[0]->sw_if_index,
 				   fib_index,
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup_exact_match(0, &pfx_2001_s_64);
@@ -3684,7 +3756,7 @@ fib_test_v6 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
 
@@ -3715,7 +3787,7 @@ fib_test_v6 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &local_pfx);
 
@@ -3760,7 +3832,7 @@ fib_test_v6 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_0_0);
 
@@ -3881,7 +3953,7 @@ fib_test_v6 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_2001_1_2_s_128);
@@ -3920,7 +3992,7 @@ fib_test_v6 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_2001_1_3_s_128);
@@ -3974,7 +4046,7 @@ fib_test_v6 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_2001_a_s_64);
     ai = fib_entry_get_adj(fei);
@@ -3988,7 +4060,7 @@ fib_test_v6 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &pfx_2001_b_s_64);
     ai = fib_entry_get_adj(fei);
@@ -4023,7 +4095,7 @@ fib_test_v6 (void)
 				   tm->hw[0]->sw_if_index,
 				   ~0,
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
     FIB_TEST(fei == fib_table_lookup_exact_match(0, &pfx_1_1_1_1_s_32),
 	     "1.1.1.1/32 o v6 route present");
@@ -4061,7 +4133,7 @@ fib_test_v6 (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0,
 			     1,
-			     MPLS_LABEL_INVALID,
+			     NULL,
 			     FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_c_s_64);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached route present");
@@ -4163,7 +4235,7 @@ fib_test_v6 (void)
 				    tm->hw[1]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &connected_pfx);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
@@ -4182,7 +4254,7 @@ fib_test_v6 (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup(fib_index, &connected_pfx);
 
@@ -4462,429 +4534,6 @@ fib_test_v6 (void)
 }
 
 /*
- * Test the recursive route route handling for GRE tunnels
- */
-static void
-fib_test_gre (void)
-{
-    /* fib_node_index_t fei; */
-    /* u32 fib_index = 0; */
-    /* test_main_t *tm; */
-    /* u32 ii; */
-
-    /* tm = &test_main; */
-
-    /* for (ii = 0; ii < 4; ii++) */
-    /* { */
-    /* 	ip4_main.fib_index_by_sw_if_index[tm->hw[ii]->sw_if_index] = 0; */
-    /* } */
-
-    /* /\* */
-    /*  * add interface routes. We'll assume this works. It's more rigorously */
-    /*  * tested elsewhere. */
-    /*  *\/ */
-    /* fib_prefix_t local_pfx = { */
-    /* 	.fp_len = 24, */
-    /* 	.fp_proto = FIB_PROTOCOL_IP4, */
-    /* 	.fp_addr = { */
-    /* 	    .ip4 = { */
-    /* 		/\* 10.10.10.10 *\/ */
-    /* 		.as_u32 = clib_host_to_net_u32(0x0a0a0a0a), */
-    /* 	    }, */
-    /* 	}, */
-    /* }; */
-
-    /* fib_table_entry_update_one_path(fib_index, &local_pfx, */
-    /* 				    FIB_SOURCE_INTERFACE, */
-    /* 				    (FIB_ENTRY_FLAG_CONNECTED | */
-    /* 				     FIB_ENTRY_FLAG_ATTACHED), */
-    /* 				    NULL, */
-    /* 				    tm->hw[0]->sw_if_index, */
-    /* 				    ~0, */
-    /* 				    1, */
-    /* 				    FIB_ROUTE_PATH_FLAG_NONE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */
-    /* 	     "attached interface route present"); */
-
-    /* local_pfx.fp_len = 32; */
-    /* fib_table_entry_update_one_path(fib_index, &local_pfx, */
-    /* 				    FIB_SOURCE_INTERFACE, */
-    /* 				    (FIB_ENTRY_FLAG_CONNECTED | */
-    /* 				     FIB_ENTRY_FLAG_LOCAL), */
-    /* 				    NULL, */
-    /* 				    tm->hw[0]->sw_if_index, */
-    /* 				    ~0, // invalid fib index */
-    /* 				    1, */
-    /* 				    FIB_ROUTE_PATH_FLAG_NONE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */
-
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */
-    /* 	     "local interface route present"); */
-
-    /* fib_prefix_t local2_pfx = { */
-    /* 	.fp_len = 24, */
-    /* 	.fp_proto = FIB_PROTOCOL_IP4, */
-    /* 	.fp_addr = { */
-    /* 	    .ip4 = { */
-    /* 		/\* 10.10.11.11 *\/ */
-    /* 		.as_u32 = clib_host_to_net_u32(0x0a0a0b0b), */
-    /* 	    }, */
-    /* 	}, */
-    /* }; */
-
-    /* fib_table_entry_update_one_path(fib_index, &local2_pfx, */
-    /* 				    FIB_SOURCE_INTERFACE, */
-    /* 				    (FIB_ENTRY_FLAG_CONNECTED | */
-    /* 				     FIB_ENTRY_FLAG_ATTACHED), */
-    /* 				    NULL, */
-    /* 				    tm->hw[1]->sw_if_index, */
-    /* 				    ~0, */
-    /* 				    1, */
-    /* 				    FIB_ROUTE_PATH_FLAG_NONE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */
-    /* 	     "attached interface route present"); */
-
-    /* local2_pfx.fp_len = 32; */
-    /* fib_table_entry_update_one_path(fib_index, &local2_pfx, */
-    /* 				    FIB_SOURCE_INTERFACE, */
-    /* 				    (FIB_ENTRY_FLAG_CONNECTED | */
-    /* 				     FIB_ENTRY_FLAG_LOCAL), */
-    /* 				    NULL, */
-    /* 				    tm->hw[0]->sw_if_index, */
-    /* 				    ~0, // invalid fib index */
-    /* 				    1, */
-    /* 				    FIB_ROUTE_PATH_FLAG_NONE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */
-
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */
-    /* 	     "local interface route present"); */
-
-    /* /\* */
-    /*  * Add the route that will be used to resolve the tunnel's destination */
-    /*  *\/ */
-    /* fib_prefix_t route_pfx = { */
-    /* 	.fp_len = 24, */
-    /* 	.fp_proto = FIB_PROTOCOL_IP4, */
-    /* 	.fp_addr = { */
-    /* 	    .ip4 = { */
-    /* 		/\* 1.1.1.0/24 *\/ */
-    /* 		.as_u32 = clib_host_to_net_u32(0x01010100), */
-    /* 	    }, */
-    /* 	}, */
-    /* }; */
-    /* /\* 10.10.10.2 *\/ */
-    /* ip46_address_t nh_10_10_10_2 = { */
-    /* 	.ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02), */
-    /* }; */
-
-    /* fib_table_entry_path_add(fib_index, &route_pfx, */
-    /* 			     FIB_SOURCE_API, */
-    /* 			     FIB_ENTRY_FLAG_NONE, */
-    /* 			     &nh_10_10_10_2, */
-    /* 			     tm->hw[0]->sw_if_index, */
-    /* 			     ~0, */
-    /* 			     1, */
-    /* 			     FIB_ROUTE_PATH_FLAG_NONE); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID != */
-    /* 	      fib_table_lookup_exact_match(fib_index, &local_pfx)), */
-    /* 	     "route present"); */
-
-    /* /\* */
-    /*  * Add a tunnel */
-    /*  *\/ */
-    /* /\* 1.1.1.1 *\/ */
-    /* fib_prefix_t tun_dst_pfx = { */
-    /* 	.fp_len = 32, */
-    /* 	.fp_proto = FIB_PROTOCOL_IP4, */
-    /* 	.fp_addr = { */
-    /* 	    .ip4.as_u32 = clib_host_to_net_u32(0x01010101), */
-    /* 	}, */
-    /* }; */
-    /* /\* 10.10.10.10 *\/ */
-    /* ip4_address_t tun_src = { */
-    /* 	.as_u32 = clib_host_to_net_u32(0x0a0a0a0a), */
-    /* }; */
-    /* /\* 172.16.0.1 *\/ */
-    /* ip4_address_t tun_itf = { */
-    /* 	.as_u32 = clib_host_to_net_u32(0xac100001), */
-    /* }; */
-    /* fib_prefix_t tun_itf_pfx = { */
-    /* 	.fp_len = 30, */
-    /* 	.fp_proto = FIB_PROTOCOL_IP4, */
-    /* 	.fp_addr = { */
-    /* 	    .ip4 = tun_itf, */
-    /* 	}, */
-    /* }; */
-    /* u32 *encap_labels = NULL; */
-    /* u32 label = 0xbaba; */
-    /* u32 encap_index; */
-    /* u32 tunnel_sw_if_index; */
-    
-    /* int rv; */
-
-    /* /\* */
-    /*  * First we need the MPLS Encap present */
-    /*  * */
-    /*  * Pretty sure this is broken. the wiki say the 1st aparamter address */
-    /*  * should be the tunnel's interface address, which makes some sense. But */
-    /*  * the code for tunnel creation checks for the tunnel's destination */
-    /*  * address. curious... */
-    /*  *\/ */
-    /* vec_add1(encap_labels, label);  */
-    /* rv =  vnet_mpls_add_del_encap(&tun_dst_pfx.fp_addr.ip4,  */
-    /* 				  0, // inner VRF */
-    /* 				  encap_labels, */
-    /* 				  ~0, // policy_tunnel_index, */
-    /* 				  0, // no_dst_hash, */
-    /* 				  &encap_index, */
-    /* 				  1); // ADD */
-    /* FIB_TEST((0 == rv), "MPLS encap created"); */
-
-    /* /\* */
-    /*  * now create the tunnel */
-    /*  *\/ */
-    /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */
-    /* 				      &tun_dst_pfx.fp_addr.ip4, */
-    /* 				      &tun_itf_pfx.fp_addr.ip4, */
-    /* 				      tun_itf_pfx.fp_len, */
-    /* 				      0, // inner VRF */
-    /* 				      0, // outer VRF */
-    /* 				      &tunnel_sw_if_index, */
-    /*                                   0, // l2 only */
-    /* 				      1);  // ADD */
-    /* FIB_TEST((0 == rv), "Tunnel created"); */
-
-    /* /\* */
-    /*  * add it again. just for giggles. */
-    /*  *\/ */
-    /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */
-    /* 				      &tun_dst_pfx.fp_addr.ip4, */
-    /* 				      &tun_itf_pfx.fp_addr.ip4, */
-    /* 				      tun_itf_pfx.fp_len, */
-    /* 				      0, // inner VRF */
-    /* 				      0, // outer VRF */
-    /* 				      &tunnel_sw_if_index, */
-    /*                                   0, // l2 only */
-    /* 				      1);  // ADD */
-    /* FIB_TEST((0 != rv), "Duplicate Tunnel not created"); */
-
-    /* /\* */
-    /*  * Find the route added for the tunnel subnet and check that */
-    /*  * it has a midchin adj that is stacked on the adj used to reach the */
-    /*  * tunnel destination */
-    /*  *\/ */
-    /* ip_adjacency_t *midchain_adj, *route_adj, *adjfib_adj; */
-    /* adj_index_t midchain_ai, route_ai, adjfib_ai1, adjfib_ai2; */
-    /* ip_lookup_main_t *lm; */
-
-    /* lm = &ip4_main.lookup_main; */
-
-    /* fei = fib_table_lookup_exact_match(fib_index, &tun_itf_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "tun itf route present"); */
-    /* midchain_ai  = fib_entry_contribute_forwarding(fei); */
-    /* midchain_adj = adj_get(midchain_ai); */
-
-    /* FIB_TEST((IP_LOOKUP_NEXT_MIDCHAIN == midchain_adj->lookup_next_index), */
-    /* 	     "Tunnel interface links to midchain"); */
-
-    /* fei = fib_table_lookup_exact_match(fib_index, &route_pfx); */
-    /* route_ai = fib_entry_contribute_forwarding(fei); */
-    /* FIB_TEST((midchain_adj->sub_type.midchain.adj_index == route_ai), */
-    /* 	     "tunnel midchain it stacked on route adj"); */
-
-    /* /\* */
-    /*  * update the route to the tunnel's destination to load-balance via */
-    /*  * interface 1. */
-    /*  *\/ */
-    /* /\* 10.10.11.2 *\/ */
-    /* ip46_address_t nh_10_10_11_2 = {        */
-    /* 	.ip4.as_u32 = clib_host_to_net_u32(0x0a0a0b02), */
-    /* }; */
-
-    /* fib_table_entry_path_add(fib_index, &route_pfx, */
-    /* 			     FIB_SOURCE_API, */
-    /* 			     FIB_ENTRY_FLAG_NONE, */
-    /* 			     &nh_10_10_11_2, */
-    /* 			     tm->hw[1]->sw_if_index, */
-    /* 			     ~0, */
-    /* 			     1, */
-    /* 			     FIB_ROUTE_PATH_FLAG_NONE); */
-
-    /* /\* */
-    /*  * the tunnels midchain should have re-stacked. This tests that the */
-    /*  * route re-resolution backwalk works to a tunnel interface. */
-    /*  *\/ */
-    /* fei = fib_table_lookup_exact_match(fib_index, &route_pfx); */
-    /* FIB_TEST((route_ai != fib_entry_contribute_forwarding(fei)), "route changed"); */
-    /* route_ai = fib_entry_contribute_forwarding(fei); */
-
-    /* midchain_adj = adj_get(midchain_ai); */
-
-    /* FIB_TEST((midchain_adj->sub_type.midchain.adj_index == route_ai), */
-    /* 	     "tunnel midchain has re-stacked on route adj"); */
-
-    /* route_adj = adj_get(route_ai); */
-
-    /* FIB_TEST((2 == route_adj->n_adj), "Route adj is multipath"); */
-
-    /* /\* */
-    /*  * At this stage both nieghbour adjs are incomplete, so the same should */
-    /*  * be true of the multipath adj */
-    /*  *\/ */
-    /* FIB_TEST((IP_LOOKUP_NEXT_ARP == route_adj->lookup_next_index), */
-    /* 	     "Adj0 is ARP: %d", route_adj->lookup_next_index); */
-    /* FIB_TEST((IP_LOOKUP_NEXT_ARP == (route_adj+1)->lookup_next_index), */
-    /* 	     "Adj1 is ARP"); */
-
-    /* /\* */
-    /*  * do the equivalent of creating an ARP entry for 10.10.10.2. */
-    /*  *  This will complete the adj, and this */
-    /*  * change should be refelct in the multipath too. */
-    /*  *\/ */
-    /* u8* rewrite = NULL, byte = 0xd; */
-    /* vec_add(rewrite, &byte, 6); */
-
-    /* adjfib_ai1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, */
-    /* 				    VNET_LINK_IP4, */
-    /* 				    &nh_10_10_10_2, */
-    /* 				    tm->hw[0]->sw_if_index); */
-    /* adj_nbr_update_rewrite(FIB_PROTOCOL_IP4, */
-    /* 			   adjfib_ai1, */
-    /* 			   rewrite); */
-    /* adjfib_adj = adj_get(adjfib_ai1); */
-    /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adjfib_adj->lookup_next_index), */
-    /* 	     "Adj-fib10 adj is rewrite"); */
-
-    /* adjfib_ai2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, */
-    /* 				    VNET_LINK_IP4, */
-    /* 				    &nh_10_10_11_2, */
-    /* 				    tm->hw[1]->sw_if_index); */
-    /* adj_nbr_update_rewrite(FIB_PROTOCOL_IP4, */
-    /* 			   adjfib_ai2, */
-    /* 			   rewrite); */
-
-    /* adjfib_adj = adj_get(adjfib_ai2); */
-
-    /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adjfib_adj->lookup_next_index), */
-    /* 	     "Adj-fib11 adj is rewrite"); */
-
-    /* fei = fib_table_lookup_exact_match(fib_index, &route_pfx); */
-    /* FIB_TEST((route_ai != fib_entry_contribute_forwarding(fei)), "route changed"); */
-    /* route_ai = fib_entry_contribute_forwarding(fei); */
-    /* route_adj = adj_get(route_ai); */
-    /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == route_adj->lookup_next_index), */
-    /* 	     "Adj0 is rewrite"); */
-    /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == (route_adj+1)->lookup_next_index), */
-    /* 	     "Adj1 is rewrite"); */
-
-    /* /\* */
-    /*  * CLEANUP */
-    /*  *\/ */
-    /* adj_index_t drop_ai = adj_get_special(FIB_PROTOCOL_IP4, */
-    /* 					  ADJ_SPECIAL_TYPE_DROP); */
-
-    /* /\* */
-    /*  * remove the route that the tunnel resovles via. expect */
-    /*  * it to now resolve via the default route, which is drop */
-    /*  *\/ */
-    /* fib_table_entry_path_remove(fib_index, &route_pfx, */
-    /* 				FIB_SOURCE_API, */
-    /* 				&nh_10_10_10_2, */
-    /* 				tm->hw[0]->sw_if_index, */
-    /* 				~0, */
-    /* 				1, */
-    /* 				FIB_ROUTE_PATH_FLAG_NONE); */
-    /* fib_table_entry_path_remove(fib_index, &route_pfx, */
-    /* 				FIB_SOURCE_API, */
-    /* 				&nh_10_10_11_2, */
-    /* 				tm->hw[1]->sw_if_index, */
-    /* 				~0, */
-    /* 				1, */
-    /* 				FIB_ROUTE_PATH_FLAG_NONE); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID != */
-    /* 	      fib_table_lookup_exact_match(fib_index, &local_pfx)), */
-    /* 	     "route present"); */
-    /* midchain_adj = adj_get(midchain_ai); */
-    /* FIB_TEST((midchain_adj->sub_type.midchain.adj_index == drop_ai), */
-    /* 	     "tunnel midchain has re-stacked on drop"); */
-
-    /* /\* */
-    /*  * remove the tunnel and its MPLS encaps */
-    /*  *\/ */
-    /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */
-    /* 				      &tun_dst_pfx.fp_addr.ip4, */
-    /* 				      &tun_itf_pfx.fp_addr.ip4, */
-    /* 				      tun_itf_pfx.fp_len, */
-    /* 				      0, // inner VRF */
-    /* 				      0, // outer VRF */
-    /* 				      &tunnel_sw_if_index, */
-    /*                                   0, // l2 only */
-    /* 				      0);  // DEL */
-    /* FIB_TEST((0 == rv), "Tunnel removed"); */
-    /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */
-    /* 				      &tun_dst_pfx.fp_addr.ip4, */
-    /* 				      &tun_itf_pfx.fp_addr.ip4, */
-    /* 				      tun_itf_pfx.fp_len, */
-    /* 				      0, // inner VRF */
-    /* 				      0, // outer VRF */
-    /* 				      &tunnel_sw_if_index, */
-    /*                                   0, // l2 only */
-    /* 				      0);  // DEL */
-    /* FIB_TEST((0 != rv), "No existant Tunnel not removed"); */
-
-    /* rv =  vnet_mpls_add_del_encap(&tun_dst_pfx.fp_addr.ip4,  */
-    /* 				  0, // inner VRF */
-    /* 				  encap_labels, */
-    /* 				  ~0, // policy_tunnel_index, */
-    /* 				  0, // no_dst_hash, */
-    /* 				  NULL, */
-    /* 				  0); // ADD */
-    /* FIB_TEST((0 == rv), "MPLS encap deleted"); */
-
-    /* vec_free(encap_labels); */
-
-    /* /\* */
-    /*  * no more FIB entries expected */
-    /*  *\/ */
-    /* fei = fib_table_lookup_exact_match(fib_index, &tun_itf_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "tun itf route removed"); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &tun_dst_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "tun dst route removed"); */
-
-    /* /\* */
-    /*  * CLEANUP the connecteds */
-    /*  *\/ */
-    /* local2_pfx.fp_len = 24; */
-    /* fib_table_entry_delete(fib_index, &local2_pfx, */
-    /* 			   FIB_SOURCE_INTERFACE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */
-    /* 	     "attached interface route remove"); */
-
-    /* local2_pfx.fp_len = 32; */
-    /* fib_table_entry_special_remove(fib_index, &local2_pfx, */
-    /* 				   FIB_SOURCE_INTERFACE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */
-    /* 	     "local interface route removed"); */
-    /* local_pfx.fp_len = 24; */
-    /* fib_table_entry_delete(fib_index, &local_pfx, */
-    /* 				FIB_SOURCE_INTERFACE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */
-    /* 	     "attached interface route remove"); */
-
-    /* local_pfx.fp_len = 32; */
-    /* fib_table_entry_special_remove(fib_index, &local_pfx, */
-    /* 				   FIB_SOURCE_INTERFACE); */
-    /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */
-    /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */
-    /* 	     "local interface route removed"); */
-}
-
-/*
  * Test Attached Exports
  */
 static void
@@ -4931,7 +4580,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
@@ -4947,7 +4596,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
 
@@ -4976,7 +4625,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_10_10_10_1_s_32);
@@ -5003,7 +4652,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created");
@@ -5045,7 +4694,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 present");
@@ -5076,7 +4725,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created");
@@ -5113,7 +4762,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 present");
@@ -5185,7 +4834,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
     FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB1");
@@ -5208,7 +4857,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported in FIB1");
@@ -5240,7 +4889,7 @@ fib_test_ae (void)
                                           tm->hw[0]->sw_if_index,
                                           ~0, // invalid fib index
                                           1,
-                                          MPLS_LABEL_INVALID,
+                                          NULL,
                                           FIB_ROUTE_PATH_FLAG_NONE);
     dpo = fib_entry_contribute_ip_forwarding(fei);
 
@@ -5296,7 +4945,7 @@ fib_test_ae (void)
                                           tm->hw[0]->sw_if_index,
                                           ~0, // invalid fib index
                                           1,
-                                          MPLS_LABEL_INVALID,
+                                          NULL,
                                           FIB_ROUTE_PATH_FLAG_NONE);
     dpo = fib_entry_contribute_ip_forwarding(fei);
 
@@ -5332,7 +4981,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
@@ -5371,7 +5020,7 @@ fib_test_ae (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
@@ -5430,6 +5079,7 @@ fib_test_ae (void)
 	     adj_nbr_db_size());
 }
 
+
 /*
  * Test the recursive route route handling for GRE tunnels
  */
@@ -5440,7 +5090,7 @@ fib_test_label (void)
     const u32 fib_index = 0;
     test_main_t *tm;
     ip4_main_t *im;
-    int lb_count;
+    int lb_count, ii;
 
     lb_count = pool_elts(load_balance_pool);
     tm = &test_main;
@@ -5476,7 +5126,7 @@ fib_test_label (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &local0_pfx);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
@@ -5492,7 +5142,7 @@ fib_test_label (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &local0_pfx);
 
@@ -5522,7 +5172,7 @@ fib_test_label (void)
 				    tm->hw[1]->sw_if_index,
 				    ~0,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &local1_pfx);
     FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
@@ -5538,7 +5188,7 @@ fib_test_label (void)
 				    tm->hw[1]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
     fei = fib_table_lookup_exact_match(fib_index, &local1_pfx);
 
@@ -5608,6 +5258,9 @@ fib_test_label (void)
 	    .eos = MPLS_NON_EOS,
 	},
     };
+    mpls_label_t *l99 = NULL;
+    vec_add1(l99, 99);
+
     fib_table_entry_update_one_path(fib_index,
 				    &pfx_1_1_1_1_s_32,
 				    FIB_SOURCE_API,
@@ -5617,7 +5270,7 @@ fib_test_label (void)
 				    tm->hw[0]->sw_if_index,
 				    ~0, // invalid fib index
 				    1,
-				    99,
+				    l99,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
@@ -5644,6 +5297,8 @@ fib_test_label (void)
 	    .adj = ai_mpls_10_10_11_1,
 	},
     };
+    mpls_label_t *l_imp_null = NULL;
+    vec_add1(l_imp_null, MPLS_IETF_IMPLICIT_NULL_LABEL);
 
     fei = fib_table_entry_path_add(fib_index,
 				   &pfx_1_1_1_1_s_32,
@@ -5654,7 +5309,7 @@ fib_test_label (void)
 				   tm->hw[1]->sw_if_index,
 				   ~0, // invalid fib index
 				   1,
-				   MPLS_IETF_IMPLICIT_NULL_LABEL,
+				   l_imp_null,
 				   FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST(fib_test_validate_entry(fei, 
@@ -5732,7 +5387,7 @@ fib_test_label (void)
 				   tm->hw[1]->sw_if_index,
 				   ~0, // invalid fib index
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST(fib_test_validate_entry(fei, 
@@ -5800,6 +5455,8 @@ fib_test_label (void)
 	    .eos = MPLS_EOS,
 	},
     };
+    mpls_label_t *l1600 = NULL;
+    vec_add1(l1600, 1600);
 
     fib_table_entry_update_one_path(fib_index,
 				    &pfx_2_2_2_2_s_32,
@@ -5810,7 +5467,7 @@ fib_test_label (void)
 				    ~0,
 				    fib_index,
 				    1,
-				    1600,
+				    l1600,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
@@ -6063,6 +5720,9 @@ fib_test_label (void)
     /*
      * add back the path with the valid label
      */
+    l99 = NULL;
+    vec_add1(l99, 99);
+
     fib_table_entry_path_add(fib_index,
 			     &pfx_1_1_1_1_s_32,
 			     FIB_SOURCE_API,
@@ -6072,7 +5732,7 @@ fib_test_label (void)
 			     tm->hw[0]->sw_if_index,
 			     ~0, // invalid fib index
 			     1,
-			     99,
+			     l99,
 			     FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
@@ -6191,6 +5851,8 @@ fib_test_label (void)
 	    .eos = MPLS_EOS,
 	},
     };
+    mpls_label_t *l101 = NULL;
+    vec_add1(l101, 101);
 
     fei = fib_table_entry_update_one_path(fib_index,
 					  &pfx_1_1_1_2_s_32,
@@ -6201,7 +5863,7 @@ fib_test_label (void)
 					  tm->hw[0]->sw_if_index,
 					  ~0, // invalid fib index
 					  1,
-					  101,
+					  l101,
 					  FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST(fib_test_validate_entry(fei,
@@ -6229,6 +5891,9 @@ fib_test_label (void)
     	    .eos = MPLS_EOS,
     	},
     };
+    mpls_label_t *l1601 = NULL;
+    vec_add1(l1601, 1601);
+
     l1600_eos_o_1_1_1_1.label_o_lb.lb = non_eos_1_1_1_1.dpoi_index;
 
     fei = fib_table_entry_path_add(fib_index,
@@ -6240,7 +5905,7 @@ fib_test_label (void)
 				   ~0,
 				   fib_index,
 				   1,
-				   1601,
+				   l1601,
 				   FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST(fib_test_validate_entry(fei, 
@@ -6256,6 +5921,9 @@ fib_test_label (void)
      * update the via-entry so it no longer has an imp-null path.
      * the LB for the recursive can use an imp-null
      */
+    l_imp_null = NULL;
+    vec_add1(l_imp_null, MPLS_IETF_IMPLICIT_NULL_LABEL);
+
     fei = fib_table_entry_update_one_path(fib_index,
 					  &pfx_1_1_1_2_s_32,
 					  FIB_SOURCE_API,
@@ -6265,7 +5933,7 @@ fib_test_label (void)
 					  tm->hw[1]->sw_if_index,
 					  ~0, // invalid fib index
 					  1,
-					  MPLS_IETF_IMPLICIT_NULL_LABEL,
+					  l_imp_null,
 					  FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST(fib_test_validate_entry(fei,
@@ -6298,7 +5966,7 @@ fib_test_label (void)
 					  tm->hw[1]->sw_if_index,
 					  ~0, // invalid fib index
 					  1,
-					  MPLS_LABEL_INVALID,
+					  NULL,
 					  FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST(fib_test_validate_entry(fei,
@@ -6340,7 +6008,7 @@ fib_test_label (void)
 				    ~0,
 				    fib_index,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fib_entry_contribute_forwarding(fib_table_lookup(fib_index,
@@ -6384,7 +6052,7 @@ fib_test_label (void)
 				    ~0,
 				    fib_index,
 				    1,
-				    MPLS_LABEL_INVALID,
+				    NULL,
 				    FIB_ROUTE_PATH_FLAG_NONE);
 
     fei = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32);
@@ -6398,6 +6066,54 @@ fib_test_label (void)
     dpo_reset(&ip_1_1_1_1);
 
     /*
+     * Create an entry with a deep label stack
+     */
+    fib_prefix_t pfx_2_2_5_5_s_32 = {
+	.fp_len = 32,
+	.fp_proto = FIB_PROTOCOL_IP4,
+	.fp_addr = {
+	    .ip4.as_u32 = clib_host_to_net_u32(0x02020505),
+	},
+    };
+    fib_test_lb_bucket_t ls_eos_o_10_10_10_1 = {
+	.type = FT_LB_LABEL_STACK_O_ADJ,
+	.label_stack_o_adj = {
+	    .adj = ai_mpls_10_10_11_1,
+	    .label_stack_size = 8,
+	    .label_stack = {
+		200, 201, 202, 203, 204, 205, 206, 207
+	    },
+	    .eos = MPLS_EOS,
+	},
+    };
+    mpls_label_t *label_stack = NULL;
+    vec_validate(label_stack, 7);
+    for (ii = 0; ii < 8; ii++)
+    {
+	label_stack[ii] = ii + 200;
+    }
+
+    fei = fib_table_entry_update_one_path(fib_index,
+					  &pfx_2_2_5_5_s_32,
+					  FIB_SOURCE_API,
+					  FIB_ENTRY_FLAG_NONE,
+					  FIB_PROTOCOL_IP4,
+					  &nh_10_10_11_1,
+					  tm->hw[1]->sw_if_index,
+					  ~0, // invalid fib index
+					  1,
+					  label_stack,
+					  FIB_ROUTE_PATH_FLAG_NONE);
+
+    FIB_TEST(fib_test_validate_entry(fei,
+				     FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+				     1,
+				     &ls_eos_o_10_10_10_1),
+	     "2.2.5.5/32 LB 1 buckets via: "
+	     "adj 10.10.11.1");
+    fib_table_entry_delete_index(fei, FIB_SOURCE_API);
+
+    /*
      * cleanup
      */
     fib_table_entry_delete(fib_index,
@@ -6950,6 +6666,7 @@ lfib_test_deagg (void)
     lookup_dpo_t *lkd;
     test_main_t *tm;
     int lb_count;
+    adj_index_t ai_mpls_10_10_10_1;
 
     tm = &test_main;
     lb_count = pool_elts(load_balance_pool);
@@ -6964,6 +6681,14 @@ lfib_test_deagg (void)
                                      tm->hw[0]->sw_if_index,
                                      1);
 
+    ip46_address_t nh_10_10_10_1 = {
+	.ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
+    };
+    ai_mpls_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
+                                             VNET_LINK_MPLS,
+                                             &nh_10_10_10_1,
+                                             tm->hw[0]->sw_if_index);
+
     /*
      * Test the specials stack properly.
      */
@@ -7023,7 +6748,7 @@ lfib_test_deagg (void)
 				   ~0,
 				   fib_index,
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)),
@@ -7074,7 +6799,7 @@ lfib_test_deagg (void)
 				   ~0,
 				   lfib_index,
 				   1,
-				   MPLS_LABEL_INVALID,
+				   NULL,
 				   FIB_ROUTE_PATH_FLAG_NONE);
 
     FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)),
@@ -7113,30 +6838,192 @@ lfib_test_deagg (void)
               format_mpls_unicast_label, deag_label,
               format_mpls_eos_bit, MPLS_EOS);
 
+    dpo_reset(&dpo);
 
-    mpls_sw_interface_enable_disable(&mpls_main,
-                                     tm->hw[0]->sw_if_index,
-                                     0);
+    /*
+     * An MPLS x-connect
+     */
+    fib_prefix_t pfx_1200 = {
+	.fp_len = 21,
+	.fp_proto = FIB_PROTOCOL_MPLS,
+	.fp_label = 1200,
+	.fp_eos = MPLS_NON_EOS,
+    };
+    fib_test_lb_bucket_t neos_o_10_10_10_1 = {
+	.type = FT_LB_LABEL_STACK_O_ADJ,
+	.label_stack_o_adj = {
+	    .adj = ai_mpls_10_10_10_1,
+	    .label_stack_size = 4,
+	    .label_stack = {
+		200, 300, 400, 500,
+	    },
+	    .eos = MPLS_NON_EOS,
+	},
+    };
+    dpo_id_t neos_1200 = DPO_INVALID;
+    dpo_id_t ip_1200 = DPO_INVALID;
+    mpls_label_t *l200 = NULL;
+    vec_add1(l200, 200);
+    vec_add1(l200, 300);
+    vec_add1(l200, 400);
+    vec_add1(l200, 500);
+
+    lfe = fib_table_entry_update_one_path(fib_index,
+					  &pfx_1200,
+					  FIB_SOURCE_API,
+					  FIB_ENTRY_FLAG_NONE,
+					  FIB_PROTOCOL_IP4,
+					  &nh_10_10_10_1,
+					  tm->hw[0]->sw_if_index,
+					  ~0, // invalid fib index
+					  1,
+					  l200,
+					  FIB_ROUTE_PATH_FLAG_NONE);
+
+    FIB_TEST(fib_test_validate_entry(lfe,
+				     FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
+				     1,
+				     &neos_o_10_10_10_1),
+	     "1200/0 LB 1 buckets via: "
+	     "adj 10.10.11.1");
 
-    dpo_reset(&dpo);
     /*
-     * +1 for the drop LB in the MPLS tables.
+     * A recursive route via the MPLS x-connect
      */
-    FIB_TEST(lb_count+1 == pool_elts(load_balance_pool),
-	     "Load-balance resources freed %d of %d",
-             lb_count+1, pool_elts(load_balance_pool));
-}
+    fib_prefix_t pfx_2_2_2_3_s_32 = {
+    	.fp_len = 32,
+    	.fp_proto = FIB_PROTOCOL_IP4,
+    	.fp_addr = {
+    	    .ip4.as_u32 = clib_host_to_net_u32(0x02020203),
+    	},
+    };
+    fib_route_path_t *rpaths = NULL, rpath = {
+    	.frp_proto = FIB_PROTOCOL_MPLS,
+    	.frp_local_label = 1200,
+    	.frp_sw_if_index = ~0, // recurive
+    	.frp_fib_index = 0, // Default MPLS fib
+    	.frp_weight = 1,
+    	.frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
+    	.frp_label_stack = NULL,
+    };
+    vec_add1(rpaths, rpath);
 
-static clib_error_t *
-lfib_test (vlib_main_t * vm, 
-           unformat_input_t * input,
-           vlib_cli_command_t * cmd_arg)
-{
-    fib_test_mk_intf(4);
+    fib_table_entry_path_add2(fib_index,
+    			      &pfx_2_2_2_3_s_32,
+    			      FIB_SOURCE_API,
+    			      FIB_ENTRY_FLAG_NONE,
+    			      rpaths);
 
-    lfib_test_deagg();
+    /*
+     * A labelled recursive route via the MPLS x-connect
+     */
+    fib_prefix_t pfx_2_2_2_4_s_32 = {
+    	.fp_len = 32,
+    	.fp_proto = FIB_PROTOCOL_IP4,
+    	.fp_addr = {
+    	    .ip4.as_u32 = clib_host_to_net_u32(0x02020204),
+    	},
+    };
+    mpls_label_t *l999 = NULL;
+    vec_add1(l999, 999);
+    rpaths[0].frp_label_stack = l999,
+
+    fib_table_entry_path_add2(fib_index,
+    			      &pfx_2_2_2_4_s_32,
+    			      FIB_SOURCE_API,
+    			      FIB_ENTRY_FLAG_NONE,
+    			      rpaths);
+
+    fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
+    				    FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+    				    &ip_1200);
+    fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
+    				    FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
+    				    &neos_1200);
+
+    fib_test_lb_bucket_t ip_o_1200 = {
+    	.type = FT_LB_O_LB,
+    	.lb = {
+    	    .lb = ip_1200.dpoi_index,
+    	},
+    };
+    fib_test_lb_bucket_t mpls_o_1200 = {
+	.type = FT_LB_LABEL_O_LB,
+	.label_o_lb = {
+    	    .lb = neos_1200.dpoi_index,
+	    .label = 999,
+	    .eos = MPLS_EOS,
+	},
+    };
 
-    return (NULL);
+    lfe = fib_table_lookup(fib_index, &pfx_2_2_2_3_s_32);
+    FIB_TEST(fib_test_validate_entry(lfe,
+    				     FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+    				     1,
+    				     &ip_o_1200),
+    	     "2.2.2.2.3/32 LB 1 buckets via: label 1200 EOS");
+    lfe = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32);
+    FIB_TEST(fib_test_validate_entry(lfe,
+    				     FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+    				     1,
+    				     &mpls_o_1200),
+    	     "2.2.2.2.4/32 LB 1 buckets via: label 1200 non-EOS");
+
+    fib_table_entry_delete(fib_index, &pfx_1200, FIB_SOURCE_API);
+    fib_table_entry_delete(fib_index, &pfx_2_2_2_3_s_32, FIB_SOURCE_API);
+    fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API);
+
+    dpo_reset(&neos_1200);
+    dpo_reset(&ip_1200);
+
+    /*
+     * A recursive via a label that does not exist
+     */
+    fib_test_lb_bucket_t bucket_drop = {
+	.type = FT_LB_SPECIAL,
+	.special = {
+	    .adj = DPO_PROTO_MPLS,
+	},
+    };
+
+    rpaths[0].frp_label_stack = NULL;
+    lfe = fib_table_entry_path_add2(fib_index,
+				    &pfx_2_2_2_4_s_32,
+				    FIB_SOURCE_API,
+				    FIB_ENTRY_FLAG_NONE,
+				    rpaths);
+
+    fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
+    				    FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+    				    &ip_1200);
+    ip_o_1200.lb.lb = ip_1200.dpoi_index;
+
+    FIB_TEST(fib_test_validate_entry(lfe,
+    				     FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+    				     1,
+    				     &ip_o_1200),
+    	     "2.2.2.2.4/32 LB 1 buckets via: label 1200 EOS");
+    lfe = fib_table_lookup(fib_index, &pfx_1200);
+    FIB_TEST(fib_test_validate_entry(lfe,
+				     FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
+				     1,
+				     &bucket_drop),
+	     "2.2.2.4/32 LB 1 buckets via: ip4-DROP");
+
+    fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API);
+
+    dpo_reset(&ip_1200);
+
+    /*
+     * cleanup
+     */
+    mpls_sw_interface_enable_disable(&mpls_main,
+                                     tm->hw[0]->sw_if_index,
+                                     0);
+
+    FIB_TEST(lb_count == pool_elts(load_balance_pool),
+	     "Load-balance resources freed %d of %d",
+             lb_count, pool_elts(load_balance_pool));
 }
 
 static clib_error_t *
@@ -7151,10 +7038,6 @@ fib_test (vlib_main_t * vm,
 	fib_test_v4();
 	fib_test_v6();
     }
-    else if (unformat (input, "gre"))
-    {
-	fib_test_gre();
-    }
     else if (unformat (input, "label"))
     {
 	fib_test_label();
@@ -7163,6 +7046,10 @@ fib_test (vlib_main_t * vm,
     {
 	fib_test_ae();
     }
+    else if (unformat (input, "lfib"))
+    {
+	lfib_test_deagg();
+    }
     else if (unformat (input, "walk"))
     {
 	fib_test_walk();
@@ -7177,9 +7064,9 @@ fib_test (vlib_main_t * vm,
          */
 	fib_test_v4();
 	fib_test_v6();
-	fib_test_gre();
 	fib_test_ae();
 	fib_test_label();
+	lfib_test_deagg();
     }
 
     return (NULL);
@@ -7191,12 +7078,6 @@ VLIB_CLI_COMMAND (test_fib_command, static) = {
     .function = fib_test,
 };
 
-VLIB_CLI_COMMAND (test_lfib_command, static) = {
-    .path = "test lfib",
-    .short_help = "mpls label fib unit tests - DO NOT RUN ON A LIVE SYSTEM",
-    .function = lfib_test,
-};
-
 clib_error_t *
 fib_test_init (vlib_main_t *vm)
 {
diff --git a/vnet/vnet/fib/fib_types.c b/vnet/vnet/fib/fib_types.c
index f52de7b8be0..d25a7731c64 100644
--- a/vnet/vnet/fib/fib_types.c
+++ b/vnet/vnet/fib/fib_types.c
@@ -64,6 +64,16 @@ fib_prefix_from_ip46_addr (const ip46_address_t *addr,
     pfx->fp_addr = *addr;
 }
 
+void
+fib_prefix_from_mpls_label (mpls_label_t label,
+			    fib_prefix_t *pfx)
+{
+    pfx->fp_proto = FIB_PROTOCOL_MPLS;
+    pfx->fp_len = 21;
+    pfx->fp_label = label;
+    pfx->fp_eos = MPLS_NON_EOS;
+}
+
 int
 fib_prefix_cmp (const fib_prefix_t *p1,
 		const fib_prefix_t *p2)
@@ -301,11 +311,6 @@ fib_forw_chain_type_to_dpo_proto (fib_forward_chain_type_t fct)
     case FIB_FORW_CHAIN_TYPE_ETHERNET:
 	return (DPO_PROTO_ETHERNET);
     case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
-	/*
-	 * insufficient information to to convert
-	 */
-	ASSERT(0);
-	break;
     case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
 	return (DPO_PROTO_MPLS);
     }
diff --git a/vnet/vnet/fib/fib_types.h b/vnet/vnet/fib/fib_types.h
index 92371e6b8ba..73eb944994b 100644
--- a/vnet/vnet/fib/fib_types.h
+++ b/vnet/vnet/fib/fib_types.h
@@ -292,13 +292,22 @@ typedef struct fib_route_path_t_ {
      * zeros address is ambiguous.
      */
     fib_protocol_t frp_proto;
-    /**
-     * The next-hop address.
-     * Will be NULL for attached paths.
-     * Will be all zeros for attached-next-hop paths on a p2p interface
-     * Will be all zeros for a deag path.
-     */
-    ip46_address_t frp_addr;
+
+    union {
+	/**
+	 * The next-hop address.
+	 * Will be NULL for attached paths.
+	 * Will be all zeros for attached-next-hop paths on a p2p interface
+	 * Will be all zeros for a deag path.
+	 */
+	ip46_address_t frp_addr;
+
+	/**
+	 * The MPLS local Label to reursively resolve through.
+	 * This is valid when the path type is MPLS.
+	 */
+	mpls_label_t frp_local_label;
+    };
     /**
      * The interface.
      * Will be invalid for recursive paths.
@@ -318,9 +327,9 @@ typedef struct fib_route_path_t_ {
      */
     fib_route_path_flags_t frp_flags;
     /**
-     * The outgoing MPLS label. INVALID implies no label.
+     * The outgoing MPLS label Stack. NULL implies no label.
      */
-    mpls_label_t frp_label;
+    mpls_label_t *frp_label_stack;
 } fib_route_path_t;
 
 /**
diff --git a/vnet/vnet/fib/fib_walk.c b/vnet/vnet/fib/fib_walk.c
index e5f9b87f927..e7376bf47a2 100644
--- a/vnet/vnet/fib/fib_walk.c
+++ b/vnet/vnet/fib/fib_walk.c
@@ -619,8 +619,8 @@ fib_walk_async (fib_node_type_t parent_type,
 	 */
 	return;
     }
-    if (0 == fib_node_child_get_n_children(parent_type,
-                                           parent_index))
+    if (0 == fib_node_get_n_children(parent_type,
+                                     parent_index))
     {
         /*
          * no children to walk - quit now
@@ -674,8 +674,8 @@ fib_walk_sync (fib_node_type_t parent_type,
 	 */
 	return;
     }
-    if (0 == fib_node_child_get_n_children(parent_type,
-                                           parent_index))
+    if (0 == fib_node_get_n_children(parent_type,
+                                     parent_index))
     {
         /*
          * no children to walk - quit now
diff --git a/vnet/vnet/fib/mpls_fib.h b/vnet/vnet/fib/mpls_fib.h
index 42c9a865276..93ae4623016 100644
--- a/vnet/vnet/fib/mpls_fib.h
+++ b/vnet/vnet/fib/mpls_fib.h
@@ -96,7 +96,7 @@ mpls_fib_table_get_index_for_sw_if_index (u32 sw_if_index)
 {
     mpls_main_t *mm = &mpls_main;
 
-    ASSERT(vec_len(mm->fib_index_by_sw_if_index) < sw_if_index);
+    ASSERT(vec_len(mm->fib_index_by_sw_if_index) > sw_if_index);
 
     return (mm->fib_index_by_sw_if_index[sw_if_index]);
 }
diff --git a/vnet/vnet/gre/interface.c b/vnet/vnet/gre/interface.c
index 7adc5268446..d624587d8e9 100644
--- a/vnet/vnet/gre/interface.c
+++ b/vnet/vnet/gre/interface.c
@@ -331,6 +331,7 @@ vnet_gre_tunnel_add (vnet_gre_add_del_tunnel_args_t *a,
   t->hw_if_index = hw_if_index;
   t->outer_fib_index = outer_fib_index;
   t->sw_if_index = sw_if_index;
+  t->l2_adj_index = ADJ_INDEX_INVALID;
 
   vec_validate_init_empty (gm->tunnel_index_by_sw_if_index, sw_if_index, ~0);
   gm->tunnel_index_by_sw_if_index[sw_if_index] = t - gm->tunnels;
@@ -416,6 +417,9 @@ vnet_gre_tunnel_delete (vnet_gre_add_del_tunnel_args_t *a,
   if (GRE_TUNNEL_TYPE_TEB == t->type)
     adj_unlock(t->l2_adj_index);
 
+  if (t->l2_adj_index != ADJ_INDEX_INVALID)
+      adj_unlock(t->l2_adj_index);
+
   fib_entry_child_remove(t->fib_entry_index,
                          t->sibling_index);
   fib_table_entry_delete_index(t->fib_entry_index,
diff --git a/vnet/vnet/ip/ip4_forward.c b/vnet/vnet/ip/ip4_forward.c
index d6fd380815b..2a6791e5055 100644
--- a/vnet/vnet/ip/ip4_forward.c
+++ b/vnet/vnet/ip/ip4_forward.c
@@ -729,7 +729,7 @@ ip4_add_interface_routes (u32 sw_if_index,
 					    sw_if_index,
 					    ~0, // invalid FIB index
 					    1,
-					    MPLS_LABEL_INVALID,
+					    NULL, // no out-label stack
 					    FIB_ROUTE_PATH_FLAG_NONE);
       a->neighbor_probe_adj_index = fib_entry_get_adj(fei);
   }
@@ -769,7 +769,7 @@ ip4_add_interface_routes (u32 sw_if_index,
 				  sw_if_index,
 				  ~0, // invalid FIB index
 				  1,
-				  MPLS_LABEL_INVALID,
+				  NULL, // no out-label stack
 				  FIB_ROUTE_PATH_FLAG_NONE);
 }
 
diff --git a/vnet/vnet/ip/ip6_forward.c b/vnet/vnet/ip/ip6_forward.c
index f3cd640a841..1f40c429310 100644
--- a/vnet/vnet/ip/ip6_forward.c
+++ b/vnet/vnet/ip/ip6_forward.c
@@ -340,7 +340,7 @@ ip6_add_interface_routes (vnet_main_t * vnm, u32 sw_if_index,
 					    sw_if_index,
 					    ~0, // invalid FIB index
 					    1,
-					    MPLS_LABEL_INVALID,
+					    NULL, // no label stack
 					    FIB_ROUTE_PATH_FLAG_NONE);
       a->neighbor_probe_adj_index = fib_entry_get_adj(fei);
   }
@@ -378,7 +378,7 @@ ip6_add_interface_routes (vnet_main_t * vnm, u32 sw_if_index,
 				  sw_if_index,
 				  ~0, // invalid FIB index
 				  1,
-				  MPLS_LABEL_INVALID,
+				  NULL,
 				  FIB_ROUTE_PATH_FLAG_NONE);
 }
 
diff --git a/vnet/vnet/ip/ip6_neighbor.c b/vnet/vnet/ip/ip6_neighbor.c
index cc176306969..a407978b3fa 100644
--- a/vnet/vnet/ip/ip6_neighbor.c
+++ b/vnet/vnet/ip/ip6_neighbor.c
@@ -586,7 +586,7 @@ vnet_set_ip6_ethernet_neighbor (vlib_main_t * vm,
 					n->key.sw_if_index,
 					~0,
 					1,
-					MPLS_LABEL_INVALID,
+					NULL, // no label stack
 					FIB_ROUTE_PATH_FLAG_NONE);
   }
   else
diff --git a/vnet/vnet/ip/lookup.c b/vnet/vnet/ip/lookup.c
index 511a5cc83ec..1a32b4a6467 100644
--- a/vnet/vnet/ip/lookup.c
+++ b/vnet/vnet/ip/lookup.c
@@ -348,8 +348,8 @@ vnet_ip_route_cmd (vlib_main_t * vm,
   fib_route_path_t *rpaths = NULL, rpath;
   dpo_id_t dpo = DPO_INVALID, *dpos = NULL;
   fib_prefix_t *prefixs = NULL, pfx;
+  mpls_label_t out_label, via_label;
   clib_error_t * error = NULL;
-  mpls_label_t out_label;
   u32 table_id, is_del;
   vnet_main_t * vnm;
   u32 fib_index;
@@ -361,6 +361,7 @@ vnet_ip_route_cmd (vlib_main_t * vm,
   table_id = 0;
   count = 1;
   memset(&pfx, 0, sizeof(pfx));
+  out_label = via_label = MPLS_LABEL_INVALID;
 
   /* Get a line of input. */
   if (! unformat_user (main_input, unformat_line_input, line_input))
@@ -403,7 +404,16 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 	      error = clib_error_return(0 , "Paths then labels");
 	      goto done;
 	  }
-	  rpaths[vec_len(rpaths)-1].frp_label = out_label;
+	  vec_add1(rpaths[vec_len(rpaths)-1].frp_label_stack, out_label);
+      }
+      else if (unformat (line_input, "via-label %U",
+                         unformat_mpls_unicast_label,
+			 &rpath.frp_local_label))
+      {
+	  rpath.frp_weight = 1;
+	  rpath.frp_proto = FIB_PROTOCOL_MPLS;
+	  rpath.frp_sw_if_index = ~0;
+	  vec_add1(rpaths, rpath);
       }
       else if (unformat (line_input, "count %f", &count))
 	;
@@ -431,7 +441,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 			 &rpath.frp_sw_if_index,
 			 &rpath.frp_weight))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_proto = FIB_PROTOCOL_IP4;
 	  vec_add1(rpaths, rpath);
       }
@@ -443,7 +452,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 			 &rpath.frp_sw_if_index,
 			 &rpath.frp_weight))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_proto = FIB_PROTOCOL_IP6;
 	  vec_add1(rpaths, rpath);
       }
@@ -454,7 +462,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 			 unformat_vnet_sw_interface, vnm,
 			 &rpath.frp_sw_if_index))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_weight = 1;
 	  rpath.frp_proto = FIB_PROTOCOL_IP4;
 	  vec_add1(rpaths, rpath);
@@ -466,7 +473,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 			 unformat_vnet_sw_interface, vnm,
 			 &rpath.frp_sw_if_index))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_weight = 1;
 	  rpath.frp_proto = FIB_PROTOCOL_IP6;
 	  vec_add1(rpaths, rpath);
@@ -478,7 +484,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
       {
 	  rpath.frp_weight = 1;
 	  rpath.frp_sw_if_index = ~0;
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_proto = FIB_PROTOCOL_IP4;
 	  vec_add1(rpaths, rpath);
       }
@@ -489,7 +494,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
       {
 	  rpath.frp_weight = 1;
 	  rpath.frp_sw_if_index = ~0;
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_proto = FIB_PROTOCOL_IP6;
 	  vec_add1(rpaths, rpath);
       }
@@ -504,7 +508,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 	  rpath.frp_fib_index = table_id;
 	  rpath.frp_weight = 1;
 	  rpath.frp_sw_if_index = ~0;
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_proto = FIB_PROTOCOL_IP4;
 	  vec_add1(rpaths, rpath);
       }
@@ -515,7 +518,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 	  rpath.frp_fib_index = table_id;
 	  rpath.frp_weight = 1;
 	  rpath.frp_sw_if_index = ~0;
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_proto = FIB_PROTOCOL_IP6;
 	  vec_add1(rpaths, rpath);
       }
@@ -523,7 +525,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 			 "lookup in table %d",
 			 &rpath.frp_fib_index))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  rpath.frp_proto = pfx.fp_proto;
 	  rpath.frp_sw_if_index = ~0;
 	  vec_add1(rpaths, rpath);
@@ -532,7 +533,6 @@ vnet_ip_route_cmd (vlib_main_t * vm,
 	       unformat (line_input, "via %U",
 			 unformat_dpo, &dpo, prefixs[0].fp_proto))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
 	  vec_add1 (dpos, dpo);
       }
       else
diff --git a/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c b/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c
index 1f2b2863695..26a93a87b9d 100644
--- a/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c
+++ b/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c
@@ -243,7 +243,6 @@ lisp_gpe_mk_fib_paths (const lisp_fwd_path_t * paths)
 
     rpaths[ii].frp_sw_if_index = ladj->sw_if_index;
     rpaths[ii].frp_weight = (paths[ii].weight ? paths[ii].weight : 1);
-    rpaths[ii].frp_label = MPLS_LABEL_INVALID;
   }
 
   ASSERT (0 != vec_len (rpaths));
diff --git a/vnet/vnet/mpls/interface.c b/vnet/vnet/mpls/interface.c
index a0f6f2f2474..692a2d1eb62 100644
--- a/vnet/vnet/mpls/interface.c
+++ b/vnet/vnet/mpls/interface.c
@@ -22,243 +22,6 @@
 #include <vnet/adj/adj_midchain.h>
 #include <vnet/dpo/classify_dpo.h>
 
-/* manually added to the interface output node */
-#define MPLS_ETH_OUTPUT_NEXT_OUTPUT	1
-
-static uword
-mpls_eth_interface_tx (vlib_main_t * vm,
-                       vlib_node_runtime_t * node,
-                       vlib_frame_t * frame)
-{
-  mpls_main_t * gm = &mpls_main;
-  vnet_main_t * vnm = gm->vnet_main;
-  u32 next_index;
-  u32 * from, * to_next, n_left_from, n_left_to_next;
-
-  /* Vector of buffer / pkt indices we're supposed to process */
-  from = vlib_frame_vector_args (frame);
-
-  /* Number of buffers / pkts */
-  n_left_from = frame->n_vectors;   
-
-  /* Speculatively send the first buffer to the last disposition we used */
-  next_index = node->cached_next_index;
-  
-  while (n_left_from > 0)
-    {
-      /* set up to enqueue to our disposition with index = next_index */
-      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
-
-      /* 
-       * As long as we have enough pkts left to process two pkts
-       * and prefetch two pkts...
-       */
-      while (n_left_from >= 4 && n_left_to_next >= 2)
-	{
-          vlib_buffer_t * b0, * b1;
-	  u32 bi0, next0, bi1, next1;
-          mpls_eth_tunnel_t * t0, * t1;
-          u32 sw_if_index0, sw_if_index1;
-          vnet_hw_interface_t * hi0, * hi1;
-          u8 * dst0, * dst1;
-      
-	  /* Prefetch the next iteration */
-	  {
-	    vlib_buffer_t * p2, * p3;
-
-	    p2 = vlib_get_buffer (vm, from[2]);
-	    p3 = vlib_get_buffer (vm, from[3]);
-
-	    vlib_prefetch_buffer_header (p2, LOAD);
-	    vlib_prefetch_buffer_header (p3, LOAD);
-
-            /* 
-             * Prefetch packet data. We expect to overwrite
-             * the inbound L2 header with an ip header and a
-             * gre header. Might want to prefetch the last line
-             * of rewrite space as well; need profile data
-             */
-	    CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE);
-	    CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE);
-	  }
-
-          /* Pick up the next two buffer indices */
-	  bi0 = from[0];
-	  bi1 = from[1];
-
-          /* Speculatively enqueue them where we sent the last buffer */
-	  to_next[0] = bi0;
-	  to_next[1] = bi1;
-	  from += 2;
-	  to_next += 2;
-	  n_left_to_next -= 2;
-	  n_left_from -= 2;
-      
-	  b0 = vlib_get_buffer (vm, bi0);
-	  b1 = vlib_get_buffer (vm, bi1);
-
-          sw_if_index0 = vnet_buffer(b0)->sw_if_index [VLIB_TX];
-          sw_if_index1 = vnet_buffer(b1)->sw_if_index [VLIB_TX];
-
-          /* get h/w intfcs */
-          hi0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
-          hi1 = vnet_get_sup_hw_interface (vnm, sw_if_index1);
-          
-          /* hw_instance = tunnel pool index */
-          t0 = pool_elt_at_index (gm->eth_tunnels, hi0->hw_instance);
-          t1 = pool_elt_at_index (gm->eth_tunnels, hi1->hw_instance);
-
-          /* Apply rewrite - $$$$$ fixme don't use memcpy */
-          vlib_buffer_advance (b0, -(word)vec_len(t0->rewrite_data));
-          vlib_buffer_advance (b1, -(word)vec_len(t1->rewrite_data));
-
-          dst0 = vlib_buffer_get_current (b0);
-          dst1 = vlib_buffer_get_current (b1);
-
-          clib_memcpy (dst0, t0->rewrite_data, vec_len(t0->rewrite_data));
-          clib_memcpy (dst1, t1->rewrite_data, vec_len(t1->rewrite_data));
-
-          /* Fix TX fib indices */
-          vnet_buffer(b0)->sw_if_index [VLIB_TX] = t0->tx_sw_if_index;
-          vnet_buffer(b1)->sw_if_index [VLIB_TX] = t1->tx_sw_if_index;
-
-          /* mpls-post-rewrite takes it from here... */
-          next0 = MPLS_ETH_OUTPUT_NEXT_OUTPUT;
-          next1 = MPLS_ETH_OUTPUT_NEXT_OUTPUT;
-
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              mpls_eth_tx_trace_t *tr = vlib_add_trace (vm, node, 
-                                                        b0, sizeof (*tr));
-              tr->lookup_miss = 0;
-              tr->tunnel_id = t0 - gm->eth_tunnels;
-              tr->tx_sw_if_index = t0->tx_sw_if_index;
-              tr->mpls_encap_index = t0->encap_index;
-              tr->length = b0->current_length;
-              hi0 = vnet_get_sup_hw_interface (vnm, t0->tx_sw_if_index);
-              clib_memcpy (tr->dst, hi0->hw_address, sizeof (tr->dst));
-            }
-          if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              mpls_eth_tx_trace_t *tr = vlib_add_trace (vm, node, 
-                                                        b1, sizeof (*tr));
-              tr->lookup_miss = 0;
-              tr->tunnel_id = t1 - gm->eth_tunnels;
-              tr->tx_sw_if_index = t1->tx_sw_if_index;
-              tr->mpls_encap_index = t1->encap_index;
-              tr->length = b1->current_length;
-              hi1 = vnet_get_sup_hw_interface (vnm, t1->tx_sw_if_index);
-              clib_memcpy (tr->dst, hi1->hw_address, sizeof (tr->dst));
-            }
-
-	  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
-					   to_next, n_left_to_next,
-					   bi0, bi1, next0, next1);
-	}
-      while (n_left_from > 0 && n_left_to_next > 0)
-	{
-          vlib_buffer_t * b0;
-          u32 bi0, next0;
-          mpls_eth_tunnel_t * t0;
-          u32 sw_if_index0;
-          vnet_hw_interface_t * hi0;
-          u8 * dst0;
-
-	  bi0 = from[0];
-	  to_next[0] = bi0;
-	  from += 1;
-	  to_next += 1;
-	  n_left_from -= 1;
-	  n_left_to_next -= 1;
-
-	  b0 = vlib_get_buffer (vm, bi0);
-
-          sw_if_index0 = vnet_buffer(b0)->sw_if_index [VLIB_TX];
-
-          hi0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
-          
-          t0 = pool_elt_at_index (gm->eth_tunnels, hi0->hw_instance);
-
-          /* Apply rewrite - $$$$$ fixme don't use memcpy */
-          vlib_buffer_advance (b0, -(word)vec_len(t0->rewrite_data));
-
-          dst0 = vlib_buffer_get_current (b0);
-
-          clib_memcpy (dst0, t0->rewrite_data, vec_len(t0->rewrite_data));
-
-          /* Fix the TX interface */
-          vnet_buffer(b0)->sw_if_index [VLIB_TX] = t0->tx_sw_if_index;
-
-          /* Send the packet */
-          next0 = MPLS_ETH_OUTPUT_NEXT_OUTPUT;
-
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              mpls_eth_tx_trace_t *tr = vlib_add_trace (vm, node, 
-                                                        b0, sizeof (*tr));
-              tr->lookup_miss = 0;
-              tr->tunnel_id = t0 - gm->eth_tunnels;
-              tr->tx_sw_if_index = t0->tx_sw_if_index;
-              tr->mpls_encap_index = t0->encap_index;
-              tr->length = b0->current_length;
-              hi0 = vnet_get_sup_hw_interface (vnm, t0->tx_sw_if_index);
-              clib_memcpy (tr->dst, hi0->hw_address, sizeof (tr->dst));
-            }
-
-	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
-					   to_next, n_left_to_next,
-					   bi0, next0);
-	}
-  
-      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
-    }
-
-  vlib_node_increment_counter (vm, mpls_input_node.index,
-                               MPLS_ERROR_PKTS_ENCAP, frame->n_vectors);
-
-  return frame->n_vectors;
-}
-
-static u8 * format_mpls_eth_tunnel_name (u8 * s, va_list * args)
-{
-  u32 dev_instance = va_arg (*args, u32);
-  return format (s, "mpls-eth%d", dev_instance);
-}
-
-static u8 * format_mpls_eth_device (u8 * s, va_list * args)
-{
-  u32 dev_instance = va_arg (*args, u32);
-  CLIB_UNUSED (int verbose) = va_arg (*args, int);
-
-  s = format (s, "MPLS-ETH tunnel: id %d\n", dev_instance);
-  return s;
-}
-
-VNET_DEVICE_CLASS (mpls_eth_device_class) = {
-  .name = "MPLS-ETH tunnel device",
-  .format_device_name = format_mpls_eth_tunnel_name,
-  .format_device = format_mpls_eth_device,
-  .format_tx_trace = format_mpls_eth_tx_trace,
-  .tx_function = mpls_eth_interface_tx,
-  .no_flatten_output_chains = 1,
-#ifdef SOON
-  .clear counter = 0;
-  .admin_up_down_function = 0;
-#endif
-};
-
-VLIB_DEVICE_TX_FUNCTION_MULTIARCH (mpls_eth_device_class,
-				   mpls_eth_interface_tx)
-
-VNET_HW_INTERFACE_CLASS (mpls_eth_hw_interface_class) = {
-  .name = "MPLS-ETH",
-  .format_header = format_mpls_eth_header_with_length,
-#if 0
-  .unformat_header = unformat_mpls_eth_header,
-#endif
-  .build_rewrite = default_build_rewrite,
-  .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
-};
 
 u8
 mpls_sw_interface_is_enabled (u32 sw_if_index)
@@ -308,753 +71,6 @@ mpls_sw_interface_enable_disable (mpls_main_t * mm,
 
 }
 
-u8 * format_mpls_encap_index (u8 * s, va_list * args)
-{
-  mpls_main_t * mm = va_arg (*args, mpls_main_t *);
-  u32 entry_index = va_arg (*args, u32);
-  mpls_encap_t * e;
-  int i;
-
-  e = pool_elt_at_index (mm->encaps, entry_index);
-  
-  for (i = 0; i < vec_len (e->labels); i++)
-    s = format 
-        (s, "%d ", vnet_mpls_uc_get_label(clib_net_to_host_u32 
-                                          (e->labels[i].label_exp_s_ttl)));
-
-  return s;
-}
-
-u8 * format_mpls_ethernet_tunnel (u8 * s, va_list * args)
-{
-  mpls_eth_tunnel_t * t = va_arg (*args, mpls_eth_tunnel_t *);
-  mpls_main_t * mm = &mpls_main;
-  
-  s = format (s, "[%d]: dst %U, adj %U/%d, labels %U\n",
-              t - mm->eth_tunnels, 
-              format_ethernet_address, &t->tunnel_dst,
-              format_ip4_address, &t->intfc_address,
-              t->mask_width, 
-              format_mpls_encap_index, mm, t->encap_index);
-
-
-  s = format (s, "      tx on %U, rx fib index %d", 
-              format_vnet_sw_if_index_name, mm->vnet_main, t->tx_sw_if_index,
-              t->inner_fib_index);
-
-  return s;
-}
-
-static clib_error_t *
-show_mpls_tunnel_command_fn (vlib_main_t * vm,
-                             unformat_input_t * input,
-                             vlib_cli_command_t * cmd)
-{
-  mpls_main_t * mm = &mpls_main;
-  mpls_eth_tunnel_t * et;
-
-  if (pool_elts (mm->eth_tunnels))
-    {
-      vlib_cli_output (vm, "MPLS-Ethernet tunnels");
-      pool_foreach (et, mm->eth_tunnels,
-      ({
-        vlib_cli_output (vm, "%U", format_mpls_ethernet_tunnel, et);
-      }));
-    }
-  else
-    vlib_cli_output (vm, "No MPLS-Ethernet tunnels");
-
-  return 0;
-}
-
-VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = {
-    .path = "show mpls tunnel",
-    .short_help = "show mpls tunnel",
-    .function = show_mpls_tunnel_command_fn,
-};
-
-
-/* force inclusion from application's main.c */
-clib_error_t *mpls_interface_init (vlib_main_t *vm)
-{
-  clib_error_t * error;
-
-  if ((error = vlib_call_init_function (vm, mpls_policy_encap_init)))
-      return error;
-
-  return 0;
-}
-VLIB_INIT_FUNCTION(mpls_interface_init);
-
-
-static u8 * mpls_ethernet_rewrite (mpls_main_t *mm, mpls_eth_tunnel_t * t)
-{
-  u8 * rewrite_data = 0;
-  mpls_encap_t * e;
-  mpls_unicast_header_t *lp0;
-  int i;
-
- /* look up the encap label stack using the RX FIB and adjacency address*/
-  e = mpls_encap_by_fib_and_dest (mm, t->inner_fib_index, 
-                                  t->intfc_address.as_u32);
-
-  if (e == 0)
-    {
-      clib_warning ("no label for inner fib index %d, dst %U",
-                    t->inner_fib_index, format_ip4_address, 
-                    &t->intfc_address);
-      return 0;
-    }
- 
-  vec_validate (rewrite_data, 
-                sizeof (mpls_unicast_header_t) * vec_len(e->labels) -1);
-
-  /* Copy the encap label stack */
-  lp0 = (mpls_unicast_header_t *) rewrite_data;
-  
-  for (i = 0; i < vec_len(e->labels); i++)
-    lp0[i] = e->labels[i];
-  
-  return (rewrite_data);
-}
-
-int vnet_mpls_ethernet_add_del_tunnel (u8 *dst,
-                                       ip4_address_t *intfc,
-                                       u32 mask_width,
-                                       u32 inner_fib_id, 
-                                       u32 tx_sw_if_index,
-                                       u32 * tunnel_sw_if_index,
-                                       u8 l2_only,
-                                       u8 is_add)
-{
-  ip4_main_t * im = &ip4_main;
-  ip_lookup_main_t * lm = &im->lookup_main;
-  mpls_main_t * mm = &mpls_main;
-  vnet_main_t * vnm = vnet_get_main();
-  mpls_eth_tunnel_t *tp;
-  u32 inner_fib_index = 0;
-  ip_adjacency_t adj;
-  u32 adj_index;
-  u8 * rewrite_data;
-  int found_tunnel = 0;
-  mpls_encap_t * e = 0;
-  u32 hw_if_index = ~0;
-  vnet_hw_interface_t * hi;
-  u32 slot;
-  u32 dummy;
-  
-  if (tunnel_sw_if_index == 0)
-    tunnel_sw_if_index = &dummy;
-
-  *tunnel_sw_if_index = ~0;
-
-  if (inner_fib_id != (u32)~0)
-    {
-      uword * p;
-      
-      p = hash_get (im->fib_index_by_table_id, inner_fib_id);
-      if (! p)
-        return VNET_API_ERROR_NO_SUCH_FIB;
-      inner_fib_index = p[0];
-    }
-
-  /* suppress duplicate mpls interface generation. */
-  pool_foreach (tp, mm->eth_tunnels, 
-  ({
-    /* 
-     * If we have a tunnel which matches (src, dst, intfc/mask)
-     * AND the expected route is in the FIB, it's a dup 
-     */
-    if (!memcmp (&tp->tunnel_dst, dst, sizeof (*dst))
-        && !memcmp (&tp->intfc_address, intfc, sizeof (*intfc))
-        && tp->inner_fib_index == inner_fib_index
-	&& FIB_NODE_INDEX_INVALID != tp->fei)
-      {
-        found_tunnel = 1;
-
-        if (is_add)
-          {
-            if (l2_only)
-              return 1;
-            else
-              {
-                e = mpls_encap_by_fib_and_dest (mm, inner_fib_index, 
-                                                intfc->as_u32);
-                if (e == 0)
-                  return VNET_API_ERROR_NO_SUCH_LABEL;
-                
-                goto reinstall_it;
-              }
-          }
-        else
-          {
-            /* Delete */
-            goto add_del_route;
-          }
-
-      }
-  }));
-    
-  /* Delete, and we can't find the tunnel */
-  if (is_add == 0 && found_tunnel == 0)
-    return VNET_API_ERROR_NO_SUCH_ENTRY;
-
-  e = mpls_encap_by_fib_and_dest (mm, inner_fib_index, intfc->as_u32);
-  if (e == 0)
-    return VNET_API_ERROR_NO_SUCH_LABEL;
-
-  pool_get(mm->eth_tunnels, tp);
-  memset (tp, 0, sizeof (*tp));
-    
-  if (vec_len (mm->free_eth_sw_if_indices) > 0)
-    {
-      hw_if_index = 
-        mm->free_eth_sw_if_indices[vec_len(mm->free_eth_sw_if_indices)-1];
-      _vec_len (mm->free_eth_sw_if_indices) -= 1;
-      hi = vnet_get_hw_interface (vnm, hw_if_index);
-      hi->dev_instance = tp - mm->eth_tunnels;
-      hi->hw_instance = tp - mm->eth_tunnels;
-    }
-  else 
-    {
-      hw_if_index = vnet_register_interface
-        (vnm, mpls_eth_device_class.index, tp - mm->eth_tunnels,
-         mpls_eth_hw_interface_class.index,
-         tp - mm->eth_tunnels);
-      hi = vnet_get_hw_interface (vnm, hw_if_index);
-
-      /* ... to make the IP and L2 x-connect cases identical */
-      slot = vlib_node_add_named_next_with_slot
-        (vnm->vlib_main, hi->tx_node_index, 
-         "interface-output", MPLS_ETH_OUTPUT_NEXT_OUTPUT);
-
-      ASSERT (slot == MPLS_ETH_OUTPUT_NEXT_OUTPUT);
-    }
-  
-  *tunnel_sw_if_index = hi->sw_if_index;
-  vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 
-                               VNET_SW_INTERFACE_FLAG_ADMIN_UP);      
-
-  tp->hw_if_index = hw_if_index;
-
- reinstall_it:
-  clib_memcpy(tp->tunnel_dst, dst, sizeof (tp->tunnel_dst));
-  tp->intfc_address.as_u32 = intfc->as_u32;
-  tp->mask_width = mask_width;
-  tp->inner_fib_index = inner_fib_index;
-  tp->encap_index = e - mm->encaps;
-  tp->tx_sw_if_index = tx_sw_if_index;
-  tp->l2_only = l2_only;
-
-  /* Create the adjacency and add to v4 fib */
-  memset(&adj, 0, sizeof (adj));
-  adj.lookup_next_index = IP_LOOKUP_NEXT_REWRITE;
-    
-  rewrite_data = mpls_ethernet_rewrite (mm, tp);
-  if (rewrite_data == 0)
-    {
-      if (*tunnel_sw_if_index != ~0)
-        {
-          hi = vnet_get_hw_interface (vnm, tp->hw_if_index);
-          vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 
-                                       0 /* admin down */);
-          vec_add1 (mm->free_eth_sw_if_indices, tp->hw_if_index);
-      }
-
-      pool_put (mm->eth_tunnels, tp);
-      return VNET_API_ERROR_NO_SUCH_LABEL;
-    }
-  
-  vnet_rewrite_for_sw_interface
-    (vnm,
-     VNET_LINK_MPLS, 
-     tx_sw_if_index,
-     ip4_rewrite_node.index,
-     tp->tunnel_dst,
-     &adj.rewrite_header,
-     sizeof (adj.rewrite_data));
-  
-  /* 
-   * Prepend the (0,1,2) VLAN tag ethernet header 
-   * we just built to the mpls header stack
-   */
-  vec_insert (rewrite_data, adj.rewrite_header.data_bytes, 0);
-  clib_memcpy(rewrite_data, 
-         vnet_rewrite_get_data_internal(&adj.rewrite_header, 
-                                        sizeof (adj.rewrite_data)),
-         adj.rewrite_header.data_bytes);
-
-  vnet_rewrite_set_data_internal (&adj.rewrite_header, 
-                                  sizeof(adj.rewrite_data),
-                                  rewrite_data, 
-                                  vec_len(rewrite_data));
-  
-  vec_free (tp->rewrite_data);
-  
-  tp->rewrite_data = rewrite_data;
-
-  if (!l2_only)
-    ip_add_adjacency (lm, &adj, 1 /* one adj */,
-                      &adj_index);
-  
- add_del_route:
-
-  if (!l2_only)
-    {
-      const fib_prefix_t pfx = {
-	  .fp_addr = {
-	      .ip4 = tp->intfc_address,
-	  },
-	  .fp_len = tp->mask_width,
-	  .fp_proto = FIB_PROTOCOL_IP4,
-      };
-      if (is_add)
-	  tp->fei = fib_table_entry_special_add(tp->inner_fib_index,
-						&pfx,
-						FIB_SOURCE_API,
-						FIB_ENTRY_FLAG_NONE,
-						adj_index);
-      else
-        {
-	  fib_table_entry_delete(tp->inner_fib_index, &pfx, FIB_SOURCE_API);
-	  tp->fei = FIB_NODE_INDEX_INVALID;
-	}
-    }
-  if (is_add == 0 && found_tunnel)
-    {
-      hi = vnet_get_hw_interface (vnm, tp->hw_if_index);
-      vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 
-                                   0 /* admin down */);
-      vec_add1 (mm->free_eth_sw_if_indices, tp->hw_if_index);
-      vec_free (tp->rewrite_data);
-      pool_put (mm->eth_tunnels, tp);
-    }
-
-  return 0;
-}
-
-static clib_error_t *
-create_mpls_ethernet_tunnel_command_fn (vlib_main_t * vm,
-                                        unformat_input_t * input,
-                                        vlib_cli_command_t * cmd)
-{
-  unformat_input_t _line_input, * line_input = &_line_input;
-  vnet_main_t * vnm = vnet_get_main();
-  ip4_address_t intfc;
-  int adj_set = 0;
-  u8 dst[6];
-  int dst_set = 0, intfc_set = 0;
-  u32 mask_width;
-  u32 inner_fib_id = (u32)~0;
-  int rv;
-  u8 is_del = 0;
-  u8 l2_only = 0;
-  u32 tx_sw_if_index;
-  u32 sw_if_index = ~0;
-  
-  /* Get a line of input. */
-  if (! unformat_user (input, unformat_line_input, line_input))
-    return 0;
-
-  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
-    {
-      if (unformat (line_input, "dst %U", 
-                    unformat_ethernet_address, &dst))
-        dst_set = 1;
-      else if (unformat (line_input, "adj %U/%d", 
-                         unformat_ip4_address, &intfc, &mask_width))
-        adj_set = 1;
-      else if (unformat (line_input, "tx-intfc %U", 
-                         unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
-        intfc_set = 1;
-      else if (unformat (line_input, "fib-id %d", &inner_fib_id))
-        ;
-      else if (unformat (line_input, "l2-only"))
-        l2_only = 1;
-      else if (unformat (line_input, "del"))
-        is_del = 1;
-      else
-        return clib_error_return (0, "unknown input '%U'",
-                                  format_unformat_error, line_input);
-    }
-
-  if (!intfc_set)
-    return clib_error_return (0, "missing tx-intfc");
-
-  if (!dst_set)
-    return clib_error_return (0, "missing: dst <ethernet-address>");
-          
-  if (!adj_set)
-    return clib_error_return (0, "missing: intfc <ip-address>/<mask-width>");
-  
-
-  rv = vnet_mpls_ethernet_add_del_tunnel (dst, &intfc, mask_width, 
-                                          inner_fib_id, tx_sw_if_index, 
-                                          &sw_if_index,
-                                          l2_only, !is_del);
-
-  switch (rv) 
-    {
-    case 0:
-      if (!is_del)
-        vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), sw_if_index);
-      break;
-    case VNET_API_ERROR_NO_SUCH_FIB:
-      return clib_error_return (0, "rx fib ID %d doesn't exist\n",
-                                inner_fib_id);
-
-    case VNET_API_ERROR_NO_SUCH_ENTRY:
-      return clib_error_return (0, "tunnel not found\n");
-
-    case VNET_API_ERROR_NO_SUCH_LABEL:
-      /* 
-       * This happens when there's no MPLS label for the dst address
-       * no need for two error messages.
-       */
-        return clib_error_return (0, "no label for %U in fib %d", 
-                                  format_ip4_address, &intfc, inner_fib_id);
-      break;
-      
-    default:
-      return clib_error_return (0, "vnet_mpls_ethernet_add_del_tunnel returned %d", rv);
-      break;
-    }
-  return 0;
-}
-
-
-VLIB_CLI_COMMAND (create_mpls_ethernet_tunnel_command, static) = {
-  .path = "create mpls ethernet tunnel",
-  .short_help = 
-  "create mpls ethernet tunnel [del] dst <mac-addr> intfc <addr>/<mw>",
-  .function = create_mpls_ethernet_tunnel_command_fn,
-};
-
-
-int vnet_mpls_policy_tunnel_add_rewrite (mpls_main_t * mm, 
-                                         mpls_encap_t * e, 
-                                         u32 policy_tunnel_index)
-{
-  mpls_eth_tunnel_t * t;
-  ip_adjacency_t adj;
-  u8 * rewrite_data = 0;
-  u8 * label_start;
-  mpls_unicast_header_t *lp;
-  int i;
-
-  if (pool_is_free_index (mm->eth_tunnels, policy_tunnel_index))
-    return VNET_API_ERROR_NO_SUCH_ENTRY;
-
-  t = pool_elt_at_index (mm->eth_tunnels, policy_tunnel_index);
-
-  memset (&adj, 0, sizeof (adj));
-
-  /* Build L2 encap */
-  vnet_rewrite_for_sw_interface
-    (mm->vnet_main, 
-     VNET_LINK_MPLS, 
-     t->tx_sw_if_index,
-     mpls_policy_encap_node.index,
-     t->tunnel_dst,
-     &adj.rewrite_header,
-     sizeof (adj.rewrite_data));
-  
-  vec_validate (rewrite_data, adj.rewrite_header.data_bytes -1);
-
-  clib_memcpy(rewrite_data, 
-         vnet_rewrite_get_data_internal(&adj.rewrite_header, 
-                                        sizeof (adj.rewrite_data)),
-         adj.rewrite_header.data_bytes);
-
-  /* Append the label stack */
-
-  vec_add2 (rewrite_data, label_start, vec_len(e->labels) * sizeof (u32));
-
-  lp = (mpls_unicast_header_t *) label_start;
-
-  for (i = 0; i < vec_len(e->labels); i++)
-    lp[i] = e->labels[i];
-  
-  /* Remember the rewrite data */
-  e->rewrite = rewrite_data;
-  e->output_next_index = adj.rewrite_header.next_index;
-
-  return 0;
-}
-
-int vnet_mpls_ethernet_add_del_policy_tunnel (u8 *dst,
-                                              ip4_address_t *intfc,
-                                              u32 mask_width,
-                                              u32 inner_fib_id, 
-                                              u32 tx_sw_if_index,
-                                              u32 * tunnel_sw_if_index,
-                                              u32 classify_table_index,
-                                              u32 * new_tunnel_index,
-                                              u8 l2_only,
-                                              u8 is_add)
-{
-  ip4_main_t * im = &ip4_main;
-  mpls_main_t * mm = &mpls_main;
-  vnet_main_t * vnm = vnet_get_main();
-  mpls_eth_tunnel_t *tp;
-  u32 inner_fib_index = 0;
-  int found_tunnel = 0;
-  mpls_encap_t * e = 0;
-  u32 hw_if_index = ~0;
-  vnet_hw_interface_t * hi;
-  u32 slot;
-  u32 dummy;
-  
-  if (tunnel_sw_if_index == 0)
-    tunnel_sw_if_index = &dummy;
-
-  *tunnel_sw_if_index = ~0;
-
-  if (inner_fib_id != (u32)~0)
-    {
-      uword * p;
-      
-      p = hash_get (im->fib_index_by_table_id, inner_fib_id);
-      if (! p)
-        return VNET_API_ERROR_NO_SUCH_FIB;
-      inner_fib_index = p[0];
-    }
-
-  /* suppress duplicate mpls interface generation. */
-  pool_foreach (tp, mm->eth_tunnels, 
-  ({
-    /* 
-     * If we have a tunnel which matches (src, dst, intfc/mask)
-     * AND the expected route is in the FIB, it's a dup 
-     */
-    if (!memcmp (&tp->tunnel_dst, dst, sizeof (*dst))
-        && !memcmp (&tp->intfc_address, intfc, sizeof (*intfc))
-        && tp->inner_fib_index == inner_fib_index
-	&& FIB_NODE_INDEX_INVALID != tp->fei)
-      {
-        found_tunnel = 1;
-
-        if (is_add)
-          {
-            if (l2_only)
-              return 1;
-            else
-              {
-                goto reinstall_it;
-              }
-          }
-        else
-          {
-            /* Delete */
-            goto add_del_route;
-          }
-
-      }
-  }));
-    
-  /* Delete, and we can't find the tunnel */
-  if (is_add == 0 && found_tunnel == 0)
-    return VNET_API_ERROR_NO_SUCH_ENTRY;
-
-  pool_get(mm->eth_tunnels, tp);
-  memset (tp, 0, sizeof (*tp));
-    
-  if (vec_len (mm->free_eth_sw_if_indices) > 0)
-    {
-      hw_if_index = 
-        mm->free_eth_sw_if_indices[vec_len(mm->free_eth_sw_if_indices)-1];
-      _vec_len (mm->free_eth_sw_if_indices) -= 1;
-      hi = vnet_get_hw_interface (vnm, hw_if_index);
-      hi->dev_instance = tp - mm->eth_tunnels;
-      hi->hw_instance = tp - mm->eth_tunnels;
-    }
-  else 
-    {
-      hw_if_index = vnet_register_interface
-        (vnm, mpls_eth_device_class.index, tp - mm->eth_tunnels,
-         mpls_eth_hw_interface_class.index,
-         tp - mm->eth_tunnels);
-      hi = vnet_get_hw_interface (vnm, hw_if_index);
-
-      /* ... to make the IP and L2 x-connect cases identical */
-      slot = vlib_node_add_named_next_with_slot
-        (vnm->vlib_main, hi->tx_node_index, 
-         "interface-output", MPLS_ETH_OUTPUT_NEXT_OUTPUT);
-
-      ASSERT (slot == MPLS_ETH_OUTPUT_NEXT_OUTPUT);
-    }
-  
-  *tunnel_sw_if_index = hi->sw_if_index;
-  vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 
-                               VNET_SW_INTERFACE_FLAG_ADMIN_UP);      
-
-  tp->hw_if_index = hw_if_index;
-
- reinstall_it:
-  clib_memcpy(tp->tunnel_dst, dst, sizeof (tp->tunnel_dst));
-  tp->intfc_address.as_u32 = intfc->as_u32;
-  tp->mask_width = mask_width;
-  tp->inner_fib_index = inner_fib_index;
-  tp->encap_index = e - mm->encaps;
-  tp->tx_sw_if_index = tx_sw_if_index;
-  tp->l2_only = l2_only;
-  tp->fei = FIB_NODE_INDEX_INVALID;
-
-  if (new_tunnel_index)
-    *new_tunnel_index = tp - mm->eth_tunnels;
-
- add_del_route:
-
-  if (!l2_only)
-    {
-      const fib_prefix_t pfx = {
-	  .fp_addr = {
-	      .ip4 = tp->intfc_address,
-	  },
-	  .fp_len = tp->mask_width,
-	  .fp_proto = FIB_PROTOCOL_IP4,
-      };
-      dpo_id_t dpo = DPO_INVALID;
-
-      if (is_add)
-        {
-          dpo_set(&dpo,
-                  DPO_CLASSIFY,
-                  DPO_PROTO_IP4,
-                  classify_dpo_create(DPO_PROTO_IP4,
-                                      classify_table_index));
-
-          tp->fei = fib_table_entry_special_dpo_add(tp->inner_fib_index,
-                                                    &pfx,
-                                                    FIB_SOURCE_API,
-                                                    FIB_ENTRY_FLAG_EXCLUSIVE,
-                                                    &dpo);
-          dpo_reset(&dpo);
-        }
-      else
-        {
-	  fib_table_entry_delete(tp->inner_fib_index, &pfx, FIB_SOURCE_API);
-	  tp->fei = FIB_NODE_INDEX_INVALID;
-	}
-    }
-  if (is_add == 0 && found_tunnel)
-    {
-      hi = vnet_get_hw_interface (vnm, tp->hw_if_index);
-      vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 
-                                   0 /* admin down */);
-      vec_add1 (mm->free_eth_sw_if_indices, tp->hw_if_index);
-      pool_put (mm->eth_tunnels, tp);
-    }
-
-  return 0;
-}
-
-static clib_error_t *
-create_mpls_ethernet_policy_tunnel_command_fn (vlib_main_t * vm,
-                                               unformat_input_t * input,
-                                               vlib_cli_command_t * cmd)
-{
-  unformat_input_t _line_input, * line_input = &_line_input;
-  vnet_main_t * vnm = vnet_get_main();
-  ip4_address_t intfc;
-  int adj_set = 0;
-  u8 dst[6];
-  int dst_set = 0, intfc_set = 0;
-  u32 mask_width;
-  u32 inner_fib_id = (u32)~0;
-  u32 classify_table_index = (u32)~0;
-  u32 new_tunnel_index;
-  int rv;
-  u8 is_del = 0;
-  u8 l2_only = 0;
-  u32 tx_sw_if_index;
-  
-  /* Get a line of input. */
-  if (! unformat_user (input, unformat_line_input, line_input))
-    return 0;
-
-  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
-    {
-      if (unformat (line_input, "dst %U", 
-                    unformat_ethernet_address, &dst))
-        dst_set = 1;
-      else if (unformat (line_input, "adj %U/%d", 
-                         unformat_ip4_address, &intfc, &mask_width))
-        adj_set = 1;
-      else if (unformat (line_input, "tx-intfc %U", 
-                         unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
-        intfc_set = 1;
-      else if (unformat (line_input, "classify-table-index %d",
-                         &classify_table_index))
-        ;
-      else if (unformat (line_input, "fib-id %d", &inner_fib_id))
-        ;
-      else if (unformat (line_input, "l2-only"))
-        l2_only = 1;
-      else if (unformat (line_input, "del"))
-        is_del = 1;
-      else
-        return clib_error_return (0, "unknown input '%U'",
-                                  format_unformat_error, line_input);
-    }
-
-  if (classify_table_index == ~0)
-    return clib_error_return (0, "missing classify_table_index");
-
-  if (!intfc_set)
-    return clib_error_return (0, "missing tx-intfc");
-
-  if (!dst_set)
-    return clib_error_return (0, "missing: dst <ethernet-address>");
-          
-  if (!adj_set)
-    return clib_error_return (0, "missing: intfc <ip-address>/<mask-width>");
-  
-
-  rv = vnet_mpls_ethernet_add_del_policy_tunnel (dst, &intfc, mask_width, 
-                                                 inner_fib_id, tx_sw_if_index, 
-                                                 0 /* tunnel sw_if_index */, 
-                                                 classify_table_index,
-                                                 &new_tunnel_index,
-                                                 l2_only, !is_del);
-  switch (rv) 
-    {
-    case 0:
-      if (!is_del)
-        vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), new_tunnel_index);
-      break;
-    case VNET_API_ERROR_NO_SUCH_FIB:
-      return clib_error_return (0, "rx fib ID %d doesn't exist\n",
-                                inner_fib_id);
-
-    case VNET_API_ERROR_NO_SUCH_ENTRY:
-      return clib_error_return (0, "tunnel not found\n");
-
-    case VNET_API_ERROR_NO_SUCH_LABEL:
-      /* 
-       * This happens when there's no MPLS label for the dst address
-       * no need for two error messages.
-       */
-        return clib_error_return (0, "no label for %U in fib %d", 
-                                  format_ip4_address, &intfc, inner_fib_id);
-      break;
-      
-    default:
-      return clib_error_return (0, "vnet_mpls_ethernet_add_del_policy_tunnel returned %d", rv);
-      break;
-    }
-
-  return 0;
-}
-
-VLIB_CLI_COMMAND (create_mpls_ethernet_policy_tunnel_command, static) = {
-  .path = "create mpls ethernet policy tunnel",
-  .short_help = 
-  "create mpls ethernet policy tunnel [del] dst <mac-addr> intfc <addr>/<mw>\n"
-  " classify-table-index <nn>",
-  .function = create_mpls_ethernet_policy_tunnel_command_fn,
-};
-
 static clib_error_t *
 mpls_interface_enable_disable (vlib_main_t * vm,
                                unformat_input_t * input,
@@ -1090,6 +106,14 @@ mpls_interface_enable_disable (vlib_main_t * vm,
   return error;
 }
 
+/*?
+ * This command enables an interface to accpet MPLS packets
+ *
+ * @cliexpar
+ * @cliexstart{set interface mpls}
+ *  set interface mpls GigEthernet0/8/0 enable
+ * @cliexend
+ ?*/
 VLIB_CLI_COMMAND (set_interface_ip_table_command, static) = {
   .path = "set interface mpls",
   .function = mpls_interface_enable_disable,
diff --git a/vnet/vnet/mpls/mpls.c b/vnet/vnet/mpls/mpls.c
index aa1d963dca1..e6ae4980067 100644
--- a/vnet/vnet/mpls/mpls.c
+++ b/vnet/vnet/mpls/mpls.c
@@ -121,45 +121,6 @@ unformat_mpls_header (unformat_input_t * input, va_list * args)
   return 1;
 }
 
-u8 * format_mpls_eth_tx_trace (u8 * s, va_list * args)
-{
-  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
-  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  mpls_eth_tx_trace_t * t = va_arg (*args, mpls_eth_tx_trace_t *);
-  mpls_main_t * mm = &mpls_main;
-    
-  if (t->lookup_miss)
-    s = format (s, "MPLS: lookup miss");
-  else
-    {
-      s = format (s, "MPLS: tunnel %d labels %U len %d tx_sw_index %d dst %U",
-                  t->tunnel_id,
-                  format_mpls_encap_index, mm, t->mpls_encap_index, 
-                  clib_net_to_host_u16 (t->length),
-                  t->tx_sw_if_index, 
-                  format_ethernet_address, t->dst);
-    }
-  return s;
-}
-
-u8 * format_mpls_eth_header_with_length (u8 * s, va_list * args)
-{
-  ethernet_header_t * h = va_arg (*args, ethernet_header_t *);
-  mpls_unicast_header_t * m = (mpls_unicast_header_t *)(h+1);
-  u32 max_header_bytes = va_arg (*args, u32);
-  uword header_bytes;
-
-  header_bytes = sizeof (h[0]);
-  if (max_header_bytes != 0 && header_bytes > max_header_bytes)
-    return format (s, "ethernet header truncated");
-
-  s = format 
-    (s, "ETHERNET-MPLS label %d", 
-     vnet_mpls_uc_get_label (clib_net_to_host_u32 (m->label_exp_s_ttl)));
-
-  return s;
-}
-
 uword
 unformat_mpls_label_net_byte_order (unformat_input_t * input,
                                         va_list * args)
@@ -176,157 +137,6 @@ unformat_mpls_label_net_byte_order (unformat_input_t * input,
   return 1;
 }
 
-mpls_encap_t * 
-mpls_encap_by_fib_and_dest (mpls_main_t * mm, u32 rx_fib, u32 dst_address)
-{
-  uword * p;
-  mpls_encap_t * e;
-  u64 key;
-
-  key = ((u64)rx_fib<<32) | ((u64) dst_address);
-  p = hash_get (mm->mpls_encap_by_fib_and_dest, key);
-
-  if (!p)
-    return 0;
-
-  e = pool_elt_at_index (mm->encaps, p[0]);
-  return e;
-}
-
-int vnet_mpls_add_del_encap (ip4_address_t *dest, u32 fib_id, 
-                             u32 *labels_host_byte_order,
-                             u32 policy_tunnel_index,
-                             int no_dst_hash, u32 * indexp, int is_add)
-{
-  mpls_main_t * mm = &mpls_main;
-  ip4_main_t * im = &ip4_main;
-  mpls_encap_t * e;
-  u32 label_net_byte_order, label_host_byte_order;
-  u32 fib_index;
-  u64 key;
-  uword *p;
-  int i;
-  
-  p = hash_get (im->fib_index_by_table_id, fib_id);
-  if (! p)
-    return VNET_API_ERROR_NO_SUCH_FIB;
-  
-  fib_index = p[0];
-  
-  key = ((u64)fib_index<<32) | ((u64) dest->as_u32);
-  
-  if (is_add)
-    {
-      pool_get (mm->encaps, e);
-      memset (e, 0, sizeof (*e));
-      
-      for (i = 0; i < vec_len (labels_host_byte_order); i++)
-        {
-          mpls_unicast_header_t h;
-          label_host_byte_order = labels_host_byte_order[i];
-          
-          /* Reformat label into mpls_unicast_header_t */
-          label_host_byte_order <<= 12;
-	  // FIXME NEOS AND EOS
-          //if (i == vec_len(labels_host_byte_order) - 1)
-          //  label_host_byte_order |= 1<<8;            /* S=1 */
-          label_host_byte_order |= 0xff;            /* TTL=FF */
-          label_net_byte_order = clib_host_to_net_u32 (label_host_byte_order);
-          h.label_exp_s_ttl = label_net_byte_order;
-          vec_add1 (e->labels, h);
-        }
-      if (no_dst_hash == 0)
-        hash_set (mm->mpls_encap_by_fib_and_dest, key, e - mm->encaps);
-      if (indexp)
-        *indexp = e - mm->encaps;
-      if (policy_tunnel_index != ~0)
-        return vnet_mpls_policy_tunnel_add_rewrite (mm, e, policy_tunnel_index);
-    }
-  else
-    {
-      p = hash_get (mm->mpls_encap_by_fib_and_dest, key);
-      if (!p)
-        return VNET_API_ERROR_NO_SUCH_LABEL;
-      
-      e = pool_elt_at_index (mm->encaps, p[0]);
-      
-      vec_free (e->labels);
-      vec_free (e->rewrite);
-      pool_put(mm->encaps, e);
-      
-      if (no_dst_hash == 0)
-        hash_unset (mm->mpls_encap_by_fib_and_dest, key);    
-    }
-  return 0;
-}
-
-static clib_error_t *
-mpls_add_encap_command_fn (vlib_main_t * vm,
-                           unformat_input_t * input,
-                           vlib_cli_command_t * cmd)
-{
-  u32 fib_id;
-  u32 *labels = 0;
-  u32 this_label;
-  ip4_address_t dest;
-  u32 policy_tunnel_index = ~0;
-  int no_dst_hash = 0;
-  int rv;
-  int fib_set = 0;
-  int dest_set = 0;
-
-  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
-    {
-      if (unformat (input, "fib %d", &fib_id))
-        fib_set = 1;
-      else if (unformat (input, "dest %U", unformat_ip4_address, &dest))
-        dest_set = 1;
-      else if (unformat (input, "no-dst-hash"))
-        no_dst_hash = 1;
-      else if (unformat (input, "label %d", &this_label))
-        vec_add1 (labels, this_label);
-      else if (unformat (input, "policy-tunnel %d", &policy_tunnel_index))
-        ;
-      else
-        break;
-    }
-
-  if (fib_set == 0)
-    return clib_error_return (0, "fib-id missing");
-  if (dest_set == 0)
-    return clib_error_return (0, "destination IP address missing");
-  if (vec_len (labels) == 0)
-    return clib_error_return (0, "label stack missing");
-  
-  rv = vnet_mpls_add_del_encap (&dest, fib_id, labels, 
-                                policy_tunnel_index, 
-                                no_dst_hash, 0 /* indexp */,
-                                1 /* is_add */);
-  vec_free (labels);
-
-  switch (rv)
-    {
-    case 0:
-      break;
-
-    case VNET_API_ERROR_NO_SUCH_FIB:
-      return clib_error_return (0, "fib id %d unknown", fib_id);
-      
-    default:
-      return clib_error_return (0, "vnet_mpls_add_del_encap returned %d", 
-                                rv);
-    }
-
-  return 0;
-}
-
-VLIB_CLI_COMMAND (mpls_add_encap_command, static) = {
-  .path = "mpls encap add",
-  .short_help = 
-  "mpls encap add label <label> ... fib <id> dest <ip4-address>",
-  .function = mpls_add_encap_command_fn,
-};
-
 u8 * format_mpls_unicast_header_host_byte_order (u8 * s, va_list * args)
 {
   mpls_unicast_header_t *h = va_arg(*args, mpls_unicast_header_t *);
@@ -351,46 +161,6 @@ u8 * format_mpls_unicast_header_net_byte_order (u8 * s, va_list * args)
                  &h_host);
 }
 
-static clib_error_t *
-mpls_del_encap_command_fn (vlib_main_t * vm,
-		 unformat_input_t * input,
-		 vlib_cli_command_t * cmd)
-{
-  u32 fib_id;
-  ip4_address_t dest;
-  int rv;
-  
-  if (unformat (input, "fib %d dest %U", &fib_id, 
-                unformat_ip4_address, &dest)) 
-    {
-      rv = vnet_mpls_add_del_encap (&dest, fib_id, 0 /* labels */, 
-                                    ~0 /* policy_tunnel_index */,
-                                    0 /* no_dst_hash */,
-                                    0 /* indexp */,
-                                    0 /* is_add */);
-      switch (rv)
-        {
-        case VNET_API_ERROR_NO_SUCH_FIB:
-          return clib_error_return (0, "fib id %d unknown", fib_id);
-        case VNET_API_ERROR_NO_SUCH_ENTRY:
-          return clib_error_return (0, "dest %U not in fib %d",
-                                    format_ip4_address, &dest, fib_id);
-        default:
-          break;
-        }
-      return 0;
-    }
-  else
-    return clib_error_return (0, "unknown input `%U'",
-                              format_unformat_error, input);
-}
-
-VLIB_CLI_COMMAND (mpls_del_encap_command, static) = {
-  .path = "mpls encap delete",
-  .short_help = "mpls encap delete fib <id> dest <ip4-address>",
-  .function = mpls_del_encap_command_fn,
-};
-
 int
 mpls_dest_cmp(void * a1, void * a2)
 {
@@ -419,65 +189,22 @@ mpls_label_cmp(void * a1, void * a2)
 }
 
 static clib_error_t *
-show_mpls_fib_command_fn (vlib_main_t * vm,
-		 unformat_input_t * input,
-		 vlib_cli_command_t * cmd)
-{
-  u64 key; 
-  u32 value;
-  show_mpls_fib_t *records = 0;
-  show_mpls_fib_t *s;
-  mpls_main_t * mm = &mpls_main;
-  ip4_fib_t * rx_fib;
-
-  hash_foreach (key, value, mm->mpls_encap_by_fib_and_dest, 
-  ({
-    vec_add2 (records, s, 1);
-    s->fib_index = (u32)(key>>32);
-    s->dest = (u32)(key & 0xFFFFFFFF);
-    s->entry_index = (u32) value;
-  }));
-
-  if (!vec_len(records))
-    {
-      vlib_cli_output (vm, "MPLS encap table empty");
-    }
-  /* sort output by dst address within fib */
-  vec_sort_with_function (records, mpls_dest_cmp);
-  vec_sort_with_function (records, mpls_fib_index_cmp);
-  vlib_cli_output (vm, "MPLS encap table");
-  vlib_cli_output (vm, "%=6s%=16s%=16s", "Table", "Dest address", "Labels");
-  vec_foreach (s, records)
-    {
-      rx_fib = ip4_fib_get (s->fib_index);
-      vlib_cli_output (vm, "%=6d%=16U%=16U", rx_fib->table_id, 
-                       format_ip4_address, &s->dest,
-                       format_mpls_encap_index, mm, s->entry_index);
-    }
-
-  vec_free(records);
-  return 0;
-}
-
-VLIB_CLI_COMMAND (show_mpls_fib_command, static) = {
-    .path = "show mpls encap",
-    .short_help = "show mpls encap",
-    .function = show_mpls_fib_command_fn,
-};
-
-static clib_error_t *
 vnet_mpls_local_label (vlib_main_t * vm,
                        unformat_input_t * input,
                        vlib_cli_command_t * cmd)
 {
   unformat_input_t _line_input, * line_input = &_line_input;
   fib_route_path_t *rpaths = NULL, rpath;
-  clib_error_t * error = 0;
   u32 table_id, is_del, is_ip;
-  fib_prefix_t pfx;
   mpls_label_t local_label;
+  mpls_label_t out_label;
+  clib_error_t * error;
   mpls_eos_bit_t eos;
+  vnet_main_t * vnm;
+  fib_prefix_t pfx;
 
+  vnm = vnet_get_main();
+  error = NULL;
   is_ip = 0;
   table_id = 0;
   eos = MPLS_EOS;
@@ -519,13 +246,99 @@ vnet_mpls_local_label (vlib_main_t * vm,
 	  pfx.fp_proto = FIB_PROTOCOL_IP6;
           is_ip = 1;
       }
+      else if (unformat (line_input, "via %U %U weight %u",
+			 unformat_ip4_address,
+			 &rpath.frp_addr.ip4,
+			 unformat_vnet_sw_interface, vnm,
+			 &rpath.frp_sw_if_index,
+			 &rpath.frp_weight))
+      {
+	  rpath.frp_proto = FIB_PROTOCOL_IP4;
+	  vec_add1(rpaths, rpath);
+      }
+
+      else if (unformat (line_input, "via %U %U weight %u",
+			 unformat_ip6_address,
+			 &rpath.frp_addr.ip6,
+			 unformat_vnet_sw_interface, vnm,
+			 &rpath.frp_sw_if_index,
+			 &rpath.frp_weight))
+      {
+	  rpath.frp_proto = FIB_PROTOCOL_IP6;
+	  vec_add1(rpaths, rpath);
+      }
+
+      else if (unformat (line_input, "via %U %U",
+			 unformat_ip4_address,
+ 			 &rpath.frp_addr.ip4,
+			 unformat_vnet_sw_interface, vnm,
+			 &rpath.frp_sw_if_index))
+      {
+	  rpath.frp_weight = 1;
+	  rpath.frp_proto = FIB_PROTOCOL_IP4;
+	  vec_add1(rpaths, rpath);
+      }
+			 
+      else if (unformat (line_input, "via %U %U",
+			 unformat_ip6_address,
+ 			 &rpath.frp_addr.ip6,
+			 unformat_vnet_sw_interface, vnm,
+			 &rpath.frp_sw_if_index))
+      {
+	  rpath.frp_weight = 1;
+	  rpath.frp_proto = FIB_PROTOCOL_IP6;
+	  vec_add1(rpaths, rpath);
+      }
+      else if (unformat (line_input, "via %U next-hop-table %d",
+			 unformat_ip4_address,
+  			 &rpath.frp_addr.ip4,
+			 &rpath.frp_fib_index))
+      {
+	  rpath.frp_weight = 1;
+	  rpath.frp_sw_if_index = ~0;
+	  rpath.frp_proto = FIB_PROTOCOL_IP4;
+	  vec_add1(rpaths, rpath);
+      }
+      else if (unformat (line_input, "via %U next-hop-table %d",
+			 unformat_ip6_address,
+  			 &rpath.frp_addr.ip6,
+			 &rpath.frp_fib_index))
+      {
+	  rpath.frp_weight = 1;
+	  rpath.frp_sw_if_index = ~0;
+	  rpath.frp_proto = FIB_PROTOCOL_IP6;
+	  vec_add1(rpaths, rpath);
+      }
+      else if (unformat (line_input, "via %U",
+			 unformat_ip4_address,
+  			 &rpath.frp_addr.ip4))
+      {
+	  /*
+	   * the recursive next-hops are by default in the same table
+	   * as the prefix
+	   */
+	  rpath.frp_fib_index = table_id;
+	  rpath.frp_weight = 1;
+	  rpath.frp_sw_if_index = ~0;
+	  rpath.frp_proto = FIB_PROTOCOL_IP4;
+	  vec_add1(rpaths, rpath);
+      }
+      else if (unformat (line_input, "via %U",
+			 unformat_ip6_address,
+  			 &rpath.frp_addr.ip6))
+      {
+	  rpath.frp_fib_index = table_id;
+	  rpath.frp_weight = 1;
+	  rpath.frp_sw_if_index = ~0;
+	  rpath.frp_proto = FIB_PROTOCOL_IP6;
+	  vec_add1(rpaths, rpath);
+      }
       else if (unformat (line_input, "%d", &local_label))
 	;
       else if (unformat (line_input,
 			 "ip4-lookup-in-table %d",
 			 &rpath.frp_fib_index))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
           rpath.frp_proto = FIB_PROTOCOL_IP4;
           rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID;
 	  pfx.fp_payload_proto = DPO_PROTO_IP4;
@@ -535,7 +348,6 @@ vnet_mpls_local_label (vlib_main_t * vm,
 			 "ip6-lookup-in-table %d",
 			 &rpath.frp_fib_index))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
           rpath.frp_proto = FIB_PROTOCOL_IP6;
           rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID;
 	  vec_add1(rpaths, rpath);
@@ -545,16 +357,26 @@ vnet_mpls_local_label (vlib_main_t * vm,
 			 "mpls-lookup-in-table %d",
 			 &rpath.frp_fib_index))
       {
-	  rpath.frp_label = MPLS_LABEL_INVALID;
           rpath.frp_proto = FIB_PROTOCOL_MPLS;
           rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID;
 	  pfx.fp_payload_proto = DPO_PROTO_MPLS;
 	  vec_add1(rpaths, rpath);
       }
+      else if (unformat (line_input, "out-label %U",
+                         unformat_mpls_unicast_label,
+			 &out_label))
+      {
+	  if (vec_len(rpaths) == 0)
+	  {
+	      error = clib_error_return(0 , "Paths then labels");
+	      goto done;
+	  }
+	  vec_add1(rpaths[vec_len(rpaths)-1].frp_label_stack, out_label);
+      }
       else
       {
           error = clib_error_return (0, "unkown input: %U",
-                                     format_unformat_error, input);
+                                     format_unformat_error, line_input);
           goto done;
       }
 
@@ -596,6 +418,7 @@ vnet_mpls_local_label (vlib_main_t * vm,
       pfx.fp_proto = FIB_PROTOCOL_MPLS;
       pfx.fp_len = 21;
       pfx.fp_label = local_label;
+      pfx.fp_payload_proto = DPO_PROTO_MPLS;
 
       if (NULL == rpaths)
       {
@@ -606,17 +429,20 @@ vnet_mpls_local_label (vlib_main_t * vm,
       /*
        * the CLI parsing stored table Ids, swap to FIB indicies
        */
-      fi = fib_table_id_find_fib_index(dpo_proto_to_fib(pfx.fp_payload_proto),
-				       rpaths[0].frp_fib_index);
-
-      if (~0 == fi)
+      if (FIB_NODE_INDEX_INVALID == rpath.frp_sw_if_index)
       {
-	  error = clib_error_return(0 , "%U Via table %d does not exist",
-				    format_fib_protocol, pfx.fp_payload_proto,
-				    rpaths[0].frp_fib_index);
-	  goto done;
+	  fi = fib_table_id_find_fib_index(dpo_proto_to_fib(pfx.fp_payload_proto),
+					   rpaths[0].frp_fib_index);
+
+	  if (~0 == fi)
+	  {
+	      error = clib_error_return(0 , "%U Via table %d does not exist",
+					format_fib_protocol, pfx.fp_payload_proto,
+					rpaths[0].frp_fib_index);
+	      goto done;
+	  }
+	  rpaths[0].frp_fib_index = fi;
       }
-      rpaths[0].frp_fib_index = fi;
 
       fib_index = mpls_fib_index_from_table_id(table_id);
 
@@ -653,44 +479,15 @@ VLIB_CLI_COMMAND (mpls_local_label_command, static) = {
   .short_help = "Create/Delete MPL local labels",
 };
 
-int mpls_fib_reset_labels (u32 fib_id)
+int
+mpls_fib_reset_labels (u32 fib_id)
 {
-  u64 key; 
-  u32 value;
-  show_mpls_fib_t *records = 0;
-  show_mpls_fib_t *s;
-  mpls_main_t * mm = &mpls_main;
-  ip4_main_t * im = &ip4_main;
-  u32 fib_index;
-  uword *p;
-
-  p = hash_get (im->fib_index_by_table_id, fib_id);
-  if (! p)
-    return VNET_API_ERROR_NO_SUCH_FIB;
-
-  fib_index = p[0];
-
-  hash_foreach (key, value, mm->mpls_encap_by_fib_and_dest, 
-  ({
-    if (fib_index == (u32)(key>>32)) {
-        vec_add2 (records, s, 1);
-        s->dest = (u32)(key & 0xFFFFFFFF);
-        s->entry_index = (u32) value;
-    }
-  }));
-
-  vec_foreach (s, records)
-    {
-      key = ((u64)fib_index<<32) | ((u64) s->dest);
-      hash_unset (mm->mpls_encap_by_fib_and_dest, key);
-      pool_put_index (mm->encaps, s->entry_index);
-    }
-                
-  vec_free(records);
+  // FIXME
   return 0;
 }
 
-static clib_error_t * mpls_init (vlib_main_t * vm)
+static clib_error_t *
+mpls_init (vlib_main_t * vm)
 {
   mpls_main_t * mm = &mpls_main;
   clib_error_t * error;
@@ -701,8 +498,6 @@ static clib_error_t * mpls_init (vlib_main_t * vm)
   if ((error = vlib_call_init_function (vm, ip_main_init)))
     return error;
 
-  mm->mpls_encap_by_fib_and_dest = hash_create (0, sizeof (uword));
-
   return vlib_call_init_function (vm, mpls_input_init);
 }
 
diff --git a/vnet/vnet/mpls/mpls.h b/vnet/vnet/mpls/mpls.h
index 59fc761ea2c..b6fdbce7d70 100644
--- a/vnet/vnet/mpls/mpls.h
+++ b/vnet/vnet/mpls/mpls.h
@@ -30,30 +30,6 @@ typedef enum {
   MPLS_N_ERROR,
 } mpls_error_t;
 
-/*
- * No protocol info, MPLS labels don't have a next-header field
- * presumably the label field tells all...
- */
-typedef struct {
-  u8 tunnel_dst[6];
-  ip4_address_t intfc_address;
-  u32 tx_sw_if_index;
-  u32 inner_fib_index;
-  u32 mask_width;
-  u32 encap_index;
-  u32 hw_if_index;
-  u8 * rewrite_data;
-  u8 l2_only;
-  fib_node_index_t fei;
-} mpls_eth_tunnel_t;
-
-typedef struct {
-  mpls_unicast_header_t *labels;
-  /* only for policy tunnels */
-  u8 * rewrite;
-  u32 output_next_index;
-} mpls_encap_t;
-
 #define MPLS_FIB_DEFAULT_TABLE_ID 0
 
 /**
@@ -94,18 +70,6 @@ typedef struct {
   /** A hash table to lookup the mpls_fib by table ID */
   uword *fib_index_by_table_id;
 
-  /* pool of ethernet tunnel instances */
-  mpls_eth_tunnel_t *eth_tunnels;
-  u32 * free_eth_sw_if_indices;
-
-  /* Encap side: map (fib, dst_address) to mpls label stack */
-  mpls_encap_t * encaps;
-  uword * mpls_encap_by_fib_and_dest;
-
-  /* mpls-o-e policy tunnel next index for ip4/ip6-classify */
-  u32 ip4_classify_mpls_policy_encap_next_index;
-  u32 ip6_classify_mpls_policy_encap_next_index;
-
   /* Feature arc indices */
   u8 input_feature_arc_index;
   u8 output_feature_arc_index;
@@ -123,7 +87,6 @@ extern mpls_main_t mpls_main;
 extern clib_error_t * mpls_feature_init(vlib_main_t * vm);
 
 format_function_t format_mpls_protocol;
-format_function_t format_mpls_eth_header_with_length;
 format_function_t format_mpls_encap_index;
 
 format_function_t format_mpls_eos_bit;
@@ -153,29 +116,8 @@ void mpls_sw_interface_enable_disable (mpls_main_t * mm,
 
 u8 mpls_sw_interface_is_enabled (u32 sw_if_index);
 
-mpls_encap_t *
-mpls_encap_by_fib_and_dest (mpls_main_t * mm, u32 rx_fib, u32 dst_address);
-
-int vnet_mpls_ethernet_add_del_tunnel (u8 *dst,
-                                       ip4_address_t *intfc,
-                                       u32 mask_width,
-                                       u32 inner_fib_id,
-                                       u32 tx_sw_if_index,
-                                       u32 * tunnel_sw_if_index,
-                                       u8 l2_only,
-                                       u8 is_add);
-
 int mpls_fib_reset_labels (u32 fib_id);
 
-int vnet_mpls_add_del_encap (ip4_address_t *dest, u32 fib_id,
-                             u32 *labels_host_byte_order,
-                             u32 policy_tunnel_index,
-                             int no_dst_hash, u32 * indexp, int is_add);
-
-int vnet_mpls_policy_tunnel_add_rewrite (mpls_main_t * mm,
-                                         mpls_encap_t * e,
-                                         u32 policy_tunnel_index);
-
 #define foreach_mpls_input_next			\
 _(DROP, "error-drop")                           \
 _(LOOKUP, "mpls-lookup")
@@ -211,26 +153,6 @@ typedef enum {
 } mpls_output_next_t;
 
 typedef struct {
-  u32 lookup_miss;
-
-  /* Tunnel-id / index in tunnel vector */
-  u32 tunnel_id;
-
-  /* output interface */
-  u32 tx_sw_if_index;
-
-  /* mpls encap index */
-  u32 mpls_encap_index;
-
-  /* pkt length */
-  u32 length;
-
-  u8 dst[6];
-} mpls_eth_tx_trace_t;
-
-u8 * format_mpls_eth_tx_trace (u8 * s, va_list * args);
-
-typedef struct {
   u32 fib_index;
   u32 entry_index;
   u32 dest;
diff --git a/vnet/vnet/mpls/mpls_lookup.c b/vnet/vnet/mpls/mpls_lookup.c
index 34ba79e40fd..2d34cbde341 100644
--- a/vnet/vnet/mpls/mpls_lookup.c
+++ b/vnet/vnet/mpls/mpls_lookup.c
@@ -170,6 +170,19 @@ mpls_lookup (vlib_main_t * vm,
                vlib_buffer_length_in_chain (vm, b1));
 
           /*
+           * before we pop the label copy th values we need to maintain.
+           * The label header is in network byte order.
+           *  last byte is the TTL.
+           *  bits 2 to 4 inclusive are the EXP bits
+           */
+          vnet_buffer (b0)->mpls.ttl = ((char*)h0)[3];
+          vnet_buffer (b0)->mpls.exp = (((char*)h0)[2] & 0xe) >> 1;
+          vnet_buffer (b0)->mpls.first = 1;
+          vnet_buffer (b1)->mpls.ttl = ((char*)h1)[3];
+          vnet_buffer (b1)->mpls.exp = (((char*)h1)[2] & 0xe) >> 1;
+          vnet_buffer (b1)->mpls.first = 1;
+
+          /*
            * pop the label that was just used in the lookup
            */
           vlib_buffer_advance(b0, sizeof(*h0));
@@ -223,8 +236,8 @@ mpls_lookup (vlib_main_t * vm,
           lfib_index0 = vec_elt(mm->fib_index_by_sw_if_index,
                                 vnet_buffer(b0)->sw_if_index[VLIB_RX]);
 
-          lbi0 = mpls_fib_table_forwarding_lookup (lfib_index0, h0);
-          lb0 = load_balance_get(lbi0);
+          lbi0 = mpls_fib_table_forwarding_lookup(lfib_index0, h0);
+	  lb0 = load_balance_get(lbi0);
 
           hash_c0 = vnet_buffer(b0)->ip.flow_hash = 0;
           if (PREDICT_FALSE(lb0->lb_n_buckets > 1))
@@ -248,6 +261,16 @@ mpls_lookup (vlib_main_t * vm,
                vlib_buffer_length_in_chain (vm, b0));
 
           /*
+           * before we pop the label copy th values we need to maintain.
+           * The label header is in network byte order.
+           *  last byte is the TTL.
+           *  bits 2 to 4 inclusive are the EXP bits
+           */
+          vnet_buffer (b0)->mpls.ttl = ((char*)h0)[3];
+          vnet_buffer (b0)->mpls.exp = (((char*)h0)[2] & 0xe) >> 1;
+          vnet_buffer (b0)->mpls.first = 1;
+
+          /*
            * pop the label that was just used in the lookup
            */
           vlib_buffer_advance(b0, sizeof(*h0));
diff --git a/vnet/vnet/mpls/mpls_tunnel.c b/vnet/vnet/mpls/mpls_tunnel.c
new file mode 100644
index 00000000000..656bf330b1a
--- /dev/null
+++ b/vnet/vnet/mpls/mpls_tunnel.c
@@ -0,0 +1,779 @@
+/*
+ * mpls_tunnel.c: MPLS tunnel interfaces (i.e. for RSVP-TE)
+ *
+ * Copyright (c) 2012 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vnet/vnet.h>
+#include <vnet/pg/pg.h>
+#include <vnet/mpls/mpls_tunnel.h>
+#include <vnet/ip/ip.h>
+#include <vnet/fib/fib_path_list.h>
+#include <vnet/adj/adj_midchain.h>
+
+/**
+ * @brief pool of tunnel instances
+ */
+static mpls_tunnel_t *mpls_tunnel_pool;
+
+/**
+ * @brief Pool of free tunnel SW indices - i.e. recycled indices
+ */
+static u32 * mpls_tunnel_free_hw_if_indices;
+
+/**
+ * @brief DB of SW index to tunnel index
+ */
+static u32 *mpls_tunnel_db;
+
+/**
+ * @brief Get a tunnel object from a SW interface index
+ */
+static mpls_tunnel_t*
+mpls_tunnel_get_from_sw_if_index (u32 sw_if_index)
+{
+    if ((vec_len(mpls_tunnel_db) < sw_if_index) ||
+	(~0 == mpls_tunnel_db[sw_if_index]))
+	return (NULL);
+
+    return (pool_elt_at_index(mpls_tunnel_pool,
+			      mpls_tunnel_db[sw_if_index]));
+}
+
+/**
+ * @brief Return true if the label stack is imp-null only
+ */
+static fib_forward_chain_type_t
+mpls_tunnel_get_fwd_chain_type (const mpls_tunnel_t *mt)
+{
+    if ((1 == vec_len(mt->mt_label_stack)) &&
+	(mt->mt_label_stack[0] == MPLS_IETF_IMPLICIT_NULL_LABEL))
+    {
+	/*
+	 * the only label in the label stack is implicit null
+	 * we need to build an IP chain.
+	 */
+	if (FIB_PROTOCOL_IP4 == fib_path_list_get_proto(mt->mt_path_list))
+	{
+	    return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
+	}
+	else
+	{
+	    return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6);
+	}
+    }
+    else
+    {
+	return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS);
+    }
+}
+
+/**
+ * @brief Build a rewrite string for the MPLS tunnel.
+ *
+ * We have choices here;
+ *  1 - have an Adjacency with a zero length string and stack it on
+ *       MPLS label objects
+ *  2 - put the label header rewrites in the adjacency string.
+ *
+ * We choose 2 since it results in fewer graph nodes in the egress path
+ */
+static u8*
+mpls_tunnel_build_rewrite (vnet_main_t * vnm,
+			   u32 sw_if_index,
+			   vnet_link_t link_type,
+			   const void *dst_address)
+{
+    mpls_unicast_header_t *muh;
+    mpls_tunnel_t *mt;
+    u8 *rewrite;
+    u32 mti, ii;
+
+    rewrite = NULL;
+    mti = mpls_tunnel_db[sw_if_index];
+    mt = pool_elt_at_index(mpls_tunnel_pool, mti);
+
+    vec_validate(rewrite, (sizeof(*muh) * vec_len(mt->mt_label_stack)) - 1);
+    muh = (mpls_unicast_header_t *)rewrite;
+
+    /*
+     * The last (inner most) label in the stack may be EOS, all the rest Non-EOS
+     */
+    for (ii = 0; ii < vec_len(mt->mt_label_stack)-1; ii++)
+    {
+	vnet_mpls_uc_set_label(&muh[ii].label_exp_s_ttl, mt->mt_label_stack[ii]);
+	vnet_mpls_uc_set_ttl(&muh[ii].label_exp_s_ttl, 255);
+	vnet_mpls_uc_set_exp(&muh[ii].label_exp_s_ttl, 0);
+	vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_NON_EOS);
+	muh[ii].label_exp_s_ttl = clib_host_to_net_u32(muh[ii].label_exp_s_ttl);
+    }
+
+    vnet_mpls_uc_set_label(&muh[ii].label_exp_s_ttl, mt->mt_label_stack[ii]);
+    vnet_mpls_uc_set_ttl(&muh[ii].label_exp_s_ttl, 255);
+    vnet_mpls_uc_set_exp(&muh[ii].label_exp_s_ttl, 0);
+
+    if (VNET_LINK_MPLS == link_type &&
+	mt->mt_label_stack[ii] != MPLS_IETF_IMPLICIT_NULL_LABEL)
+	vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_NON_EOS);
+    else
+	vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_EOS);
+
+    muh[ii].label_exp_s_ttl = clib_host_to_net_u32(muh[ii].label_exp_s_ttl);
+
+    return ((u8*)muh);
+}
+
+/**
+ * mpls_tunnel_stack
+ *
+ * 'stack' (resolve the recursion for) the tunnel's midchain adjacency
+ */
+static void
+mpls_tunnel_stack (adj_index_t ai)
+{
+    ip_adjacency_t *adj;
+    mpls_tunnel_t *mt;
+    u32 sw_if_index;
+
+    adj = adj_get(ai);
+    sw_if_index = adj->rewrite_header.sw_if_index;
+
+    mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
+
+    if (NULL == mt)
+	return;
+
+    /*
+     * find the adjacency that is contributed by the FIB path-list
+     * that this tunnel resovles via, and use it as the next adj
+     * in the midchain
+     */
+    if (vnet_hw_interface_get_flags(vnet_get_main(),
+				    mt->mt_hw_if_index) &
+	VNET_HW_INTERFACE_FLAG_LINK_UP)
+    {
+	dpo_id_t dpo = DPO_INVALID;
+
+	fib_path_list_contribute_forwarding(mt->mt_path_list,
+					    mpls_tunnel_get_fwd_chain_type(mt),
+					    &dpo);
+
+	if (DPO_LOAD_BALANCE == dpo.dpoi_type)
+	{
+	    /*
+	     * we don't support multiple paths, so no need to load-balance.
+	     * pull the first and only choice and stack directly on that.
+	     */
+	    load_balance_t *lb;
+
+	    lb = load_balance_get (dpo.dpoi_index);
+
+	    ASSERT(1 == lb->lb_n_buckets);
+
+	    dpo_copy(&dpo, load_balance_get_bucket_i (lb, 0));
+	}
+
+	adj_nbr_midchain_stack(ai, &dpo);
+	dpo_reset(&dpo);
+    }
+    else
+    {
+	adj_nbr_midchain_unstack(ai);
+    }
+}
+
+/**
+ * @brief Call back when restacking all adjacencies on a MPLS interface
+ */
+static adj_walk_rc_t
+mpls_adj_walk_cb (adj_index_t ai,
+		 void *ctx)
+{
+    mpls_tunnel_stack(ai);
+
+    return (ADJ_WALK_RC_CONTINUE);
+}
+
+static void
+mpls_tunnel_restack (mpls_tunnel_t *mt)
+{
+    fib_protocol_t proto;
+
+    /*
+     * walk all the adjacencies on the MPLS interface and restack them
+     */
+    FOR_EACH_FIB_PROTOCOL(proto)
+    {
+	adj_nbr_walk(mt->mt_sw_if_index,
+		     proto,
+		     mpls_adj_walk_cb,
+		     NULL);
+    }
+}
+
+static clib_error_t *
+mpls_tunnel_admin_up_down (vnet_main_t * vnm,
+			   u32 hw_if_index,
+			   u32 flags)
+{
+    vnet_hw_interface_t * hi;
+    mpls_tunnel_t *mt;
+
+    hi = vnet_get_hw_interface (vnm, hw_if_index);
+
+    mt = mpls_tunnel_get_from_sw_if_index(hi->sw_if_index);
+
+    if (NULL == mt)
+	return (NULL);
+
+    if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
+	vnet_hw_interface_set_flags (vnm, hw_if_index,
+				     VNET_HW_INTERFACE_FLAG_LINK_UP);
+    else
+	vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */);
+
+    mpls_tunnel_restack(mt);
+
+    return (NULL);
+}
+
+/**
+ * @brief Fixup the adj rewrite post encap. This is a no-op since the
+ * rewrite is a stack of labels.
+ */
+static void
+mpls_tunnel_fixup (vlib_main_t *vm,
+		   ip_adjacency_t *adj,
+		   vlib_buffer_t *b0)
+{
+}
+
+static void
+mpls_tunnel_update_adj (vnet_main_t * vnm,
+			u32 sw_if_index,
+			adj_index_t ai)
+{
+    adj_nbr_midchain_update_rewrite(
+	ai, mpls_tunnel_fixup, 
+	ADJ_MIDCHAIN_FLAG_NONE,
+	mpls_tunnel_build_rewrite(vnm, sw_if_index,
+				  adj_get_link_type(ai),
+				  NULL));
+
+    mpls_tunnel_stack(ai);
+}
+
+static u8 *
+format_mpls_tunnel_name (u8 * s, va_list * args)
+{
+  u32 dev_instance = va_arg (*args, u32);
+  return format (s, "mpls-tunnel%d", dev_instance);
+}
+
+static u8 *
+format_mpls_tunnel_device (u8 * s, va_list * args)
+{
+  u32 dev_instance = va_arg (*args, u32);
+  CLIB_UNUSED (int verbose) = va_arg (*args, int);
+
+  return (format (s, "MPLS-tunnel: id %d\n", dev_instance));
+}
+
+/**
+ * @brief Packet trace structure
+ */
+typedef struct mpls_tunnel_trace_t_
+{
+    /**
+   * Tunnel-id / index in tunnel vector
+   */
+  u32 tunnel_id;
+} mpls_tunnel_trace_t;
+
+static u8 *
+format_mpls_tunnel_tx_trace (u8 * s,
+			     va_list * args)
+{
+  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
+  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
+  mpls_tunnel_trace_t * t = va_arg (*args, mpls_tunnel_trace_t *);
+
+  s = format (s, "MPLS: tunnel %d", t->tunnel_id);
+  return s;
+}
+
+/**
+ * @brief TX function. Only called L2. L3 traffic uses the adj-midchains
+ */
+static uword
+mpls_tunnel_tx (vlib_main_t * vm,
+		vlib_node_runtime_t * node,
+		vlib_frame_t * frame)
+{
+  u32 next_index;
+  u32 * from, * to_next, n_left_from, n_left_to_next;
+  vnet_interface_output_runtime_t * rd = (void *) node->runtime_data;
+  const mpls_tunnel_t *mt;
+
+  mt = pool_elt_at_index(mpls_tunnel_pool, rd->dev_instance);
+
+  /* Vector of buffer / pkt indices we're supposed to process */
+  from = vlib_frame_vector_args (frame);
+
+  /* Number of buffers / pkts */
+  n_left_from = frame->n_vectors;
+
+  /* Speculatively send the first buffer to the last disposition we used */
+  next_index = node->cached_next_index;
+
+  while (n_left_from > 0)
+    {
+      /* set up to enqueue to our disposition with index = next_index */
+      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+      /*
+       * FIXME DUAL LOOP
+       */
+      while (n_left_from > 0 && n_left_to_next > 0)
+	{
+	  vlib_buffer_t * b0;
+	  u32 bi0;
+
+	  bi0 = from[0];
+	  to_next[0] = bi0;
+	  from += 1;
+	  to_next += 1;
+	  n_left_from -= 1;
+	  n_left_to_next -= 1;
+
+	  b0 = vlib_get_buffer(vm, bi0);
+
+	  vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_adj;
+
+	  if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      mpls_tunnel_trace_t *tr = vlib_add_trace (vm, node,
+						   b0, sizeof (*tr));
+	      tr->tunnel_id = rd->dev_instance;
+	    }
+
+	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
+					   to_next, n_left_to_next,
+					   bi0, mt->mt_l2_tx_arc);
+	}
+
+      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
+    }
+
+  return frame->n_vectors;
+}
+
+VNET_DEVICE_CLASS (mpls_tunnel_class) = {
+    .name = "MPLS tunnel device",
+    .format_device_name = format_mpls_tunnel_name,
+    .format_device = format_mpls_tunnel_device,
+    .format_tx_trace = format_mpls_tunnel_tx_trace,
+    .tx_function = mpls_tunnel_tx,
+    .no_flatten_output_chains = 1,
+    .admin_up_down_function = mpls_tunnel_admin_up_down,
+};
+
+VNET_HW_INTERFACE_CLASS (mpls_tunnel_hw_interface_class) = {
+  .name = "MPLS-Tunnel",
+//  .format_header = format_mpls_eth_header_with_length,
+//  .unformat_header = unformat_mpls_eth_header,
+  .update_adjacency = mpls_tunnel_update_adj,
+  .build_rewrite = mpls_tunnel_build_rewrite,
+  .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
+};
+
+const mpls_tunnel_t *
+mpls_tunnel_get (u32 mti)
+{
+    return (pool_elt_at_index(mpls_tunnel_pool, mti));
+}
+
+/**
+ * @brief Walk all the MPLS tunnels
+ */
+void
+mpls_tunnel_walk (mpls_tunnel_walk_cb_t cb,
+		  void *ctx)
+{
+    u32 mti;
+
+    pool_foreach_index(mti, mpls_tunnel_pool,
+    ({
+	cb(mti, ctx);
+    }));
+}
+
+void
+vnet_mpls_tunnel_del (u32 sw_if_index)
+{
+    mpls_tunnel_t *mt;
+
+    mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
+
+    if (NULL == mt)
+	return;
+    
+    fib_path_list_child_remove(mt->mt_path_list,
+			       mt->mt_sibling_index);
+    if (ADJ_INDEX_INVALID != mt->mt_l2_adj)
+	adj_unlock(mt->mt_l2_adj);
+
+    vec_free(mt->mt_label_stack);
+
+    vec_add1 (mpls_tunnel_free_hw_if_indices, mt->mt_hw_if_index);
+    pool_put(mpls_tunnel_pool, mt);
+    mpls_tunnel_db[sw_if_index] = ~0;
+}
+
+void
+vnet_mpls_tunnel_add (fib_route_path_t *rpaths,
+		      mpls_label_t *label_stack,
+		      u8 l2_only,
+		      u32 *sw_if_index)
+{
+    vnet_hw_interface_t * hi;
+    mpls_tunnel_t *mt;
+    vnet_main_t * vnm;
+    u32 mti;
+
+    vnm = vnet_get_main();
+    pool_get(mpls_tunnel_pool, mt);
+    memset (mt, 0, sizeof (*mt));
+    mti = mt - mpls_tunnel_pool;
+    fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL);
+    mt->mt_l2_adj = ADJ_INDEX_INVALID;
+
+    /*
+     * Create a new, or re=use and old, tunnel HW interface
+     */
+    if (vec_len (mpls_tunnel_free_hw_if_indices) > 0)
+    {
+	mt->mt_hw_if_index = 
+	    mpls_tunnel_free_hw_if_indices[vec_len(mpls_tunnel_free_hw_if_indices)-1];
+	_vec_len (mpls_tunnel_free_hw_if_indices) -= 1;
+	hi = vnet_get_hw_interface (vnm, mt->mt_hw_if_index);
+	hi->hw_instance = mti;
+	hi->dev_instance = mti;
+    }
+    else 
+    {
+	mt->mt_hw_if_index = vnet_register_interface(
+	                         vnm,
+				 mpls_tunnel_class.index,
+				 mti,
+				 mpls_tunnel_hw_interface_class.index,
+				 mti);
+	hi = vnet_get_hw_interface(vnm, mt->mt_hw_if_index);
+    }
+
+    /*
+     * Add the new tunnel to the tunnel DB - key:SW if index
+     */
+    mt->mt_sw_if_index = hi->sw_if_index;
+    vec_validate_init_empty(mpls_tunnel_db, mt->mt_sw_if_index, ~0);
+    mpls_tunnel_db[mt->mt_sw_if_index] = mti;
+
+    /*
+     * construct a path-list from the path provided
+     */
+    mt->mt_path_list = fib_path_list_create(FIB_PATH_LIST_FLAG_SHARED, rpaths);
+    mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
+						   FIB_NODE_TYPE_MPLS_TUNNEL,
+						   mti);
+
+    mt->mt_label_stack = vec_dup(label_stack);
+
+    if (l2_only)
+    {
+	mt->mt_l2_adj =
+	    adj_nbr_add_or_lock(fib_path_list_get_proto(mt->mt_path_list),
+				VNET_LINK_ETHERNET,
+				&zero_addr,
+				mt->mt_sw_if_index);
+
+	mt->mt_l2_tx_arc = vlib_node_add_named_next(vlib_get_main(),
+						    hi->tx_node_index,
+						    "adj-l2-midchain");
+    }
+
+    *sw_if_index = mt->mt_sw_if_index;
+}
+
+static clib_error_t *
+vnet_create_mpls_tunnel_command_fn (vlib_main_t * vm,
+				    unformat_input_t * input,
+				    vlib_cli_command_t * cmd)
+{
+    unformat_input_t _line_input, * line_input = &_line_input;
+    vnet_main_t * vnm = vnet_get_main();
+    u8 is_del = 0;
+    u8 l2_only = 0;
+    fib_route_path_t rpath, *rpaths = NULL;
+    mpls_label_t out_label = MPLS_LABEL_INVALID, *labels = NULL;
+    u32 sw_if_index;
+
+    memset(&rpath, 0, sizeof(rpath));
+
+    /* Get a line of input. */
+    if (! unformat_user (input, unformat_line_input, line_input))
+	return 0;
+
+    while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+	if (unformat (line_input, "del %U",
+		      unformat_vnet_sw_interface, vnm,
+		      &sw_if_index))
+	    is_del = 1;
+	else if (unformat (line_input, "add"))
+	    is_del = 0;
+	else if (unformat (line_input, "out-label %U",
+			   unformat_mpls_unicast_label, &out_label))
+	{
+	    vec_add1(labels, out_label);
+	}
+	else if (unformat (line_input, "via %U %U",
+			   unformat_ip4_address,
+			   &rpath.frp_addr.ip4,
+			   unformat_vnet_sw_interface, vnm,
+			   &rpath.frp_sw_if_index))
+	{
+	    rpath.frp_weight = 1;
+	    rpath.frp_proto = FIB_PROTOCOL_IP4;
+	}
+			 
+	else if (unformat (line_input, "via %U %U",
+			   unformat_ip6_address,
+			   &rpath.frp_addr.ip6,
+			   unformat_vnet_sw_interface, vnm,
+			   &rpath.frp_sw_if_index))
+	{
+	    rpath.frp_weight = 1;
+	    rpath.frp_proto = FIB_PROTOCOL_IP6;
+	}
+	else if (unformat (line_input, "via %U",
+			   unformat_ip6_address,
+			   &rpath.frp_addr.ip6))
+	{
+	    rpath.frp_fib_index = 0;
+	    rpath.frp_weight = 1;
+	    rpath.frp_sw_if_index = ~0;
+	    rpath.frp_proto = FIB_PROTOCOL_IP6;
+	}
+	else if (unformat (line_input, "via %U",
+			   unformat_ip4_address,
+			   &rpath.frp_addr.ip4))
+	{
+	    rpath.frp_fib_index = 0;
+	    rpath.frp_weight = 1;
+	    rpath.frp_sw_if_index = ~0;
+	    rpath.frp_proto = FIB_PROTOCOL_IP4;
+	}
+	else if (unformat (line_input, "l2-only"))
+	    l2_only = 1;
+	else
+	    return clib_error_return (0, "unknown input '%U'",
+				      format_unformat_error, line_input);
+    }
+
+    if (is_del)
+    {
+	vnet_mpls_tunnel_del(sw_if_index);
+    }
+    else
+    {
+	if (0 == vec_len(labels))
+	    return clib_error_return (0, "No Output Labels '%U'",
+				      format_unformat_error, line_input);
+
+	vec_add1(rpaths, rpath);
+	vnet_mpls_tunnel_add(rpaths, labels, l2_only, &sw_if_index);
+    }
+
+    vec_free(labels);
+    vec_free(rpaths);
+
+    return (NULL);
+}
+
+/*?
+ * This command create a uni-directional MPLS tunnel
+ *
+ * @cliexpar
+ * @cliexstart{create mpls tunnel}
+ *  create mpls tunnel via 10.0.0.1 GigEthernet0/8/0 out-label 33 out-label 34
+ * @cliexend
+ ?*/
+VLIB_CLI_COMMAND (create_mpls_tunnel_command, static) = {
+  .path = "mpls tunnel",
+  .short_help = 
+  "mpls tunnel via [addr] [interface] [out-labels]",
+  .function = vnet_create_mpls_tunnel_command_fn,
+};
+
+static u8 *
+format_mpls_tunnel (u8 * s, va_list * args)
+{
+    mpls_tunnel_t *mt = va_arg (*args, mpls_tunnel_t *);
+    int ii;
+
+    s = format(s, "mpls_tunnel%d: sw_if_index:%d hw_if_index:%d",
+	       mt - mpls_tunnel_pool,
+	       mt->mt_sw_if_index,
+	       mt->mt_hw_if_index);
+    s = format(s, "\n label-stack:\n  ");
+    for (ii = 0; ii < vec_len(mt->mt_label_stack); ii++)
+    {
+	s = format(s, "%d, ", mt->mt_label_stack[ii]);
+    }
+    s = format(s, "\n via:\n");
+    s = fib_path_list_format(mt->mt_path_list, s);
+    s = format(s, "\n");
+
+    return (s);
+}
+
+static clib_error_t *
+show_mpls_tunnel_command_fn (vlib_main_t * vm,
+			     unformat_input_t * input,
+			     vlib_cli_command_t * cmd)
+{
+    mpls_tunnel_t * mt;
+    u32 mti = ~0;
+
+    if (pool_elts (mpls_tunnel_pool) == 0)
+	vlib_cli_output (vm, "No MPLS tunnels configured...");
+
+    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+	if (unformat (input, "%d", &mti))
+	    ;
+	else
+	    break;
+    }
+
+    if (~0 == mti)
+    {
+	pool_foreach (mt, mpls_tunnel_pool,
+	({
+	    vlib_cli_output (vm, "[@%d] %U",
+			     mt - mpls_tunnel_pool,
+			     format_mpls_tunnel, mt);
+	}));
+    }
+    else
+    {
+	if (pool_is_free_index(mpls_tunnel_pool, mti))
+	    return clib_error_return (0, "Not atunnel index %d", mti);
+
+	mt = pool_elt_at_index(mpls_tunnel_pool, mti);
+
+	vlib_cli_output (vm, "[@%d] %U",
+			 mt - mpls_tunnel_pool,
+			 format_mpls_tunnel, mt);
+    }
+
+    return 0;
+}
+
+/*?
+ * This command to show MPLS tunnels
+ *
+ * @cliexpar
+ * @cliexstart{sh mpls tunnel 2}
+ * [@2] mpls_tunnel2: sw_if_index:5 hw_if_index:5
+ *  label-stack:
+ *    3, 
+ *  via:
+ *   index:26 locks:1 proto:ipv4 uPRF-list:26 len:1 itfs:[2, ]
+ *     index:26 pl-index:26 ipv4 weight=1 attached-nexthop:  oper-flags:resolved,
+ *      10.0.0.2 loop0
+ *         [@0]: ipv4 via 10.0.0.2 loop0: IP4: de:ad:00:00:00:00 -> 00:00:11:aa:bb:cc
+ * @cliexend
+ ?*/
+VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = {
+    .path = "show mpls tunnel",
+    .function = show_mpls_tunnel_command_fn,
+};
+
+static mpls_tunnel_t *
+mpls_tunnel_from_fib_node (fib_node_t *node)
+{
+#if (CLIB_DEBUG > 0)
+    ASSERT(FIB_NODE_TYPE_MPLS_TUNNEL == node->fn_type);
+#endif
+    return ((mpls_tunnel_t*) (((char*)node) -
+                             STRUCT_OFFSET_OF(mpls_tunnel_t, mt_node)));
+}
+
+/**
+ * Function definition to backwalk a FIB node
+ */
+static fib_node_back_walk_rc_t
+mpls_tunnel_back_walk (fib_node_t *node,
+		      fib_node_back_walk_ctx_t *ctx)
+{
+    mpls_tunnel_restack(mpls_tunnel_from_fib_node(node));
+
+    return (FIB_NODE_BACK_WALK_CONTINUE);
+}
+
+/**
+ * Function definition to get a FIB node from its index
+ */
+static fib_node_t*
+mpls_tunnel_fib_node_get (fib_node_index_t index)
+{
+    mpls_tunnel_t * mt;
+
+    mt = pool_elt_at_index(mpls_tunnel_pool, index);
+
+    return (&mt->mt_node);
+}
+
+/**
+ * Function definition to inform the FIB node that its last lock has gone.
+ */
+static void
+mpls_tunnel_last_lock_gone (fib_node_t *node)
+{
+    /*
+     * The MPLS MPLS tunnel is a root of the graph. As such
+     * it never has children and thus is never locked.
+     */
+    ASSERT(0);
+}
+
+/*
+ * Virtual function table registered by MPLS MPLS tunnels
+ * for participation in the FIB object graph.
+ */
+const static fib_node_vft_t mpls_vft = {
+    .fnv_get = mpls_tunnel_fib_node_get,
+    .fnv_last_lock = mpls_tunnel_last_lock_gone,
+    .fnv_back_walk = mpls_tunnel_back_walk,
+};
+
+static clib_error_t *
+mpls_tunnel_init (vlib_main_t *vm)
+{
+  fib_node_register_type(FIB_NODE_TYPE_MPLS_TUNNEL, &mpls_vft);
+
+  return 0;
+}
+VLIB_INIT_FUNCTION(mpls_tunnel_init);
diff --git a/vnet/vnet/mpls/mpls_tunnel.h b/vnet/vnet/mpls/mpls_tunnel.h
new file mode 100644
index 00000000000..ee56c0fc8e3
--- /dev/null
+++ b/vnet/vnet/mpls/mpls_tunnel.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __MPLS_TUNNEL_H__
+#define __MPLS_TUNNEL_H__
+
+#include <vnet/mpls/mpls.h>
+
+/**
+ * @brief A uni-directional MPLS tunnel
+ */
+typedef struct mpls_tunnel_t_
+{
+    /**
+     * @brief The tunnel hooks into the FIB control plane graph.
+     */
+    fib_node_t mt_node;
+
+    /**
+     * @brief If the tunnel is an L2 tunnel, this is the link type ETHERNET
+     * adjacency
+     */
+    adj_index_t mt_l2_adj;
+
+    /**
+     * @brief on a L2 tunnel this is the VLIB arc from the L2-tx to the l2-midchain
+     */
+    u32 mt_l2_tx_arc;
+
+    /**
+     * @brief The path-list over which the tunnel's destination is reachable
+     */
+    fib_node_index_t mt_path_list;
+
+    /**
+     * @brief sibling index on the path-list so notifications are received.
+     */
+    u32 mt_sibling_index;
+
+    /**
+     * @brief The Label stack to apply to egress packets
+     */
+    mpls_label_t *mt_label_stack;
+
+    /**
+     * @brief Flag to indicate the tunnel is only for L2 traffic, that is
+     * this tunnel belongs in a bridge domain.
+     */
+    u8 mt_l2_only;
+
+    /**
+     * @brief The HW interface index of the tunnel interfaces
+     */
+    u32 mt_hw_if_index;
+
+    /**
+     * @brief The SW interface index of the tunnel interfaces
+     */
+    u32 mt_sw_if_index;
+
+} mpls_tunnel_t;
+
+/**
+ * @brief Create a new MPLS tunnel
+ */
+extern void vnet_mpls_tunnel_add (fib_route_path_t *rpath,
+				  mpls_label_t *label_stack,
+				  u8 l2_only,
+				  u32 *sw_if_index);
+
+extern void vnet_mpls_tunnel_del (u32 sw_if_index);
+
+extern const mpls_tunnel_t *mpls_tunnel_get(u32 index);
+
+/**
+ * @brief Callback function invoked while walking MPLS tunnels
+ */
+typedef void (*mpls_tunnel_walk_cb_t)(u32 index, void *ctx);
+
+/**
+ * @brief Walk all the MPLS tunnels
+ */
+extern void mpls_tunnel_walk(mpls_tunnel_walk_cb_t cb,
+			     void *ctx);
+
+#endif
diff --git a/vnet/vnet/mpls/policy_encap.c b/vnet/vnet/mpls/policy_encap.c
deleted file mode 100644
index d48a153b37d..00000000000
--- a/vnet/vnet/mpls/policy_encap.c
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * policy_encap.c: mpls-o-e policy encap
- *
- * Copyright (c) 2012-2014 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <vlib/vlib.h>
-#include <vnet/pg/pg.h>
-#include <vnet/mpls/mpls.h>
-#include <vnet/classify/vnet_classify.h>
-
-typedef struct {
-  u32 next_index;
-  u32 encap_index;
-} mpls_policy_encap_trace_t;
-
-u8 * format_mpls_policy_encap_trace (u8 * s, va_list * args)
-{
-  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
-  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  mpls_policy_encap_trace_t * t = va_arg (*args, mpls_policy_encap_trace_t *);
-
-  s = format (s, "MPLS-POLICY-ENCAP: next-index %d encap-index %d",
-              t->next_index, t->encap_index);
-
-  return s;
-}
-
-vlib_node_registration_t mpls_policy_encap_node;
-
-#define foreach_mpls_policy_encap_next          \
-_(DROP, "error-drop")
-
-typedef enum {
-#define _(s,n) MPLS_POLICY_ENCAP_NEXT_##s,
-  foreach_mpls_policy_encap_next
-#undef _
-  MPLS_POLICY_ENCAP_N_NEXT,
-} mpls_policy_encap_next_t;
-
-#define foreach_mpls_policy_error                               \
-_(PKTS_ENCAP, "mpls policy tunnel packets encapsulated")
-
-typedef enum {
-#define _(n,s) MPLS_POLICY_ENCAP_ERROR_##n,
-  foreach_mpls_policy_error
-  MPLS_POLICY_ENCAP_N_ERROR,
-#undef _
-} mpls_policy_encap_error_t;
-
-static char * mpls_policy_encap_error_strings[] =
-  {
-#define _(n,s) s,
-    foreach_mpls_policy_error
-#undef _
-};
-    
-static uword
-mpls_policy_encap (vlib_main_t * vm,
-                   vlib_node_runtime_t * node,
-                   vlib_frame_t * from_frame)
-{
-  u32 n_left_from, next_index, * from, * to_next;
-  mpls_main_t * mm = &mpls_main;
-  
-  from = vlib_frame_vector_args (from_frame);
-  n_left_from = from_frame->n_vectors;
-  
-  next_index = node->cached_next_index;
-  
-  while (n_left_from > 0)
-    {
-      u32 n_left_to_next;
-
-      vlib_get_next_frame (vm, node, next_index,
-			   to_next, n_left_to_next);
-
-      while (n_left_from > 0 && n_left_to_next > 0)
-	{
-	  u32 bi0;
-	  vlib_buffer_t * b0;
-          u8 * h0;
-          u32 encap_index0;
-          u32 next0;
-          mpls_encap_t * e0;
-
-	  bi0 = from[0];
-	  to_next[0] = bi0;
-	  from += 1;
-	  to_next += 1;
-	  n_left_from -= 1;
-	  n_left_to_next -= 1;
-
-	  b0 = vlib_get_buffer (vm, bi0);
-
-          encap_index0 = vnet_buffer(b0)->l2_classify.opaque_index;
-
-          e0 = pool_elt_at_index (mm->encaps, encap_index0);
-
-          vlib_buffer_advance (b0, -(word)vec_len(e0->rewrite));
-          h0 = vlib_buffer_get_current (b0);
-          clib_memcpy (h0, e0->rewrite, vec_len(e0->rewrite));
-
-          next0 = e0->output_next_index;
-
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              mpls_policy_encap_trace_t *tr = 
-                vlib_add_trace (vm, node, b0, sizeof (*tr));
-              tr->next_index = next0;
-              tr->encap_index = encap_index0;
-            }
-	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
-					   to_next, n_left_to_next,
-					   bi0, next0);
-	}
-      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
-    }
-  vlib_node_increment_counter (vm, mpls_policy_encap_node.index,
-                               MPLS_POLICY_ENCAP_ERROR_PKTS_ENCAP, 
-                               from_frame->n_vectors);
-  return from_frame->n_vectors;
-}
-
-VLIB_REGISTER_NODE (mpls_policy_encap_node) =  {
-  .function = mpls_policy_encap,
-  .name = "mpls-policy-encap",
-  /* Takes a vector of packets. */
-  .vector_size = sizeof (u32),
-  
-  .runtime_data_bytes = 0,
-  
-  .n_errors = MPLS_POLICY_ENCAP_N_ERROR,
-  .error_strings = mpls_policy_encap_error_strings,
-  
-  .format_trace = format_mpls_policy_encap_trace,
-  
-  .n_next_nodes = MPLS_POLICY_ENCAP_N_NEXT,
-  .next_nodes = {
-#define _(s,n) [MPLS_POLICY_ENCAP_NEXT_##s] = n,
-    foreach_mpls_policy_encap_next
-#undef _
-  },
-};
-
-VLIB_NODE_FUNCTION_MULTIARCH (mpls_policy_encap_node, mpls_policy_encap)
-
-static clib_error_t *
-mpls_policy_encap_init (vlib_main_t * vm)
-{
-  mpls_main_t * mm = &mpls_main;
-  clib_error_t * error;
-
-  if ((error = vlib_call_init_function (vm, mpls_init)))
-    return error;
-  
-  mm->ip4_classify_mpls_policy_encap_next_index =
-    vlib_node_add_next (mm->vlib_main,
-                        ip4_classify_node.index, 
-                        mpls_policy_encap_node.index);
-
-  mm->ip6_classify_mpls_policy_encap_next_index =
-    vlib_node_add_next (mm->vlib_main,
-                        ip6_classify_node.index, 
-                        mpls_policy_encap_node.index);
-
-  return 0;
-}
-
-VLIB_INIT_FUNCTION (mpls_policy_encap_init);