fib: fib api updates

Enhance the route add/del APIs to take a set of paths rather than just one.
Most unicast routing protocols calcualte all the available paths in one
run of the algorithm so updating all the paths at once is beneficial for the client.
two knobs control the behaviour:
  is_multipath - if set the the set of paths passed will be added to those
                 that already exist, otherwise the set will replace them.
  is_add - add or remove the set

is_add=0, is_multipath=1 and an empty set, results in deleting the route.

It is also considerably faster to add multiple paths at once, than one at a time:

vat# ip_add_del_route 1.1.1.1/32 count 100000 multipath via 10.10.10.11
100000 routes in .572240 secs, 174751.80 routes/sec
vat# ip_add_del_route 1.1.1.1/32 count 100000 multipath via 10.10.10.12
100000 routes in .528383 secs, 189256.54 routes/sec
vat# ip_add_del_route 1.1.1.1/32 count 100000 multipath via 10.10.10.13
100000 routes in .757131 secs, 132077.52 routes/sec
vat# ip_add_del_route 1.1.1.1/32 count 100000 multipath via 10.10.10.14
100000 routes in .878317 secs, 113854.12 routes/sec

vat# ip_route_add_del 1.1.1.1/32 count 100000 multipath via 10.10.10.11 via 10.10.10.12 via 10.10.10.13 via 10.10.10.14
100000 routes in .900212 secs, 111084.93 routes/sec

Change-Id: I416b93f7684745099c1adb0b33edac58c9339c1a
Signed-off-by: Neale Ranns <neale.ranns@cisco.com>
Signed-off-by: Ole Troan <ot@cisco.com>
Signed-off-by: Paul Vinciguerra <pvinci@vinciconsulting.com>

1 files changed, 253 insertions, 803 deletions

diff --git a/src/vnet/ip/ip_api.c b/src/vnet/ip/ip_api.c
index bcbcf5ac8d4..4d2f0704ca3 100644
--- a/src/vnet/ip/ip_api.c
+++ b/src/vnet/ip/ip_api.c
@@ -29,18 +29,15 @@
 #include <vnet/ip/ip_types_api.h>
 #include <vnet/ip/ip6_neighbor.h>
 #include <vnet/ip/ip_punt_drop.h>
+#include <vnet/ip/ip_types_api.h>
 #include <vnet/fib/fib_table.h>
 #include <vnet/fib/fib_api.h>
-#include <vnet/dpo/drop_dpo.h>
-#include <vnet/dpo/receive_dpo.h>
-#include <vnet/dpo/lookup_dpo.h>
-#include <vnet/dpo/classify_dpo.h>
-#include <vnet/dpo/ip_null_dpo.h>
 #include <vnet/ethernet/arp_packet.h>
 #include <vnet/mfib/ip6_mfib.h>
 #include <vnet/mfib/ip4_mfib.h>
 #include <vnet/mfib/mfib_signal.h>
 #include <vnet/mfib/mfib_entry.h>
+#include <vnet/mfib/mfib_api.h>
 #include <vnet/ip/ip_source_and_port_range_check.h>
 #include <vnet/fib/ip4_fib.h>
 #include <vnet/fib/ip6_fib.h>
@@ -71,10 +68,10 @@
 
 
 #define foreach_ip_api_msg                                              \
-_(IP_FIB_DUMP, ip_fib_dump)                                             \
-_(IP6_FIB_DUMP, ip6_fib_dump)                                           \
-_(IP_MFIB_DUMP, ip_mfib_dump)                                           \
-_(IP6_MFIB_DUMP, ip6_mfib_dump)                                         \
+_(IP_TABLE_DUMP, ip_table_dump)                                         \
+_(IP_ROUTE_DUMP, ip_route_dump)                                         \
+_(IP_MTABLE_DUMP, ip_mtable_dump)                                       \
+_(IP_MROUTE_DUMP, ip_mroute_dump)                                       \
 _(IP_NEIGHBOR_DUMP, ip_neighbor_dump)                                   \
 _(IP_MROUTE_ADD_DEL, ip_mroute_add_del)                                 \
 _(MFIB_SIGNAL_DUMP, mfib_signal_dump)                                   \
@@ -93,7 +90,7 @@ _(PROXY_ARP_DUMP, proxy_arp_dump)                                       \
 _(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable)       \
  _(PROXY_ARP_INTFC_DUMP, proxy_arp_intfc_dump)                          \
 _(RESET_FIB, reset_fib)							\
-_(IP_ADD_DEL_ROUTE, ip_add_del_route)                                   \
+_(IP_ROUTE_ADD_DEL, ip_route_add_del)                                   \
 _(IP_TABLE_ADD_DEL, ip_table_add_del)                                   \
 _(IP_PUNT_POLICE, ip_punt_police)                                       \
 _(IP_PUNT_REDIRECT, ip_punt_redirect)                                   \
@@ -211,137 +208,104 @@ vl_api_ip_neighbor_dump_t_handler (vl_api_ip_neighbor_dump_t * mp)
 }
 
 static void
