X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vnet%2Fvnet%2Flisp-cp%2Fcontrol.c;h=b6612c44bb422f354684055476cb870cdc0ff078;hb=8ebb2a1632ccf2079cd6217af2d4045021dc3b9e;hp=3448fb3e058eb8aa2a0a960ee79072d05183eb54;hpb=f1213b82771ce929c076339c24a777cfd59690e6;p=vpp.git

diff --git a/vnet/vnet/lisp-cp/control.c b/vnet/vnet/lisp-cp/control.c
index 3448fb3e058..b6612c44bb4 100644
--- a/vnet/vnet/lisp-cp/control.c
+++ b/vnet/vnet/lisp-cp/control.c
@@ -18,30 +18,45 @@
 #include <vnet/lisp-cp/lisp_msg_serdes.h>
 #include <vnet/lisp-gpe/lisp_gpe.h>
 
-/* Adds mapping to map-cache but does NOT program LISP forwarding */
+static void
+add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index);
+
+static void
+del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index);
+
+static u8
+compare_locators (lisp_cp_main_t *lcm, u32 * old_ls_indexes,
+                  locator_t * new_locators);
+
+/* Stores mapping in map-cache. It does NOT program data plane forwarding for
+ * remote/learned mappings. */
 int
 vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a,
                            u32 * map_index_result)
 {
   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
   u32 mi, * map_indexp, map_index, i;
-  mapping_t * m;
+  mapping_t * m, * old_map;
   u32 ** eid_indexes;
 
   mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &a->deid);
+  old_map = mi != ~0 ? pool_elt_at_index (lcm->mapping_pool, mi) : 0;
   if (a->is_add)
     {
       /* TODO check if overwriting and take appropriate actions */
-      if (mi != GID_LOOKUP_MISS) {
+      if (mi != GID_LOOKUP_MISS && !gid_address_cmp (&old_map->eid,
+                                                     &a->deid))
+        {
           clib_warning("eid %U found in the eid-table", format_ip_address,
                        &a->deid);
           return VNET_API_ERROR_VALUE_EXIST;
-      }
+        }
 
       pool_get(lcm->mapping_pool, m);
       m->eid = a->deid;
       m->locator_set_index = a->locator_set_index;
       m->ttl = a->ttl;
+      m->action = a->action;
       m->local = a->local;
 
       map_index = m - lcm->mapping_pool;
@@ -65,18 +80,17 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a,
         {
           /* mark as local */
           vec_add1(lcm->local_mappings_indexes, map_index);
-
-          /* XXX do something else? */
         }
       map_index_result[0] = map_index;
     }
   else
     {
-      if (mi == GID_LOOKUP_MISS) {
+      if (mi == GID_LOOKUP_MISS)
+        {
           clib_warning("eid %U not found in the eid-table", format_ip_address,
                        &a->deid);
           return VNET_API_ERROR_INVALID_VALUE;
-      }
+        }
 
       /* clear locator-set to eids binding */
       eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids,
@@ -115,6 +129,78 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a,
   return 0;
 }
 
+/* Stores mapping in map-cache and programs data plane for local mappings. */
+int
+vnet_lisp_add_del_local_mapping (vnet_lisp_add_del_mapping_args_t * a,
+                                 u32 * map_index_result)
+{
+  uword * table_id, * refc;
+  u32 rv, vni;
+  vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai;
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+
+  if (vnet_lisp_enable_disable_status () == 0)
+    {
+      clib_warning ("LISP is disabled!");
+      return VNET_API_ERROR_LISP_DISABLED;
+    }
+
+  vni = gid_address_vni(&a->deid);
+
+  /* store/remove mapping from map-cache */
+  rv = vnet_lisp_add_del_mapping (a, map_index_result);
+  if (rv)
+    return rv;
+
+  table_id = hash_get(lcm->table_id_by_vni, vni);
+
+  if (!table_id)
+    {
+      clib_warning ("vni %d not associated to a vrf!", vni);
+      return VNET_API_ERROR_INVALID_VALUE;
+    }
+
+  refc = hash_get(lcm->dp_if_refcount_by_vni, vni);
+
+  /* enable/disable data-plane interface */
+  if (a->is_add)
+    {
+      /* create interface or update refcount */
+      if (!refc)
+        {
+          ai->is_add = 1;
+          ai->vni = vni;
+          ai->table_id = table_id[0];
+          vnet_lisp_gpe_add_del_iface (ai, 0);
+
+          /* counts the number of eids in a vni that use the interface */
+          hash_set(lcm->dp_if_refcount_by_vni, vni, 1);
+        }
+      else
+        {
+          refc[0]++;
+        }
+    }
+  else
+    {
+      /* since this is a remove for an existing eid, the iface should exist */
+      ASSERT(refc != 0);
+      refc[0]--;
+
+      /* remove iface if needed */
+      if (refc[0] == 0)
+        {
+          ai->is_add = 0;
+          ai->vni = vni;
+          ai->table_id = table_id[0];
+          vnet_lisp_gpe_add_del_iface (ai, 0);
+          hash_unset (lcm->dp_if_refcount_by_vni, vni);
+        }
+    }
+
+  return rv;
+}
+
 static clib_error_t *
 lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input,
                                    vlib_cli_command_t * cmd)
@@ -126,12 +212,13 @@ lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input,
   ip_prefix_t * prefp = &gid_address_ippref(&eid);
   gid_address_t * eids = 0;
   clib_error_t * error = 0;
-  u8 * locator_set_name;
+  u8 * locator_set_name = 0;
   u32 locator_set_index = 0, map_index = 0;
   uword * p;
   vnet_lisp_add_del_mapping_args_t _a, * a = &_a;
+  int rv = 0;
 
-  gid_address_type (&eid) = IP_PREFIX;
+  gid_address_type (&eid) = GID_ADDR_IP_PREFIX;
 
   /* Get a line of input. */
   if (! unformat_user (input, unformat_line_input, line_input))
@@ -171,9 +258,16 @@ lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input,
   a->locator_set_index = locator_set_index;
   a->local = 1;
 
-  vnet_lisp_add_del_mapping (a, &map_index);
+  rv = vnet_lisp_add_del_local_mapping (a, &map_index);
+  if (0 != rv)
+   {
+      error = clib_error_return(0, "failed to %s eid-table!",
+                                is_add ? "add" : "delete");
+   }
  done:
   vec_free(eids);
+  if (locator_set_name)
+    vec_free (locator_set_name);
   return error;
 }
 
@@ -183,6 +277,532 @@ VLIB_CLI_COMMAND (lisp_add_del_local_eid_command) = {
     .function = lisp_add_del_local_eid_command_fn,
 };
 
