VPP-376: Refactor LISP dump API + VAT

- refactor VAT so it won't cache data
- remove unused filter flag from locator dump API call
- json structure changed for locator and EID table dump calls
- remote mapping VAT cli now accepts string for negative mapping action

Change-Id: I776fb50659aaa7e98ad93715d282a83f78287344
Signed-off-by: Filip Tehlar <ftehlar@cisco.com>

7 files changed, 377 insertions, 1041 deletions

diff --git a/vnet/vnet/lisp-cp/control.c b/vnet/vnet/lisp-cp/control.c
index 0236e6ef6ef..16d7bfa0e1f 100644
--- a/vnet/vnet/lisp-cp/control.c
+++ b/vnet/vnet/lisp-cp/control.c
@@ -1049,6 +1049,12 @@ lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
       else if (unformat (line_input, "rloc %U", unformat_ip_address,
 			 &gid_address_ip (&rloc.address)))
 	{
+	  /* since rloc is stored in ip prefix we need to set prefix length */
+	  ip_prefix_t *pref = &gid_address_ippref (&rloc.address);
+
+	  u8 version = gid_address_ip_version (&rloc.address);
+	  ip_prefix_len (pref) = ip_address_max_len (version);
+
 	  vec_add1 (rlocs, rloc);
 	  curr_rloc = &rlocs[vec_len (rlocs) - 1];
 	}
@@ -1710,7 +1716,7 @@ vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t * a,
 	vec_validate (lcm->locator_to_locator_sets, loc_index);
 	ls_indexes = vec_elt_at_index (lcm->locator_to_locator_sets,
 				       loc_index);
-	vec_add1 (ls_indexes[0], ls_index);
+	vec_add1 (ls_indexes[0], p[0]);
       }
     }
   else
@@ -2213,7 +2219,7 @@ lisp_cp_show_locator_sets_command_fn (vlib_main_t * vm,
   u32 *locit;
   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 
-  vlib_cli_output (vm, "%=20s%=16s%=16s%=16s", "Locator-set", "Locator",
+  vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator",
 		   "Priority", "Weight");
 
   /* *INDENT-OFF* */
@@ -2223,11 +2229,11 @@ lisp_cp_show_locator_sets_command_fn (vlib_main_t * vm,
     int next_line = 0;
     if (lsit->local)
       {
-        msg = format (msg, "%=16v", lsit->name);
+        msg = format (msg, "%v", lsit->name);
       }
     else
       {
-        msg = format (msg, "%=16s", "remote");
+        msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool);
       }
     vec_foreach (locit, lsit->locator_indices)
       {
diff --git a/vnet/vnet/lisp-cp/lisp_types.c b/vnet/vnet/lisp-cp/lisp_types.c
index 203698ad89a..b4fb1d91bfc 100644
--- a/vnet/vnet/lisp-cp/lisp_types.c
+++ b/vnet/vnet/lisp-cp/lisp_types.c
@@ -1253,6 +1253,7 @@ gid_address_parse (u8 * offset, gid_address_t * a)
 void
 gid_address_ip_set (gid_address_t * dst, void *src, u8 version)
 {
+  gid_address_ippref_len (dst) = ip_address_max_len (version);
   ip_address_set (&gid_address_ip (dst), src, version);
 }
 
diff --git a/vpp-api-test/vat/api_format.c b/vpp-api-test/vat/api_format.c
index 0df2051e6c7..e29b47e3862 100644
--- a/vpp-api-test/vat/api_format.c
+++ b/vpp-api-test/vat/api_format.c
@@ -1315,53 +1315,6 @@ static void vl_api_control_ping_reply_t_handler_json
   vam->result_ready = 1;
 }
 
-static void vl_api_noprint_control_ping_reply_t_handler
-  (vl_api_noprint_control_ping_reply_t * mp)
-{
-  vat_main_t *vam = &vat_main;
-  i32 retval = ntohl (mp->retval);
-  if (vam->async_mode)
-    {
-      vam->async_errors += (retval < 0);
-    }
-  else
-    {
-      vam->retval = retval;
-      vam->result_ready = 1;
-    }
-}
-
-static void vl_api_noprint_control_ping_reply_t_handler_json
-  (vl_api_noprint_control_ping_reply_t * mp)
-{
-  vat_main_t *vam = &vat_main;
-  i32 retval = ntohl (mp->retval);
-
-  if (vam->noprint_msg)
-    {
-      vam->retval = retval;
-      vam->result_ready = 1;
-      return;
-    }
-
-  if (VAT_JSON_NONE != vam->json_tree.type)
-    {
-      vat_json_print (vam->ofp, &vam->json_tree);
-      vat_json_free (&vam->json_tree);
-      vam->json_tree.type = VAT_JSON_NONE;
-    }
-  else
-    {
-      /* just print [] */
-      vat_json_init_array (&vam->json_tree);
-      vat_json_print (vam->ofp, &vam->json_tree);
-      vam->json_tree.type = VAT_JSON_NONE;
-    }
-
-  vam->retval = retval;
-  vam->result_ready = 1;
-}
-
 static void
 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
 {
@@ -2277,47 +2230,23 @@ static void
 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
 {
   vat_main_t *vam = &vat_main;
-  locator_msg_t loc;
-  u8 *tmp_str = 0;
+  u8 *s = 0;
 
-  memset (&loc, 0, sizeof (loc));
-  if (vam->noprint_msg)
+  if (mp->local)
     {
-      loc.local = mp->local;
-      loc.priority = mp->priority;
-      loc.weight = mp->weight;
-      if (loc.local)
-	{
-	  loc.sw_if_index = ntohl (mp->sw_if_index);
-	}
-      else
-	{
-	  loc.is_ipv6 = mp->is_ipv6;
-	  clib_memcpy (loc.ip_address, mp->ip_address,
-		       sizeof (loc.ip_address));
-	}
-      vec_add1 (vam->locator_msg, loc);
+      s = format (s, "%=16d%=16d%=16d\n",
+		  ntohl (mp->sw_if_index), mp->priority, mp->weight);
     }
   else
     {
-      if (mp->local)
-	{
-	  tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
-			    ntohl (mp->sw_if_index),
-			    mp->priority, mp->weight);
-	}
-      else
-	{
-	  tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
-			    mp->is_ipv6 ? format_ip6_address :
-			    format_ip4_address,
-			    mp->ip_address, mp->priority, mp->weight);
-	}
-
-      fformat (vam->ofp, "%s", tmp_str);
-
-      vec_free (tmp_str);
+      s = format (s, "%=16U%=16d%=16d\n",
+		  mp->is_ipv6 ? format_ip6_address :
+		  format_ip4_address,
+		  mp->ip_address, mp->priority, mp->weight);
     }
+
+  fformat (vam->ofp, "%v", s);
+  vec_free (s);
 }
 
 static void