-send_ip_fib_details (vpe_api_main_t * am,
-		     vl_api_registration_t * reg,
-		     const fib_table_t * table,
-		     const fib_prefix_t * pfx,
-		     fib_route_path_encode_t * api_rpaths, u32 context)
-{
-  vl_api_ip_fib_details_t *mp;
-  fib_route_path_encode_t *api_rpath;
-  vl_api_fib_path_t *fp;
-  int path_count;
+send_ip_table_details (vpe_api_main_t * am,
+		       vl_api_registration_t * reg,
+		       u32 context, const fib_table_t * table)
+{
+  vl_api_ip_table_details_t *mp;
 
-  path_count = vec_len (api_rpaths);
-  mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
+  mp = vl_msg_api_alloc (sizeof (*mp));
   if (!mp)
     return;
   clib_memset (mp, 0, sizeof (*mp));
-  mp->_vl_msg_id = ntohs (VL_API_IP_FIB_DETAILS);
+  mp->_vl_msg_id = ntohs (VL_API_IP_TABLE_DETAILS);
   mp->context = context;
 
-  mp->table_id = htonl (table->ft_table_id);
-  memcpy (mp->table_name, table->ft_desc,
-	  clib_min (vec_len (table->ft_desc), sizeof (mp->table_name)));
-  mp->address_length = pfx->fp_len;
-  memcpy (mp->address, &pfx->fp_addr.ip4, sizeof (pfx->fp_addr.ip4));
-  mp->stats_index =
-    htonl (fib_table_entry_get_stats_index (table->ft_index, pfx));
-
-  mp->count = htonl (path_count);
-  fp = mp->path;
-  vec_foreach (api_rpath, api_rpaths)
-  {
-    fib_api_path_encode (api_rpath, fp);
-    fp++;
-  }
+  mp->table.is_ip6 = (table->ft_proto == FIB_PROTOCOL_IP6);
+  mp->table.table_id = htonl (table->ft_table_id);
+  memcpy (mp->table.name, table->ft_desc,
+	  clib_min (vec_len (table->ft_desc), sizeof (mp->table.name)));
 
   vl_api_send_msg (reg, (u8 *) mp);
 }
 
-typedef struct vl_api_ip_fib_dump_walk_ctx_t_
-{
-  fib_node_index_t *feis;
-} vl_api_ip_fib_dump_walk_ctx_t;
-
-static fib_table_walk_rc_t
-vl_api_ip_fib_dump_walk (fib_node_index_t fei, void *arg)
-{
-  vl_api_ip_fib_dump_walk_ctx_t *ctx = arg;
-
-  vec_add1 (ctx->feis, fei);
-
-  return (FIB_TABLE_WALK_CONTINUE);
-}
-
 static void
-vl_api_ip_fib_dump_t_handler (vl_api_ip_fib_dump_t * mp)
+vl_api_ip_table_dump_t_handler (vl_api_ip_table_dump_t * mp)
 {
   vpe_api_main_t *am = &vpe_api_main;
   vl_api_registration_t *reg;
-  ip4_main_t *im = &ip4_main;
   fib_table_t *fib_table;
-  fib_node_index_t *lfeip;
-  const fib_prefix_t *pfx;
-  u32 fib_index;
-  fib_route_path_encode_t *api_rpaths;
-  vl_api_ip_fib_dump_walk_ctx_t ctx = {
-    .feis = NULL,
-  };
 
   reg = vl_api_client_index_to_registration (mp->client_index);
   if (!reg)
     return;
 
   /* *INDENT-OFF* */
-  pool_foreach (fib_table, im->fibs,
+  pool_foreach (fib_table, ip4_main.fibs,
   ({
-    fib_table_walk(fib_table->ft_index,
-                   FIB_PROTOCOL_IP4,
-                   vl_api_ip_fib_dump_walk,
-                   &ctx);
+    send_ip_table_details(am, reg, mp->context, fib_table);
+  }));
+  pool_foreach (fib_table, ip6_main.fibs,
+  ({
+    /* don't send link locals */
+    if (fib_table->ft_flags & FIB_TABLE_FLAG_IP6_LL)
+      continue;
+    send_ip_table_details(am, reg, mp->context, fib_table);
   }));
   /* *INDENT-ON* */
+}
 
-  vec_sort_with_function (ctx.feis, fib_entry_cmp_for_sort);
+typedef struct vl_api_ip_fib_dump_walk_ctx_t_
+{
+  fib_node_index_t *feis;
+} vl_api_ip_fib_dump_walk_ctx_t;
 
-  vec_foreach (lfeip, ctx.feis)
-  {
-    pfx = fib_entry_get_prefix (*lfeip);
-    fib_index = fib_entry_get_fib_index (*lfeip);
-    fib_table = fib_table_get (fib_index, pfx->fp_proto);
-    api_rpaths = NULL;
-    fib_entry_encode (*lfeip, &api_rpaths);
-    send_ip_fib_details (am, reg, fib_table, pfx, api_rpaths, mp->context);
-    vec_free (api_rpaths);
-  }
+static fib_table_walk_rc_t
+vl_api_ip_fib_dump_walk (fib_node_index_t fei, void *arg)
+{
+  vl_api_ip_fib_dump_walk_ctx_t *ctx = arg;
 
-  vec_free (ctx.feis);
+  vec_add1 (ctx->feis, fei);
+
+  return (FIB_TABLE_WALK_CONTINUE);
 }
 
 static void
-send_ip6_fib_details (vpe_api_main_t * am,
-		      vl_api_registration_t * reg,
-		      const fib_table_t * table,
-		      const fib_prefix_t * pfx,
-		      fib_route_path_encode_t * api_rpaths, u32 context)
-{
-  vl_api_ip6_fib_details_t *mp;
-  fib_route_path_encode_t *api_rpath;
+send_ip_route_details (vpe_api_main_t * am,
+		       vl_api_registration_t * reg,
+		       u32 context, fib_node_index_t fib_entry_index)
+{
+  fib_route_path_t *rpaths, *rpath;
+  vl_api_ip_route_details_t *mp;
+  const fib_prefix_t *pfx;
   vl_api_fib_path_t *fp;
   int path_count;
 
-  path_count = vec_len (api_rpaths);
+  rpaths = NULL;
+  pfx = fib_entry_get_prefix (fib_entry_index);
+  rpaths = fib_entry_encode (fib_entry_index);
+
+  path_count = vec_len (rpaths);
   mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
   if (!mp)
     return;
   clib_memset (mp, 0, sizeof (*mp));
-  mp->_vl_msg_id = ntohs (VL_API_IP6_FIB_DETAILS);
+  mp->_vl_msg_id = ntohs (VL_API_IP_ROUTE_DETAILS);
   mp->context = context;
 
-  mp->table_id = htonl (table->ft_table_id);
-  mp->address_length = pfx->fp_len;
-  memcpy (mp->address, &pfx->fp_addr.ip6, sizeof (pfx->fp_addr.ip6));
-  memcpy (mp->table_name, table->ft_desc,
-	  clib_min (vec_len (table->ft_desc), sizeof (mp->table_name)));
-  mp->stats_index =
-    htonl (fib_table_entry_get_stats_index (table->ft_index, pfx));
-
-  mp->count = htonl (path_count);
-  fp = mp->path;
-  vec_foreach (api_rpath, api_rpaths)
+  ip_prefix_encode (pfx, &mp->route.prefix);
+  mp->route.table_id =
+    htonl (fib_table_get_table_id
+	   (fib_entry_get_fib_index (fib_entry_index), pfx->fp_proto));
+  mp->route.n_paths = path_count;
+  mp->route.stats_index =
+    htonl (fib_table_entry_get_stats_index
+	   (fib_entry_get_fib_index (fib_entry_index), pfx));
+
+  fp = mp->route.paths;
+  vec_foreach (rpath, rpaths)
   {
-    fib_api_path_encode (api_rpath, fp);
+    fib_api_path_encode (rpath, fp);
     fp++;
   }
 
@@ -353,232 +317,144 @@ typedef struct apt_ip6_fib_show_ctx_t_
   fib_node_index_t *entries;
 } api_ip6_fib_show_ctx_t;
 
-static fib_table_walk_rc_t
-api_ip6_fib_table_put_entries (fib_node_index_t fei, void *arg)
-{
-  api_ip6_fib_show_ctx_t *ctx = arg;
-
-  vec_add1 (ctx->entries, fei);
-
-  return (FIB_TABLE_WALK_CONTINUE);
-}
-
 static void
-api_ip6_fib_table_get_all (vl_api_registration_t * reg,
-			   vl_api_ip6_fib_dump_t * mp,
-			   fib_table_t * fib_table)
+vl_api_ip_route_dump_t_handler (vl_api_ip_route_dump_t * mp)
 {
   vpe_api_main_t *am = &vpe_api_main;
   fib_node_index_t *fib_entry_index;
-  api_ip6_fib_show_ctx_t ctx = {
-    .entries = NULL,
-  };
-  fib_route_path_encode_t *api_rpaths;
-  const fib_prefix_t *pfx;
-
-  ip6_fib_table_walk (fib_table->ft_index,
-		      api_ip6_fib_table_put_entries, &ctx);
-
-  vec_sort_with_function (ctx.entries, fib_entry_cmp_for_sort);
-
-  vec_foreach (fib_entry_index, ctx.entries)
-  {
-    pfx = fib_entry_get_prefix (*fib_entry_index);
-    api_rpaths = NULL;
-    fib_entry_encode (*fib_entry_index, &api_rpaths);
-    send_ip6_fib_details (am, reg, fib_table, pfx, api_rpaths, mp->context);
-    vec_free (api_rpaths);
-  }
-
-  vec_free (ctx.entries);
-}
-
-static void
-vl_api_ip6_fib_dump_t_handler (vl_api_ip6_fib_dump_t * mp)
-{
   vl_api_registration_t *reg;
-  ip6_main_t *im6 = &ip6_main;
-  fib_table_t *fib_table;
+  fib_protocol_t fproto;
+  u32 fib_index;
 
   reg = vl_api_client_index_to_registration (mp->client_index);
   if (!reg)
     return;
 
-  /* *INDENT-OFF* */
-  pool_foreach (fib_table, im6->fibs,
-  ({
-    /* don't send link locals */
-    if (fib_table->ft_flags & FIB_TABLE_FLAG_IP6_LL)
-      continue;
-
-    api_ip6_fib_table_get_all(reg, mp, fib_table);
-  }));
-  /* *INDENT-ON* */
-}
-
-static void
-send_ip_mfib_details (vl_api_registration_t * reg,
-		      u32 context, u32 table_id, fib_node_index_t mfei)
-{
-  fib_route_path_encode_t *api_rpath, *api_rpaths = NULL;
-  vl_api_ip_mfib_details_t *mp;
-  const mfib_prefix_t *pfx;
-  mfib_entry_t *mfib_entry;
-  vl_api_mfib_path_t *fp;
-  int path_count;
+  vl_api_ip_fib_dump_walk_ctx_t ctx = {
+    .feis = NULL,
+  };
 
-  mfib_entry = mfib_entry_get (mfei);
-  pfx = mfib_entry_get_prefix (mfei);
-  mfib_entry_encode (mfei, &api_rpaths);
+  fproto = (mp->table.is_ip6 ? FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
+  fib_index = fib_table_find (fproto, ntohl (mp->table.table_id));
 
-  path_count = vec_len (api_rpaths);
-  mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
-  if (!mp)
+  if (INDEX_INVALID == fib_index)
     return;
-  clib_memset (mp, 0, sizeof (*mp));
-  mp->_vl_msg_id = ntohs (VL_API_IP_MFIB_DETAILS);
-  mp->context = context;
 
-  mp->rpf_id = mfib_entry->mfe_rpf_id;
-  mp->entry_flags = mfib_entry->mfe_flags;
-  mp->table_id = htonl (table_id);
-  mp->address_length = pfx->fp_len;
-  memcpy (mp->grp_address, &pfx->fp_grp_addr.ip4,
-	  sizeof (pfx->fp_grp_addr.ip4));
-  memcpy (mp->src_address, &pfx->fp_src_addr.ip4,
-	  sizeof (pfx->fp_src_addr.ip4));
-
-  mp->count = htonl (path_count);
-  fp = mp->path;
-  vec_foreach (api_rpath, api_rpaths)
+  fib_table_walk (fib_index, fproto, vl_api_ip_fib_dump_walk, &ctx);
+
+  vec_foreach (fib_entry_index, ctx.feis)
   {
-    fib_api_path_encode (api_rpath, &fp->path);
-    fp->itf_flags = ntohl (api_rpath->rpath.frp_mitf_flags);
-    fp++;
+    send_ip_route_details (am, reg, mp->context, *fib_entry_index);
   }
-  vec_free (api_rpaths);
 
-  vl_api_send_msg (reg, (u8 *) mp);
+  vec_free (ctx.feis);
 }
 
-typedef struct vl_api_ip_mfib_dump_ctc_t_
+static void
+send_ip_mtable_details (vl_api_registration_t * reg,
+			u32 context, const mfib_table_t * mfib_table)
 {
-  fib_node_index_t *entries;
-} vl_api_ip_mfib_dump_ctc_t;
+  vl_api_ip_mtable_details_t *mp;
 
-static int
-vl_api_ip_mfib_table_dump_walk (fib_node_index_t fei, void *arg)
-{
-  vl_api_ip_mfib_dump_ctc_t *ctx = arg;
+  mp = vl_msg_api_alloc (sizeof (*mp));
+  if (!mp)
+    return;
+  memset (mp, 0, sizeof (*mp));
+  mp->_vl_msg_id = ntohs (VL_API_IP_MTABLE_DETAILS);
+  mp->context = context;
 
-  vec_add1 (ctx->entries, fei);
+  mp->table.table_id = htonl (mfib_table->mft_table_id);
+  mp->table.is_ip6 = (FIB_PROTOCOL_IP6 == mfib_table->mft_proto);
 
-  return (0);
+  vl_api_send_msg (reg, (u8 *) mp);
 }
 
 static void
-vl_api_ip_mfib_dump_t_handler (vl_api_ip_mfib_dump_t * mp)
+vl_api_ip_mtable_dump_t_handler (vl_api_ip_mtable_dump_t * mp)
 {
   vl_api_registration_t *reg;
-  ip4_main_t *im = &ip4_main;
   mfib_table_t *mfib_table;
-  fib_node_index_t *mfeip;
-  vl_api_ip_mfib_dump_ctc_t ctx = {
-    .entries = NULL,
-  };
 
   reg = vl_api_client_index_to_registration (mp->client_index);
   if (!reg)
     return;
 
   /* *INDENT-OFF* */
-  pool_foreach (mfib_table, im->mfibs,
+  pool_foreach (mfib_table, ip4_main.mfibs,
+  ({
+      send_ip_mtable_details (reg, mp->context, mfib_table);
+  }));
+  pool_foreach (mfib_table, ip6_main.mfibs,
   ({
-    ip4_mfib_table_walk(&mfib_table->v4,
-                        vl_api_ip_mfib_table_dump_walk,
-                        &ctx);
+      send_ip_mtable_details (reg, mp->context, mfib_table);
+  }));
+  /* *INDENT-ON* */
+}
 
-    vec_sort_with_function (ctx.entries, mfib_entry_cmp_for_sort);
+typedef struct vl_api_ip_mfib_dump_ctx_t_
+{
+  fib_node_index_t *entries;
+} vl_api_ip_mfib_dump_ctx_t;
 
-    vec_foreach (mfeip, ctx.entries)
-    {
-      send_ip_mfib_details (reg, mp->context,
-                            mfib_table->mft_table_id,
-                            *mfeip);
-    }
-    vec_reset_length (ctx.entries);
+static int
+mfib_route_dump_walk (fib_node_index_t fei, void *arg)
+{
+  vl_api_ip_mfib_dump_ctx_t *ctx = arg;
 
-  }));
-  /* *INDENT-ON* */
+  vec_add1 (ctx->entries, fei);
 
-  vec_free (ctx.entries);
+  return (0);
 }
 
 static void
-send_ip6_mfib_details (vpe_api_main_t * am,
-		       vl_api_registration_t * reg,
-		       u32 table_id,
-		       const mfib_prefix_t * pfx,
-		       fib_route_path_encode_t * api_rpaths, u32 context)
+send_ip_mroute_details (vpe_api_main_t * am,
+			vl_api_registration_t * reg,
+			u32 context, fib_node_index_t mfib_entry_index)
 {
-  vl_api_ip6_mfib_details_t *mp;
-  fib_route_path_encode_t *api_rpath;
+  fib_route_path_t *rpaths, *rpath;
+  vl_api_ip_mroute_details_t *mp;
+  const mfib_prefix_t *pfx;
   vl_api_mfib_path_t *fp;
   int path_count;
 
-  path_count = vec_len (api_rpaths);
+  rpaths = NULL;
+  pfx = mfib_entry_get_prefix (mfib_entry_index);
+  rpaths = mfib_entry_encode (mfib_entry_index);
+
+  path_count = vec_len (rpaths);
   mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
   if (!mp)
     return;
   clib_memset (mp, 0, sizeof (*mp));
-  mp->_vl_msg_id = ntohs (VL_API_IP6_MFIB_DETAILS);
+  mp->_vl_msg_id = ntohs (VL_API_IP_MROUTE_DETAILS);
   mp->context = context;
 
-  mp->table_id = htonl (table_id);
-  mp->address_length = pfx->fp_len;
-  memcpy (mp->grp_address, &pfx->fp_grp_addr.ip6,
-	  sizeof (pfx->fp_grp_addr.ip6));
-  memcpy (mp->src_address, &pfx->fp_src_addr.ip6,
-	  sizeof (pfx->fp_src_addr.ip6));
-
-  mp->count = htonl (path_count);
-  fp = mp->path;
-  vec_foreach (api_rpath, api_rpaths)
+  ip_mprefix_encode (pfx, &mp->route.prefix);
+  mp->route.table_id =
+    htonl (mfib_table_get_table_id
+	   (mfib_entry_get_fib_index (mfib_entry_index), pfx->fp_proto));
+  mp->route.n_paths = htonl (path_count);
+  fp = mp->route.paths;
+  vec_foreach (rpath, rpaths)
   {
-    fib_api_path_encode (api_rpath, &fp->path);
-    fp->itf_flags = ntohl (api_rpath->rpath.frp_mitf_flags);
+    mfib_api_path_encode (rpath, fp);
     fp++;
   }
 
   vl_api_send_msg (reg, (u8 *) mp);
-}
-
-typedef struct vl_api_ip6_mfib_dump_ctc_t_
-{
-  fib_node_index_t *entries;
-} vl_api_ip6_mfib_dump_ctc_t;
-
-static int
-vl_api_ip6_mfib_table_dump_walk (fib_node_index_t fei, void *arg)
-{
-  vl_api_ip6_mfib_dump_ctc_t *ctx = arg;
-
-  vec_add1 (ctx->entries, fei);
-
-  return (0);
+  vec_free (rpaths);
 }
 
 static void
-vl_api_ip6_mfib_dump_t_handler (vl_api_ip6_mfib_dump_t * mp)
+vl_api_ip_mroute_dump_t_handler (vl_api_ip_mroute_dump_t * mp)
 {
   vpe_api_main_t *am = &vpe_api_main;
   vl_api_registration_t *reg;
-  ip6_main_t *im = &ip6_main;
-  mfib_table_t *mfib_table;
-  const mfib_prefix_t *pfx;
   fib_node_index_t *mfeip;
-  fib_route_path_encode_t *api_rpaths = NULL;
-  vl_api_ip6_mfib_dump_ctc_t ctx = {
+  fib_protocol_t fproto;
+  u32 fib_index;
+
+  vl_api_ip_mfib_dump_ctx_t ctx = {
     .entries = NULL,
   };
 
@@ -586,33 +462,22 @@ vl_api_ip6_mfib_dump_t_handler (vl_api_ip6_mfib_dump_t * mp)
   if (!reg)
     return;
 
+  fproto = fib_ip_proto (mp->table.is_ip6);
+  fib_index = mfib_table_find (fproto, ntohl (mp->table.table_id));
 
-  /* *INDENT-OFF* */
-  pool_foreach (mfib_table, im->mfibs,
-  ({
-    ip6_mfib_table_walk(&mfib_table->v6,
-                        vl_api_ip6_mfib_table_dump_walk,
-                        &ctx);
+  if (INDEX_INVALID == fib_index)
+    return;
 
-    vec_sort_with_function (ctx.entries, mfib_entry_cmp_for_sort);
+  mfib_table_walk (fib_index, fproto, mfib_route_dump_walk, &ctx);
 
-    vec_foreach(mfeip, ctx.entries)
-    {
-      pfx = mfib_entry_get_prefix (*mfeip);
-      mfib_entry_encode (*mfeip, &api_rpaths);
-      send_ip6_mfib_details (am, reg,
-                             mfib_table->mft_table_id,
-                             pfx, api_rpaths,
-                             mp->context);
-    }
-    vec_reset_length (api_rpaths);
-    vec_reset_length (ctx.entries);
+  vec_sort_with_function (ctx.entries, mfib_entry_cmp_for_sort);
 
-  }));
-  /* *INDENT-ON* */
+  vec_foreach (mfeip, ctx.entries)
+  {
+    send_ip_mroute_details (am, reg, mp->context, *mfeip);
+  }
 
   vec_free (ctx.entries);
-  vec_free (api_rpaths);
 }
 
 static void
@@ -698,7 +563,7 @@ vl_api_ip_neighbor_add_del_t_handler (vl_api_ip_neighbor_add_del_t * mp,
   ip46_address_t ip;
   mac_address_t mac;
   ip46_type_t type;
-  int rv = 0;
+  int rv;
 
   VALIDATE_SW_IF_INDEX ((&mp->neighbor));
 
@@ -767,13 +632,14 @@ void
 vl_api_ip_table_add_del_t_handler (vl_api_ip_table_add_del_t * mp)
 {
   vl_api_ip_table_add_del_reply_t *rmp;
-  fib_protocol_t fproto = (mp->is_ipv6 ? FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
-  u32 table_id = ntohl (mp->table_id);
+  fib_protocol_t fproto = (mp->table.is_ip6 ?
+			   FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
+  u32 table_id = ntohl (mp->table.table_id);
   int rv = 0;
 
   if (mp->is_add)
     {
-      ip_table_create (fproto, table_id, 1, mp->name);
+      ip_table_create (fproto, table_id, 1, mp->table.name);
     }
   else
     {
@@ -783,398 +649,71 @@ vl_api_ip_table_add_del_t_handler (vl_api_ip_table_add_del_t * mp)
   REPLY_MACRO (VL_API_IP_TABLE_ADD_DEL_REPLY);
 }
 
-int
-add_del_route_t_handler (u8 is_multipath,
-			 u8 is_add,
-			 u8 is_drop,
-			 u8 is_unreach,
-			 u8 is_prohibit,
-			 u8 is_local,
-			 u8 is_multicast,
-			 u8 is_classify,
-			 u32 classify_table_index,
-			 u8 is_resolve_host,
-			 u8 is_resolve_attached,
-			 u8 is_interface_rx,
-			 u8 is_rpf_id,
-			 u8 is_dvr,
-			 u8 is_source_lookup,
-			 u8 is_udp_encap,
-			 u32 fib_index,
-			 const fib_prefix_t * prefix,
-			 dpo_proto_t next_hop_proto,
-			 const ip46_address_t * next_hop,
-			 u32 next_hop_id,
-			 u32 next_hop_sw_if_index,
-			 u8 next_hop_fib_index,
-			 u16 next_hop_weight,
-			 u16 next_hop_preference,
-			 mpls_label_t next_hop_via_label,
-			 fib_mpls_label_t * next_hop_out_label_stack)
-{
-  vnet_classify_main_t *cm = &vnet_classify_main;
-  fib_route_path_flags_t path_flags = FIB_ROUTE_PATH_FLAG_NONE;
-  fib_route_path_t path = {
-    .frp_proto = next_hop_proto,
-    .frp_addr = (NULL == next_hop ? zero_addr : *next_hop),
-    .frp_sw_if_index = next_hop_sw_if_index,
-    .frp_fib_index = next_hop_fib_index,
-    .frp_weight = next_hop_weight,
-    .frp_preference = next_hop_preference,
-    .frp_label_stack = next_hop_out_label_stack,
-  };
-  fib_route_path_t *paths = NULL;
-  fib_entry_flag_t entry_flags = FIB_ENTRY_FLAG_NONE;
-
-  /*
-   * the special INVALID label means we are not recursing via a
-   * label. Exp-null value is never a valid via-label so that
-   * also means it's not a via-label and means clients that set
-   * it to 0 by default get the expected behaviour
-   */
-  if ((MPLS_LABEL_INVALID != next_hop_via_label) && (0 != next_hop_via_label))
-    {
-      path.frp_proto = DPO_PROTO_MPLS;
-      path.frp_local_label = next_hop_via_label;
-      path.frp_eos = MPLS_NON_EOS;
-    }
-  if (is_local)
-    {
-      path_flags |= FIB_ROUTE_PATH_LOCAL;
-      if (~0 != next_hop_sw_if_index)
-	{
-	  entry_flags |= (FIB_ENTRY_FLAG_CONNECTED | FIB_ENTRY_FLAG_LOCAL);
-	}
-    }
-  if (is_dvr)
-    path_flags |= FIB_ROUTE_PATH_DVR;
-  if (is_resolve_host)
-    path_flags |= FIB_ROUTE_PATH_RESOLVE_VIA_HOST;
-  if (is_resolve_attached)
-    path_flags |= FIB_ROUTE_PATH_RESOLVE_VIA_ATTACHED;
-  if (is_interface_rx)
-    path_flags |= FIB_ROUTE_PATH_INTF_RX;
-  if (is_rpf_id)
-    path_flags |= FIB_ROUTE_PATH_RPF_ID;
-  if (is_source_lookup)
-    path_flags |= FIB_ROUTE_PATH_SOURCE_LOOKUP;
-  if (is_multicast)
-    entry_flags |= FIB_ENTRY_FLAG_MULTICAST;
-  if (is_udp_encap)
-    {
-      path_flags |= FIB_ROUTE_PATH_UDP_ENCAP;
-      path.frp_udp_encap_id = next_hop_id;
-    }
-  if (path.frp_sw_if_index == ~0 && ip46_address_is_zero (&path.frp_addr)
-      && path.frp_fib_index != ~0)
-    {
-      path_flags |= FIB_ROUTE_PATH_DEAG;
-    }
-
-  path.frp_flags = path_flags;
-
-  if (is_drop || (is_local && (~0 == next_hop_sw_if_index)) ||
-      is_classify || is_unreach || is_prohibit)
-    {
-      /*
-       * special route types that link directly to the adj
-       */
-      if (is_add)
-	{
-	  dpo_id_t dpo = DPO_INVALID;
-	  dpo_proto_t dproto;
-
-	  dproto = fib_proto_to_dpo (prefix->fp_proto);
-
-	  if (is_drop)
-	    ip_null_dpo_add_and_lock (dproto, IP_NULL_ACTION_NONE, &dpo);
-	  else if (is_local)
-	    receive_dpo_add_or_lock (dproto, ~0, NULL, &dpo);
-	  else if (is_unreach)
-	    ip_null_dpo_add_and_lock (dproto,
-				      IP_NULL_ACTION_SEND_ICMP_UNREACH, &dpo);
-	  else if (is_prohibit)
-	    ip_null_dpo_add_and_lock (dproto,
-				      IP_NULL_ACTION_SEND_ICMP_PROHIBIT,
-				      &dpo);
-	  else if (is_classify)
-	    {
-	      if (pool_is_free_index (cm->tables,
-				      ntohl (classify_table_index)))
-		{
-		  return VNET_API_ERROR_NO_SUCH_TABLE;
-		}
-
-	      dpo_set (&dpo, DPO_CLASSIFY, dproto,
-		       classify_dpo_create (dproto,
-					    ntohl (classify_table_index)));
-	    }
-	  else
-	    {
-	      return VNET_API_ERROR_NO_SUCH_TABLE;
-	    }
-
-	  fib_table_entry_special_dpo_update (fib_index,
-					      prefix,
-					      FIB_SOURCE_API,
-					      FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
-	  dpo_reset (&dpo);
-	}
-      else
-	{
-	  fib_table_entry_special_remove (fib_index, prefix, FIB_SOURCE_API);
-	}
-    }
-  else if (is_multipath)
-    {
-      vec_add1 (paths, path);
-
-      if (is_add)
-	fib_table_entry_path_add2 (fib_index,
-				   prefix,
-				   FIB_SOURCE_API, entry_flags, paths);
-      else
-	fib_table_entry_path_remove2 (fib_index,
-				      prefix, FIB_SOURCE_API, paths);
-
-      vec_free (paths);
-    }
-  else
-    {
-      if (is_add)
-	{
-	  vec_add1 (paths, path);
-	  fib_table_entry_update (fib_index,
-				  prefix, FIB_SOURCE_API, entry_flags, paths);
-	  vec_free (paths);
-	}
-      else
-	{
-	  fib_table_entry_delete (fib_index, prefix, FIB_SOURCE_API);
-	}
-    }
-
-  return (0);
-}
-
-int
-add_del_route_check (fib_protocol_t table_proto,
-		     u32 table_id,
-		     u32 next_hop_sw_if_index,
-		     dpo_proto_t next_hop_table_proto,
-		     u32 next_hop_table_id,
-		     u8 is_rpf_id, u32 * fib_index, u32 * next_hop_fib_index)
-{
-  vnet_main_t *vnm = vnet_get_main ();
-
-  *fib_index = fib_table_find (table_proto, ntohl (table_id));
-  if (~0 == *fib_index)
-    {
-      /* No such VRF, and we weren't asked to create one */
-      return VNET_API_ERROR_NO_SUCH_FIB;
-    }
-
-  if (!is_rpf_id && ~0 != ntohl (next_hop_sw_if_index))
-    {
-      if (pool_is_free_index (vnm->interface_main.sw_interfaces,
-			      ntohl (next_hop_sw_if_index)))
-	{
-	  return VNET_API_ERROR_NO_MATCHING_INTERFACE;
-	}
-    }
-  else
-    {
-      fib_protocol_t fib_nh_proto;
-
-      if (next_hop_table_proto > DPO_PROTO_MPLS)
-	return (0);
-
-      fib_nh_proto = dpo_proto_to_fib (next_hop_table_proto);
-
-      if (is_rpf_id)
-	*next_hop_fib_index = mfib_table_find (fib_nh_proto,
-					       ntohl (next_hop_table_id));
-      else
-	*next_hop_fib_index = fib_table_find (fib_nh_proto,
-					      ntohl (next_hop_table_id));
-
-      if (~0 == *next_hop_fib_index)
-	{
-	  /* No such VRF, and we weren't asked to create one */
-	  return VNET_API_ERROR_NO_SUCH_FIB;
-	}
-    }
-
-  return (0);
-}
-
 static int
-ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp,
-			     u32 * stats_index)
+ip_route_add_del_t_handler (vl_api_ip_route_add_del_t * mp, u32 * stats_index)
 {
-  u32 fib_index, next_hop_fib_index;
-  fib_mpls_label_t *label_stack = NULL;
-  int rv, ii, n_labels;;
+  fib_route_path_t *rpaths = NULL, *rpath;
+  fib_entry_flag_t entry_flags;
+  vl_api_fib_path_t *apath;
+  fib_prefix_t pfx;
+  u32 fib_index;
+  int rv, ii;
 
-  rv = add_del_route_check (FIB_PROTOCOL_IP4,
-			    mp->table_id,
-			    mp->next_hop_sw_if_index,
-			    DPO_PROTO_IP4,
-			    mp->next_hop_table_id,
-			    0, &fib_index, &next_hop_fib_index);
+  entry_flags = FIB_ENTRY_FLAG_NONE;
+  ip_prefix_decode (&mp->route.prefix, &pfx);
 
+  rv = fib_api_table_id_decode (pfx.fp_proto,
+				ntohl (mp->route.table_id), &fib_index);
   if (0 != rv)
-    return (rv);
-
-  fib_prefix_t pfx = {
-    .fp_len = mp->dst_address_length,
-    .fp_proto = FIB_PROTOCOL_IP4,
-  };
-  clib_memcpy (&pfx.fp_addr.ip4, mp->dst_address, sizeof (pfx.fp_addr.ip4));
-
-  ip46_address_t nh;
-  clib_memset (&nh, 0, sizeof (nh));
-  memcpy (&nh.ip4, mp->next_hop_address, sizeof (nh.ip4));
+    goto out;
 
-  n_labels = mp->next_hop_n_out_labels;
-  if (n_labels == 0)
-    ;
-  else
+  if (0 == mp->route.n_paths)
     {
-      vec_validate (label_stack, n_labels - 1);
-      for (ii = 0; ii < n_labels; ii++)
-	{
-	  label_stack[ii].fml_value =
-	    ntohl (mp->next_hop_out_label_stack[ii].label);
-	  label_stack[ii].fml_ttl = mp->next_hop_out_label_stack[ii].ttl;
-	  label_stack[ii].fml_exp = mp->next_hop_out_label_stack[ii].exp;
-	  label_stack[ii].fml_mode =
-	    (mp->next_hop_out_label_stack[ii].is_uniform ?
-	     FIB_MPLS_LSP_MODE_UNIFORM : FIB_MPLS_LSP_MODE_PIPE);
-	}
+      rv = VNET_API_ERROR_NO_PATHS_IN_ROUTE;
+      goto out;
     }
 
-  rv = add_del_route_t_handler (mp->is_multipath,
-				mp->is_add,
-				mp->is_drop,
-				mp->is_unreach,
-				mp->is_prohibit,
-				mp->is_local, 0,
-				mp->is_classify,
-				mp->classify_table_index,
-				mp->is_resolve_host,
-				mp->is_resolve_attached, 0, 0,
-				mp->is_dvr,
-				mp->is_source_lookup,
-				mp->is_udp_encap,
-				fib_index, &pfx, DPO_PROTO_IP4,
-				&nh,
-				ntohl (mp->next_hop_id),
-				ntohl (mp->next_hop_sw_if_index),
-				next_hop_fib_index,
-				mp->next_hop_weight,
-				mp->next_hop_preference,
-				ntohl (mp->next_hop_via_label), label_stack);
-
-  if (mp->is_add && 0 == rv)
-    *stats_index = fib_table_entry_get_stats_index (fib_index, &pfx);
-
-  return (rv);
-}
-
-static int
-ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp,
-			     u32 * stats_index)
-{
-  fib_mpls_label_t *label_stack = NULL;
-  u32 fib_index, next_hop_fib_index;
-  int rv, ii, n_labels;;
+  vec_validate (rpaths, mp->route.n_paths - 1);
 
-  rv = add_del_route_check (FIB_PROTOCOL_IP6,
-			    mp->table_id,
-			    mp->next_hop_sw_if_index,
-			    DPO_PROTO_IP6,
-			    mp->next_hop_table_id,
-			    0, &fib_index, &next_hop_fib_index);
+  for (ii = 0; ii < mp->route.n_paths; ii++)
+    {
+      apath = &mp->route.paths[ii];
+      rpath = &rpaths[ii];
 
-  if (0 != rv)
-    return (rv);
+      rv = fib_api_path_decode (apath, rpath);
 
-  fib_prefix_t pfx = {
-    .fp_len = mp->dst_address_length,
-    .fp_proto = FIB_PROTOCOL_IP6,
-  };
-  clib_memcpy (&pfx.fp_addr.ip6, mp->dst_address, sizeof (pfx.fp_addr.ip6));
-
-  ip46_address_t nh;
-  clib_memset (&nh, 0, sizeof (nh));
-  memcpy (&nh.ip6, mp->next_hop_address, sizeof (nh.ip6));
+      if ((rpath->frp_flags & FIB_ROUTE_PATH_LOCAL) &&
+	  (~0 == rpath->frp_sw_if_index))
+	entry_flags |= (FIB_ENTRY_FLAG_CONNECTED | FIB_ENTRY_FLAG_LOCAL);
 
-  n_labels = mp->next_hop_n_out_labels;
-  if (n_labels == 0)
-    ;
-  else
-    {
-      vec_validate (label_stack, n_labels - 1);
-      for (ii = 0; ii < n_labels; ii++)
-	{
-	  label_stack[ii].fml_value =
-	    ntohl (mp->next_hop_out_label_stack[ii].label);
-	  label_stack[ii].fml_ttl = mp->next_hop_out_label_stack[ii].ttl;
-	  label_stack[ii].fml_exp = mp->next_hop_out_label_stack[ii].exp;
-	  label_stack[ii].fml_mode =
-	    (mp->next_hop_out_label_stack[ii].is_uniform ?
-	     FIB_MPLS_LSP_MODE_UNIFORM : FIB_MPLS_LSP_MODE_PIPE);
-	}
+      if (0 != rv)
+	goto out;
     }
 
-  rv = add_del_route_t_handler (mp->is_multipath,
-				mp->is_add,
-				mp->is_drop,
-				mp->is_unreach,
-				mp->is_prohibit,
-				mp->is_local, 0,
-				mp->is_classify,
-				mp->classify_table_index,
-				mp->is_resolve_host,
-				mp->is_resolve_attached, 0, 0,
-				mp->is_dvr,
-				mp->is_source_lookup,
-				mp->is_udp_encap,
-				fib_index, &pfx, DPO_PROTO_IP6,
-				&nh, ntohl (mp->next_hop_id),
-				ntohl (mp->next_hop_sw_if_index),
-				next_hop_fib_index,
-				mp->next_hop_weight,
-				mp->next_hop_preference,
-				ntohl (mp->next_hop_via_label), label_stack);
+  fib_api_route_add_del (mp->is_add,
+			 mp->is_multipath,
+			 fib_index, &pfx, entry_flags, rpaths);
 
   if (mp->is_add && 0 == rv)
     *stats_index = fib_table_entry_get_stats_index (fib_index, &pfx);
 
+out:
+  vec_free (rpaths);
+
   return (rv);
 }
 
 void
-vl_api_ip_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp)
+vl_api_ip_route_add_del_t_handler (vl_api_ip_route_add_del_t * mp)
 {
-  vl_api_ip_add_del_route_reply_t *rmp;
-  u32 stats_index;
+  vl_api_ip_route_add_del_reply_t *rmp;
+  u32 stats_index = ~0;
   int rv;
-  vnet_main_t *vnm = vnet_get_main ();
-
-  vnm->api_errno = 0;
-  stats_index = ~0;
 
-  if (mp->is_ipv6)
-    rv = ip6_add_del_route_t_handler (mp, &stats_index);
-  else
-    rv = ip4_add_del_route_t_handler (mp, &stats_index);
-
-  rv = (rv == 0) ? vnm->api_errno : rv;
+  rv = ip_route_add_del_t_handler (mp, &stats_index);
 
   /* *INDENT-OFF* */
-  REPLY_MACRO2 (VL_API_IP_ADD_DEL_ROUTE_REPLY,
+  REPLY_MACRO2 (VL_API_IP_ROUTE_ADD_DEL_REPLY,
   ({
     rmp->stats_index = htonl (stats_index);
   }))
@@ -1221,80 +760,37 @@ ip_table_create (fib_protocol_t fproto,
     }
 }
 
-static int
-add_del_mroute_check (fib_protocol_t table_proto,
-		      u32 table_id,
-		      u32 next_hop_sw_if_index, u8 is_local, u32 * fib_index)
-{
-  vnet_main_t *vnm = vnet_get_main ();
-
-  *fib_index = mfib_table_find (table_proto, ntohl (table_id));
-  if (~0 == *fib_index)
-    {
-      /* No such table */
-      return VNET_API_ERROR_NO_SUCH_FIB;
-    }
-
-  if (~0 != ntohl (next_hop_sw_if_index))
-    {
-      if (pool_is_free_index (vnm->interface_main.sw_interfaces,
-			      ntohl (next_hop_sw_if_index)))
-	{
-	  return VNET_API_ERROR_NO_MATCHING_INTERFACE;
-	}
-    }
-
-  return (0);
-}
-
-static fib_node_index_t
+static u32
 mroute_add_del_handler (u8 is_add,
-			u8 is_local,
+			u8 is_multipath,
 			u32 fib_index,
 			const mfib_prefix_t * prefix,
-			dpo_proto_t nh_proto,
 			u32 entry_flags,
-			fib_rpf_id_t rpf_id,
-			u32 next_hop_sw_if_index,
-			ip46_address_t * nh, u32 itf_flags, u32 bier_imp)
+			u32 rpf_id, fib_route_path_t * rpaths)
 {
-  fib_node_index_t mfib_entry_index = ~0;
-
-  fib_route_path_t path = {
-    .frp_sw_if_index = next_hop_sw_if_index,
-    .frp_proto = nh_proto,
-    .frp_addr = *nh,
-  };
+  u32 mfib_entry_index = ~0;
 
-  if (is_local)
-    path.frp_flags |= FIB_ROUTE_PATH_LOCAL;
-
-  if (DPO_PROTO_BIER == nh_proto)
-    {
-      path.frp_bier_imp = bier_imp;
-      path.frp_flags = FIB_ROUTE_PATH_BIER_IMP;
-    }
-  else if (!is_local && ~0 == next_hop_sw_if_index)
+  if (0 == vec_len (rpaths))
     {
       mfib_entry_index = mfib_table_entry_update (fib_index, prefix,
 						  MFIB_SOURCE_API,
 						  rpf_id, entry_flags);
-      goto done;
-    }
-
-  if (is_add)
-    {
-      mfib_entry_index = mfib_table_entry_path_update (fib_index, prefix,
-						       MFIB_SOURCE_API,
-						       &path, itf_flags);
     }
   else
     {
-      mfib_table_entry_path_remove (fib_index, prefix,
-				    MFIB_SOURCE_API, &path);
+      if (is_add)
+	{
+	  mfib_entry_index =
+	    mfib_table_entry_paths_update (fib_index, prefix,
+					   MFIB_SOURCE_API, rpaths);
+	}
+      else
+	{
+	  mfib_table_entry_paths_remove (fib_index, prefix,
+					 MFIB_SOURCE_API, rpaths);
+	}
     }
 
-done:
   return (mfib_entry_index);
 }
 
@@ -1302,64 +798,43 @@ static int
 api_mroute_add_del_t_handler (vl_api_ip_mroute_add_del_t * mp,
 			      u32 * stats_index)
 {
+  fib_route_path_t *rpath, *rpaths = NULL;
   fib_node_index_t mfib_entry_index;
-  fib_protocol_t fproto;
-  dpo_proto_t nh_proto;
-  ip46_address_t nh;
+  mfib_prefix_t pfx;
   u32 fib_index;
   int rv;
+  u16 ii;
 
-  nh_proto = mp->next_hop_afi;
-  fproto = (mp->is_ipv6 ? FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
-  rv = add_del_mroute_check (fproto,
-			     mp->table_id,
-			     mp->next_hop_sw_if_index,
-			     mp->is_local, &fib_index);
+  ip_mprefix_decode (&mp->route.prefix, &pfx);
 
+  rv = mfib_api_table_id_decode (pfx.fp_proto,
+				 ntohl (mp->route.table_id), &fib_index);
   if (0 != rv)
-    return (rv);
+    goto out;
 
-  mfib_prefix_t pfx = {
-    .fp_len = ntohs (mp->grp_address_length),
-    .fp_proto = fproto,
-  };
+  vec_validate (rpaths, mp->route.n_paths - 1);
 
-  if (FIB_PROTOCOL_IP4 == fproto)
-    {
-      clib_memcpy (&pfx.fp_grp_addr.ip4, mp->grp_address,
-		   sizeof (pfx.fp_grp_addr.ip4));
-      clib_memcpy (&pfx.fp_src_addr.ip4, mp->src_address,
-		   sizeof (pfx.fp_src_addr.ip4));
-      clib_memset (&nh.ip6, 0, sizeof (nh.ip6));
-      clib_memcpy (&nh.ip4, mp->nh_address, sizeof (nh.ip4));
-      if (!ip46_address_is_zero (&pfx.fp_src_addr))
-	pfx.fp_len = 64;
-    }
-  else
+  for (ii = 0; ii < mp->route.n_paths; ii++)
     {
-      clib_memcpy (&pfx.fp_grp_addr.ip6, mp->grp_address,
-		   sizeof (pfx.fp_grp_addr.ip6));
-      clib_memcpy (&pfx.fp_src_addr.ip6, mp->src_address,
-		   sizeof (pfx.fp_src_addr.ip6));
-      clib_memcpy (&nh.ip6, mp->nh_address, sizeof (nh.ip6));
-      if (!ip46_address_is_zero (&pfx.fp_src_addr))
-	pfx.fp_len = 256;
+      rpath = &rpaths[ii];
+
+      rv = mfib_api_path_decode (&mp->route.paths[ii], rpath);
+
+      if (0 != rv)
+	goto out;
     }
 
   mfib_entry_index = mroute_add_del_handler (mp->is_add,
-					     mp->is_local,
+					     mp->is_add,
 					     fib_index, &pfx,
-					     nh_proto,
-					     ntohl (mp->entry_flags),
-					     ntohl (mp->rpf_id),
-					     ntohl (mp->next_hop_sw_if_index),
-					     &nh,
-					     ntohl (mp->itf_flags),
-					     ntohl (mp->bier_imp));
+					     ntohl (mp->route.entry_flags),
+					     ntohl (mp->route.rpf_id),
+					     rpaths);
 
   if (~0 != mfib_entry_index)
     *stats_index = mfib_entry_get_stats_index (mfib_entry_index);
 
+out:
   return (rv);
 }
 
@@ -1367,14 +842,9 @@ void
 vl_api_ip_mroute_add_del_t_handler (vl_api_ip_mroute_add_del_t * mp)
 {
   vl_api_ip_mroute_add_del_reply_t *rmp;
-  vnet_main_t *vnm;
-  u32 stats_index;
+  u32 stats_index = ~0;
   int rv;
 
-  vnm = vnet_get_main ();
-  vnm->api_errno = 0;
-  stats_index = ~0;
-
   rv = api_mroute_add_del_t_handler (mp, &stats_index);
 
   /* *INDENT-OFF* */
@@ -1406,8 +876,8 @@ send_ip_details (vpe_api_main_t * am,
 static void
 send_ip_address_details (vpe_api_main_t * am,
 			 vl_api_registration_t * reg,
-			 u8 * ip, u16 prefix_length,
-			 u32 sw_if_index, u8 is_ipv6, u32 context)
+			 const fib_prefix_t * pfx,
+			 u32 sw_if_index, u32 context)
 {
   vl_api_ip_address_details_t *mp;
 
@@ -1415,19 +885,9 @@ send_ip_address_details (vpe_api_main_t * am,
   clib_memset (mp, 0, sizeof (*mp));
   mp->_vl_msg_id = ntohs (VL_API_IP_ADDRESS_DETAILS);
 
-  if (is_ipv6)
-    {
-      clib_memcpy (&mp->ip, ip, sizeof (mp->ip));
-    }
-  else
-    {
-      u32 *tp = (u32 *) mp->ip;
-      *tp = *(u32 *) ip;
-    }
-  mp->prefix_length = prefix_length;
+  ip_prefix_encode (pfx, &mp->prefix);
   mp->context = context;
   mp->sw_if_index = htonl (sw_if_index);
-  mp->is_ipv6 = is_ipv6;
 
   vl_api_send_msg (reg, (u8 *) mp);
 }
@@ -1437,8 +897,6 @@ vl_api_ip_address_dump_t_handler (vl_api_ip_address_dump_t * mp)
 {
   vpe_api_main_t *am = &vpe_api_main;
   vl_api_registration_t *reg;
-  ip6_address_t *r6;
-  ip4_address_t *r4;
   ip6_main_t *im6 = &ip6_main;
   ip4_main_t *im4 = &ip4_main;
   ip_lookup_main_t *lm6 = &im6->lookup_main;
@@ -1464,10 +922,12 @@ vl_api_ip_address_dump_t_handler (vl_api_ip_address_dump_t * mp)
        * than one interface */
       foreach_ip_interface_address (lm6, ia, sw_if_index, 0,
       ({
-        r6 = ip_interface_address_get_address (lm6, ia);
-        u16 prefix_length = ia->address_length;
-        send_ip_address_details(am, reg, (u8*)r6, prefix_length,
-				sw_if_index, 1, mp->context);
+        fib_prefix_t pfx = {
+          .fp_addr.ip6 = *(ip6_address_t *)ip_interface_address_get_address (lm6, ia),
+          .fp_len = ia->address_length,
+          .fp_proto = FIB_PROTOCOL_IP6,
+        };
+        send_ip_address_details(am, reg, &pfx, sw_if_index, mp->context);
       }));
       /* *INDENT-ON* */
     }
@@ -1476,10 +936,13 @@ vl_api_ip_address_dump_t_handler (vl_api_ip_address_dump_t * mp)
       /* *INDENT-OFF* */
       foreach_ip_interface_address (lm4, ia, sw_if_index, 0,
       ({
-        r4 = ip_interface_address_get_address (lm4, ia);
-        u16 prefix_length = ia->address_length;
-        send_ip_address_details(am, reg, (u8*)r4, prefix_length,
-				sw_if_index, 0, mp->context);
+        fib_prefix_t pfx = {
+          .fp_addr.ip4 = *(ip4_address_t *)ip_interface_address_get_address (lm4, ia),
+          .fp_len = ia->address_length,
+          .fp_proto = FIB_PROTOCOL_IP4,
+        };
+
+        send_ip_address_details(am, reg, &pfx, sw_if_index, mp->context);
       }));
       /* *INDENT-ON* */
     }
@@ -1883,22 +1346,7 @@ vl_mfib_signal_send_one (vl_api_registration_t * reg,
   mp->table_id = ntohl (mfib->mft_table_id);
   mp->sw_if_index = ntohl (mfi->mfi_sw_if_index);
 
-  if (FIB_PROTOCOL_IP4 == prefix->fp_proto)
-    {
-      mp->grp_address_len = ntohs (prefix->fp_len);
-
-      memcpy (mp->grp_address, &prefix->fp_grp_addr.ip4, 4);
-      if (prefix->fp_len > 32)
-	{
-	  memcpy (mp->src_address, &prefix->fp_src_addr.ip4, 4);
-	}
-    }
-  else
-    {
-      mp->grp_address_len = ntohs (prefix->fp_len);
-
-      ASSERT (0);
-    }
+  ip_mprefix_encode (prefix, &mp->prefix);
 
   if (0 != mfs->mfs_buffer_len)
     {
@@ -3369,9 +2817,11 @@ static walk_rc_t
 send_ip_punt_redirect_details (u32 rx_sw_if_index,
 			       const ip_punt_redirect_rx_t * ipr, void *arg)
 {
-  fib_route_path_encode_t *api_rpaths = NULL;
   ip_punt_redirect_walk_ctx_t *ctx = arg;
   vl_api_ip_punt_redirect_details_t *mp;
+  fib_path_encode_ctx_t path_ctx = {
+    .rpaths = NULL,
+  };
 
   mp = vl_msg_api_alloc (sizeof (*mp));
   if (!mp)
@@ -3381,17 +2831,17 @@ send_ip_punt_redirect_details (u32 rx_sw_if_index,
   mp->_vl_msg_id = ntohs (VL_API_IP_PUNT_REDIRECT_DETAILS);
   mp->context = ctx->context;
 
-  fib_path_list_walk_w_ext (ipr->pl, NULL, fib_path_encode, &api_rpaths);
+  fib_path_list_walk_w_ext (ipr->pl, NULL, fib_path_encode, &path_ctx);
 
   mp->punt.rx_sw_if_index = htonl (rx_sw_if_index);
-  mp->punt.tx_sw_if_index = htonl (api_rpaths[0].rpath.frp_sw_if_index);
+  mp->punt.tx_sw_if_index = htonl (path_ctx.rpaths[0].frp_sw_if_index);
 
-  ip_address_encode (&api_rpaths[0].rpath.frp_addr,
+  ip_address_encode (&path_ctx.rpaths[0].frp_addr,
 		     fib_proto_to_ip46 (ipr->fproto), &mp->punt.nh);
 
   vl_api_send_msg (ctx->reg, (u8 *) mp);
 
-  vec_free (api_rpaths);
+  vec_free (path_ctx.rpaths);
 
   return (WALK_CONTINUE);
 }
@@ -3461,8 +2911,8 @@ ip_api_hookup (vlib_main_t * vm)
   /*
    * Mark the route add/del API as MP safe
    */
-  am->is_mp_safe[VL_API_IP_ADD_DEL_ROUTE] = 1;
-  am->is_mp_safe[VL_API_IP_ADD_DEL_ROUTE_REPLY] = 1;
+  am->is_mp_safe[VL_API_IP_ROUTE_ADD_DEL] = 1;
+  am->is_mp_safe[VL_API_IP_ROUTE_ADD_DEL_REPLY] = 1;
 
   /*
    * Set up the (msg_name, crc, message-id) table