+static int
+lisp_add_del_negative_static_mapping (gid_address_t * deid,
+    vnet_lisp_add_del_locator_set_args_t * ls, u8 action, u8 is_add)
+{
+  uword * p;
+  mapping_t * map;
+  u32 mi = ~0;
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+  uword * refc;
+  vnet_lisp_add_del_mapping_args_t _dm_args, * dm_args = &_dm_args;
+  int rv = 0;
+  u32 ls_index = 0, dst_map_index;
+  vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai;
+
+  memset (dm_args, 0, sizeof (dm_args[0]));
+  u32 vni = gid_address_vni (deid);
+  refc = hash_get (lcm->dp_if_refcount_by_vni, vni);
+
+  p = hash_get (lcm->table_id_by_vni, vni);
+  if (!p)
+    {
+      clib_warning ("vni %d not associated to a vrf!", vni);
+      return VNET_API_ERROR_INVALID_VALUE;
+    }
+
+  if (is_add)
+    {
+      vnet_lisp_add_del_locator_set (ls, &ls_index);
+      /* add mapping */
+      gid_address_copy (&dm_args->deid, deid);
+      dm_args->is_add = 1;
+      dm_args->action = action;
+      dm_args->locator_set_index = ls_index;
+
+      /* create interface or update refcount */
+      if (!refc)
+        {
+          vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai;
+          ai->is_add = 1;
+          ai->vni = vni;
+          ai->table_id = p[0];
+          vnet_lisp_gpe_add_del_iface (ai, 0);
+
+          /* counts the number of eids in a vni that use the interface */
+          hash_set (lcm->dp_if_refcount_by_vni, vni, 1);
+        }
+      else
+        refc[0]++;
+
+      rv = vnet_lisp_add_del_local_mapping (dm_args, &dst_map_index);
+      if (!rv)
+        add_fwd_entry (lcm, lcm->pitr_map_index, dst_map_index);
+    }
+  else
+    {
+      mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, deid);
+      if ((u32)~0 == mi)
+        {
+          clib_warning ("eid %U marked for removal, but not found in "
+                        "map-cache!", unformat_gid_address, deid);
+          return VNET_API_ERROR_INVALID_VALUE;
+        }
+
+      /* delete forwarding entry */
+      del_fwd_entry (lcm, 0, mi);
+
+      dm_args->is_add = 0;
+      gid_address_copy (&dm_args->deid, deid);
+      map = pool_elt_at_index (lcm->mapping_pool, mi);
+      dm_args->locator_set_index = map->locator_set_index;
+
+      /* delete mapping associated to fwd entry */
+      vnet_lisp_add_del_mapping (dm_args, 0);
+
+      refc = hash_get (lcm->dp_if_refcount_by_vni, vni);
+      ASSERT(refc != 0);
+      refc[0]--;
+
+      /* remove iface if needed */
+      if (refc[0] == 0)
+        {
+          ai->is_add = 0;
+          ai->vni = vni;
+          ai->table_id = p[0];
+          vnet_lisp_gpe_add_del_iface (ai, 0);
+          hash_unset (lcm->dp_if_refcount_by_vni, vni);
+        }
+    }
+  return rv;
+}
+
+/**
+ * Adds/removes/updates static remote mapping.
+ *
+ * This function also modifies forwarding entries if needed.
+ *
+ * @param deid destination EID
+ * @param seid source EID
+ * @param rlocs vector of remote locators
+ * @param action action for negative map-reply
+ * @param is_add add mapping if non-zero, delete otherwise
+ * @param del_all if set, delete all remote mappings
+ * @return return code
+ */
+int
+vnet_lisp_add_del_remote_mapping (gid_address_t * deid, gid_address_t * seid,
+                                  ip_address_t * rlocs, u8 action, u8 is_add,
+                                  u8 del_all)
+{
+  vnet_lisp_add_del_mapping_args_t _dm_args, * dm_args = &_dm_args;
+  vnet_lisp_add_del_mapping_args_t _sm_args, * sm_args = &_sm_args;
+  vnet_lisp_add_del_locator_set_args_t _ls, * ls = &_ls;
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+  u32 mi, ls_index = 0, dst_map_index, src_map_index;
+  locator_t loc;
+  ip_address_t * dl;
+  int rc = -1;
+
+  if (vnet_lisp_enable_disable_status() == 0)
+    {
+      clib_warning ("LISP is disabled!");
+      return VNET_API_ERROR_LISP_DISABLED;
+    }
+
+  if (del_all)
+    return vnet_lisp_clear_all_remote_mappings ();
+
+  memset (sm_args, 0, sizeof (sm_args[0]));
+  memset (dm_args, 0, sizeof (dm_args[0]));
+  memset (ls, 0, sizeof (ls[0]));
+
+  /* prepare remote locator set */
+  vec_foreach (dl, rlocs)
+    {
+      memset (&loc, 0, sizeof (loc));
+      gid_address_ip (&loc.address) = dl[0];
+      vec_add1 (ls->locators, loc);
+    }
+  src_map_index = gid_dictionary_lookup (&lcm->mapping_index_by_gid, seid);
+
+  mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, deid);
+  /* new mapping */
+  if ((u32)~0 == mi)
+    {
+      ls->is_add = 1;
+      ls->index = ~0;
+
+      /* process a negative mapping */
+      if (0 == vec_len (rlocs))
+        return lisp_add_del_negative_static_mapping (deid, ls,
+                                                     action, is_add);
+
+      if ((u32)~0 == src_map_index)
+        {
+          clib_warning ("seid %U not found!", format_gid_address, seid);
+          goto done;
+        }
+
+      if (!is_add)
+        {
+          clib_warning ("deid %U marked for removal but not "
+                        "found!", format_gid_address, deid);
+          goto done;
+        }
+
+      vnet_lisp_add_del_locator_set (ls, &ls_index);
+
+      /* add mapping */
+      gid_address_copy (&dm_args->deid, deid);
+      dm_args->is_add = 1;
+      dm_args->action = action;
+      dm_args->locator_set_index = ls_index;
+      vnet_lisp_add_del_mapping (dm_args, &dst_map_index);
+
+      /* add fwd tunnel */
+      add_fwd_entry (lcm, src_map_index, dst_map_index);
+    }
+  else
+    {
+      /* delete mapping */
+      if (!is_add)
+        {
+          /* delete forwarding entry */
+          del_fwd_entry (lcm, 0, mi);
+          dm_args->is_add = 0;
+          gid_address_copy (&dm_args->deid, deid);
+          mapping_t * map = pool_elt_at_index (lcm->mapping_pool, mi);
+          dm_args->locator_set_index = map->locator_set_index;
+
+          /* delete mapping associated to fwd entry */
+          vnet_lisp_add_del_mapping (dm_args, 0);
+
+          ls->is_add = 0;
+          ls->index = map->locator_set_index;
+          /* delete locator set */
+          vnet_lisp_add_del_locator_set (ls, 0);
+        }
+      /* update existing locator set */
+      else
+        {
+          if ((u32)~0 == src_map_index)
+            {
+              clib_warning ("seid %U not found!", format_gid_address, seid);
+              goto done;
+            }
+
+          mapping_t * old_map;
+          locator_set_t * old_ls;
+          old_map = pool_elt_at_index (lcm->mapping_pool, mi);
+
+          /* update mapping attributes */
+          old_map->action = action;
+
+          old_ls = pool_elt_at_index(lcm->locator_set_pool,
+                                     old_map->locator_set_index);
+          if (compare_locators (lcm, old_ls->locator_indices,
+                                ls->locators))
+            {
+              /* set locator-set index to overwrite */
+              ls->is_add = 1;
+              ls->index = old_map->locator_set_index;
+              vnet_lisp_add_del_locator_set (ls, 0);
+              add_fwd_entry (lcm, src_map_index, mi);
+            }
+        }
+    }
+  /* success */
+  rc = 0;
+done:
+  vec_free (ls->locators);
+  return rc;
+}
+
+int
+vnet_lisp_clear_all_remote_mappings (void)
+{
+  int rv = 0;
+  u32 mi, * map_indices = 0, * map_indexp;
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+  vnet_lisp_add_del_mapping_args_t _dm_args, * dm_args = &_dm_args;
+  vnet_lisp_add_del_locator_set_args_t _ls, * ls = &_ls;
+
+  pool_foreach_index (mi, lcm->mapping_pool,
+    ({
+      vec_add1 (map_indices, mi);
+    }));
+
+  vec_foreach (map_indexp, map_indices)
+    {
+      mapping_t * map = pool_elt_at_index (lcm->mapping_pool, map_indexp[0]);
+      if (!map->local)
+        {
+          del_fwd_entry (lcm, 0, map_indexp[0]);
+
+          dm_args->is_add = 0;
+          gid_address_copy (&dm_args->deid, &map->eid);
+          dm_args->locator_set_index = map->locator_set_index;
+
+          /* delete mapping associated to fwd entry */
+          vnet_lisp_add_del_mapping (dm_args, 0);
+
+          ls->is_add = 0;
+          ls->local = 0;
+          ls->index = map->locator_set_index;
+          /* delete locator set */
+          rv = vnet_lisp_add_del_locator_set (ls, 0);
+          if (rv != 0)
+            goto cleanup;
+        }
+    }
+
+cleanup:
+  if (map_indices)
+    vec_free (map_indices);
+  return rv;
+}
+
+/**
+ * Handler for add/del remote mapping CLI.
+ *
+ * @param vm vlib context
+ * @param input input from user
+ * @param cmd cmd
+ * @return pointer to clib error structure
+ */
+static clib_error_t *
+lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
+                                        unformat_input_t * input,
+                                        vlib_cli_command_t * cmd)
+{
+  clib_error_t * error = 0;
+  unformat_input_t _line_input, * line_input = &_line_input;
+  u8 is_add = 1, del_all = 0;
+  ip_address_t rloc, * rlocs = 0;
+  ip_prefix_t * deid_ippref, * seid_ippref;
+  gid_address_t seid, deid;
+  u8 deid_set = 0, seid_set = 0;
+  u8 * s = 0;
+  u32 vni, action = ~0;
+
+  /* Get a line of input. */
+  if (! unformat_user (input, unformat_line_input, line_input))
+    return 0;
+
+  memset (&deid, 0, sizeof (deid));
+  memset (&seid, 0, sizeof (seid));
+
+  seid_ippref = &gid_address_ippref(&seid);
+  deid_ippref = &gid_address_ippref(&deid);
+
+  gid_address_type (&deid) = GID_ADDR_IP_PREFIX;
+  gid_address_type (&seid) = GID_ADDR_IP_PREFIX;
+
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "del-all"))
+        del_all = 1;
+      else if (unformat (line_input, "del"))
+        is_add = 0;
+      else if (unformat (line_input, "add"))
+        ;
+      else if (unformat (line_input, "deid %U",
+                         unformat_ip_prefix, deid_ippref))
+        {
+          deid_set = 1;
+        }
+      else if (unformat (line_input, "vni %u", &vni))
+        {
+          gid_address_set_vni (&seid, vni);
+          gid_address_set_vni (&deid, vni);
+        }
+      else if (unformat (line_input, "seid %U",
+                         unformat_ip_prefix, seid_ippref))
+        {
+          seid_set = 1;
+        }
+      else if (unformat (line_input, "rloc %U", unformat_ip_address, &rloc))
+        vec_add1 (rlocs, rloc);
+      else if (unformat (line_input, "action %s", &s))
+        {
+          if (!strcmp ((char *)s, "no-action"))
+            action = ACTION_NONE;
+          if (!strcmp ((char *)s, "natively-forward"))
+            action = ACTION_NATIVELY_FORWARDED;
+          if (!strcmp ((char *)s, "send-map-request"))
+            action = ACTION_SEND_MAP_REQUEST;
+          else if (!strcmp ((char *)s, "drop"))
+            action = ACTION_DROP;
+          else
+            {
+              clib_warning ("invalid action: '%s'", s);
+              goto done;
+            }
+        }
+      else
+        {
+          clib_warning ("parse error");
+          goto done;
+        }
+    }
+
+  if (!del_all)
+    {
+      if (!deid_set)
+        {
+          clib_warning ("missing deid!");
+          goto done;
+        }
+
+      /* if seid not set, make sure the ip version is the same as that of the
+       * deid. This ensures the seid to be configured will be either 0/0 or
+       * ::/0 */
+      if (!seid_set)
+        ip_prefix_version(seid_ippref) = ip_prefix_version(deid_ippref);
+
+      if (is_add &&
+          (ip_prefix_version (deid_ippref) != ip_prefix_version(seid_ippref)))
+        {
+          clib_warning ("source and destination EIDs are not"
+                        " in the same IP family!");
+          goto done;
+        }
+
+      if (is_add && (~0 == action)
+          && 0 == vec_len (rlocs))
+        {
+          clib_warning ("no action set for negative map-reply!");
+          goto done;
+        }
+    }
+
+  int rv = vnet_lisp_add_del_remote_mapping (&deid, &seid, rlocs,
+                                             action, is_add, del_all);
+  if (rv)
+    clib_warning ("failed to %s remote mapping!",
+                  is_add ? "add" : "delete");
+
+done:
+  unformat_free (line_input);
+  if (s)
+    vec_free (s);
+  return error;
+}
+
+VLIB_CLI_COMMAND (lisp_add_del_remote_mapping_command) = {
+    .path = "lisp remote-mapping",
+    .short_help = "lisp remote-mapping add|del [del-all] vni <vni>"
+     "deid <dest-eid> seid <src-eid> [action <no-action|natively-forward|"
+     "send-map-request|drop>] rloc <dst-locator> [rloc <dst-locator> ... ]",
+    .function = lisp_add_del_remote_mapping_command_fn,
+};
+
+static clib_error_t *
+lisp_show_map_resolvers_command_fn (vlib_main_t * vm,
+                                    unformat_input_t * input,
+                                    vlib_cli_command_t * cmd)
+{
+  ip_address_t * addr;
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+
+  vec_foreach (addr, lcm->map_resolvers)
+    {
+      vlib_cli_output (vm, "%U", format_ip_address, addr);
+    }
+  return 0;
+}
+
+VLIB_CLI_COMMAND (lisp_show_map_resolvers_command) = {
+    .path = "show lisp map-resolvers",
+    .short_help = "show lisp map-resolvers",
+    .function = lisp_show_map_resolvers_command_fn,
+};
+
+int
+vnet_lisp_pitr_set_locator_set (u8 * locator_set_name, u8 is_add)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+  u32 locator_set_index = ~0;
+  mapping_t * m;
+  uword * p;
+
+  if (vnet_lisp_enable_disable_status () == 0)
+    {
+      clib_warning ("LISP is disabled!");
+      return VNET_API_ERROR_LISP_DISABLED;
+    }
+
+  p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name);
+  if (!p)
+    {
+      clib_warning ("locator-set %v doesn't exist", locator_set_name);
+      return -1;
+    }
+  locator_set_index = p[0];
+
+  if (is_add)
+    {
+      pool_get (lcm->mapping_pool, m);
+      m->locator_set_index = locator_set_index;
+      m->local = 1;
+      lcm->pitr_map_index = m - lcm->mapping_pool;
+
+      /* enable pitr mode */
+      lcm->lisp_pitr = 1;
+    }
+  else
+    {
+      /* remove pitr mapping */
+      pool_put_index (lcm->mapping_pool, lcm->pitr_map_index);
+
+      /* disable pitr mode */
+      lcm->lisp_pitr = 0;
+    }
+  return 0;
+}
+
+static clib_error_t *
+lisp_pitr_set_locator_set_command_fn (vlib_main_t * vm,
+                                      unformat_input_t * input,
+                                      vlib_cli_command_t * cmd)
+{
+  u8 locator_name_set = 0;
+  u8 * locator_set_name = 0;
+  u8 is_add = 1;
+  unformat_input_t _line_input, * line_input = &_line_input;
+  clib_error_t * error = 0;
+  int rv = 0;
+
+  /* Get a line of input. */
+  if (! unformat_user (input, unformat_line_input, line_input))
+    return 0;
+
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "ls %_%v%_", &locator_set_name))
+        locator_name_set = 1;
+      else if (unformat (line_input, "disable"))
+        is_add = 0;
+      else
+        return clib_error_return (0, "parse error");
+    }
+
+  if (!locator_name_set)
+    {
+      clib_warning ("No locator set specified!");
+      goto done;
+    }
+  rv = vnet_lisp_pitr_set_locator_set (locator_set_name, is_add);
+  if (0 != rv)
+    {
+      error = clib_error_return(0, "failed to %s pitr!",
+                                is_add ? "add" : "delete");
+    }
+
+done:
+  if (locator_set_name)
+    vec_free (locator_set_name);
+  return error;
+}
+
+VLIB_CLI_COMMAND (lisp_pitr_set_locator_set_command) = {
+    .path = "lisp pitr",
+    .short_help = "lisp pitr [disable] ls <locator-set-name>",
+    .function = lisp_pitr_set_locator_set_command_fn,
+};
+
 static clib_error_t *
 lisp_show_local_eid_table_command_fn (vlib_main_t * vm,
                                       unformat_input_t * input,
@@ -216,7 +836,7 @@ VLIB_CLI_COMMAND (lisp_cp_show_local_eid_table_command) = {
 static void
 clean_locator_to_locator_set (lisp_cp_main_t * lcm, u32 lsi)
 {
-  u32 i, j, *loc_indexp, *ls_indexp, **ls_indexes;
+  u32 i, j, *loc_indexp, *ls_indexp, **ls_indexes, *to_be_deleted = 0;
   locator_set_t * ls = pool_elt_at_index(lcm->locator_set_pool, lsi);
   for (i = 0; i < vec_len(ls->locator_indices); i++)
     {
@@ -230,32 +850,204 @@ clean_locator_to_locator_set (lisp_cp_main_t * lcm, u32 lsi)
             break;
         }
 
-      /* delete index for removed locator-set*/
-      vec_del1(ls_indexes[0], j);
+      /* delete index for removed locator-set*/
+      vec_del1(ls_indexes[0], j);
+
+      /* delete locator if it's part of no locator-set */
+      if (vec_len (ls_indexes[0]) == 0)
+        {
+          pool_put_index (lcm->locator_pool, loc_indexp[0]);
+          vec_add1 (to_be_deleted, i);
+        }
+    }
+
+  if (to_be_deleted)
+    {
+      for (i = 0; i < vec_len (to_be_deleted); i++)
+        {
+          loc_indexp = vec_elt_at_index (to_be_deleted, i);
+          vec_del1 (ls->locator_indices, loc_indexp[0]);
+        }
+      vec_free (to_be_deleted);
+    }
+}
+
+static inline
+uword *get_locator_set_index(vnet_lisp_add_del_locator_set_args_t * a,
+                             uword * p)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+
+  ASSERT(a != NULL);
+  ASSERT(p != NULL);
+
+  /* find locator-set */
+  if (a->local)
+    {
+      p = hash_get_mem(lcm->locator_set_index_by_name, a->name);
+    }
+  else
+    {
+      *p = a->index;
+    }
+
+  return p;
+}
+
+static inline
+int is_locator_in_locator_set(lisp_cp_main_t * lcm, locator_set_t * ls,
+                              locator_t * loc)
+{
+  locator_t * itloc;
+  u32 * locit;
+
+  ASSERT(ls != NULL);
+  ASSERT(loc != NULL);
+
+  vec_foreach(locit, ls->locator_indices)
+    {
+      itloc = pool_elt_at_index(lcm->locator_pool, locit[0]);
+      if (itloc->sw_if_index == loc->sw_if_index ||
+          !gid_address_cmp(&itloc->address, &loc->address))
+        {
+          clib_warning("Duplicate locator");
+          return VNET_API_ERROR_VALUE_EXIST;
+        }
+    }
+
+  return 0;
+}
+
+static inline
+void remove_locator_from_locator_set(locator_set_t * ls, u32 * locit,
+                                     u32 ls_index, u32 loc_id)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+  u32 ** ls_indexes = NULL;
+
+  ASSERT(ls != NULL);
+  ASSERT(locit != NULL);
+
+  ls_indexes = vec_elt_at_index(lcm->locator_to_locator_sets,
+                                locit[0]);
+  pool_put_index(lcm->locator_pool, locit[0]);
+  vec_del1(ls->locator_indices, loc_id);
+  vec_del1(ls_indexes[0], ls_index);
+}
+
+int
+vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t * a,
+                           locator_set_t * ls, u32 * ls_result)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+  locator_t * loc = NULL, *itloc = NULL;
+  uword _p = (u32)~0, * p = &_p;
+  u32 loc_index = ~0, ls_index = ~0, * locit = NULL, ** ls_indexes = NULL;
+  u32 loc_id = ~0;
+  int ret = 0;
+
+  ASSERT(a != NULL);
+
+  if (vnet_lisp_enable_disable_status () == 0)
+    {
+      clib_warning ("LISP is disabled!");
+      return VNET_API_ERROR_LISP_DISABLED;
+    }
+
+  p = get_locator_set_index(a, p);
+  if (!p)
+    {
+      clib_warning("locator-set %v doesn't exist", a->name);
+      return VNET_API_ERROR_INVALID_ARGUMENT;
+    }
+
+  if (ls == 0)
+    {
+      ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
+      if (!ls)
+        {
+          clib_warning("locator-set %d to be overwritten doesn't exist!",
+                       p[0]);
+          return VNET_API_ERROR_INVALID_ARGUMENT;
+        }
+    }
+
+  if (a->is_add)
+    {
+
+        if (ls_result)
+          ls_result[0] = p[0];
+
+        /* allocate locators */
+        vec_foreach (itloc, a->locators)
+          {
+            ret = is_locator_in_locator_set(lcm, ls, itloc);
+            if (0 != ret)
+              {
+                return ret;
+              }
+
+            pool_get(lcm->locator_pool, loc);
+            loc[0] = itloc[0];
+            loc_index = loc - lcm->locator_pool;
+
+            vec_add1(ls->locator_indices, loc_index);
+
+            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);
+          }
+      }
+    else
+      {
+        ls_index = p[0];
+
+        itloc = a->locators;
+        loc_id = 0;
+        vec_foreach (locit, ls->locator_indices)
+          {
+            loc = pool_elt_at_index(lcm->locator_pool, locit[0]);
+
+            if (loc->local && loc->sw_if_index == itloc->sw_if_index)
+              {
+                remove_locator_from_locator_set(ls, locit,
+                                                ls_index, loc_id);
+              }
+            if (0 == loc->local &&
+                !gid_address_cmp(&loc->address, &itloc->address))
+              {
+                remove_locator_from_locator_set(ls, locit,
+                                                ls_index, loc_id);
+              }
+
+            loc_id++;
+          }
+      }
 