@@ -2326,59 +2255,37 @@ vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
 {
   vat_main_t *vam = &vat_main;
   vat_json_node_t *node = NULL;
-  locator_msg_t loc;
   struct in6_addr ip6;
   struct in_addr ip4;
 
-  memset (&loc, 0, sizeof (loc));
-  if (vam->noprint_msg)
-    {
-      loc.local = mp->local;
-      loc.priority = mp->priority;
-      loc.weight = mp->weight;
-      if (loc.local)
-	{
-	  loc.sw_if_index = ntohl (mp->sw_if_index);
-	}
-      else
-	{
-	  loc.is_ipv6 = mp->is_ipv6;
-	  clib_memcpy (loc.ip_address, mp->ip_address,
-		       sizeof (loc.ip_address));
-	}
-      vec_add1 (vam->locator_msg, loc);
-      return;
-    }
-
   if (VAT_JSON_ARRAY != vam->json_tree.type)
     {
       ASSERT (VAT_JSON_NONE == vam->json_tree.type);
       vat_json_init_array (&vam->json_tree);
     }
   node = vat_json_array_add (&vam->json_tree);
-
   vat_json_init_object (node);
 
+  vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
+  vat_json_object_add_uint (node, "priority", mp->priority);
+  vat_json_object_add_uint (node, "weight", mp->weight);
+
   if (mp->local)
-    {
-      vat_json_object_add_uint (node, "locator_index",
-				ntohl (mp->sw_if_index));
-    }
+    vat_json_object_add_uint (node, "sw_if_index",
+			      clib_net_to_host_u32 (mp->sw_if_index));
   else
     {
       if (mp->is_ipv6)
 	{
 	  clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
-	  vat_json_object_add_ip6 (node, "locator", ip6);
+	  vat_json_object_add_ip6 (node, "address", ip6);
 	}
       else
 	{
 	  clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
-	  vat_json_object_add_ip4 (node, "locator", ip4);
+	  vat_json_object_add_ip4 (node, "address", ip4);
 	}
     }
-  vat_json_object_add_uint (node, "priority", mp->priority);
-  vat_json_object_add_uint (node, "weight", mp->weight);
 }
 
 static void
@@ -2386,11 +2293,13 @@ vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
 					   mp)
 {
   vat_main_t *vam = &vat_main;
-  locator_set_msg_t ls;
+  u8 *ls_name = 0;
 
-  ls.locator_set_index = ntohl (mp->locator_set_index);
-  ls.locator_set_name = format (0, "%s", mp->locator_set_name);
-  vec_add1 (vam->locator_set_msg, ls);
+  ls_name = format (0, "%s", mp->ls_name);
+
+  fformat (vam->ofp, "%=10d%=15v\n", clib_net_to_host_u32 (mp->ls_index),
+	   ls_name);
+  vec_free (ls_name);
 }
 
 static void
@@ -2398,37 +2307,88 @@ static void
   (vl_api_lisp_locator_set_details_t * mp)
 {
   vat_main_t *vam = &vat_main;
-  locator_set_msg_t ls;
+  vat_json_node_t *node = 0;
+  u8 *ls_name = 0;
+
+  ls_name = format (0, "%s", mp->ls_name);
+  vec_add1 (ls_name, 0);
+
+  if (VAT_JSON_ARRAY != vam->json_tree.type)
+    {
+      ASSERT (VAT_JSON_NONE == vam->json_tree.type);
+      vat_json_init_array (&vam->json_tree);
+    }
+  node = vat_json_array_add (&vam->json_tree);
 
-  ls.locator_set_index = ntohl (mp->locator_set_index);
-  ls.locator_set_name = format (0, "%s", mp->locator_set_name);
-  vec_add1 (vam->locator_set_msg, ls);
+  vat_json_init_object (node);
+  vat_json_object_add_string_copy (node, "ls_name", ls_name);
+  vat_json_object_add_uint (node, "ls_index",
+			    clib_net_to_host_u32 (mp->ls_index));
+  vec_free (ls_name);
 }
 
-static void
-add_lisp_eid_table_entry (vat_main_t * vam,
-			  vl_api_lisp_eid_table_details_t * mp)
+static u8 *
+format_lisp_flat_eid (u8 * s, va_list * args)
 {
-  eid_table_t eid_table;
+  u32 type = va_arg (*args, u32);
+  u8 *eid = va_arg (*args, u8 *);
+  u32 eid_len = va_arg (*args, u32);
 
-  memset (&eid_table, 0, sizeof (eid_table));
-  eid_table.is_local = mp->is_local;
-  eid_table.locator_set_index = clib_net_to_host_u32 (mp->locator_set_index);
-  eid_table.eid_type = mp->eid_type;
-  eid_table.vni = clib_net_to_host_u32 (mp->vni);
-  eid_table.eid_prefix_len = mp->eid_prefix_len;
-  eid_table.ttl = clib_net_to_host_u32 (mp->ttl);
-  eid_table.action = mp->action;
-  eid_table.authoritative = mp->authoritative;
-  clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
-  vec_add1 (vam->eid_tables, eid_table);
+  switch (type)
+    {
+    case 0:
+      return format (s, "%U/%d", format_ip4_address, eid, eid_len);
+    case 1:
+      return format (s, "%U/%d", format_ip6_address, eid, eid_len);
+    case 2:
+      return format (s, "%U", format_ethernet_address, eid);
+    }
+  return 0;
+}
+
+static u8 *
+format_lisp_eid_vat (u8 * s, va_list * args)
+{
+  u32 type = va_arg (*args, u32);
+  u8 *eid = va_arg (*args, u8 *);
+  u32 eid_len = va_arg (*args, u32);
+  u8 *seid = va_arg (*args, u8 *);
+  u32 seid_len = va_arg (*args, u32);
+  u32 is_src_dst = va_arg (*args, u32);
+
+  if (is_src_dst)
+    s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
+
+  s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
+
+  return s;
 }
 
 static void
 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
 {
   vat_main_t *vam = &vat_main;
-  add_lisp_eid_table_entry (vam, mp);
+  u8 *s = 0, *eid = 0;
+
+  if (~0 == mp->locator_set_index)
+    s = format (0, "action: %d", mp->action);
+  else
+    s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
+
+  eid = format (0, "%U", format_lisp_eid_vat,
+		mp->eid_type,
+		mp->eid,
+		mp->eid_prefix_len,
+		mp->seid, mp->seid_prefix_len, mp->is_src_dst);
+  vec_add1 (eid, 0);
+
+  fformat (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-d\n",
+	   clib_net_to_host_u32 (mp->vni),
+	   eid,
+	   mp->is_local ? "local" : "remote",
+	   s, clib_net_to_host_u32 (mp->ttl), mp->authoritative);
+  vec_free (s);
+  vec_free (eid);
 }
 
 static void
@@ -2436,7 +2396,35 @@ vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
 					      * mp)
 {
   vat_main_t *vam = &vat_main;
-  add_lisp_eid_table_entry (vam, mp);
+  vat_json_node_t *node = 0;
+  u8 *eid = 0;
+
+  if (VAT_JSON_ARRAY != vam->json_tree.type)
+    {
+      ASSERT (VAT_JSON_NONE == vam->json_tree.type);
+      vat_json_init_array (&vam->json_tree);
+    }
+  node = vat_json_array_add (&vam->json_tree);
+
+  vat_json_init_object (node);
+  if (~0 == mp->locator_set_index)
+    vat_json_object_add_uint (node, "action", mp->action);
+  else
+    vat_json_object_add_uint (node, "locator_set_index",
+			      clib_net_to_host_u32 (mp->locator_set_index));
+
+  vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
+  eid = format (0, "%U", format_lisp_eid_vat,
+		mp->eid_type,
+		mp->eid,
+		mp->eid_prefix_len,
+		mp->seid, mp->seid_prefix_len, mp->is_src_dst);
+  vec_add1 (eid, 0);
+  vat_json_object_add_string_copy (node, "eid", eid);
+  vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
+  vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
+  vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
+  vec_free (eid);
 }
 
 static void
@@ -3477,7 +3465,6 @@ _(SW_INTERFACE_DETAILS, sw_interface_details)                           \
 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags)                       \
 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply)           \
 _(CONTROL_PING_REPLY, control_ping_reply)                               \
