X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vnet%2Fvnet%2Flisp-cp%2Fcontrol.c;h=537a3340dfd0d9f2c5beb060477e890541e28241;hb=b6e4d3990ed694fd0aeaa2e4a75c1b4602cf0379;hp=7d545c56976901e1ab70966b55724ddab6f1cd13;hpb=6a2e4392e9206fe4398e1ccdd431446097fc5503;p=vpp.git

diff --git a/vnet/vnet/lisp-cp/control.c b/vnet/vnet/lisp-cp/control.c
index 7d545c56976..537a3340dfd 100644
--- a/vnet/vnet/lisp-cp/control.c
+++ b/vnet/vnet/lisp-cp/control.c
@@ -366,11 +366,13 @@ lisp_add_del_negative_static_mapping (gid_address_t * deid,
  * @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)
+                                  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;
@@ -381,6 +383,9 @@ vnet_lisp_add_del_remote_mapping (gid_address_t * deid, gid_address_t * seid,
   ip_address_t * dl;
   int rc = -1;
 
+  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]));
@@ -487,6 +492,50 @@ done:
   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.
  *
@@ -502,11 +551,11 @@ lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
 {
   clib_error_t * error = 0;
   unformat_input_t _line_input, * line_input = &_line_input;
-  u8 is_add = 1;
+  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;
+  u8 deid_set = 0, seid_set = 0;
   u8 * s = 0;
   u32 vni, action = ~0;
 
@@ -525,9 +574,11 @@ lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
 
   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
     {
-      if (unformat (line_input, "del"))
+      if (unformat (line_input, "del-all"))
+        del_all = 1;
+      else if (unformat (line_input, "del"))
         is_add = 0;
-      if (unformat (line_input, "add"))
+      else if (unformat (line_input, "add"))
         ;
       else if (unformat (line_input, "deid %U",
                          unformat_ip_prefix, deid_ippref))
@@ -541,7 +592,9 @@ lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
         }
       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))
@@ -567,30 +620,38 @@ lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
         }
     }
 
-  if (!deid_set)
+  if (!del_all)
     {
-      clib_warning ("missing deid!");
-      goto done;
-    }
+      if (!deid_set)
+        {
+          clib_warning ("missing deid!");
+          goto done;
+        }
 
-  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 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 && (~0 == action)
-      && 0 == vec_len (rlocs))
-    {
-      clib_warning ("no action set for negative map-reply!");
-      goto done;
+      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);
+                                             action, is_add, del_all);
   if (rv)
     clib_warning ("failed to %s remote mapping!",
                   is_add ? "add" : "delete");
@@ -604,7 +665,7 @@ done:
 
 VLIB_CLI_COMMAND (lisp_add_del_remote_mapping_command) = {
     .path = "lisp remote-mapping",
-    .short_help = "lisp remote-mapping add|del vni <vni>"
+    .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,
@@ -1014,6 +1075,13 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
           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)
       {
           eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids, p[0]);
@@ -1361,6 +1429,117 @@ VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = {
     .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
+    {
+      lcm->mreq_itr_rlocs = ~0;
+    }
+
+  return 0;
+}
+
+static clib_error_t *
+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;
+  u8 * locator_set_name = 0;
+  clib_error_t * error = 0;
+  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))
+    return 0;
+
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "del"))
+        is_add = 0;
+      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->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_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) */
 #define foreach_lisp_cp_lookup_error           \
 _(DROP, "drop")                                \
@@ -1407,6 +1586,49 @@ format_lisp_cp_lookup_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_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)
@@ -1418,104 +1640,105 @@ 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_mr_and_local_iface_ip (lisp_cp_main_t *lcm, ip_address_t * mr_ip,
-                            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;
+
+  adj_index = ip_fib_lookup_with_table (lcm, 0, dst);
+  adj = ip_get_adjacency (lm, adj_index);
+
+  if (adj == 0)
+    return ~0;
+
+  /* we only want outgoing routes */
+  if (adj->lookup_next_index != IP_LOOKUP_NEXT_ARP
+      && adj->lookup_next_index != IP_LOOKUP_NEXT_REWRITE)
+    return ~0;
+
+  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;
-  ip4_address_t * l4 = 0;
-  ip6_address_t * l6 = 0;
+
+  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_warning("No map-resolver configured");
-      return;
+      return 0;
     }
 
   /* 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)
     {
-      lm = ip_addr_version (mrit) == IP4 ?
-          &lcm->im4->lookup_main : &lcm->im6->lookup_main;
-
-      adj_index = ip_fib_lookup_with_table (lcm, 0, mrit);
-      adj = ip_get_adjacency (lm, adj_index);
-
-      if (adj == 0)
-        continue;
-
-      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(mrit) == 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;
-
-          /* find suitable address */
-          if (ip_addr_version(mrit) == 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;
-              }));
-            }
-        }
-
-      if (l4)
-        {
-          ip_addr_v4(sloc).as_u32 = l4->as_u32;
-          ip_addr_version(sloc) = IP4;
+      if (0 != ip_fib_get_first_egress_ip_for_dst (lcm, mrit, sloc)) {
           ip_address_copy(mr_ip, mrit);
-          return;
-        }
-      else if (l6)
-        {
-          clib_memcpy (&ip_addr_v6(sloc), l6, sizeof(*l6));
-          ip_addr_version(sloc) = IP6;
-          ip_address_copy(mr_ip, mrit);
-          return;
-        }
+          return 1;
+      }
     }
 
   clib_warning("Can't find map-resolver and local interface ip!");
-  return;
+  return 0;
 }
 
 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;
@@ -1531,24 +1754,22 @@ build_itr_rloc_list (lisp_cp_main_t * lcm, locator_set_t * loc_set)
       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];
+	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];
+        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]);
       }));
@@ -1593,8 +1814,7 @@ build_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
 
   bi_res[0] = bi;
 
-  if (rlocs)
-    vec_free(rlocs);
+  vec_free(rlocs);
   return b;
 }
 
@@ -1611,6 +1831,7 @@ send_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
   mapping_t * map;
   pending_map_request_t * pmr;
   ip_address_t mr_ip, sloc;
+  u32 ls_index;
 
   /* get locator-set for seid */
   if (!lcm->lisp_pitr)
@@ -1631,17 +1852,26 @@ send_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
                        format_gid_address, seid);
           return;
         }
+      ls_index = map->locator_set_index;
     }
   else
     {
       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 XXX fib 0 for now*/
-  get_mr_and_local_iface_ip (lcm, &mr_ip, &sloc);
+  /* 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, &mr_ip,
@@ -1680,18 +1910,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);
     }
 }
 
@@ -1857,30 +2083,6 @@ 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);
-}
-
 static void
 del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index,
                u32 dst_map_index)
@@ -1911,13 +2113,92 @@ del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index,
   pool_put(lcm->fwd_entry_pool, fe);
 }
 
+/**
+ * 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, sw_if_index;
-  locator_t * dl = 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;
@@ -1943,56 +2224,13 @@ add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index)
     }
   a->table_id = tidp[0];
 
-  /* 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++)
-    {
-      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)
-            == GID_ADDR_IP_PREFIX)
-        {
-          minp = l->priority;
-          dl = l;
-        }
-    }
-  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);
-
-          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 */
   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;
     }
@@ -2280,6 +2518,7 @@ 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);