-      /* delete locator if it's part of no locator-set */
-      if (vec_len (ls_indexes[0]) == 0)
-        pool_put_index(lcm->locator_pool, loc_indexp[0]);
-    }
+  return 0;
 }
+
 int
 vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
                                u32 * ls_result)
 {
   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
   locator_set_t * ls;
-  locator_t * loc, * itloc;
   uword _p = (u32)~0, * p = &_p;
-  u32 loc_index, ls_index, ** ls_indexes;
-  u32 **eid_indexes;
+  u32 ls_index;
+  u32 ** eid_indexes;
+  int ret = 0;
+
+  if (vnet_lisp_enable_disable_status () == 0)
+    {
+      clib_warning ("LISP is disabled!");
+      return VNET_API_ERROR_LISP_DISABLED;
+    }
 
   if (a->is_add)
     {
-      /* check if overwrite */
-      if (a->local)
-        p = hash_get_mem(lcm->locator_set_index_by_name, a->name);
-      else
-        *p = a->index;
+      p = get_locator_set_index(a, p);
 
       /* overwrite */
       if (p && p[0] != (u32)~0)
@@ -284,6 +1076,7 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
       else
         {
           pool_get(lcm->locator_set_pool, ls);
+          memset(ls, 0, sizeof(*ls));
           ls_index = ls - lcm->locator_set_pool;
 
           if (a->local)
@@ -303,35 +1096,20 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
             ls_result[0] = ls_index;
         }
 
-      /* allocate locators */
-      vec_foreach (itloc, a->locators)
+      ret = vnet_lisp_add_del_locator(a, ls, NULL);
+      if (0 != ret)
         {
-          pool_get(lcm->locator_pool, loc);
-          loc[0] = itloc[0];
-          loc_index = loc - lcm->locator_pool;
-
-          vec_add1(ls->locator_indices, loc_index);
-
-          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);
+          return ret;
         }
     }
   else
     {
-      /* find locator-set */
-      if (a->local)
+      p = get_locator_set_index(a, p);
+      if (!p)
         {
-          p = hash_get_mem(lcm->locator_set_index_by_name, a->name);
-          if (!p)
-            {
-              clib_warning("locator-set %v doesn't exists", a->name);
-              return -1;
-            }
+          clib_warning("locator-set %v doesn't exists", a->name);
+          return -1;
         }
-      else
-        *p = a->index;
 
       ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
       if (!ls)
@@ -339,12 +1117,13 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
           clib_warning("locator-set with index %d doesn't exists", p[0]);
           return -1;
         }