-_(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply)               \
 _(CLI_REPLY, cli_reply)                                                 \
 _(CLI_INBAND_REPLY, cli_inband_reply)                                   \
 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY,                                   \
@@ -3712,21 +3699,6 @@ do {                                            \
     return -99;                                 \
 } while(0);
 
-/* W_L: wait for results, with timeout */
-#define W_L(body)                               \
-do {                                            \
-    timeout = vat_time_now (vam) + 1.0;         \
-                                                \
-    while (vat_time_now (vam) < timeout) {      \
-        if (vam->result_ready == 1) {           \
-          (body);                               \
-          return (vam->retval);                 \
-        }                                       \
-    }                                           \
-    vam->noprint_msg = 0;     \
-    return -99;                                 \
-} while(0);
-
 typedef struct
 {
   u8 *name;
@@ -12525,6 +12497,35 @@ api_lisp_eid_table_add_del_map (vat_main_t * vam)
   return 0;
 }
 
+uword
+unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
+{
+  u32 *action = va_arg (*args, u32 *);
+  u8 *s = 0;
+
+  if (unformat (input, "%s", &s))
+    {
+      if (!strcmp ((char *) s, "no-action"))
+	action[0] = 0;
+      else if (!strcmp ((char *) s, "natively-forward"))
+	action[0] = 1;
+      else if (!strcmp ((char *) s, "send-map-request"))
+	action[0] = 2;
+      else if (!strcmp ((char *) s, "drop"))
+	action[0] = 3;
+      else
+	{
+	  clib_warning ("invalid action: '%s'", s);
+	  action[0] = 3;
+	}
+    }
+  else
+    return 0;
+
+  vec_free (s);
+  return 1;
+}
+
 /**
  * Add/del remote mapping to/from LISP control plane
  *
@@ -12538,10 +12539,9 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam)
   vl_api_lisp_add_del_remote_mapping_t *mp;
   f64 timeout = ~0;
   u32 vni = 0;
-  //TODO: seid need remove
   lisp_eid_vat_t _eid, *eid = &_eid;
   lisp_eid_vat_t _seid, *seid = &_seid;
-  u8 is_add = 1, del_all = 0, eid_set = 0;
+  u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
   u32 action = ~0, p, w;
   ip4_address_t rloc4;
   ip6_address_t rloc6;
@@ -12564,13 +12564,13 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam)
 	{
 	  is_add = 1;
 	}
-      else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid))
+      else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
 	{
 	  eid_set = 1;
 	}
-      else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid))
+      else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
 	{
-	  //TODO: Need remove, but first must be remove from CSIT test
+	  seid_set = 1;
 	}
       else if (unformat (input, "vni %d", &vni))
 	{
@@ -12600,7 +12600,8 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam)
 	  vec_add1 (rlocs, rloc);
 	  curr_rloc = &rlocs[vec_len (rlocs) - 1];
 	}
-      else if (unformat (input, "action %d", &action))
+      else if (unformat (input, "action %U",
+			 unformat_negative_mapping_action, &action))
 	{
 	  ;
 	}
@@ -12627,10 +12628,13 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam)
   mp->is_add = is_add;
   mp->vni = htonl (vni);
   mp->action = (u8) action;
+  mp->is_src_dst = seid_set;
   mp->eid_len = eid->len;
+  mp->seid_len = seid->len;
   mp->del_all = del_all;
   mp->eid_type = eid->type;
   lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
+  lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
 
   mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
   clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
@@ -12913,320 +12917,73 @@ api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
 }
 
 static int
-lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index,
-			    u8 filter)
+api_lisp_locator_dump (vat_main_t * vam)
 {
+  unformat_input_t *input = vam->input;
   vl_api_lisp_locator_dump_t *mp;
   f64 timeout = ~0;
+  u8 is_index_set = 0, is_name_set = 0;
+  u8 *ls_name = 0;
+  u32 ls_index = ~0;
 
-  M (LISP_LOCATOR_DUMP, lisp_locator_dump);
-
-  mp->locator_set_index = htonl (locator_set_index);
-  mp->filter = filter;
-
-  /* send it... */
-  S;
-
-  /* Use a control ping for synchronization */
-  {
-    vl_api_noprint_control_ping_t *mp;
-    M (NOPRINT_CONTROL_PING, noprint_control_ping);
-    S;
-  }
-  /* Wait for a reply... */
-  W;
-}
-
-static inline void
-clean_locator_set_message (vat_main_t * vam)
-{
-  locator_set_msg_t *ls = 0;
-
-  vec_foreach (ls, vam->locator_set_msg)
-  {
-    vec_free (ls->locator_set_name);
-  }
-
-  vec_free (vam->locator_set_msg);
-}
-
-static int
-print_locator_in_locator_set (vat_main_t * vam, u8 filter)
-{
-  locator_set_msg_t *ls;
-  locator_msg_t *loc;
-  u8 *tmp_str = 0;
-  int i = 0, ret = 0;
-
-  vec_foreach (ls, vam->locator_set_msg)
-  {
-    ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
-    if (ret)
-      {
-	vec_free (vam->locator_msg);
-	clean_locator_set_message (vam);
-	return ret;
-      }
-
-    tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name,
-		      ls->locator_set_index,
-		      vec_len (vam->locator_msg) ? "" : "\n");
-    i = 0;
-    vec_foreach (loc, vam->locator_msg)
+  /* Parse args required to build the message */
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
-      if (i)
-	{
-	  tmp_str = format (tmp_str, "%=37s", " ");
-	}
-      if (loc->local)
+      if (unformat (input, "ls_name %_%v%_", &ls_name))
 	{
-	  tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
-			    loc->sw_if_index, loc->priority, loc->weight);
+	  is_name_set = 1;
 	}