-//      /* XXX what happens when a mapping is configured to use the loc-set ? */
-//      if (vec_len (vec_elt_at_index(lcm->locator_set_to_eids, p[0])) != 0)
-//        {
-//          clib_warning ("Can't delete a locator that supports a mapping!");
-//          return -1;
-//        }
+
+      if (lcm->mreq_itr_rlocs == p[0])
+        {
+          clib_warning ("Can't delete the locator-set used to constrain "
+                        "the itr-rlocs in map-requests!");
+          return -1;
+        }
 
       if (vec_len(lcm->locator_set_to_eids) != 0)
       {
@@ -373,227 +1152,148 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
               }
           }
           hash_unset_mem(lcm->locator_set_index_by_name, ls->name);
-          vec_free(ls->name);
         }
+      vec_free(ls->name);
+      vec_free(ls->locator_indices);
       pool_put(lcm->locator_set_pool, ls);
     }
   return 0;
 }
 
-static inline
-uword *vnet_lisp_get_locator(vnet_lisp_add_del_locator_set_args_t * a,
-                             uword *p)
-{
-  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
-
-  ASSERT(a != NULL);
-  ASSERT(p != NULL);
-
-  /* find locator-set */
-  if (a->local)
-  {
-      p = hash_get_mem(lcm->locator_set_index_by_name, a->name);
-  }
-  else
-  {
-      *p = a->index;
-  }
-
-  return p;
-}
-
-int
-vnet_lisp_add_del_locator_set_name (vnet_lisp_add_del_locator_set_args_t * a,
-                                    u32 * ls_result)
+clib_error_t *
+vnet_lisp_enable_disable (u8 is_enabled)
 {
-  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
-  locator_set_t * ls;
-  uword _p = (u32)~0, * p = &_p;
-  u32 ls_index = ~0;
-  u32 **eid_indexes = NULL;
-
-  ASSERT(a != NULL);
-  ASSERT(ls_result != NULL);
-
-  p = vnet_lisp_get_locator(a, p);
+  vnet_lisp_gpe_add_del_iface_args_t _ai, * ai= &_ai;
+  uword * table_id, * refc;
+  u32 i;
+  clib_error_t * error = 0;
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+  vnet_lisp_gpe_enable_disable_args_t _a, * a = &_a;
 
-  if (a->is_add)
+  a->is_en = is_enabled;
+  error = vnet_lisp_gpe_enable_disable (a);
+  if (error)
     {
-      /* overwrite */
-      if (p && p[0] != (u32)~0)
-        {
-          ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
-          if (!ls)
-            {
-              clib_warning("locator-set %d to be overwritten doesn't exist!",
-                           p[0]);
-              return VNET_API_ERROR_UNSPECIFIED;
-            }
-
-          /* clean locator to locator-set vectors and remove locators if
-           * they're not part of another locator-set */
-          clean_locator_to_locator_set (lcm, p[0]);
-
-          /* remove locator indices from locator set */
-          vec_free(ls->locator_indices);
-
-          ls_index = p[0];
+      return clib_error_return (0, "failed to %s data-plane!",
+                                a->is_en ? "enable" : "disable");
+    }
 
-          if (ls_result)
-            ls_result[0] = p[0];
-        }
-      /* new locator-set */
-      else
+  if (is_enabled)
+    {
+      /* enable all ifaces */
+      for (i = 0; i < vec_len (lcm->local_mappings_indexes); i++)
         {
-          pool_get(lcm->locator_set_pool, ls);
-          ls_index = ls - lcm->locator_set_pool;
+          mapping_t * m = vec_elt_at_index (lcm->mapping_pool, i);
+          ai->is_add = 1;
+          ai->vni = gid_address_vni (&m->eid);
 
-          if (a->local)
+          refc = hash_get (lcm->dp_if_refcount_by_vni, ai->vni);
+          if (!refc)
             {
-              ls->name = vec_dup(a->name);
-
-              if (!lcm->locator_set_index_by_name)
-                lcm->locator_set_index_by_name = hash_create_vec(
-                    /* size */0, sizeof(ls->name[0]), sizeof(uword));
-              hash_set_mem(lcm->locator_set_index_by_name, ls->name, ls_index);
+              table_id = hash_get (lcm->table_id_by_vni, ai->vni);
+              if (table_id)
+                {
+                  ai->table_id = table_id[0];
+                  /* enables interface and adds defaults */
+                  vnet_lisp_gpe_add_del_iface (ai, 0);
+                }
+              else
+                return clib_error_return (0, "no table_id found for vni %u!",
+                                          ai->vni);
 
-              /* mark as local locator-set */
-              vec_add1(lcm->local_locator_set_indexes, ls_index);
+              hash_set (lcm->dp_if_refcount_by_vni, ai->vni, 1);
+            }
+          else
+            {
+              refc[0]++;
             }
-          ls->local = a->local;
-	  ls->locator_indices = NULL;
-          if (ls_result)
-            ls_result[0] = ls_index;
         }
     }
   else
     {
-       if (!p)
-       {
-           clib_warning("locator-set %v doesn't exists", a->name);
-           return VNET_API_ERROR_INVALID_ARGUMENT;
-       }
-
-       ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
-       if (!ls)
-       {
-           clib_warning("locator-set with index %d doesn't exists", p[0]);
-           return VNET_API_ERROR_INVALID_ARGUMENT;
-       }
-
-      if (vec_len(lcm->locator_set_to_eids) != 0)
-      {
-          eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids, p[0]);
-          if (vec_len(eid_indexes[0]) != 0)
-          {
-              clib_warning ("Can't delete a locator that supports a mapping!");
-              return -1;
-          }
-      }
-
-      /* clean locator to locator-sets data */
-      clean_locator_to_locator_set (lcm, p[0]);
+      /* clear refcount table */
+      hash_free (lcm->dp_if_refcount_by_vni);
+      hash_free (lcm->fwd_entry_by_mapping_index);
+      pool_free (lcm->fwd_entry_pool);
+    }
 
-      if (ls->local)
-        {
-          u32 it, lsi;
+  /* update global flag */
+  lcm->is_enabled = is_enabled;
 
-          vec_foreach_index(it, lcm->local_locator_set_indexes)
-            {
-              lsi = vec_elt(lcm->local_locator_set_indexes, it);
-              if (lsi == p[0])
-                {
-                  vec_del1(lcm->local_locator_set_indexes, it);
-                  break;
-                }
-            }
-          hash_unset_mem(lcm->locator_set_index_by_name, ls->name);
-          vec_free(ls->name);
-        }
-      pool_put(lcm->locator_set_pool, ls);
-    }
   return 0;
 }
 
-int
-vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t *a,
-                           u32 *ls_result)
+static clib_error_t *
+lisp_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input,
+                                   vlib_cli_command_t * cmd)
 {
-  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
-  locator_set_t *ls = NULL;
-  locator_t *loc = NULL, *itloc = NULL;
-  uword _p = (u32)~0, * p = &_p;
-  u32 loc_index = ~0, ls_index = ~0, *locit = NULL, **ls_indexes = NULL;
-  u32 i = ~0;
-
-  ASSERT(a != NULL);
-  ASSERT(ls_result != NULL);
-
-  p = vnet_lisp_get_locator(a, p);
-  if (!p) {
-      clib_warning("locator-set %v doesn't exists", a->name);
-      return VNET_API_ERROR_INVALID_ARGUMENT;
-  }
+  unformat_input_t _line_input, * line_input = &_line_input;
+  u8 is_enabled = 0;
+  u8 is_set = 0;
 
-  ls_index = p[0];
+  /* Get a line of input. */
+  if (! unformat_user (input, unformat_line_input, line_input))
+    return 0;
 
-  if (a->is_add)
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
     {
-        ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
-        if (!ls)
+      if (unformat (line_input, "enable"))
+        {
+          is_set = 1;
+          is_enabled = 1;
+        }
+      else if (unformat (line_input, "disable"))
+        is_set = 1;
+      else
         {
-            clib_warning("locator-set %d to be overwritten doesn't exist!",
-                         p[0]);
-            return VNET_API_ERROR_INVALID_ARGUMENT;
+          return clib_error_return (0, "parse error: '%U'",
+                                   format_unformat_error, line_input);
         }
+    }
 
-        if (ls_result)
-            ls_result[0] = p[0];
+  if (!is_set)
+      return clib_error_return (0, "state not set");
 
-      /* allocate locators */
-      itloc = a->locators;
-      pool_get(lcm->locator_pool, loc);
-      loc[0] = itloc[0];
-      loc_index = loc - lcm->locator_pool;
+  return vnet_lisp_enable_disable (is_enabled);
+}
 
-      vec_add1(ls->locator_indices, loc_index);
+VLIB_CLI_COMMAND (lisp_cp_enable_disable_command) = {
+    .path = "lisp",
+    .short_help = "lisp [enable|disable]",
+    .function = lisp_enable_disable_command_fn,
+};
 
-      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);
-    }
-  else
-    {
-      ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
-      if (!ls)
-        {
-          clib_warning("locator-set with index %d doesn't exists", p[0]);
-          return VNET_API_ERROR_INVALID_ARGUMENT;
-        }
+u8
+vnet_lisp_enable_disable_status (void)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+  return lcm->is_enabled;
+}
 
-      if (ls->local)
-      {
-          itloc = a->locators;
-          i = 0;
-          vec_foreach (locit, ls->locator_indices)
-          {
-              loc = pool_elt_at_index(lcm->locator_pool, locit[0]);
-              if (loc->local && loc->sw_if_index == itloc->sw_if_index)
-              {
-                  ls_indexes = vec_elt_at_index(lcm->locator_to_locator_sets,
-                                                locit[0]);
-                  pool_put_index(lcm->locator_pool, locit[0]);
-                  vec_del1(ls->locator_indices, i);
-                  vec_del1(ls_indexes[0], ls_index);
-              }
-              i++;
-          }
-      }
-    }
+static u8 *
+format_lisp_status (u8 * s, va_list * args)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+  return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled");
+}
+
+static clib_error_t *
+lisp_show_status_command_fn (vlib_main_t * vm, unformat_input_t * input,
+                             vlib_cli_command_t * cmd)
+{
+  u8 * msg = 0;
+  msg = format (msg, "feature: %U\ngpe: %U\n",
+                format_lisp_status, format_vnet_lisp_gpe_status);
+  vlib_cli_output (vm, "%v", msg);
+  vec_free (msg);
   return 0;
 }
 
+VLIB_CLI_COMMAND (lisp_show_status_command) = {
+    .path = "show lisp status",
+    .short_help = "show lisp status",
+    .function = lisp_show_status_command_fn,
+};
 static clib_error_t *
 lisp_add_del_locator_set_command_fn (vlib_main_t * vm, unformat_input_t * input,
                                      vlib_cli_command_t * cmd)
@@ -607,6 +1307,7 @@ lisp_add_del_locator_set_command_fn (vlib_main_t * vm, unformat_input_t * input,
   locator_t locator, * locators = 0;
   vnet_lisp_add_del_locator_set_args_t _a, * a = &_a;
   u32 ls_index = 0;
+  int rv = 0;
 
   memset(&locator, 0, sizeof(locator));
   memset(a, 0, sizeof(a[0]));
@@ -640,17 +1341,24 @@ lisp_add_del_locator_set_command_fn (vlib_main_t * vm, unformat_input_t * input,
   a->is_add = is_add;
   a->local = 1;
 
-  vnet_lisp_add_del_locator_set(a, &ls_index);
+  rv = vnet_lisp_add_del_locator_set(a, &ls_index);
+  if (0 != rv)
+    {
+      error = clib_error_return(0, "failed to %s locator-set!",
+                                is_add ? "add" : "delete");
+    }
 
  done:
   vec_free(locators);
-  vec_free(locator_set_name);
+  if (locator_set_name)
+    vec_free (locator_set_name);
   return error;
 }
 
 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_set_command) = {
     .path = "lisp locator-set",
-    .short_help = "lisp locator-set add/del <name> <iface-name> <priority> <weight>",
+    .short_help = "lisp locator-set add/del <name> iface <iface-name> "
+        "p <priority> w <weight>",
     .function = lisp_add_del_locator_set_command_fn,
 };
 
@@ -699,6 +1407,12 @@ vnet_lisp_add_del_map_resolver (vnet_lisp_add_del_map_resolver_args_t * a)
   ip_address_t * addr;
   u32 i;
 
+  if (vnet_lisp_enable_disable_status () == 0)
+    {
+      clib_warning ("LISP is disabled!");
+      return VNET_API_ERROR_LISP_DISABLED;
+    }
+
   if (a->is_add)
     {
       vec_foreach(addr, lcm->map_resolvers)
@@ -710,33 +1424,115 @@ vnet_lisp_add_del_map_resolver (vnet_lisp_add_del_map_resolver_args_t * a)
               return -1;
             }
         }
-      vec_add1(lcm->map_resolvers, a->address);
+      vec_add1(lcm->map_resolvers, a->address);
+    }
+  else
+    {
+      for (i = 0; i < vec_len(lcm->map_resolvers); i++)
+        {
+          addr = vec_elt_at_index(lcm->map_resolvers, i);
+          if (!ip_address_cmp (addr, &a->address))
+            {
+              vec_delete(lcm->map_resolvers, 1, i);
+              break;
+            }
+        }
+    }
+  return 0;
+}
+
+static clib_error_t *
+lisp_add_del_map_resolver_command_fn (vlib_main_t * vm,
+                                         unformat_input_t * input,
+                                         vlib_cli_command_t * cmd)
+{
+  unformat_input_t _line_input, * line_input = &_line_input;
+  u8 is_add = 1;
+  ip_address_t ip_addr;
+  clib_error_t * error = 0;
+  int rv = 0;
+  vnet_lisp_add_del_map_resolver_args_t _a, * a = &_a;
+
+  /* Get a line of input. */
+  if (! unformat_user (input, unformat_line_input, line_input))
+    return 0;
+
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "add"))
+        is_add = 1;
+      else if (unformat (line_input, "del"))
+        is_add = 0;
+      else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
+        ;
+      else
+        {
+          error = unformat_parse_error(line_input);
+          goto done;
+        }
+    }
+  a->is_add = is_add;
+  a->address = ip_addr;
+  rv = vnet_lisp_add_del_map_resolver (a);
+  if (0 != rv)
+    {
+      error = clib_error_return(0, "failed to %s map-resolver!",
+                                is_add ? "add" : "delete");
+    }
+
+ done:
+  return error;
+}
+
+VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = {
+    .path = "lisp map-resolver",
+    .short_help = "lisp map-resolver add/del <ip_address>",
+    .function = lisp_add_del_map_resolver_command_fn,
+};
+
+int
+vnet_lisp_add_del_mreq_itr_rlocs (vnet_lisp_add_del_mreq_itr_rloc_args_t * a)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+  uword * p = 0;
+
+  //TODO: Wait for merge https://gerrit.fd.io/r/#/c/1427/
+//   if (vnet_lisp_enable_disable_status () == 0)
+//     {
+//       clib_warning ("LISP is disabled!");
+//       return VNET_API_ERROR_LISP_DISABLED;
+//     }
+
+  if (a->is_add)
+    {
+      p = hash_get_mem(lcm->locator_set_index_by_name, a->locator_set_name);
+      if (!p)
+        {
+          clib_warning("locator-set %v doesn't exist", a->locator_set_name);
+          return VNET_API_ERROR_INVALID_ARGUMENT;
+        }
+
+      lcm->mreq_itr_rlocs = p[0];
     }
   else
     {
-      for (i = 0; i < vec_len(lcm->map_resolvers); i++)
-        {
-          addr = vec_elt_at_index(lcm->map_resolvers, i);
-          if (!ip_address_cmp (addr, &a->address))
-            {
-              vec_delete(lcm->map_resolvers, 1, i);
-              break;
-            }
-        }
+      lcm->mreq_itr_rlocs = ~0;
     }
+
   return 0;
 }
 
 static clib_error_t *
-lisp_add_del_map_resolver_command_fn (vlib_main_t * vm,
-                                         unformat_input_t * input,
-                                         vlib_cli_command_t * cmd)
+lisp_add_del_mreq_itr_rlocs_command_fn(vlib_main_t * vm,
+                                       unformat_input_t * input,
+                                       vlib_cli_command_t * cmd)
 {
   unformat_input_t _line_input, * line_input = &_line_input;
   u8 is_add = 1;
-  ip_address_t ip_addr;
+  u8 * locator_set_name = 0;
   clib_error_t * error = 0;
-  vnet_lisp_add_del_map_resolver_args_t _a, * a = &_a;
+  int rv = 0;
+  vnet_lisp_add_del_mreq_itr_rloc_args_t _a, * a = &_a;
 
   /* Get a line of input. */
   if (! unformat_user (input, unformat_line_input, line_input))
@@ -744,30 +1540,65 @@ lisp_add_del_map_resolver_command_fn (vlib_main_t * vm,
 
   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
     {
-      if (unformat (line_input, "add"))
-        is_add = 1;
-      else if (unformat (line_input, "del"))
+      if (unformat (line_input, "del"))
         is_add = 0;
-      else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
-        ;
+      else if (unformat (line_input, "add %s", &locator_set_name))
+        is_add = 1;
       else
         {
           error = unformat_parse_error(line_input);
           goto done;
         }
     }
+
   a->is_add = is_add;
-  a->address = ip_addr;
-  vnet_lisp_add_del_map_resolver (a);
+  a->locator_set_name = locator_set_name;
+  rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
+  if (0 != rv)
+    {
+      error = clib_error_return(0, "failed to %s map-request itr-rlocs!",
+                                is_add ? "add" : "delete");
+    }
+
+  vec_free(locator_set_name);
 
  done:
   return error;
+
 }
 
-VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = {
-    .path = "lisp map-resolver",
-    .short_help = "lisp map-resolver add/del <ip_address>",
-    .function = lisp_add_del_map_resolver_command_fn,
+VLIB_CLI_COMMAND (lisp_add_del_map_request_command) = {
+    .path = "lisp map-request itr-rlocs",
+    .short_help = "lisp map-request itr-rlocs add/del <locator_set_name>",
+    .function = lisp_add_del_mreq_itr_rlocs_command_fn,
+};
+
+static clib_error_t *
+lisp_show_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
+                                    unformat_input_t * input,
+                                    vlib_cli_command_t * cmd)
+{
+  lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+  locator_set_t * loc_set;
+
+  vlib_cli_output (vm, "%=20s", "itr-rlocs");
+
+  if (~0 == lcm->mreq_itr_rlocs)
+    {
+      return 0;
+    }
+
+  loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
+
+  vlib_cli_output (vm, "%=20s", loc_set->name);
+
+  return 0;
+}
+
+VLIB_CLI_COMMAND (lisp_show_map_request_command) = {
+    .path = "show lisp map-request itr-rlocs",
+    .short_help = "Shows map-request itr-rlocs",
+    .function = lisp_show_mreq_itr_rlocs_command_fn,
 };
 
 /* Statistics (not really errors) */
@@ -800,7 +1631,7 @@ typedef enum
 typedef struct
 {
   gid_address_t dst_eid;
-  ip4_address_t map_resolver_ip;
+  ip_address_t map_resolver_ip;
 } lisp_cp_lookup_trace_t;
 
 u8 *
@@ -811,11 +1642,54 @@ format_lisp_cp_lookup_trace (u8 * s, va_list * args)
   lisp_cp_lookup_trace_t * t = va_arg (*args, lisp_cp_lookup_trace_t *);
 
   s = format (s, "LISP-CP-LOOKUP: map-resolver: %U destination eid %U",
-              format_ip4_address, &t->map_resolver_ip, format_gid_address,
+              format_ip_address, &t->map_resolver_ip, format_gid_address,
               &t->dst_eid);
   return s;
 }
 