-      else
-	{
-	  tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
-			    loc->is_ipv6 ? format_ip6_address :
-			    format_ip4_address,
-			    loc->ip_address, loc->priority, loc->weight);
-	}
-      i++;
-    }
-
-    fformat (vam->ofp, "%s", tmp_str);
-    vec_free (tmp_str);
-    vec_free (vam->locator_msg);
-  }
-
-  clean_locator_set_message (vam);
-
-  return ret;
-}
-
-static int
-json_locator_in_locator_set (vat_main_t * vam, u8 filter)
-{
-  locator_set_msg_t *ls;
-  locator_msg_t *loc;
-  vat_json_node_t *node = NULL;
-  vat_json_node_t *locator_array;
-  vat_json_node_t *locator;
-  struct in6_addr ip6;
-  struct in_addr ip4;
-  int ret = 0;
-
-  if (!vec_len (vam->locator_set_msg))
-    {
-      /* just print [] */
-      vat_json_init_array (&vam->json_tree);
-      vat_json_print (vam->ofp, &vam->json_tree);
-      vam->json_tree.type = VAT_JSON_NONE;
-      return ret;
-    }
-
-  if (VAT_JSON_ARRAY != vam->json_tree.type)
-    {
-      ASSERT (VAT_JSON_NONE == vam->json_tree.type);
-      vat_json_init_array (&vam->json_tree);
-    }
-
-  vec_foreach (ls, vam->locator_set_msg)
-  {
-    ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
-    if (ret)
-      {
-	vec_free (ls->locator_set_name);
-	vec_free (vam->locator_msg);
-	vec_free (vam->locator_set_msg);
-	vat_json_free (&vam->json_tree);
-	vam->json_tree.type = VAT_JSON_NONE;
-	return ret;
-      }
-
-    node = vat_json_array_add (&vam->json_tree);
-    vat_json_init_object (node);
-
-    vat_json_object_add_uint (node, "locator-set-index",
-			      ls->locator_set_index);
-    vat_json_object_add_string_copy (node, "locator-set",
-				     ls->locator_set_name);
-    locator_array = vat_json_object_add_list (node, "locator");
-    vec_foreach (loc, vam->locator_msg)
-    {
-      locator = vat_json_array_add (locator_array);
-      vat_json_init_object (locator);
-      if (loc->local)
+      else if (unformat (input, "ls_index %d", &ls_index))
 	{
-	  vat_json_object_add_uint (locator, "locator-index",
-				    loc->sw_if_index);
+	  is_index_set = 1;
 	}
       else
 	{
-	  if (loc->is_ipv6)
-	    {
-	      clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
-	      vat_json_object_add_ip6 (locator, "locator", ip6);
-	    }
-	  else
-	    {
-	      clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
-	      vat_json_object_add_ip4 (locator, "locator", ip4);
-	    }
+	  errmsg ("parse error '%U'", format_unformat_error, input);
+	  return -99;
 	}
-      vat_json_object_add_uint (locator, "priority", loc->priority);
-      vat_json_object_add_uint (locator, "weight", loc->weight);
     }
 
-    vec_free (ls->locator_set_name);
-    vec_free (vam->locator_msg);
-  }
-
-  vat_json_print (vam->ofp, &vam->json_tree);
-  vat_json_free (&vam->json_tree);
-  vam->json_tree.type = VAT_JSON_NONE;
-
-  vec_free (vam->locator_set_msg);
-
-  return ret;
-}
-
-static int
-get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set,
-				u32 * locator_set_index)
-{
-  locator_set_msg_t *ls;
-  int ret = 0;
-
-  *locator_set_index = ~0;
-
-  if (!vec_len (vam->locator_set_msg))
+  if (!is_index_set && !is_name_set)
     {
-      return ret;
-    }
-
-  vec_foreach (ls, vam->locator_set_msg)
-  {
-    if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name))
-      {
-	*locator_set_index = ls->locator_set_index;
-	vec_free (vam->locator_set_msg);
-	return ret;
-      }
-  }
-
-  vec_free (vam->locator_set_msg);
-
-  return ret;
-}
-
-static int
-get_locator_set_index (vat_main_t * vam, u8 * locator_set,
-		       u32 * locator_set_index)
-{
-  vl_api_lisp_locator_set_dump_t *mp;
-  f64 timeout = ~0;
-
-  M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
-  /* send it... */
-  S;
-
-  /* Use a control ping for synchronization */
-  {
-    vl_api_noprint_control_ping_t *mp;
-    M (NOPRINT_CONTROL_PING, noprint_control_ping);
-    S;
-  }
-
-  vam->noprint_msg = 1;
-  /* Wait for a reply... */
-  /* *INDENT-OFF* */
-  W_L
-  ({
-    get_locator_set_index_from_msg (vam, locator_set, locator_set_index);
-    vam->noprint_msg = 0;
-  });
-  /* *INDENT-ON* */
-
-  /* NOTREACHED */
-  return 0;
-}
-
-static inline int
-lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
-		   u8 filter)
-{
-  int ret = 0;
-
-  ASSERT (vam);
-
-  if (!vam->json_output)
-    {
-      fformat (vam->ofp, "%=20s%=16s%=16s\n",
-	       "locator", "priority", "weight");
-    }
-
-  if (locator_set)
-    {
-      ret = get_locator_set_index (vam, locator_set, &locator_set_index);
+      errmsg ("error: expected one of index or name!\n");
+      return -99;
     }
 
-  if (!ret && ~0 == locator_set_index)
+  if (is_index_set && is_name_set)
     {
+      errmsg ("error: only one param expected!\n");
       return -99;
     }
 
-  ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter);
-
-  return ret;
-}
-
-static int
-lisp_locator_set_dump (vat_main_t * vam, u8 filter)
-{
-  vl_api_lisp_locator_set_dump_t *mp;
-  f64 timeout = ~0;
-
   if (!vam->json_output)
     {
-      fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
-	       "locator-set", "locator-set-index", "locator", "priority",
+      fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
 	       "weight");
     }
 
-  vam->noprint_msg = 1;
-
-  M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
+  M (LISP_LOCATOR_DUMP, lisp_locator_dump);
+  mp->is_index_set = is_index_set;
 
-  mp->filter = filter;
+  if (is_index_set)
+    mp->ls_index = clib_host_to_net_u32 (ls_index);
+  else
+    {
+      vec_add1 (ls_name, 0);
+      strcpy ((char *) mp->ls_name, (char *) ls_name);
+    }
 
   /* send it... */
   S;
 
   /* Use a control ping for synchronization */
   {
-    vl_api_noprint_control_ping_t *mp;
-    M (NOPRINT_CONTROL_PING, noprint_control_ping);
+    vl_api_control_ping_t *mp;
+    M (CONTROL_PING, control_ping);
     S;
   }
-
   /* Wait for a reply... */
-  /* *INDENT-OFF* */
-  W_L
-  ({
-    if (vam->noprint_msg)
-      {
-        if (!vam->json_output)
-          {
-            print_locator_in_locator_set(vam, filter);
-          }
-        else
-          {
-            json_locator_in_locator_set(vam, filter);
-          }
-      }
-    vam->noprint_msg = 0;
-  });
-  /* *INDENT-ON* */
+  W;
 
   /* NOTREACHED */
   return 0;
@@ -13235,27 +12992,15 @@ lisp_locator_set_dump (vat_main_t * vam, u8 filter)
 static int
 api_lisp_locator_set_dump (vat_main_t * vam)
 {
+  vl_api_lisp_locator_set_dump_t *mp;
   unformat_input_t *input = vam->input;
-  vam->noprint_msg = 0;
-  u32 locator_set_index = ~0;
-  u8 locator_set_index_set = 0;
-  u8 *locator_set = 0;
-  u8 locator_set_set = 0;
+  f64 timeout = ~0;
   u8 filter = 0;
-  int ret = 0;
 
   /* Parse args required to build the message */
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
-      if (unformat (input, "locator-set-index %u", &locator_set_index))
-	{
-	  locator_set_index_set = 1;
-	}
-      else if (unformat (input, "locator-set %s", &locator_set))
-	{
-	  locator_set_set = 1;
-	}
-      else if (unformat (input, "local"))
+      if (unformat (input, "local"))
 	{
 	  filter = 1;
 	}
@@ -13265,28 +13010,34 @@ api_lisp_locator_set_dump (vat_main_t * vam)
 	}
       else
 	{
-	  break;
+	  errmsg ("parse error '%U'", format_unformat_error, input);
+	  return -99;
 	}
     }
 
-  if (locator_set_index_set && locator_set_set)
+  if (!vam->json_output)
     {
-      errmsg ("use only input parameter!\n");
-      return -99;
+      fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
     }
 
-  if (locator_set_index_set || locator_set_set)
-    {
-      ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter);
-    }
-  else
-    {
-      ret = lisp_locator_set_dump (vam, filter);
-    }
+  M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
+
+  mp->filter = filter;
+
+  /* send it... */
+  S;
 
-  vec_free (locator_set);
+  /* Use a control ping for synchronization */
+  {
+    vl_api_control_ping_t *mp;
+    M (CONTROL_PING, control_ping);
+    S;
+  }
+  /* Wait for a reply... */
+  W;
 