+ip_interface_address_t *
+ip_interface_get_first_interface_address (ip_lookup_main_t *lm, u32 sw_if_index,
+                                          u8 loop)
+{
+  vnet_main_t *vnm = vnet_get_main ();
+  vnet_sw_interface_t * swif = vnet_get_sw_interface (vnm, sw_if_index);
+  if (loop && swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
+    sw_if_index = swif->unnumbered_sw_if_index;
+  u32 ia =
+      (vec_len((lm)->if_address_pool_index_by_sw_if_index) > (sw_if_index)) ?
+          vec_elt((lm)->if_address_pool_index_by_sw_if_index, (sw_if_index)) :
+          (u32) ~0;
+  return pool_elt_at_index((lm)->if_address_pool, ia);
+}
+
+void *
+ip_interface_get_first_address (ip_lookup_main_t * lm, u32 sw_if_index,
+                                u8 version)
+{
+  ip_interface_address_t * ia;
+
+  ia = ip_interface_get_first_interface_address (lm, sw_if_index, 1);
+  if (!ia)
+    return 0;
+  return ip_interface_address_get_address (lm, ia);
+}
+
+int
+ip_interface_get_first_ip_address (lisp_cp_main_t * lcm, u32 sw_if_index,
+                                   u8 version, ip_address_t * result)
+{
+  ip_lookup_main_t * lm;
+  void * addr;
+
+  lm = (version == IP4) ? &lcm->im4->lookup_main : &lcm->im6->lookup_main;
+  addr = ip_interface_get_first_address (lm, sw_if_index, version);
+  if (!addr)
+    return 0;
+
+  ip_address_set (result, addr, version);
+  return 1;
+}
+
 static u32
 ip_fib_lookup_with_table (lisp_cp_main_t * lcm, u32 fib_index,
                           ip_address_t * dst)
@@ -827,119 +1701,138 @@ ip_fib_lookup_with_table (lisp_cp_main_t * lcm, u32 fib_index,
       return ip6_fib_lookup_with_table (lcm->im6, fib_index, &ip_addr_v6(dst));
 }
 
-void
-get_local_iface_ip_for_dst (lisp_cp_main_t *lcm, ip_address_t * dst,
-                            ip_address_t * sloc)
+u32
+ip_fib_get_egress_iface_for_dst_with_lm (lisp_cp_main_t * lcm,
+                                         ip_address_t * dst,
+                                         ip_lookup_main_t * lm)
 {
   u32 adj_index;
   ip_adjacency_t * adj;
-  ip_interface_address_t * ia = 0;
-  ip_lookup_main_t * lm = &lcm->im4->lookup_main;
-  ip4_address_t * l4 = 0;
-  ip6_address_t * l6 = 0;
 
   adj_index = ip_fib_lookup_with_table (lcm, 0, dst);
   adj = ip_get_adjacency (lm, adj_index);
 
-  if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP)
-    {
-      ia = pool_elt_at_index(lm->if_address_pool, adj->if_address_index);
-      if (ip_addr_version(dst) == IP4)
-        {
-          l4 = ip_interface_address_get_address (lm, ia);
-        }
-      else
-        {
-          l6 = ip_interface_address_get_address (lm, ia);
-        }
-    }
-  else if (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE)
-    {
-      /* find sw_if_index in rewrite header */
-      u32 sw_if_index = adj->rewrite_header.sw_if_index;
+  if (adj == 0)
+    return ~0;
 
-      /* find suitable address */
-      if (ip_addr_version(dst) == IP4)
-        {
-          /* find the first ip address */
-          foreach_ip_interface_address (&lcm->im4->lookup_main, ia,
-                                        sw_if_index, 1 /* unnumbered */,
-          ({
-            l4 = ip_interface_address_get_address (&lcm->im4->lookup_main, ia);
-            break;
-          }));
-        }
-      else
-        {
-          /* find the first ip address */
-          foreach_ip_interface_address (&lcm->im6->lookup_main, ia,
-                                        sw_if_index, 1 /* unnumbered */,
-          ({
-            l6 = ip_interface_address_get_address (&lcm->im6->lookup_main, ia);
-            break;
-          }));
-        }
-    }
-  else
-    {
-      clib_warning("Can't find local local interface ip for dst %U",
-                   format_ip_address, dst);
-      return;
-    }
+  /* we only want outgoing routes */
+  if (adj->lookup_next_index != IP_LOOKUP_NEXT_ARP
+      && adj->lookup_next_index != IP_LOOKUP_NEXT_REWRITE)
+    return ~0;
 
-  if (l4)
-    {
-      ip_addr_v4(sloc).as_u32 = l4->as_u32;
-      ip_addr_version(sloc) = IP4;
-    }
-  else if (l6)
+  return adj->rewrite_header.sw_if_index;
+}
+
+/**
+ * Find the sw_if_index of the interface that would be used to egress towards
+ * dst.
+ */
+u32
+ip_fib_get_egress_iface_for_dst (lisp_cp_main_t * lcm, ip_address_t * dst)
+{
+  ip_lookup_main_t * lm;
+
+  lm = ip_addr_version (dst) == IP4 ?
+      &lcm->im4->lookup_main : &lcm->im6->lookup_main;
+
+  return ip_fib_get_egress_iface_for_dst_with_lm (lcm, dst, lm);
+}
+
+/**
+ * Find first IP of the interface that would be used to egress towards dst.
+ * Returns 1 if the address is found 0 otherwise.
+ */
+int
+ip_fib_get_first_egress_ip_for_dst (lisp_cp_main_t * lcm, ip_address_t * dst,
+                                    ip_address_t * result)
+{
+  u32 si;
+  ip_lookup_main_t * lm;
+  void * addr = 0;
+  u8 ipver;
+
+  ASSERT(result != 0);
+
+  ipver = ip_addr_version(dst);
+
+  lm = (ipver == IP4) ? &lcm->im4->lookup_main : &lcm->im6->lookup_main;
+  si = ip_fib_get_egress_iface_for_dst_with_lm (lcm, dst, lm);
+
+  if ((u32) ~0 == si)
+    return 0;
+
+  /* find the first ip address */
+  addr = ip_interface_get_first_address (lm, si, ipver);
+  if (0 == addr)
+    return 0;
+
+  ip_address_set (result, addr, ipver);
+  return 1;
+}
+
+int
+get_mr_and_local_iface_ip (lisp_cp_main_t * lcm, ip_address_t * mr_ip,
+                           ip_address_t * sloc)
+{
+  ip_address_t * mrit;
+
+  if (vec_len(lcm->map_resolvers) == 0)
     {
-      clib_memcpy (&ip_addr_v6(sloc), l6, sizeof(*l6));
-      ip_addr_version(sloc) = IP6;
+      clib_warning("No map-resolver configured");
+      return 0;
     }
-  else
+
+  /* find the first mr ip we have a route to and the ip of the
+   * iface that has a route to it */
+  vec_foreach(mrit, lcm->map_resolvers)
     {
-      clib_warning("Can't find local interface addr for dst %U",
-                   format_ip_address, dst);
+      if (0 != ip_fib_get_first_egress_ip_for_dst (lcm, mrit, sloc)) {
+          ip_address_copy(mr_ip, mrit);
+          return 1;
+      }
     }
-}
 
+  clib_warning("Can't find map-resolver and local interface ip!");
+  return 0;
+}
 
-static ip_address_t *
+static gid_address_t *
 build_itr_rloc_list (lisp_cp_main_t * lcm, locator_set_t * loc_set)
 {
-  ip4_address_t * l4;
-  ip6_address_t * l6;
+  void * addr;
   u32 i;
   locator_t * loc;
   u32 * loc_indexp;
   ip_interface_address_t * ia = 0;
-  ip_address_t * rlocs = 0;
-  ip_address_t _rloc, * rloc = &_rloc;
+  gid_address_t gid_data, * gid = &gid_data;
+  gid_address_t * rlocs = 0;
+  ip_prefix_t * ippref = &gid_address_ippref (gid);
+  ip_address_t * rloc = &ip_prefix_addr (ippref);
 
+  gid_address_type (gid) = GID_ADDR_IP_PREFIX;
   for (i = 0; i < vec_len(loc_set->locator_indices); i++)
     {
       loc_indexp = vec_elt_at_index(loc_set->locator_indices, i);
       loc = pool_elt_at_index (lcm->locator_pool, loc_indexp[0]);
 
-      ip_addr_version(rloc) = IP4;
       /* Add ipv4 locators first TODO sort them */
       foreach_ip_interface_address (&lcm->im4->lookup_main, ia,
 				    loc->sw_if_index, 1 /* unnumbered */,
       ({
-	l4 = ip_interface_address_get_address (&lcm->im4->lookup_main, ia);
-  ip_addr_v4(rloc) = l4[0];
-  vec_add1(rlocs, rloc[0]);
+	addr = ip_interface_address_get_address (&lcm->im4->lookup_main, ia);
+	ip_address_set (rloc, addr, IP4);
+        ip_prefix_len (ippref) = 32;
+        vec_add1 (rlocs, gid[0]);
       }));
 
-      ip_addr_version(rloc) = IP6;
       /* Add ipv6 locators */
       foreach_ip_interface_address (&lcm->im6->lookup_main, ia,
 				    loc->sw_if_index, 1 /* unnumbered */,
       ({
-  l6 = ip_interface_address_get_address (&lcm->im6->lookup_main, ia);
-  ip_addr_v6(rloc) = l6[0];
-  vec_add1(rlocs, rloc[0]);
+        addr = ip_interface_address_get_address (&lcm->im6->lookup_main, ia);
+        ip_address_set (rloc, addr, IP6);
+        ip_prefix_len (ippref) = 128;
+        vec_add1 (rlocs, gid[0]);
       }));
     }
   return rlocs;
@@ -948,13 +1841,13 @@ build_itr_rloc_list (lisp_cp_main_t * lcm, locator_set_t * loc_set)
 static vlib_buffer_t *
 build_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
                                 gid_address_t * seid, gid_address_t * deid,
-                                locator_set_t * loc_set, u8 is_smr_invoked,
+                                locator_set_t * loc_set, ip_address_t * mr_ip,
+                                ip_address_t * sloc, u8 is_smr_invoked,
                                 u64 *nonce_res, u32 * bi_res)
 {
   vlib_buffer_t * b;
   u32 bi;
-  ip_address_t * mr_ip, sloc;
-  ip_address_t * rlocs = 0;
+  gid_address_t * rlocs = 0;
 
   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
     {
@@ -976,20 +1869,13 @@ build_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
   /* push ecm: udp-ip-lisp */
   lisp_msg_push_ecm (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, seid, deid);
 
-  /* get map-resolver ip XXX use first*/
-  mr_ip = vec_elt_at_index(lcm->map_resolvers, 0);
-
-  /* get local iface ip to use in map-request XXX fib 0 for now*/
-  get_local_iface_ip_for_dst (lcm, mr_ip, &sloc);
-
   /* push outer ip header */
-  pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, &sloc,
+  pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc,
                        mr_ip);
 
   bi_res[0] = bi;
 
-  if (rlocs)
-    vec_free(rlocs);
+  vec_free(rlocs);
   return b;
 }
 