-  return ret;
+  /* NOTREACHED */
+  return 0;
 }
 
 static int
@@ -13378,412 +13129,6 @@ api_lisp_eid_table_vni_dump (vat_main_t * vam)
 }
 
 static int
-get_locator_set (vat_main_t * vam)
-{
-  vl_api_lisp_locator_set_dump_t *mp;
-  f64 timeout = ~0;
-
-  M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
-  /* send it... */
-  S;
-
-  /* Use a control ping for synchronization */
-  {
-    vl_api_noprint_control_ping_t *mp;
-    M (NOPRINT_CONTROL_PING, noprint_control_ping);
-    S;
-  }
-
-  /* Wait for a reply... */
-  W;
-
-  /* NOTREACHED */
-  return 0;
-}
-
-static inline u8 *
-format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table,
-			  int *ret)
-{
-  u8 *(*format_eid) (u8 *, va_list *) = 0;
-
-  ASSERT (vam != NULL);
-  ASSERT (eid_table != NULL);
-
-  if (ret)
-    {
-      *ret = 0;
-    }
-
-  switch (eid_table->eid_type)
-    {
-    case 0:
-    case 1:
-      format_eid = (eid_table->eid_type ? format_ip6_address :
-		    format_ip4_address);
-      str = format (0, "[%d] %U/%d", eid_table->vni,
-		    format_eid, eid_table->eid, eid_table->eid_prefix_len);
-      break;
-    case 2:
-      str = format (0, "[%d] %U", eid_table->vni,
-		    format_ethernet_address, eid_table->eid);
-      break;
-    default:
-      errmsg ("unknown EID type %d!", eid_table->eid_type);
-      if (ret)
-	{
-	  *ret = -99;
-	}
-      return 0;
-    }
-
-  return str;
-}
-
-static inline u8 *
-format_locator_set_for_eid_table (vat_main_t * vam, u8 * str,
-				  eid_table_t * eid_table)
-{
-  locator_set_msg_t *ls = 0;
-
-  ASSERT (vam != NULL);
-  ASSERT (eid_table != NULL);
-
-  if (eid_table->is_local)
-    {
-      vec_foreach (ls, vam->locator_set_msg)
-      {
-	if (ls->locator_set_index == eid_table->locator_set_index)
-	  {
-	    str = format (0, "local(%s)", ls->locator_set_name);
-	    return str;
-	  }
-      }
-
-      str = format (0, "local(N/A)");
-    }
-  else
-    {
-      str = format (0, "remote");
-    }
-
-  return str;
-}
-
-static inline u8 *
-format_locator_for_eid_table (vat_main_t * vam, u8 * str,
-			      eid_table_t * eid_table)
-{
-  locator_msg_t *loc = 0;
-  int first_line = 1;
-
-  ASSERT (vam != NULL);
-  ASSERT (eid_table != NULL);
-
-  if (~0 == eid_table->locator_set_index)
-    {
-      return format (0, "action: %d\n", eid_table->action);
-    }
-
-  vec_foreach (loc, vam->locator_msg)
-  {
-    if (!first_line)
-      {
-	if (loc->local)
-	  {
-	    str = format (str, "%-55s%-d\n", " ", loc->sw_if_index);
-	  }
-	else
-	  {
-	    str = format (str, "%=55s%-U\n", " ",
-			  loc->is_ipv6 ? format_ip6_address :
-			  format_ip4_address, loc->ip_address);
-	  }
-
-	continue;
-      }
-
-    if (loc->local)
-      {
-	str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index,
-		      eid_table->ttl, eid_table->authoritative);
-      }
-    else
-      {
-	str = format (str, "%-30U%-20u%-u\n",
-		      loc->is_ipv6 ? format_ip6_address :
-		      format_ip4_address,
-		      loc->ip_address, eid_table->ttl,
-		      eid_table->authoritative);
-      }
-    first_line = 0;
-  }
-
-  return str;
-}
-
-static int
-print_lisp_eid_table_dump (vat_main_t * vam)
-{
-  eid_table_t *eid_table = 0;
-  u8 *tmp_str = 0, *tmp_str2 = 0;
-  int ret = 0;
-
-  ASSERT (vam != NULL);
-
-  ret = get_locator_set (vam);
-  if (ret)
-    {
-      vec_free (vam->eid_tables);
-      return ret;
-    }
-
-  fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators",
-	   "ttl", "authoritative");
-
-  vec_foreach (eid_table, vam->eid_tables)
-  {
-    if (~0 != eid_table->locator_set_index)
-      {
-	ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index,
-					  0);
-	if (ret)
-	  {
-	    vec_free (vam->locator_msg);
-	    clean_locator_set_message (vam);
-	    vec_free (vam->eid_tables);
-	    return ret;
-	  }
-      }
-
-    tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret);
-    if (ret)
-      {
-	vec_free (vam->locator_msg);
-	clean_locator_set_message (vam);
-	vec_free (vam->eid_tables);
-	return ret;
-      }
-
-    tmp_str = format (0, "%-35s", tmp_str2);
-    vec_free (tmp_str2);
-
-    tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table);
-    tmp_str = format (tmp_str, "%-20s", tmp_str2);
-    vec_free (tmp_str2);
-
-    tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table);
-    tmp_str = format (tmp_str, "%-s", tmp_str2);
-    vec_free (tmp_str2);
-
-    fformat (vam->ofp, "%s", tmp_str);
-    vec_free (tmp_str);
-    vec_free (vam->locator_msg);
-  }
-
-  clean_locator_set_message (vam);
-  vec_free (vam->eid_tables);
-
-  return ret;
-}
-
-static inline void
-json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
-				eid_table_t * eid_table)
-{
-  locator_set_msg_t *ls = 0;
-  u8 *s = 0;
-
-  ASSERT (vam != NULL);
-  ASSERT (node != NULL);
-  ASSERT (eid_table != NULL);
-
-  if (eid_table->is_local)
-    {
-      vec_foreach (ls, vam->locator_set_msg)
-      {
-	if (ls->locator_set_index == eid_table->locator_set_index)
-	  {
-	    vat_json_object_add_string_copy (node, "locator-set",
-					     ls->locator_set_name);
-	    return;
-	  }
-      }
-
-      s = format (0, "N/A");
-      vec_add1 (s, 0);
-      vat_json_object_add_string_copy (node, "locator-set", s);
-      vec_free (s);
-    }
-  else
-    {
-      s = format (0, "remote");
-      vec_add1 (s, 0);
-      vat_json_object_add_string_copy (node, "locator-set", s);
-      vec_free (s);
-    }
-}
-
-static inline int
-json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
-			eid_table_t * eid_table)
-{
-  u8 *s = 0;
-  struct in6_addr ip6;
-  struct in_addr ip4;
-
-  ASSERT (vam != NULL);
-  ASSERT (node != NULL);
-  ASSERT (eid_table != NULL);
-
-  switch (eid_table->eid_type)
-    {
-    case 0:
-      clib_memcpy (&ip4, eid_table->eid, sizeof (ip4));
-      vat_json_object_add_ip4 (node, "eid", ip4);
-      vat_json_object_add_uint (node, "eid-prefix-len",
-				eid_table->eid_prefix_len);
-      break;
-    case 1:
-      clib_memcpy (&ip6, eid_table->eid, sizeof (ip6));
-      vat_json_object_add_ip6 (node, "eid", ip6);
-      vat_json_object_add_uint (node, "eid-prefix-len",
-				eid_table->eid_prefix_len);
-      break;
-    case 2:
-      s = format (0, "%U", format_ethernet_address, eid_table->eid);
-      vec_add1 (s, 0);
-      vat_json_object_add_string_copy (node, "eid", s);
-      vec_free (s);
-      break;
-    default:
-      errmsg ("unknown EID type %d!", eid_table->eid_type);
-      return -99;
-    }
-
-  return 0;
-}
-
-static inline void
-json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
-			    eid_table_t * eid_table)
-{
-  locator_msg_t *loc = 0;
-  vat_json_node_t *locator_array = 0;
-  vat_json_node_t *locator = 0;
-  struct in6_addr ip6;
-  struct in_addr ip4;
-
-  ASSERT (vam != NULL);
-  ASSERT (node != NULL);
-  ASSERT (eid_table != NULL);
-
-  locator_array = vat_json_object_add_list (node, "locator");
-  vec_foreach (loc, vam->locator_msg)
-  {
-    locator = vat_json_array_add (locator_array);
-    vat_json_init_object (locator);
-    if (loc->local)
-      {
-	vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index);
-      }
-    else
-      {
-	if (loc->is_ipv6)
-	  {
-	    clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
-	    vat_json_object_add_ip6 (locator, "locator", ip6);
-	  }
-	else
-	  {
-	    clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
-	    vat_json_object_add_ip4 (locator, "locator", ip4);
-	  }
-      }
-  }
-}
-
-static int
-json_lisp_eid_table_dump (vat_main_t * vam)
-{
-  eid_table_t *eid_table;
-  vat_json_node_t *node = 0;
-  int ret = 0;
-
-  ASSERT (vam != NULL);
-
-  ret = get_locator_set (vam);
-  if (ret)
-    {
-      vec_free (vam->eid_tables);
-      return ret;
-    }
-
-  if (!vec_len (vam->eid_tables))
-    {
-      /* just print [] */
-      vat_json_init_array (&vam->json_tree);
-      vat_json_print (vam->ofp, &vam->json_tree);
-      vam->json_tree.type = VAT_JSON_NONE;
-      return ret;
-    }
-
-  if (VAT_JSON_ARRAY != vam->json_tree.type)
-    {
-      ASSERT (VAT_JSON_NONE == vam->json_tree.type);
-      vat_json_init_array (&vam->json_tree);
-    }
-
-  vec_foreach (eid_table, vam->eid_tables)
-  {
-    ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
-    if (ret)
-      {
-	vec_free (vam->locator_msg);
-	vec_free (vam->eid_tables);
-	clean_locator_set_message (vam);
-	vat_json_free (&vam->json_tree);
-	vam->json_tree.type = VAT_JSON_NONE;
-	return ret;
-      }
-
-    node = vat_json_array_add (&vam->json_tree);
-    vat_json_init_object (node);
-
-    vat_json_object_add_uint (node, "vni", eid_table->vni);
-
-    json_locator_set_for_eid_table (vam, node, eid_table);
-    ret = json_eid_for_eid_table (vam, node, eid_table);
-    if (ret)
-      {
-	vec_free (vam->locator_msg);
-	vec_free (vam->eid_tables);
-	clean_locator_set_message (vam);
-	vat_json_free (&vam->json_tree);
-	vam->json_tree.type = VAT_JSON_NONE;
-	return ret;
-      }
-
-    json_locator_for_eid_table (vam, node, eid_table);
-
-    vat_json_object_add_uint (node, "ttl", eid_table->ttl);
-    vat_json_object_add_uint (node, "authoritative",
-			      eid_table->authoritative);
-
-    vec_free (vam->locator_msg);
-  }
-
-  vat_json_print (vam->ofp, &vam->json_tree);
-  vat_json_free (&vam->json_tree);
-  vam->json_tree.type = VAT_JSON_NONE;
-
-  clean_locator_set_message (vam);
-  vec_free (vam->eid_tables);
-
-  return ret;
-}
-
-static int
 api_lisp_eid_table_dump (vat_main_t * vam)
 {
   unformat_input_t *i = vam->input;
@@ -13834,6 +13179,12 @@ api_lisp_eid_table_dump (vat_main_t * vam)
 	}
     }
 