@@ -1005,35 +1891,59 @@ send_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
   locator_set_t * loc_set;
   mapping_t * map;
   pending_map_request_t * pmr;
+  ip_address_t mr_ip, sloc;
+  u32 ls_index;
 
   /* get locator-set for seid */
-  map_index = gid_dictionary_lookup (&lcm->mapping_index_by_gid, seid);
-  if (map_index == ~0)
+  if (!lcm->lisp_pitr)
     {
-      clib_warning("No local mapping found in eid-table for %U!",
-                   format_gid_address, seid);
-      return;
-    }
+      map_index = gid_dictionary_lookup (&lcm->mapping_index_by_gid, seid);
+      if (map_index == ~0)
+        {
+          clib_warning("No local mapping found in eid-table for %U!",
+                       format_gid_address, seid);
+          return;
+        }
 
-  map = pool_elt_at_index (lcm->mapping_pool, map_index);
+      map = pool_elt_at_index (lcm->mapping_pool, map_index);
 
-  if (!map->local)
+      if (!map->local)
+        {
+          clib_warning("Mapping found for src eid %U is not marked as local!",
+                       format_gid_address, seid);
+          return;
+        }
+      ls_index = map->locator_set_index;
+    }
+  else
     {
-      clib_warning("Mapping found for src eid %U is not marked as local!",
-                   format_gid_address, seid);
-      return;
+      map_index = lcm->pitr_map_index;
+      map = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
+      ls_index = map->locator_set_index;
+    }
+
+  /* overwrite locator set if map-request itr-rlocs configured */
+  if (~0 != lcm->mreq_itr_rlocs)
+    {
+      ls_index = lcm->mreq_itr_rlocs;
     }
-  loc_set = pool_elt_at_index (lcm->locator_set_pool, map->locator_set_index);
+
+  loc_set = pool_elt_at_index (lcm->locator_set_pool, ls_index);
+
+  /* get local iface ip to use in map-request */
+  if (0 == get_mr_and_local_iface_ip (lcm, &mr_ip, &sloc))
+    return;
 
   /* build the encapsulated map request */
-  b = build_encapsulated_map_request (vm, lcm, seid, deid, loc_set,
-                                      is_smr_invoked, &nonce, &bi);
+  b = build_encapsulated_map_request (vm, lcm, seid, deid, loc_set, &mr_ip,
+                                      &sloc, is_smr_invoked, &nonce, &bi);
 
   if (!b)
     return;
 
+  /* set fib index and lookup node */
   vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0;
-  next_index = (ip_prefix_version(&gid_address_ippref(seid)) == IP4) ?
+  next_index = (ip_addr_version(&mr_ip) == IP4) ?
       ip4_lookup_node.index : ip6_lookup_node.index;
 
   f = vlib_get_frame_to_node (vm, next_index);
@@ -1061,18 +1971,14 @@ get_src_and_dst (void *hdr, ip_address_t * src, ip_address_t *dst)
 
   if ((ip4->ip_version_and_header_length & 0xF0) == 0x40)
     {
-      ip_addr_v4(src).as_u32 = ip4->src_address.as_u32;
-      ip_addr_version(src) = IP4;
-      ip_addr_v4(dst).as_u32 = ip4->dst_address.as_u32;
-      ip_addr_version(dst) = IP4;
+      ip_address_set(src, &ip4->src_address, IP4);
+      ip_address_set(dst, &ip4->dst_address, IP4);
     }
   else
     {
       ip6 = hdr;
-      clib_memcpy (&ip_addr_v6(src), &ip6->src_address, sizeof(ip6->src_address));
-      ip_addr_version(src) = IP6;
-      clib_memcpy (&ip_addr_v6(dst), &ip6->dst_address, sizeof(ip6->dst_address));
-      ip_addr_version(dst) = IP6;
+      ip_address_set(src, &ip6->src_address, IP6);
+      ip_address_set(dst, &ip6->dst_address, IP6);
     }
 }
 
@@ -1080,7 +1986,7 @@ static uword
 lisp_cp_lookup (vlib_main_t * vm, vlib_node_runtime_t * node,
               vlib_frame_t * from_frame)
 {
-  u32 * from, * to_next_drop;
+  u32 * from, * to_next_drop, di, si;
   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main();
   u32 pkts_mapped = 0;
   uword n_left_from, n_left_to_next_drop;
@@ -1101,9 +2007,9 @@ lisp_cp_lookup (vlib_main_t * vm, vlib_node_runtime_t * node,
           gid_address_t src, dst;
           ip_prefix_t * spref, * dpref;
 
-          gid_address_type (&src) = IP_PREFIX;
+          gid_address_type (&src) = GID_ADDR_IP_PREFIX;
           spref = &gid_address_ippref(&src);
-          gid_address_type (&dst) = IP_PREFIX;
+          gid_address_type (&dst) = GID_ADDR_IP_PREFIX;
           dpref = &gid_address_ippref(&dst);
 
           pi0 = from[0];
@@ -1122,19 +2028,50 @@ lisp_cp_lookup (vlib_main_t * vm, vlib_node_runtime_t * node,
           ip_prefix_len(spref) = ip_address_max_len (ip_prefix_version(spref));
           ip_prefix_len(dpref) = ip_address_max_len (ip_prefix_version(dpref));
 
-          /* send map-request */
-          send_encapsulated_map_request (vm, lcm, &src, &dst, 0);
-
-          pkts_mapped++;
+          /* if we have remote mapping for destination already in map-chache
+             add forwarding tunnel directly. If not send a map-request */
+          di = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst);
+          if (~0 != di)
+            {
+              mapping_t * m =  vec_elt_at_index (lcm->mapping_pool, di);
+              /* send a map-request also in case of negative mapping entry
+                with corresponding action */
+              if (m->action == ACTION_SEND_MAP_REQUEST)
+                {
+                  /* send map-request */
+                  send_encapsulated_map_request (vm, lcm, &src, &dst, 0);
+                  pkts_mapped++;
+                }
+              else
+                {
+                  si =  gid_dictionary_lookup (&lcm->mapping_index_by_gid,
+                                               &src);
+                  if (~0 != si)
+                    {
+                      add_fwd_entry (lcm, si, di);
+                    }
+                }
+            }
+          else
+            {
+              /* send map-request */
+              send_encapsulated_map_request (vm, lcm, &src, &dst, 0);
+              pkts_mapped++;
+            }
 
           if (PREDICT_FALSE(p0->flags & VLIB_BUFFER_IS_TRACED))
             {
               lisp_cp_lookup_trace_t *tr = vlib_add_trace (vm, node, p0,
                                                           sizeof(*tr));
+
+              memset(tr, 0, sizeof(*tr));
               gid_address_copy (&tr->dst_eid, &dst);
-              clib_memcpy (&tr->map_resolver_ip,
-                      vec_elt_at_index(lcm->map_resolvers, 0),
-                      sizeof(ip_address_t));
+              if (vec_len(lcm->map_resolvers) > 0)
+                {
+                  clib_memcpy (&tr->map_resolver_ip,
+                               vec_elt_at_index(lcm->map_resolvers, 0),
+                               sizeof(ip_address_t));
+                }
             }
         }
 
@@ -1207,31 +2144,7 @@ format_lisp_cp_input_trace (u8 * s, va_list * args)
   return s;
 }
 
-ip_interface_address_t *
-ip_interface_get_first_interface_address (ip_lookup_main_t *lm, u32 sw_if_index,
-                                          u8 loop)
-{
-  vnet_main_t *vnm = vnet_get_main ();
-  vnet_sw_interface_t * swif = vnet_get_sw_interface (vnm, sw_if_index);
-  if (loop && swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
-    sw_if_index = swif->unnumbered_sw_if_index;
-  u32 ia =
-      (vec_len((lm)->if_address_pool_index_by_sw_if_index) > (sw_if_index)) ?
-          vec_elt((lm)->if_address_pool_index_by_sw_if_index, (sw_if_index)) :
-          (u32) ~0;
-  return pool_elt_at_index((lm)->if_address_pool, ia);
-}
-
-void *
-ip_interface_get_first_ip_addres (ip_lookup_main_t *lm, u32 sw_if_index,
-                                   u8 loop)
-{
-  ip_interface_address_t * ia = ip_interface_get_first_interface_address (
-      lm, sw_if_index, loop);
-  return ip_interface_address_get_address (lm, ia);
-}
-
-void
+static void
 del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index,
                u32 dst_map_index)
 {
@@ -1251,7 +2164,7 @@ del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index,
   a->is_add = 0;
   a->dlocator = fe->dst_loc;
   a->slocator = fe->src_loc;
-  a->iid = 0; // XXX should be part of mapping/eid
+  a->vni = gid_address_vni(&a->deid);
   gid_address_copy(&a->deid, &fe->deid);
 
   vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index);