+  if (!vam->json_output)
+    {
+      fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type",
+	       "ls_index", "ttl", "authoritative");
+    }
+
   M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
 
   mp->filter = filter;
@@ -13861,36 +13212,18 @@ api_lisp_eid_table_dump (vat_main_t * vam)
 	}
     }
 
-  vam->noprint_msg = 1;
-
   /* send it... */
   S;
 
   /* Use a control ping for synchronization */
   {
-    vl_api_noprint_control_ping_t *mp;
-    M (NOPRINT_CONTROL_PING, noprint_control_ping);
+    vl_api_control_ping_t *mp;
+    M (CONTROL_PING, control_ping);
     S;
   }
 
   /* Wait for a reply... */
-  /* *INDENT-OFF* */
-  W_L
-  ({
-    if (vam->noprint_msg)
-      {
-        if (!vam->json_output)
-          {
-            vam->retval = print_lisp_eid_table_dump(vam);
-          }
-        else
-          {
-            vam->retval = json_lisp_eid_table_dump(vam);
-          }
-      }
-    vam->noprint_msg = 0;
-  });
-  /* *INDENT-ON* */
+  W;
 
   /* NOTREACHED */
   return 0;
@@ -16036,7 +15369,8 @@ _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]")                      \
 _(lisp_gpe_enable_disable, "enable|disable")                            \
 _(lisp_enable_disable, "enable|disable")                                \
 _(lisp_gpe_add_del_iface, "up|down")                                    \
-_(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> "     \
+_(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> "      \
+                               "[seid <seid>] "                         \
                                "rloc <locator> p <prio> "               \
                                "w <weight> [rloc <loc> ... ] "          \
                                "action <action> [del-all]")             \
@@ -16046,8 +15380,8 @@ _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid "     \
 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del")        \
 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]")           \
 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>")              \
-_(lisp_locator_set_dump, "[locator-set-index <ls-index> | "             \
-                         "locator-set <loc-set-name>] [local | remote]")\
+_(lisp_locator_set_dump, "[local | remote]")                            \
+_(lisp_locator_dump, "ls_index <index> | ls_name <name>")               \
 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] "      \
                        "[local] | [remote]")                            \
 _(lisp_eid_table_vni_dump, "")                                          \
diff --git a/vpp-api-test/vat/vat.h b/vpp-api-test/vat/vat.h
index ce8b16674b0..041b3fb9a2c 100644
--- a/vpp-api-test/vat/vat.h
+++ b/vpp-api-test/vat/vat.h
@@ -95,35 +95,6 @@ typedef struct
 
 typedef struct
 {
-  u8 *locator_set_name;
-  u32 locator_set_index;
-} locator_set_msg_t;
-
-typedef struct
-{
-  u8 local;
-  u32 sw_if_index;
-  u8 is_ipv6;
-  u8 ip_address[16];
-  u8 priority;
-  u8 weight;
-} locator_msg_t;
-
-typedef struct
-{
-  u32 locator_set_index;
-  u8 is_local;
-  u8 eid_type;
-  u32 vni;
-  u8 eid[16];
-  u8 eid_prefix_len;
-  u8 action;
-  u32 ttl;
-  u8 authoritative;
-} eid_table_t;
-
-typedef struct
-{
   /* vpe input queue */
   unix_shared_memory_queue_t *vl_input_queue;
 
@@ -210,13 +181,6 @@ typedef struct
   u32 *ip4_fib_counters_vrf_id_by_index;
   ip6_fib_counter_t **ip6_fib_counters;
   u32 *ip6_fib_counters_vrf_id_by_index;
-
-  /* Lisp */
-  u8 noprint_msg;
-  locator_set_msg_t *locator_set_msg;
-  locator_msg_t *locator_msg;
-  eid_table_t *eid_tables;
-
 } vat_main_t;
 
 vat_main_t vat_main;
diff --git a/vpp/vpp-api/api.c b/vpp/vpp-api/api.c
index 44afd6745f6..c1da5aa93cf 100644
--- a/vpp/vpp-api/api.c
+++ b/vpp/vpp-api/api.c
@@ -283,7 +283,6 @@ _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, 				\
 _(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered)		\
 _(CREATE_LOOPBACK, create_loopback)					\
 _(CONTROL_PING, control_ping)                                           \
-_(NOPRINT_CONTROL_PING, noprint_control_ping)                           \
 _(CLI_REQUEST, cli_request)                                             \
 _(CLI_INBAND, cli_inband)						\
 _(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit)			\
@@ -3636,20 +3635,6 @@ vl_api_control_ping_t_handler (vl_api_control_ping_t * mp)
   /* *INDENT-ON* */
 }
 
-static void vl_api_noprint_control_ping_t_handler
-  (vl_api_noprint_control_ping_t * mp)
-{
-  vl_api_noprint_control_ping_reply_t *rmp;
-  int rv = 0;
-
-  /* *INDENT-OFF* */
-  REPLY_MACRO2(VL_API_NOPRINT_CONTROL_PING_REPLY,
-  ({
-    rmp->vpe_pid = ntohl (getpid());
-  }));
-  /* *INDENT-ON* */
-}
-
 static void
 shmem_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
 {
@@ -5711,12 +5696,13 @@ send_lisp_locator_details (lisp_cp_main_t * lcm,
 static void
 vl_api_lisp_locator_dump_t_handler (vl_api_lisp_locator_dump_t * mp)
 {
+  u8 *ls_name = 0;
   unix_shared_memory_queue_t *q = 0;
   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
   locator_set_t *lsit = 0;
   locator_t *loc = 0;
   u32 ls_index = ~0, *locit = 0;
-  u8 filter;
+  uword *p = 0;
 
   q = vl_api_client_index_to_input_queue (mp->client_index);
   if (q == 0)
@@ -5724,22 +5710,29 @@ vl_api_lisp_locator_dump_t_handler (vl_api_lisp_locator_dump_t * mp)
       return;
     }
 
-  ls_index = htonl (mp->locator_set_index);
-
-  lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
-
-  filter = mp->filter;
-  if (filter && !((1 == filter && lsit->local) ||
-		  (2 == filter && !lsit->local)))
+  if (mp->is_index_set)
+    ls_index = htonl (mp->ls_index);
+  else
     {
-      return;
+      ls_name = format (0, "%s", mp->ls_name);
+      p = hash_get_mem (lcm->locator_set_index_by_name, ls_name);
+      if (!p)
+	goto out;
+      ls_index = p[0];
     }
 
+  if (pool_is_free_index (lcm->locator_set_pool, ls_index))
+    return;
+
+  lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
+
   vec_foreach (locit, lsit->locator_indices)
   {
     loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
     send_lisp_locator_details (lcm, loc, q, mp->context);
   };
+out:
+  vec_free (ls_name);
 }
 
 static void
@@ -5756,19 +5749,17 @@ send_lisp_locator_set_details (lisp_cp_main_t * lcm,
   rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
   rmp->context = context;
 
-  rmp->local = lsit->local;
-  rmp->locator_set_index = htonl (ls_index);
+  rmp->ls_index = htonl (ls_index);
   if (lsit->local)
     {
       ASSERT (lsit->name != NULL);
-      strncpy ((char *) rmp->locator_set_name,
-	       (char *) lsit->name, ARRAY_LEN (rmp->locator_set_name) - 1);
+      strncpy ((char *) rmp->ls_name, (char *) lsit->name,
+	       vec_len (lsit->name));
     }
   else
     {
-      str = format (0, "remote-%d", ls_index);
-      strncpy ((char *) rmp->locator_set_name, (char *) str,
-	       ARRAY_LEN (rmp->locator_set_name) - 1);
+      str = format (0, "<remote-%d>", ls_index);
+      strncpy ((char *) rmp->ls_name, (char *) str, vec_len (str));
       vec_free (str);
     }
 
@@ -5781,7 +5772,6 @@ vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t * mp)
   unix_shared_memory_queue_t *q = NULL;
   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
   locator_set_t *lsit = NULL;
-  u32 index;
   u8 filter;
 
   q = vl_api_client_index_to_input_queue (mp->client_index);
@@ -5791,25 +5781,76 @@ vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t * mp)
     }
 
   filter = mp->filter;
-  index = 0;
   /* *INDENT-OFF* */
   pool_foreach (lsit, lcm->locator_set_pool,
   ({
     if (filter && !((1 == filter && lsit->local) ||
-                    (2 == filter && !lsit->local))) {
-      index++;
-      continue;
-    }
-    send_lisp_locator_set_details(lcm, lsit, q, mp->context, index++);
+                    (2 == filter && !lsit->local)))
+      {
+        continue;
+      }
+    send_lisp_locator_set_details (lcm, lsit, q, mp->context,
+                                   lsit - lcm->locator_set_pool);
   }));
   /* *INDENT-ON* */
 }
 
 static void