@@ -1261,15 +2174,96 @@ del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index,
   pool_put(lcm->fwd_entry_pool, fe);
 }
 
-void
+/**
+ * Finds first remote locator with best (lowest) priority that has a local
+ * peer locator with an underlying route to it.
+ *
+ */
+static u32
+get_locator_pair (lisp_cp_main_t* lcm, mapping_t * lcl_map, mapping_t * rmt_map,
+                  ip_address_t * lcl_loc, ip_address_t * rmt_loc)
+{
+  u32 i, minp = ~0, limitp = 0, li, check_index = 0, done = 0, esi;
+  locator_set_t * rmt_ls, * lcl_ls;
+  ip_address_t _lcl, * lcl = &_lcl;
+  locator_t * l, * rmt = 0;
+  uword * checked = 0;
+
+  rmt_ls = pool_elt_at_index(lcm->locator_set_pool, rmt_map->locator_set_index);
+  lcl_ls = pool_elt_at_index(lcm->locator_set_pool, lcl_map->locator_set_index);
+
+  if (!rmt_ls || vec_len(rmt_ls->locator_indices) == 0)
+    return 0;
+
+  while (!done)
+    {
+      /* find unvisited remote locator with best priority */
+      for (i = 0; i < vec_len(rmt_ls->locator_indices); i++)
+        {
+          if (0 != hash_get(checked, i))
+            continue;
+
+          li = vec_elt(rmt_ls->locator_indices, i);
+          l = pool_elt_at_index(lcm->locator_pool, li);
+
+          /* we don't support non-IP locators for now */
+          if (gid_address_type(&l->address) != GID_ADDR_IP_PREFIX)
+            continue;
+
+          if (l->priority < minp && l->priority >= limitp)
+            {
+              minp = l->priority;
+              rmt = l;
+              check_index = i;
+            }
+        }
+      /* check if a local locator with a route to remote locator exists */
+      if (rmt != 0)
+        {
+          esi = ip_fib_get_egress_iface_for_dst (
+              lcm, &gid_address_ip(&rmt->address));
+          if ((u32) ~0 == esi)
+            continue;
+
+          for (i = 0; i < vec_len(lcl_ls->locator_indices); i++)
+            {
+              li = vec_elt (lcl_ls->locator_indices, i);
+              locator_t * sl = pool_elt_at_index (lcm->locator_pool, li);
+
+              /* found local locator */
+              if (sl->sw_if_index == esi)
+                {
+                  if (0 == ip_interface_get_first_ip_address (lcm,
+                             sl->sw_if_index,
+                             gid_address_ip_version(&rmt->address), lcl))
+                    continue;
+
+                  ip_address_copy(rmt_loc, &gid_address_ip(&rmt->address));
+                  ip_address_copy(lcl_loc, lcl);
+                  done = 2;
+                }
+            }
+
+          /* skip this remote locator in next searches */
+          limitp = minp;
+          hash_set(checked, check_index, 1);
+        }
+      else
+        done = 1;
+    }
+  hash_free(checked);
+  return (done == 2) ? 1 : 0;
+}
+
+static void
 add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index)
 {
   mapping_t * src_map, * dst_map;
-  locator_set_t * dst_ls, * src_ls;
-  u32 i, minp = ~0;
-  locator_t * dl = 0;
-  uword * feip = 0;
+  u32 sw_if_index;
+  uword * feip = 0, * tidp;
+  fwd_entry_t* fe;
   vnet_lisp_gpe_add_del_fwd_entry_args_t _a, * a = &_a;
+
   memset (a, 0, sizeof(*a));
 
   /* remove entry if it already exists */
@@ -1280,69 +2274,36 @@ add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index)
   src_map = pool_elt_at_index (lcm->mapping_pool, src_map_index);
   dst_map = pool_elt_at_index (lcm->mapping_pool, dst_map_index);
 
-  /* XXX simple forwarding policy: first lowest (value) priority locator */
-  dst_ls = pool_elt_at_index (lcm->locator_set_pool,
-                              dst_map->locator_set_index);
-  for (i = 0; i < vec_len (dst_ls->locator_indices); i++)
+  gid_address_copy (&a->deid, &dst_map->eid);
+  a->vni = gid_address_vni(&a->deid);
+
+  tidp = hash_get(lcm->table_id_by_vni, a->vni);
+  if (!tidp)
     {
-      u32 li = vec_elt (dst_ls->locator_indices, i);
-      locator_t * l = pool_elt_at_index (lcm->locator_pool, li);
-      if (l->priority < minp && gid_address_type(&l->address) == IP_PREFIX)
-        {
-          minp = l->priority;
-          dl = l;
-        }
+      clib_warning("vni %d not associated to a vrf!", a->vni);
+      return;
     }
-  if (dl)
-    {
-      src_ls = pool_elt_at_index (lcm->locator_set_pool,
-                                  src_map->locator_set_index);
-      for (i = 0; i < vec_len (src_ls->locator_indices); i++)
-        {
-          u32 li = vec_elt (src_ls->locator_indices, i);
-          locator_t * sl = pool_elt_at_index (lcm->locator_pool, li);
+  a->table_id = tidp[0];
 
-          if (ip_addr_version(&gid_address_ip(&dl->address)) == IP4)
-            {
-              ip4_address_t * l4;
-              l4 = ip_interface_get_first_ip_addres (&lcm->im4->lookup_main,
-                                                     sl->sw_if_index,
-                                                     1 /* unnumbered */);
-              ip_addr_v4(&a->slocator) = *l4;
-              ip_addr_version(&a->slocator) = IP4;
-            }
-          else
-            {
-              ip6_address_t * l6;
-              l6 = ip_interface_get_first_ip_addres (&lcm->im6->lookup_main,
-                                                     sl->sw_if_index,
-                                                     1 /* unnumbered */);
-              ip_addr_v6(&a->slocator) = *l6;
-              ip_addr_version(&a->slocator) = IP6;
-            }
-        }
-    }
   /* insert data plane forwarding entry */
-  u32 sw_if_index;
   a->is_add = 1;
-  if (dl)
-    a->dlocator = gid_address_ip(&dl->address);
-  else
+
+  /* find best locator pair that 1) verifies LISP policy 2) are connected */
+  if (0 == get_locator_pair (lcm, src_map, dst_map, &a->slocator, &a->dlocator))
     {
+      /* negative entry */
       a->is_negative = 1;
       a->action = dst_map->action;
     }
 
-  gid_address_copy (&a->deid, &dst_map->eid);
-  a->iid = 0; // XXX should be part of mapping/eid
+  /* TODO remove */
   u8 ipver = ip_prefix_version(&gid_address_ippref(&a->deid));
   a->decap_next_index = (ipver == IP4) ?
           LISP_GPE_INPUT_NEXT_IP4_INPUT : LISP_GPE_INPUT_NEXT_IP6_INPUT;
-  /* XXX tunnels work only with IP4 now */
+
   vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index);
 
   /* add tunnel to fwd entry table XXX check return value from DP insertion */
-  fwd_entry_t* fe;
   pool_get (lcm->fwd_entry_pool, fe);
   fe->dst_loc = a->dlocator;
   fe->src_loc = a->slocator;
@@ -1378,6 +2339,8 @@ compare_locators (lisp_cp_main_t *lcm, u32 * old_ls_indexes,
 void
 process_map_reply (lisp_cp_main_t * lcm, vlib_buffer_t * b)
 {
+  mapping_t * old_map;
+  locator_t * loc;
   u32 len = 0, i, ls_index = 0;
   void * h;
   vnet_lisp_add_del_locator_set_args_t _ls_arg, * ls_arg = &_ls_arg;
@@ -1418,19 +2381,22 @@ process_map_reply (lisp_cp_main_t * lcm, vlib_buffer_t * b)
       if (len == ~0)
         {
           clib_warning ("Failed to parse mapping record!");
+          vec_foreach (loc, ls_arg->locators)
+            {
+              locator_free (loc);
+            }
           vec_free(ls_arg->locators);
           return;
         }
 
       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &m_args->deid);
+      old_map = mi != ~0 ? pool_elt_at_index(lcm->mapping_pool, mi) : 0;
 
       /* if mapping already exists, decide if locators (and forwarding) should
        * be updated and be done */
-      if (mi != ~0)
+      if (old_map != 0 && !gid_address_cmp (&old_map->eid, &m_args->deid))
         {
-          mapping_t * old_map;
           locator_set_t * old_ls;
-          old_map = pool_elt_at_index(lcm->mapping_pool, mi);
 
           /* update mapping attributes */
           old_map->action = m_args->action;
@@ -1481,7 +2447,7 @@ process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, vlib_buffer_t * b)
   gid_address_t src, dst;
 //  u64 nonce;
   u32 i, len = 0;
-  gid_address_t * itr_rlocs = 0;
+  gid_address_t * itr_rlocs = 0, * rloc;
 
   mreq_hdr = vlib_buffer_get_current (b);
   vlib_buffer_pull (b, sizeof(*mreq_hdr));
@@ -1503,6 +2469,12 @@ process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, vlib_buffer_t * b)
   if (len == ~0)
     return;
 
+  /* TODO: RLOCs are currently unused, so free them for now */
+  vec_foreach (rloc, itr_rlocs)
+    {
+      gid_address_free (rloc);
+    }
+
   /* parse eid records and send SMR-invoked map-requests */
   for (i = 0; i < MREQ_REC_COUNT(mreq_hdr); i++)
     {
@@ -1607,9 +2579,12 @@ lisp_cp_init (vlib_main_t *vm)
   lcm->im6 = &ip6_main;
   lcm->vlib_main = vm;
   lcm->vnet_main = vnet_get_main();
+  lcm->mreq_itr_rlocs = ~0;
 
   gid_dictionary_init (&lcm->mapping_index_by_gid);
-  gid_dictionary_init (&lcm->mapping_index_by_gid);
+
+  /* default vrf mapped to vni 0 */
+  hash_set(lcm->table_id_by_vni, 0, 0);
 
   udp_register_dst_port (vm, UDP_DST_PORT_lisp_cp,
                          lisp_cp_input_node.index, 1 /* is_ip4 */);