+lisp_fid_put_api (u8 * dst, fid_address_t * src, u8 * prefix_length)
+{
+  ASSERT (prefix_length);
+  ip_prefix_t *ippref = &fid_addr_ippref (src);
+
+  switch (fid_addr_type (src))
+    {
+    case FID_ADDR_IP_PREF:
+      if (ip_prefix_version (ippref) == IP4)
+	clib_memcpy (dst, &ip_prefix_v4 (ippref), 4);
+      else
+	clib_memcpy (dst, &ip_prefix_v6 (ippref), 16);
+      prefix_length[0] = ip_prefix_len (ippref);
+      break;
+
+    case FID_ADDR_MAC:
+      prefix_length[0] = 0;
+      clib_memcpy (dst, fid_addr_mac (src), 6);
+      break;
+
+    default:
+      clib_warning ("Unknown FID type %d!", fid_addr_type (src));
+      break;
+    }
+}
+
+static u8
+fid_type_to_api_type (fid_address_t * fid)
+{
+  ip_prefix_t *ippref;
+
+  switch (fid_addr_type (fid))
+    {
+    case FID_ADDR_IP_PREF:
+      ippref = &fid_addr_ippref (fid);
+      if (ip_prefix_version (ippref) == IP4)
+	return 0;
+      else if (ip_prefix_version (ippref) == IP6)
+	return 1;
+      else
+	return ~0;
+
+    case FID_ADDR_MAC:
+      return 2;
+    }
+
+  return ~0;
+}
+
+static void
 send_lisp_eid_table_details (mapping_t * mapit,
 			     unix_shared_memory_queue_t * q,
 			     u32 context, u8 filter)
 {
+  fid_address_t *fid;
   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
   locator_set_t *ls = 0;
   vl_api_lisp_eid_table_details_t *rmp = NULL;
@@ -5856,6 +5897,15 @@ send_lisp_eid_table_details (mapping_t * mapit,
 
   switch (gid_address_type (gid))
     {
+    case GID_ADDR_SRC_DST:
+      rmp->is_src_dst = 1;
+      fid = &gid_address_sd_src (gid);
+      rmp->eid_type = fid_type_to_api_type (fid);
+      lisp_fid_put_api (rmp->seid, &gid_address_sd_src (gid),
+			&rmp->seid_prefix_len);
+      lisp_fid_put_api (rmp->eid, &gid_address_sd_dst (gid),
+			&rmp->eid_prefix_len);
+      break;
     case GID_ADDR_IP_PREFIX:
       rmp->eid_prefix_len = ip_prefix_len (ip_prefix);
       if (ip_prefix_version (ip_prefix) == IP4)
diff --git a/vpp/vpp-api/custom_dump.c b/vpp/vpp-api/custom_dump.c
index e8ee5516ea3..a92e6803198 100644
--- a/vpp/vpp-api/custom_dump.c
+++ b/vpp/vpp-api/custom_dump.c
@@ -2337,24 +2337,6 @@ format_lisp_flat_eid (u8 * s, va_list * args)
   return 0;
 }
 
-static u8 *
-format_lisp_eid_vat (u8 * s, va_list * args)
-{
-  u32 type = va_arg (*args, u32);
-  u8 *eid = va_arg (*args, u8 *);
-  u32 eid_len = va_arg (*args, u32);
-  u8 *seid = va_arg (*args, u8 *);
-  u32 seid_len = va_arg (*args, u32);
-  u32 is_src_dst = va_arg (*args, u32);
-
-  if (is_src_dst)
-    s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
-
-  s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
-
-  return s;
-}
-
 /** Used for transferring locators via VPP API */
 typedef CLIB_PACKED (struct
 		     {
@@ -2397,9 +2379,14 @@ static void *vl_api_lisp_add_del_remote_mapping_t_print
   s = format (s, "%s ", mp->is_add ? "add" : "del");
   s = format (s, "vni %d ", clib_net_to_host_u32 (mp->vni));
 
-  s = format (s, "deid %U ", format_lisp_eid_vat,
-	      mp->eid_type, mp->eid, mp->eid_len, mp->seid, mp->seid_len,
-	      mp->is_src_dst);
+  s = format (s, "eid %U ", format_lisp_flat_eid,
+	      mp->eid_type, mp->eid, mp->eid_len);
+
+  if (mp->is_src_dst)
+    {
+      s = format (s, "seid %U ", format_lisp_flat_eid,
+		  mp->eid_type, mp->seid, mp->seid_len);
+    }
 
   rloc_num = clib_net_to_host_u32 (mp->rloc_num);
 
@@ -2585,8 +2572,24 @@ static void *vl_api_lisp_locator_set_dump_t_print
   u8 *s;
 
   s = format (0, "SCRIPT: lisp_locator_set_dump ");
+  if (mp->filter == 1)
+    s = format (s, "local");
+  else if (mp->filter == 2)
+    s = format (s, "remote");
 
-  /* not possible to reconstruct original VAT command */
+  FINISH;
+}
+
+static void *vl_api_lisp_locator_dump_t_print
+  (vl_api_lisp_locator_dump_t * mp, void *handle)
+{
+  u8 *s;
+
+  s = format (0, "SCRIPT: lisp_locator_dump ");
+  if (mp->is_index_set)
+    s = format (s, "ls_index %d", clib_net_to_host_u32 (mp->ls_index));
+  else
+    s = format (s, "ls_name %s", mp->ls_name);
 
   FINISH;
 }
@@ -2819,7 +2822,7 @@ _(LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump)                     \
 _(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump)                           \
 _(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump)                       \
 _(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump)                         \
-_(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump)                         \
+_(LISP_LOCATOR_DUMP, lisp_locator_dump)                                 \
 _(IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel)                   \
 _(IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump)                         \
 _(DELETE_SUBIF, delete_subif)
diff --git a/vpp/vpp-api/vpe.api b/vpp/vpp-api/vpe.api
index 11bb30c1cc3..ae4c12d4569 100644
--- a/vpp/vpp-api/vpe.api
+++ b/vpp/vpp-api/vpe.api
@@ -1148,30 +1148,6 @@ define control_ping_reply
   u32 vpe_pid;
 };
 
-/** \brief Control ping from client to api server request, no print json output
-    @param client_index - opaque cookie to identify the sender
-    @param context - sender context, to match reply w/ request
-*/
-define noprint_control_ping
-{
-  u32 client_index;
-  u32 context;
-};
-
-/** \brief Control ping from the client to the server response
-    @param client_index - opaque cookie to identify the sender
-    @param context - sender context, to match reply w/ request
-    @param retval - return code for the request
-    @param vpe_pid - the pid of the vpe, returned by the server
-*/
-define noprint_control_ping_reply
-{
-  u32 context;
-  i32 retval;
-  u32 client_index;
-  u32 vpe_pid;
-};
-
 /** \brief Process a vpe parser cli string request
     @param client_index - opaque cookie to identify the sender
     @param context - sender context, to match reply w/ request
@@ -2753,18 +2729,16 @@ define lisp_eid_table_add_del_map_reply
     @param client_index - opaque cookie to identify the sender
     @param context - sender context, to match reply w/ request
     @param locator_set_index - index of locator_set
-    @param filter - filter type;
-      Support value:
-        0: all locator
-        1: local locator
-        2: remote locator
+    @param ls_name - locator set name
+    @param is_index_set - flag indicating whether ls_name or ls_index is set
  */
 define lisp_locator_dump
 {
   u32 client_index;
   u32 context;
-  u32 locator_set_index;
-  u8 filter;
+  u32 ls_index;
+  u8 ls_name[64];
+  u8 is_index_set;
 };
 
 /** \brief LISP locator_set status
@@ -2786,27 +2760,25 @@ define lisp_locator_details
 };
 
 /** \brief LISP locator_set status
-    @param locator_set_name - name of the locator_set
-    @param local - if is set, then locator_set is local
-    @param locator_count - number of locator this stats block includes
-    @param locator - locator data
+    @param context - sender context, to match reply w/ request
+    @param ls_index - locator set index
+    @param ls_name - name of the locator set
  */
 define lisp_locator_set_details
 {
   u32 context;
-  u8 local;
-  u32 locator_set_index;
-  u8 locator_set_name[64];
+  u32 ls_index;
+  u8 ls_name[64];
 };
 
 /** \brief Request for locator_set summary status
     @param client_index - opaque cookie to identify the sender
     @param context - sender context, to match reply w/ request
-    @param filter - filter type;
-      Support value:
-        0: all locator_set
-        1: local locator_set
-        2: remote locator_set
+    @param filter - filter type
+      Supported values:
+        0: all locator sets
+        1: local locator sets
+        2: remote locator sets
  */
 define lisp_locator_set_dump
 {
@@ -2826,8 +2798,11 @@ define lisp_locator_set_dump
       0 : ipv4
       1 : ipv6
       2 : mac
+    @param is_src_dst - EID is type of source/destination
     @param eid - EID can be ip4, ip6 or mac
-    @param prefix_len - prefix len
+    @param eid_prefix_len - prefix length
+    @param seid - source EID can be ip4, ip6 or mac
+    @param seid_prefix_len - source prefix length
     @param vni - virtual network instance
     @param ttl - time to live
     @param authoritative - authoritative
@@ -2840,9 +2815,12 @@ define lisp_eid_table_details
   u8 action;
   u8 is_local;
   u8 eid_type;
+  u8 is_src_dst;
   u32 vni;
   u8 eid[16];
   u8 eid_prefix_len;
+  u8 seid[16];
+  u8 seid_prefix_len;
   u32 ttl;
   u8 authoritative;
 };