src/plugins/lisp/lisp-cp/control.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vlibmemory/api.h>
  17 #include <lisp/lisp-cp/control.h>
  18 #include <lisp/lisp-cp/packets.h>
  19 #include <lisp/lisp-cp/lisp_msg_serdes.h>
  20 #include <lisp/lisp-gpe/lisp_gpe_fwd_entry.h>
  21 #include <lisp/lisp-gpe/lisp_gpe_tenant.h>
  22 #include <lisp/lisp-gpe/lisp_gpe_tunnel.h>
  23 #include <vnet/fib/fib_entry.h>
  24 #include <vnet/fib/fib_table.h>
  25 #include <vnet/ethernet/arp_packet.h>
  26 #include <vnet/ethernet/packet.h>
  27
  28 #include <openssl/evp.h>
  29 #include <vnet/crypto/crypto.h>
  30
  31 #define MAX_VALUE_U24 0xffffff
  32
  33 /* mapping timer control constants (in seconds) */
  34 #define TIME_UNTIL_REFETCH_OR_DELETE  20
  35 #define MAPPING_TIMEOUT (((m->ttl) * 60) - TIME_UNTIL_REFETCH_OR_DELETE)
  36
  37 u8 *format_lisp_cp_input_trace (u8 * s, va_list * args);
  38 static void *send_map_request_thread_fn (void *arg);
  39
  40 typedef enum
  41 {
  42   LISP_CP_INPUT_NEXT_DROP,
  43   LISP_CP_INPUT_N_NEXT,
  44 } lisp_cp_input_next_t;
  45
  46 typedef struct
  47 {
  48   u8 is_resend;
  49   gid_address_t seid;
  50   gid_address_t deid;
  51   u8 smr_invoked;
  52 } map_request_args_t;
  53
  54 u8
  55 vnet_lisp_get_map_request_mode (void)
  56 {
  57   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
  58   return lcm->map_request_mode;
  59 }
  60
  61 static u16
  62 auth_data_len_by_key_id (lisp_key_type_t key_id)
  63 {
  64   switch (key_id)
  65     {
  66     case HMAC_SHA_1_96:
  67       return SHA1_AUTH_DATA_LEN;
  68     case HMAC_SHA_256_128:
  69       return SHA256_AUTH_DATA_LEN;
  70     default:
  71       clib_warning ("unsupported key type: %d!", key_id);
  72       return (u16) ~ 0;
  73     }
  74   return (u16) ~ 0;
  75 }
  76
  77 static int
  78 queue_map_request (gid_address_t * seid, gid_address_t * deid,
  79                    u8 smr_invoked, u8 is_resend);
  80
  81 ip_interface_address_t *
  82 ip_interface_get_first_interface_address (ip_lookup_main_t * lm,
  83                                           u32 sw_if_index, u8 loop)
  84 {
  85   vnet_main_t *vnm = vnet_get_main ();
  86   vnet_sw_interface_t *swif = vnet_get_sw_interface (vnm, sw_if_index);
  87   if (loop && swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
  88     sw_if_index = swif->unnumbered_sw_if_index;
  89   u32 ia =
  90     (vec_len ((lm)->if_address_pool_index_by_sw_if_index) > (sw_if_index)) ?
  91     vec_elt ((lm)->if_address_pool_index_by_sw_if_index, (sw_if_index)) :
  92     (u32) ~ 0;
  93   return pool_elt_at_index ((lm)->if_address_pool, ia);
  94 }
  95
  96 void *
  97 ip_interface_get_first_address (ip_lookup_main_t * lm, u32 sw_if_index,
  98                                 u8 version)
  99 {
 100   ip_interface_address_t *ia;
 101
 102   ia = ip_interface_get_first_interface_address (lm, sw_if_index, 1);
 103   if (!ia)
 104     return 0;
 105   return ip_interface_address_get_address (lm, ia);
 106 }
 107
 108 int
 109 ip_interface_get_first_ip_address (lisp_cp_main_t *lcm, u32 sw_if_index,
 110                                    ip_address_family_t version,
 111                                    ip_address_t *result)
 112 {
 113   ip_lookup_main_t *lm;
 114   void *addr;
 115
 116   lm = (version == AF_IP4) ? &lcm->im4->lookup_main : &lcm->im6->lookup_main;
 117   addr = ip_interface_get_first_address (lm, sw_if_index, version);
 118   if (!addr)
 119     return 0;
 120
 121   ip_address_set (result, addr, version);
 122   return 1;
 123 }
 124
 125 /**
 126  * Find the sw_if_index of the interface that would be used to egress towards
 127  * dst.
 128  */
 129 u32
 130 ip_fib_get_egress_iface_for_dst (lisp_cp_main_t * lcm, ip_address_t * dst)
 131 {
 132   fib_node_index_t fei;
 133   fib_prefix_t prefix;
 134
 135   ip_address_to_fib_prefix (dst, &prefix);
 136
 137   fei = fib_table_lookup (0, &prefix);
 138
 139   return (fib_entry_get_resolving_interface (fei));
 140 }
 141
 142 /**
 143  * Find first IP of the interface that would be used to egress towards dst.
 144  * Returns 1 if the address is found 0 otherwise.
 145  */
 146 int
 147 ip_fib_get_first_egress_ip_for_dst (lisp_cp_main_t * lcm, ip_address_t * dst,
 148                                     ip_address_t * result)
 149 {
 150   u32 si;
 151   ip_lookup_main_t *lm;
 152   void *addr = 0;
 153   ip_address_family_t ipver;
 154
 155   ASSERT (result != 0);
 156
 157   ipver = ip_addr_version (dst);
 158
 159   lm = (ipver == AF_IP4) ? &lcm->im4->lookup_main : &lcm->im6->lookup_main;
 160   si = ip_fib_get_egress_iface_for_dst (lcm, dst);
 161
 162   if ((u32) ~ 0 == si)
 163     return 0;
 164
 165   /* find the first ip address */
 166   addr = ip_interface_get_first_address (lm, si, ipver);
 167   if (0 == addr)
 168     return 0;
 169
 170   ip_address_set (result, addr, ipver);
 171   return 1;
 172 }
 173
 174 static int
 175 dp_add_del_iface (lisp_cp_main_t * lcm, u32 vni, u8 is_l2, u8 is_add,
 176                   u8 with_default_route)
 177 {
 178   uword *dp_table;
 179
 180   if (!is_l2)
 181     {
 182       dp_table = hash_get (lcm->table_id_by_vni, vni);
 183
 184       if (!dp_table)
 185         {
 186           clib_warning ("vni %d not associated to a vrf!", vni);
 187           return VNET_API_ERROR_INVALID_VALUE;
 188         }
 189     }
 190   else
 191     {
 192       dp_table = hash_get (lcm->bd_id_by_vni, vni);
 193       if (!dp_table)
 194         {
 195           clib_warning ("vni %d not associated to a bridge domain!", vni);
 196           return VNET_API_ERROR_INVALID_VALUE;
 197         }
 198     }
 199
 200   /* enable/disable data-plane interface */
 201   if (is_add)
 202     {
 203       if (is_l2)
 204         lisp_gpe_tenant_l2_iface_add_or_lock (vni, dp_table[0]);
 205       else
 206         lisp_gpe_tenant_l3_iface_add_or_lock (vni, dp_table[0],
 207                                               with_default_route);
 208     }
 209   else
 210     {
 211       if (is_l2)
 212         lisp_gpe_tenant_l2_iface_unlock (vni);
 213       else
 214         lisp_gpe_tenant_l3_iface_unlock (vni);
 215     }
 216
 217   return 0;
 218 }
 219
 220 static void
 221 dp_del_fwd_entry (lisp_cp_main_t * lcm, u32 dst_map_index)
 222 {
 223   vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a;
 224   fwd_entry_t *fe = 0;
 225   uword *feip = 0;
 226   clib_memset (a, 0, sizeof (*a));
 227
 228   feip = hash_get (lcm->fwd_entry_by_mapping_index, dst_map_index);
 229   if (!feip)
 230     return;
 231
 232   fe = pool_elt_at_index (lcm->fwd_entry_pool, feip[0]);
 233
 234   /* delete dp fwd entry */
 235   u32 sw_if_index;
 236   a->is_add = 0;
 237   a->locator_pairs = fe->locator_pairs;
 238   a->vni = gid_address_vni (&fe->reid);
 239   gid_address_copy (&a->rmt_eid, &fe->reid);
 240   if (fe->is_src_dst)
 241     gid_address_copy (&a->lcl_eid, &fe->leid);
 242
 243   vnet_lisp_gpe_del_fwd_counters (a, feip[0]);
 244   vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index);
 245
 246   /* delete entry in fwd table */
 247   hash_unset (lcm->fwd_entry_by_mapping_index, dst_map_index);
 248   vec_free (fe->locator_pairs);
 249   pool_put (lcm->fwd_entry_pool, fe);
 250 }
 251
 252 /**
 253  * Finds first remote locator with best (lowest) priority that has a local
 254  * peer locator with an underlying route to it.
 255  *
 256  */
 257 static u32
 258 get_locator_pairs (lisp_cp_main_t * lcm, mapping_t * lcl_map,
 259                    mapping_t * rmt_map, locator_pair_t ** locator_pairs)
 260 {
 261   u32 i, limitp = 0, li, found = 0, esi;
 262   locator_set_t *rmt_ls, *lcl_ls;
 263   ip_address_t _lcl_addr, *lcl_addr = &_lcl_addr;
 264   locator_t *lp, *rmt = 0;
 265   uword *checked = 0;
 266   locator_pair_t pair;
 267
 268   rmt_ls =
 269     pool_elt_at_index (lcm->locator_set_pool, rmt_map->locator_set_index);
 270   lcl_ls =
 271     pool_elt_at_index (lcm->locator_set_pool, lcl_map->locator_set_index);
 272
 273   if (!rmt_ls || vec_len (rmt_ls->locator_indices) == 0)
 274     return 0;
 275
 276   while (1)
 277     {
 278       rmt = 0;
 279
 280       /* find unvisited remote locator with best priority */
 281       for (i = 0; i < vec_len (rmt_ls->locator_indices); i++)
 282         {
 283           if (0 != hash_get (checked, i))
 284             continue;
 285
 286           li = vec_elt (rmt_ls->locator_indices, i);
 287           lp = pool_elt_at_index (lcm->locator_pool, li);
 288
 289           /* we don't support non-IP locators for now */
 290           if (gid_address_type (&lp->address) != GID_ADDR_IP_PREFIX)
 291             continue;
 292
 293           if ((found && lp->priority == limitp)
 294               || (!found && lp->priority >= limitp))
 295             {
 296               rmt = lp;
 297
 298               /* don't search for locators with lower priority and don't
 299                * check this locator again*/
 300               limitp = lp->priority;
 301               hash_set (checked, i, 1);
 302               break;
 303             }
 304         }
 305       /* check if a local locator with a route to remote locator exists */
 306       if (rmt != 0)
 307         {
 308           /* find egress sw_if_index for rmt locator */
 309           esi =
 310             ip_fib_get_egress_iface_for_dst (lcm,
 311                                              &gid_address_ip (&rmt->address));
 312           if ((u32) ~ 0 == esi)
 313             continue;
 314
 315           for (i = 0; i < vec_len (lcl_ls->locator_indices); i++)
 316             {
 317               li = vec_elt (lcl_ls->locator_indices, i);
 318               locator_t *sl = pool_elt_at_index (lcm->locator_pool, li);
 319
 320               /* found local locator with the needed sw_if_index */
 321               if (sl->sw_if_index == esi)
 322                 {
 323                   /* and it has an address */
 324                   if (0 == ip_interface_get_first_ip_address (lcm,
 325                                                               sl->sw_if_index,
 326                                                               gid_address_ip_version
 327                                                               (&rmt->address),
 328                                                               lcl_addr))
 329                     continue;
 330
 331                   clib_memset (&pair, 0, sizeof (pair));
 332                   ip_address_copy (&pair.rmt_loc,
 333                                    &gid_address_ip (&rmt->address));
 334                   ip_address_copy (&pair.lcl_loc, lcl_addr);
 335                   pair.weight = rmt->weight;
 336                   pair.priority = rmt->priority;
 337                   vec_add1 (locator_pairs[0], pair);
 338                   found = 1;
 339                 }
 340             }
 341         }
 342       else
 343         break;
 344     }
 345
 346   hash_free (checked);
 347   return found;
 348 }
 349
 350 static void
 351 gid_address_sd_to_flat (gid_address_t * dst, gid_address_t * src,
 352                         fid_address_t * fid)
 353 {
 354   ASSERT (GID_ADDR_SRC_DST == gid_address_type (src));
 355
 356   dst[0] = src[0];
 357
 358   switch (fid_addr_type (fid))
 359     {
 360     case FID_ADDR_IP_PREF:
 361       gid_address_type (dst) = GID_ADDR_IP_PREFIX;
 362       gid_address_ippref (dst) = fid_addr_ippref (fid);
 363       break;
 364     case FID_ADDR_MAC:
 365       gid_address_type (dst) = GID_ADDR_MAC;
 366       mac_copy (gid_address_mac (dst), fid_addr_mac (fid));
 367       break;
 368     default:
 369       clib_warning ("Unsupported fid type %d!", fid_addr_type (fid));
 370       break;
 371     }
 372 }
 373
 374 u8
 375 vnet_lisp_map_register_state_get (void)
 376 {
 377   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 378   return lcm->map_registering;
 379 }
 380
 381 u8
 382 vnet_lisp_rloc_probe_state_get (void)
 383 {
 384   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 385   return lcm->rloc_probing;
 386 }
 387
 388 static void
 389 dp_add_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index)
 390 {
 391   vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a;
 392   gid_address_t *rmt_eid, *lcl_eid;
 393   mapping_t *lcl_map, *rmt_map;
 394   u32 sw_if_index, **rmts, rmts_idx;
 395   uword *feip = 0, *dpid, *rmts_stored_idxp = 0;
 396   fwd_entry_t *fe;
 397   u8 type, is_src_dst = 0;
 398   int rv;
 399
 400   clib_memset (a, 0, sizeof (*a));
 401
 402   /* remove entry if it already exists */
 403   feip = hash_get (lcm->fwd_entry_by_mapping_index, dst_map_index);
 404   if (feip)
 405     dp_del_fwd_entry (lcm, dst_map_index);
 406
 407   /*
 408    * Determine local mapping and eid
 409    */
 410   if (lcm->flags & LISP_FLAG_PITR_MODE)
 411     {
 412       if (lcm->pitr_map_index != ~0)
 413         lcl_map = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
 414       else
 415         {
 416           clib_warning ("no PITR mapping configured!");
 417           return;
 418         }
 419     }
 420   else
 421     lcl_map = pool_elt_at_index (lcm->mapping_pool, src_map_index);
 422   lcl_eid = &lcl_map->eid;
 423
 424   /*
 425    * Determine remote mapping and eid
 426    */
 427   rmt_map = pool_elt_at_index (lcm->mapping_pool, dst_map_index);
 428   rmt_eid = &rmt_map->eid;
 429
 430   /*
 431    * Build and insert data plane forwarding entry
 432    */
 433   a->is_add = 1;
 434
 435   if (MR_MODE_SRC_DST == lcm->map_request_mode)
 436     {
 437       if (GID_ADDR_SRC_DST == gid_address_type (rmt_eid))
 438         {
 439           gid_address_sd_to_flat (&a->rmt_eid, rmt_eid,
 440                                   &gid_address_sd_dst (rmt_eid));
 441           gid_address_sd_to_flat (&a->lcl_eid, rmt_eid,
 442                                   &gid_address_sd_src (rmt_eid));
 443         }
 444       else
 445         {
 446           gid_address_copy (&a->rmt_eid, rmt_eid);
 447           gid_address_copy (&a->lcl_eid, lcl_eid);
 448         }
 449       is_src_dst = 1;
 450     }
 451   else
 452     gid_address_copy (&a->rmt_eid, rmt_eid);
 453
 454   a->vni = gid_address_vni (&a->rmt_eid);
 455   a->is_src_dst = is_src_dst;
 456
 457   /* get vrf or bd_index associated to vni */
 458   type = gid_address_type (&a->rmt_eid);
 459   if (GID_ADDR_IP_PREFIX == type)
 460     {
 461       dpid = hash_get (lcm->table_id_by_vni, a->vni);
 462       if (!dpid)
 463         {
 464           clib_warning ("vni %d not associated to a vrf!", a->vni);
 465           return;
 466         }
 467       a->table_id = dpid[0];
 468     }
 469   else if (GID_ADDR_MAC == type)
 470     {
 471       dpid = hash_get (lcm->bd_id_by_vni, a->vni);
 472       if (!dpid)
 473         {
 474           clib_warning ("vni %d not associated to a bridge domain !", a->vni);
 475           return;
 476         }
 477       a->bd_id = dpid[0];
 478     }
 479
 480   /* find best locator pair that 1) verifies LISP policy 2) are connected */
 481   rv = get_locator_pairs (lcm, lcl_map, rmt_map, &a->locator_pairs);
 482
 483   /* Either rmt mapping is negative or we can't find underlay path.
 484    * Try again with petr if configured */
 485   if (rv == 0 && (lcm->flags & LISP_FLAG_USE_PETR))
 486     {
 487       rmt_map = lisp_get_petr_mapping (lcm);
 488       rv = get_locator_pairs (lcm, lcl_map, rmt_map, &a->locator_pairs);
 489     }
 490
 491   /* negative entry */
 492   if (rv == 0)
 493     {
 494       a->is_negative = 1;
 495       a->action = rmt_map->action;
 496     }
 497
 498   rv = vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index);
 499   if (rv)
 500     {
 501       if (a->locator_pairs)
 502         vec_free (a->locator_pairs);
 503       return;
 504     }
 505
 506   /* add tunnel to fwd entry table */
 507   pool_get (lcm->fwd_entry_pool, fe);
 508   vnet_lisp_gpe_add_fwd_counters (a, fe - lcm->fwd_entry_pool);
 509
 510   fe->locator_pairs = a->locator_pairs;
 511   gid_address_copy (&fe->reid, &a->rmt_eid);
 512
 513   if (is_src_dst)
 514     gid_address_copy (&fe->leid, &a->lcl_eid);
 515   else
 516     gid_address_copy (&fe->leid, lcl_eid);
 517
 518   fe->is_src_dst = is_src_dst;
 519   hash_set (lcm->fwd_entry_by_mapping_index, dst_map_index,
 520             fe - lcm->fwd_entry_pool);
 521
 522   /* Add rmt mapping to the vector of adjacent mappings to lcl mapping */
 523   rmts_stored_idxp =
 524     hash_get (lcm->lcl_to_rmt_adjs_by_lcl_idx, src_map_index);
 525   if (!rmts_stored_idxp)
 526     {
 527       pool_get (lcm->lcl_to_rmt_adjacencies, rmts);
 528       clib_memset (rmts, 0, sizeof (*rmts));
 529       rmts_idx = rmts - lcm->lcl_to_rmt_adjacencies;
 530       hash_set (lcm->lcl_to_rmt_adjs_by_lcl_idx, src_map_index, rmts_idx);
 531     }
 532   else
 533     {
 534       rmts_idx = (u32) (*rmts_stored_idxp);
 535       rmts = pool_elt_at_index (lcm->lcl_to_rmt_adjacencies, rmts_idx);
 536     }
 537   vec_add1 (rmts[0], dst_map_index);
 538 }
 539
 540 typedef struct
 541 {
 542   u32 si;
 543   u32 di;
 544 } fwd_entry_mt_arg_t;
 545
 546 static void *
 547 dp_add_fwd_entry_thread_fn (void *arg)
 548 {
 549   fwd_entry_mt_arg_t *a = arg;
 550   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 551   dp_add_fwd_entry (lcm, a->si, a->di);
 552   return 0;
 553 }
 554
 555 static int
 556 dp_add_fwd_entry_from_mt (u32 si, u32 di)
 557 {
 558   fwd_entry_mt_arg_t a;
 559
 560   clib_memset (&a, 0, sizeof (a));
 561   a.si = si;
 562   a.di = di;
 563
 564   vl_api_rpc_call_main_thread (dp_add_fwd_entry_thread_fn,
 565                                (u8 *) & a, sizeof (a));
 566   return 0;
 567 }
 568
 569 /**
 570  * Returns vector of adjacencies.
 571  *
 572  * The caller must free the vector returned by this function.
 573  *
 574  * @param vni virtual network identifier
 575  * @return vector of adjacencies
 576  */
 577 lisp_adjacency_t *
 578 vnet_lisp_adjacencies_get_by_vni (u32 vni)
 579 {
 580   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 581   fwd_entry_t *fwd;
 582   lisp_adjacency_t *adjs = 0, adj;
 583
 584   /* *INDENT-OFF* */
 585   pool_foreach (fwd, lcm->fwd_entry_pool)
 586    {
 587     if (gid_address_vni (&fwd->reid) != vni)
 588       continue;
 589
 590     gid_address_copy (&adj.reid, &fwd->reid);
 591     gid_address_copy (&adj.leid, &fwd->leid);
 592     vec_add1 (adjs, adj);
 593   }
 594   /* *INDENT-ON* */
 595
 596   return adjs;
 597 }
 598
 599 static lisp_msmr_t *
 600 get_map_server (ip_address_t * a)
 601 {
 602   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 603   lisp_msmr_t *m;
 604
 605   vec_foreach (m, lcm->map_servers)
 606   {
 607     if (!ip_address_cmp (&m->address, a))
 608       {
 609         return m;
 610       }
 611   }
 612   return 0;
 613 }
 614
 615 static lisp_msmr_t *
 616 get_map_resolver (ip_address_t * a)
 617 {
 618   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 619   lisp_msmr_t *m;
 620
 621   vec_foreach (m, lcm->map_resolvers)
 622   {
 623     if (!ip_address_cmp (&m->address, a))
 624       {
 625         return m;
 626       }
 627   }
 628   return 0;
 629 }
 630
 631 int
 632 vnet_lisp_add_del_map_server (ip_address_t * addr, u8 is_add)
 633 {
 634   u32 i;
 635   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 636   lisp_msmr_t _ms, *ms = &_ms;
 637
 638   if (vnet_lisp_enable_disable_status () == 0)
 639     {
 640       clib_warning ("LISP is disabled!");
 641       return VNET_API_ERROR_LISP_DISABLED;
 642     }
 643
 644   if (is_add)
 645     {
 646       if (get_map_server (addr))
 647         {
 648           clib_warning ("map-server %U already exists!", format_ip_address,
 649                         addr);
 650           return -1;
 651         }
 652
 653       clib_memset (ms, 0, sizeof (*ms));
 654       ip_address_copy (&ms->address, addr);
 655       vec_add1 (lcm->map_servers, ms[0]);
 656
 657       if (vec_len (lcm->map_servers) == 1)
 658         lcm->do_map_server_election = 1;
 659     }
 660   else
 661     {
 662       for (i = 0; i < vec_len (lcm->map_servers); i++)
 663         {
 664           ms = vec_elt_at_index (lcm->map_servers, i);
 665           if (!ip_address_cmp (&ms->address, addr))
 666             {
 667               if (!ip_address_cmp (&ms->address, &lcm->active_map_server))
 668                 lcm->do_map_server_election = 1;
 669
 670               vec_del1 (lcm->map_servers, i);
 671               break;
 672             }
 673         }
 674     }
 675
 676   return 0;
 677 }
 678
 679 /**
 680  * Add/remove mapping to/from map-cache. Overwriting not allowed.
 681  */
 682 int
 683 vnet_lisp_map_cache_add_del (vnet_lisp_add_del_mapping_args_t * a,
 684                              u32 * map_index_result)
 685 {
 686   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 687   u32 mi, *map_indexp, map_index, i;
 688   u32 **rmts = 0, *remote_idxp, rmts_itr, remote_idx;
 689   uword *rmts_idxp;
 690   mapping_t *m, *old_map;
 691   u32 **eid_indexes;
 692
 693   if (gid_address_type (&a->eid) == GID_ADDR_NSH)
 694     {
 695       if (gid_address_vni (&a->eid) != 0)
 696         {
 697           clib_warning ("Supported only default VNI for NSH!");
 698           return VNET_API_ERROR_INVALID_ARGUMENT;
 699         }
 700       if (gid_address_nsh_spi (&a->eid) > MAX_VALUE_U24)
 701         {
 702           clib_warning ("SPI is greater than 24bit!");
 703           return VNET_API_ERROR_INVALID_ARGUMENT;
 704         }
 705     }
 706
 707   mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &a->eid);
 708   old_map = mi != ~0 ? pool_elt_at_index (lcm->mapping_pool, mi) : 0;
 709   if (a->is_add)
 710     {
 711       /* TODO check if overwriting and take appropriate actions */
 712       if (mi != GID_LOOKUP_MISS && !gid_address_cmp (&old_map->eid, &a->eid))
 713         {
 714           clib_warning ("eid %U found in the eid-table", format_gid_address,
 715                         &a->eid);
 716           return VNET_API_ERROR_VALUE_EXIST;
 717         }
 718
 719       pool_get (lcm->mapping_pool, m);
 720       gid_address_copy (&m->eid, &a->eid);
 721       m->locator_set_index = a->locator_set_index;
 722       m->ttl = a->ttl;
 723       m->action = a->action;
 724       m->local = a->local;
 725       m->is_static = a->is_static;
 726       m->key = vec_dup (a->key);
 727       m->key_id = a->key_id;
 728       m->authoritative = a->authoritative;
 729
 730       map_index = m - lcm->mapping_pool;
 731       gid_dictionary_add_del (&lcm->mapping_index_by_gid, &a->eid, map_index,
 732                               1);
 733
 734       if (pool_is_free_index (lcm->locator_set_pool, a->locator_set_index))
 735         {
 736           clib_warning ("Locator set with index %d doesn't exist",
 737                         a->locator_set_index);
 738           return VNET_API_ERROR_INVALID_VALUE;
 739         }
 740
 741       /* add eid to list of eids supported by locator-set */
 742       vec_validate (lcm->locator_set_to_eids, a->locator_set_index);
 743       eid_indexes = vec_elt_at_index (lcm->locator_set_to_eids,
 744                                       a->locator_set_index);
 745       vec_add1 (eid_indexes[0], map_index);
 746
 747       if (a->local)
 748         {
 749           /* mark as local */
 750           vec_add1 (lcm->local_mappings_indexes, map_index);
 751         }
 752       map_index_result[0] = map_index;
 753     }
 754   else
 755     {
 756       if (mi == GID_LOOKUP_MISS)
 757         {
 758           clib_warning ("eid %U not found in the eid-table",
 759                         format_gid_address, &a->eid);
 760           return VNET_API_ERROR_INVALID_VALUE;
 761         }
 762
 763       /* clear locator-set to eids binding */
 764       eid_indexes = vec_elt_at_index (lcm->locator_set_to_eids,
 765                                       a->locator_set_index);
 766       for (i = 0; i < vec_len (eid_indexes[0]); i++)
 767         {
 768           map_indexp = vec_elt_at_index (eid_indexes[0], i);
 769           if (map_indexp[0] == mi)
 770             break;
 771         }
 772       vec_del1 (eid_indexes[0], i);
 773
 774       /* remove local mark if needed */
 775       m = pool_elt_at_index (lcm->mapping_pool, mi);
 776       if (m->local)
 777         {
 778           /* Remove adjacencies associated with the local mapping */
 779           rmts_idxp = hash_get (lcm->lcl_to_rmt_adjs_by_lcl_idx, mi);
 780           if (rmts_idxp)
 781             {
 782               rmts =
 783                 pool_elt_at_index (lcm->lcl_to_rmt_adjacencies, rmts_idxp[0]);
 784               vec_foreach (remote_idxp, rmts[0])
 785               {
 786                 dp_del_fwd_entry (lcm, remote_idxp[0]);
 787               }
 788               vec_free (rmts[0]);
 789               pool_put (lcm->lcl_to_rmt_adjacencies, rmts);
 790               hash_unset (lcm->lcl_to_rmt_adjs_by_lcl_idx, mi);
 791             }
 792
 793           u32 k, *lm_indexp;
 794           for (k = 0; k < vec_len (lcm->local_mappings_indexes); k++)
 795             {
 796               lm_indexp = vec_elt_at_index (lcm->local_mappings_indexes, k);
 797               if (lm_indexp[0] == mi)
 798                 break;
 799             }
 800           vec_del1 (lcm->local_mappings_indexes, k);
 801         }
 802       else
 803         {
 804           /* Remove remote (if present) from the vectors of lcl-to-rmts
 805            * TODO: Address this in a more efficient way.
 806            */
 807           /* *INDENT-OFF* */
 808           pool_foreach (rmts, lcm->lcl_to_rmt_adjacencies)
 809            {
 810             vec_foreach_index (rmts_itr, rmts[0])
 811             {
 812               remote_idx = vec_elt (rmts[0], rmts_itr);
 813               if (mi == remote_idx)
 814                 {
 815                   vec_del1 (rmts[0], rmts_itr);
 816                   break;
 817                 }
 818             }
 819           }
 820           /* *INDENT-ON* */
 821         }
 822
 823       /* remove mapping from dictionary */
 824       gid_dictionary_add_del (&lcm->mapping_index_by_gid, &a->eid, 0, 0);
 825       gid_address_free (&m->eid);
 826       pool_put_index (lcm->mapping_pool, mi);
 827     }
 828
 829   return 0;
 830 }
 831
 832 /**
 833  *  Add/update/delete mapping to/in/from map-cache.
 834  */
 835 int
 836 vnet_lisp_add_del_local_mapping (vnet_lisp_add_del_mapping_args_t * a,
 837                                  u32 * map_index_result)
 838 {
 839   uword *dp_table = 0;
 840   u32 vni;
 841   u8 type;
 842
 843   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 844
 845   if (vnet_lisp_enable_disable_status () == 0)
 846     {
 847       clib_warning ("LISP is disabled!");
 848       return VNET_API_ERROR_LISP_DISABLED;
 849     }
 850
 851   vni = gid_address_vni (&a->eid);
 852   type = gid_address_type (&a->eid);
 853   if (GID_ADDR_IP_PREFIX == type)
 854     dp_table = hash_get (lcm->table_id_by_vni, vni);
 855   else if (GID_ADDR_MAC == type)
 856     dp_table = hash_get (lcm->bd_id_by_vni, vni);
 857
 858   if (!dp_table && GID_ADDR_NSH != type)
 859     {
 860       clib_warning ("vni %d not associated to a %s!", vni,
 861                     GID_ADDR_IP_PREFIX == type ? "vrf" : "bd");
 862       return VNET_API_ERROR_INVALID_VALUE;
 863     }
 864
 865   /* store/remove mapping from map-cache */
 866   return vnet_lisp_map_cache_add_del (a, map_index_result);
 867 }
 868
 869 static int
 870 add_l2_arp_bd (BVT (clib_bihash_kv) * kvp, void *arg)
 871 {
 872   u32 **ht = arg;
 873   u32 version = (u32) kvp->key[0];
 874   if (AF_IP6 == version)
 875     return (BIHASH_WALK_CONTINUE);
 876
 877   u32 bd = (u32) (kvp->key[0] >> 32);
 878   hash_set (ht[0], bd, 0);
 879   return (BIHASH_WALK_CONTINUE);
 880 }
 881
 882 u32 *
 883 vnet_lisp_l2_arp_bds_get (void)
 884 {
 885   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 886   u32 *bds = 0;
 887
 888   gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid,
 889                                      add_l2_arp_bd, &bds);
 890   return bds;
 891 }
 892
 893 static int
 894 add_ndp_bd (BVT (clib_bihash_kv) * kvp, void *arg)
 895 {
 896   u32 **ht = arg;
 897   u32 version = (u32) kvp->key[0];
 898   if (AF_IP4 == version)
 899     return (BIHASH_WALK_CONTINUE);
 900
 901   u32 bd = (u32) (kvp->key[0] >> 32);
 902   hash_set (ht[0], bd, 0);
 903   return (BIHASH_WALK_CONTINUE);
 904 }
 905
 906 u32 *
 907 vnet_lisp_ndp_bds_get (void)
 908 {
 909   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 910   u32 *bds = 0;
 911
 912   gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid,
 913                                      add_ndp_bd, &bds);
 914   return bds;
 915 }
 916
 917 typedef struct
 918 {
 919   void *vector;
 920   u32 bd;
 921 } lisp_add_l2_arp_ndp_args_t;
 922
 923 static int
 924 add_l2_arp_entry (BVT (clib_bihash_kv) * kvp, void *arg)
 925 {
 926   lisp_add_l2_arp_ndp_args_t *a = arg;
 927   lisp_api_l2_arp_entry_t **vector = a->vector, e;
 928
 929   u32 version = (u32) kvp->key[0];
 930   if (AF_IP6 == version)
 931     return (BIHASH_WALK_CONTINUE);
 932
 933   u32 bd = (u32) (kvp->key[0] >> 32);
 934
 935   if (bd == a->bd)
 936     {
 937       mac_copy (e.mac, (void *) &kvp->value);
 938       e.ip4 = (u32) kvp->key[1];
 939       vec_add1 (vector[0], e);
 940     }
 941   return (BIHASH_WALK_CONTINUE);
 942 }
 943
 944 lisp_api_l2_arp_entry_t *
 945 vnet_lisp_l2_arp_entries_get_by_bd (u32 bd)
 946 {
 947   lisp_api_l2_arp_entry_t *entries = 0;
 948   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 949   lisp_add_l2_arp_ndp_args_t a;
 950
 951   a.vector = &entries;
 952   a.bd = bd;
 953
 954   gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid,
 955                                      add_l2_arp_entry, &a);
 956   return entries;
 957 }
 958
 959 static int
 960 add_ndp_entry (BVT (clib_bihash_kv) * kvp, void *arg)
 961 {
 962   lisp_add_l2_arp_ndp_args_t *a = arg;
 963   lisp_api_ndp_entry_t **vector = a->vector, e;
 964
 965   u32 version = (u32) kvp->key[0];
 966   if (AF_IP4 == version)
 967     return (BIHASH_WALK_CONTINUE);
 968
 969   u32 bd = (u32) (kvp->key[0] >> 32);
 970
 971   if (bd == a->bd)
 972     {
 973       mac_copy (e.mac, (void *) &kvp->value);
 974       clib_memcpy (e.ip6, &kvp->key[1], 16);
 975       vec_add1 (vector[0], e);
 976     }
 977   return (BIHASH_WALK_CONTINUE);
 978 }
 979
 980 lisp_api_ndp_entry_t *
 981 vnet_lisp_ndp_entries_get_by_bd (u32 bd)
 982 {
 983   lisp_api_ndp_entry_t *entries = 0;
 984   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 985   lisp_add_l2_arp_ndp_args_t a;
 986
 987   a.vector = &entries;
 988   a.bd = bd;
 989
 990   gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid,
 991                                      add_ndp_entry, &a);
 992   return entries;
 993 }
 994
 995 int
 996 vnet_lisp_add_del_l2_arp_ndp_entry (gid_address_t * key, u8 * mac, u8 is_add)
 997 {
 998   if (vnet_lisp_enable_disable_status () == 0)
 999     {
1000       clib_warning ("LISP is disabled!");
1001       return VNET_API_ERROR_LISP_DISABLED;
1002     }
1003
1004   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1005   int rc = 0;
1006
1007   u64 res = gid_dictionary_lookup (&lcm->mapping_index_by_gid, key);
1008   if (is_add)
1009     {
1010       if (res != GID_LOOKUP_MISS_L2)
1011         {
1012           clib_warning ("Entry %U exists in DB!", format_gid_address, key);
1013           return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
1014         }
1015       u64 val = mac_to_u64 (mac);
1016       gid_dictionary_add_del (&lcm->mapping_index_by_gid, key, val,
1017                               1 /* is_add */ );
1018     }
1019   else
1020     {
1021       if (res == GID_LOOKUP_MISS_L2)
1022         {
1023           clib_warning ("ONE entry %U not found - cannot delete!",
1024                         format_gid_address, key);
1025           return -1;
1026         }
1027       gid_dictionary_add_del (&lcm->mapping_index_by_gid, key, 0,
1028                               0 /* is_add */ );
1029     }
1030
1031   return rc;
1032 }
1033
1034 int
1035 vnet_lisp_eid_table_map (u32 vni, u32 dp_id, u8 is_l2, u8 is_add)
1036 {
1037   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1038   uword *dp_idp, *vnip, **dp_table_by_vni, **vni_by_dp_table;
1039
1040   if (vnet_lisp_enable_disable_status () == 0)
1041     {
1042       clib_warning ("LISP is disabled!");
1043       return VNET_API_ERROR_LISP_DISABLED;
1044     }
1045
1046   dp_table_by_vni = is_l2 ? &lcm->bd_id_by_vni : &lcm->table_id_by_vni;
1047   vni_by_dp_table = is_l2 ? &lcm->vni_by_bd_id : &lcm->vni_by_table_id;
1048
1049   if (!is_l2 && (vni == 0 || dp_id == 0))
1050     {
1051       clib_warning ("can't add/del default vni-vrf mapping!");
1052       return -1;
1053     }
1054
1055   dp_idp = hash_get (dp_table_by_vni[0], vni);
1056   vnip = hash_get (vni_by_dp_table[0], dp_id);
1057
1058   if (is_add)
1059     {
1060       if (dp_idp || vnip)
1061         {
1062           clib_warning ("vni %d or vrf %d already used in vrf/vni "
1063                         "mapping!", vni, dp_id);
1064           return -1;
1065         }
1066       hash_set (dp_table_by_vni[0], vni, dp_id);
1067       hash_set (vni_by_dp_table[0], dp_id, vni);
1068
1069       /* create dp iface */
1070       dp_add_del_iface (lcm, vni, is_l2, 1 /* is_add */ ,
1071                         1 /* with_default_route */ );
1072     }
1073   else
1074     {
1075       if (!dp_idp || !vnip)
1076         {
1077           clib_warning ("vni %d or vrf %d not used in any vrf/vni! "
1078                         "mapping!", vni, dp_id);
1079           return -1;
1080         }
1081       /* remove dp iface */
1082       dp_add_del_iface (lcm, vni, is_l2, 0 /* is_add */ , 0 /* unused */ );
1083
1084       hash_unset (dp_table_by_vni[0], vni);
1085       hash_unset (vni_by_dp_table[0], dp_id);
1086     }
1087   return 0;
1088
1089 }
1090
1091 /* return 0 if the two locator sets are identical 1 otherwise */
1092 static u8
1093 compare_locators (lisp_cp_main_t * lcm, u32 * old_ls_indexes,
1094                   locator_t * new_locators)
1095 {
1096   u32 i, old_li;
1097   locator_t *old_loc, *new_loc;
1098
1099   if (vec_len (old_ls_indexes) != vec_len (new_locators))
1100     return 1;
1101
1102   for (i = 0; i < vec_len (new_locators); i++)
1103     {
1104       old_li = vec_elt (old_ls_indexes, i);
1105       old_loc = pool_elt_at_index (lcm->locator_pool, old_li);
1106
1107       new_loc = vec_elt_at_index (new_locators, i);
1108
1109       if (locator_cmp (old_loc, new_loc))
1110         return 1;
1111     }
1112   return 0;
1113 }
1114
1115 typedef struct
1116 {
1117   u8 is_negative;
1118   void *lcm;
1119   gid_address_t *eids_to_be_deleted;
1120 } remove_mapping_args_t;
1121
1122 /**
1123  * Callback invoked when a sub-prefix is found
1124  */
1125 static void
1126 remove_mapping_if_needed (u32 mi, void *arg)
1127 {
1128   u8 delete = 0;
1129   remove_mapping_args_t *a = arg;
1130   lisp_cp_main_t *lcm = a->lcm;
1131   mapping_t *m;
1132   locator_set_t *ls;
1133
1134   m = pool_elt_at_index (lcm->mapping_pool, mi);
1135   if (!m)
1136     return;
1137
1138   ls = pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
1139
1140   if (a->is_negative)
1141     {
1142       if (0 != vec_len (ls->locator_indices))
1143         delete = 1;
1144     }
1145   else
1146     {
1147       if (0 == vec_len (ls->locator_indices))
1148         delete = 1;
1149     }
1150
1151   if (delete)
1152     vec_add1 (a->eids_to_be_deleted, m->eid);
1153 }
1154
1155 /**
1156  * This function searches map cache and looks for IP prefixes that are subset
1157  * of the provided one. If such prefix is found depending on 'is_negative'
1158  * it does follows:
1159  *
1160  * 1) if is_negative is true and found prefix points to positive mapping,
1161  *    then the mapping is removed
1162  * 2) if is_negative is false and found prefix points to negative mapping,
1163  *    then the mapping is removed
1164  */
1165 static void
1166 remove_overlapping_sub_prefixes (lisp_cp_main_t * lcm, gid_address_t * eid,
1167                                  u8 is_negative)
1168 {
1169   gid_address_t *e;
1170   remove_mapping_args_t a;
1171
1172   clib_memset (&a, 0, sizeof (a));
1173
1174   /* do this only in src/dst mode ... */
1175   if (MR_MODE_SRC_DST != lcm->map_request_mode)
1176     return;
1177
1178   /* ... and  only for IP prefix */
1179   if (GID_ADDR_SRC_DST != gid_address_type (eid)
1180       || (FID_ADDR_IP_PREF != gid_address_sd_dst_type (eid)))
1181     return;
1182
1183   a.is_negative = is_negative;
1184   a.lcm = lcm;
1185
1186   gid_dict_foreach_subprefix (&lcm->mapping_index_by_gid, eid,
1187                               remove_mapping_if_needed, &a);
1188
1189   vec_foreach (e, a.eids_to_be_deleted)
1190   {
1191     vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args;
1192
1193     clib_memset (adj_args, 0, sizeof (adj_args[0]));
1194     gid_address_copy (&adj_args->reid, e);
1195     adj_args->is_add = 0;
1196     if (vnet_lisp_add_del_adjacency (adj_args))
1197       clib_warning ("failed to del adjacency!");
1198
1199     vnet_lisp_del_mapping (e, NULL);
1200   }
1201
1202   vec_free (a.eids_to_be_deleted);
1203 }
1204
1205 static int
1206 is_local_ip (lisp_cp_main_t * lcm, ip_address_t * addr)
1207 {
1208   fib_node_index_t fei;
1209   fib_prefix_t prefix;
1210   fib_entry_flag_t flags;
1211
1212   ip_address_to_fib_prefix (addr, &prefix);
1213
1214   fei = fib_table_lookup (0, &prefix);
1215   flags = fib_entry_get_flags (fei);
1216   return (FIB_ENTRY_FLAG_LOCAL & flags);
1217 }
1218
1219 /**
1220  * Adds/updates mapping. Does not program forwarding.
1221  *
1222  * @param a parameters of the new mapping
1223  * @param rlocs vector of remote locators
1224  * @param res_map_index index of the newly created mapping
1225  * @param locators_changed indicator if locators were updated in the mapping
1226  * @return return code
1227  */
1228 int
1229 vnet_lisp_add_mapping (vnet_lisp_add_del_mapping_args_t * a,
1230                        locator_t * rlocs,
1231                        u32 * res_map_index, u8 * is_updated)
1232 {
1233   vnet_lisp_add_del_locator_set_args_t _ls_args, *ls_args = &_ls_args;
1234   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1235   u32 mi, ls_index = 0, dst_map_index;
1236   mapping_t *old_map;
1237   locator_t *loc;
1238
1239   if (vnet_lisp_enable_disable_status () == 0)
1240     {
1241       clib_warning ("LISP is disabled!");
1242       return VNET_API_ERROR_LISP_DISABLED;
1243     }
1244
1245   if (res_map_index)
1246     res_map_index[0] = ~0;
1247   if (is_updated)
1248     is_updated[0] = 0;
1249
1250   clib_memset (ls_args, 0, sizeof (ls_args[0]));
1251
1252   ls_args->locators = rlocs;
1253   mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &a->eid);
1254   old_map = ((u32) ~ 0 != mi) ? pool_elt_at_index (lcm->mapping_pool, mi) : 0;
1255
1256   /* check if none of the locators match locally configured address */
1257   vec_foreach (loc, rlocs)
1258   {
1259     ip_prefix_t *p = &gid_address_ippref (&loc->address);
1260     if (is_local_ip (lcm, &ip_prefix_addr (p)))
1261       {
1262         clib_warning ("RLOC %U matches a local address!",
1263                       format_gid_address, &loc->address);
1264         return VNET_API_ERROR_LISP_RLOC_LOCAL;
1265       }
1266   }
1267
1268   /* overwrite: if mapping already exists, decide if locators should be
1269    * updated and be done */
1270   if (old_map && gid_address_cmp (&old_map->eid, &a->eid) == 0)
1271     {
1272       if (!a->is_static && (old_map->is_static || old_map->local))
1273         {
1274           /* do not overwrite local or static remote mappings */
1275           clib_warning ("mapping %U rejected due to collision with local "
1276                         "or static remote mapping!", format_gid_address,
1277                         &a->eid);
1278           return 0;
1279         }
1280
1281       locator_set_t *old_ls;
1282
1283       /* update mapping attributes */
1284       old_map->action = a->action;
1285       if (old_map->action != a->action && NULL != is_updated)
1286         is_updated[0] = 1;
1287
1288       old_map->authoritative = a->authoritative;
1289       old_map->ttl = a->ttl;
1290
1291       old_ls = pool_elt_at_index (lcm->locator_set_pool,
1292                                   old_map->locator_set_index);
1293       if (compare_locators (lcm, old_ls->locator_indices, ls_args->locators))
1294         {
1295           /* set locator-set index to overwrite */
1296           ls_args->is_add = 1;
1297           ls_args->index = old_map->locator_set_index;
1298           vnet_lisp_add_del_locator_set (ls_args, 0);
1299           if (is_updated)
1300             is_updated[0] = 1;
1301         }
1302       if (res_map_index)
1303         res_map_index[0] = mi;
1304     }
1305   /* new mapping */
1306   else
1307     {
1308       if (is_updated)
1309         is_updated[0] = 1;
1310       remove_overlapping_sub_prefixes (lcm, &a->eid, 0 == ls_args->locators);
1311
1312       ls_args->is_add = 1;
1313       ls_args->index = ~0;
1314
1315       vnet_lisp_add_del_locator_set (ls_args, &ls_index);
1316
1317       /* add mapping */
1318       a->is_add = 1;
1319       a->locator_set_index = ls_index;
1320       vnet_lisp_map_cache_add_del (a, &dst_map_index);
1321
1322       if (res_map_index)
1323         res_map_index[0] = dst_map_index;
1324     }
1325
1326   /* success */
1327   return 0;
1328 }
1329
1330 /**
1331  * Removes a mapping. Does not program forwarding.
1332  *
1333  * @param eid end-host identifier
1334  * @param res_map_index index of the removed mapping
1335  * @return return code
1336  */
1337 int
1338 vnet_lisp_del_mapping (gid_address_t * eid, u32 * res_map_index)
1339 {
1340   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1341   vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
1342   vnet_lisp_add_del_locator_set_args_t _ls_args, *ls_args = &_ls_args;
1343   mapping_t *old_map;
1344   u32 mi;
1345
1346   clib_memset (ls_args, 0, sizeof (ls_args[0]));
1347   clib_memset (m_args, 0, sizeof (m_args[0]));
1348   if (res_map_index)
1349     res_map_index[0] = ~0;
1350
1351   mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid);
1352   old_map = ((u32) ~ 0 != mi) ? pool_elt_at_index (lcm->mapping_pool, mi) : 0;
1353
1354   if (old_map == 0 || gid_address_cmp (&old_map->eid, eid) != 0)
1355     {
1356       clib_warning ("cannot delete mapping for eid %U",
1357                     format_gid_address, eid);
1358       return -1;
1359     }
1360
1361   m_args->is_add = 0;
1362   gid_address_copy (&m_args->eid, eid);
1363   m_args->locator_set_index = old_map->locator_set_index;
1364
1365   ls_args->is_add = 0;
1366   ls_args->index = old_map->locator_set_index;
1367
1368   /* delete timer associated to the mapping if any */
1369   if (old_map->timer_set)
1370     TW (tw_timer_stop) (&lcm->wheel, old_map->timer_handle);
1371
1372   /* delete locator set */
1373   vnet_lisp_add_del_locator_set (ls_args, 0);
1374
1375   /* delete mapping associated from map-cache */
1376   vnet_lisp_map_cache_add_del (m_args, 0);
1377
1378   /* return old mapping index */
1379   if (res_map_index)
1380     res_map_index[0] = mi;
1381
1382   /* success */
1383   return 0;
1384 }
1385
1386 int
1387 vnet_lisp_clear_all_remote_adjacencies (void)
1388 {
1389   int rv = 0;
1390   u32 mi, *map_indices = 0, *map_indexp;
1391   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1392   vnet_lisp_add_del_mapping_args_t _dm_args, *dm_args = &_dm_args;
1393   vnet_lisp_add_del_locator_set_args_t _ls, *ls = &_ls;
1394
1395   /* *INDENT-OFF* */
1396   pool_foreach_index (mi, lcm->mapping_pool)
1397    {
1398     vec_add1 (map_indices, mi);
1399   }
1400   /* *INDENT-ON* */
1401
1402   vec_foreach (map_indexp, map_indices)
1403   {
1404     mapping_t *map = pool_elt_at_index (lcm->mapping_pool, map_indexp[0]);
1405     if (!map->local)
1406       {
1407         dp_del_fwd_entry (lcm, map_indexp[0]);
1408
1409         dm_args->is_add = 0;
1410         gid_address_copy (&dm_args->eid, &map->eid);
1411         dm_args->locator_set_index = map->locator_set_index;
1412
1413         /* delete mapping associated to fwd entry */
1414         vnet_lisp_map_cache_add_del (dm_args, 0);
1415
1416         ls->is_add = 0;
1417         ls->local = 0;
1418         ls->index = map->locator_set_index;
1419         /* delete locator set */
1420         rv = vnet_lisp_add_del_locator_set (ls, 0);
1421         if (rv != 0)
1422           goto cleanup;
1423       }
1424   }
1425
1426 cleanup:
1427   if (map_indices)
1428     vec_free (map_indices);
1429   return rv;
1430 }
1431
1432 /**
1433  * Adds adjacency or removes forwarding entry associated to remote mapping.
1434  * Note that adjacencies are not stored, they only result in forwarding entries
1435  * being created.
1436  */
1437 int
1438 vnet_lisp_add_del_adjacency (vnet_lisp_add_del_adjacency_args_t * a)
1439 {
1440   lisp_cp_main_t *lcm = &lisp_control_main;
1441   u32 local_mi, remote_mi = ~0;
1442
1443   if (vnet_lisp_enable_disable_status () == 0)
1444     {
1445       clib_warning ("LISP is disabled!");
1446       return VNET_API_ERROR_LISP_DISABLED;
1447     }
1448
1449   remote_mi = gid_dictionary_sd_lookup (&lcm->mapping_index_by_gid,
1450                                         &a->reid, &a->leid);
1451   if (GID_LOOKUP_MISS == remote_mi)
1452     {
1453       clib_warning ("Remote eid %U not found. Cannot add adjacency!",
1454                     format_gid_address, &a->reid);
1455
1456       return -1;
1457     }
1458
1459   if (a->is_add)
1460     {
1461       /* check if source eid has an associated mapping. If pitr mode is on,
1462        * just use the pitr's mapping */
1463       if (lcm->flags & LISP_FLAG_PITR_MODE)
1464         {
1465           if (lcm->pitr_map_index != ~0)
1466             {
1467               local_mi = lcm->pitr_map_index;
1468             }
1469           else
1470             {
1471               /* PITR mode is on, but no mapping is configured */
1472               return -1;
1473             }
1474         }
1475       else
1476         {
1477           if (gid_address_type (&a->reid) == GID_ADDR_NSH)
1478             {
1479               if (lcm->nsh_map_index == ~0)
1480                 local_mi = GID_LOOKUP_MISS;
1481               else
1482                 local_mi = lcm->nsh_map_index;
1483             }
1484           else
1485             {
1486               local_mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid,
1487                                                 &a->leid);
1488             }
1489         }
1490
1491       if (GID_LOOKUP_MISS == local_mi)
1492         {
1493           clib_warning ("Local eid %U not found. Cannot add adjacency!",
1494                         format_gid_address, &a->leid);
1495
1496           return -1;
1497         }
1498
1499       /* update forwarding */
1500       dp_add_fwd_entry (lcm, local_mi, remote_mi);
1501     }
1502   else
1503     dp_del_fwd_entry (lcm, remote_mi);
1504
1505   return 0;
1506 }
1507
1508 int
1509 vnet_lisp_set_map_request_mode (u8 mode)
1510 {
1511   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1512
1513   if (vnet_lisp_enable_disable_status () == 0)
1514     {
1515       clib_warning ("LISP is disabled!");
1516       return VNET_API_ERROR_LISP_DISABLED;
1517     }
1518
1519   if (mode >= _MR_MODE_MAX)
1520     {
1521       clib_warning ("Invalid LISP map request mode %d!", mode);
1522       return VNET_API_ERROR_INVALID_ARGUMENT;
1523     }
1524
1525   lcm->map_request_mode = mode;
1526   return 0;
1527 }
1528
1529 int
1530 vnet_lisp_nsh_set_locator_set (u8 * locator_set_name, u8 is_add)
1531 {
1532   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1533   lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
1534   u32 locator_set_index = ~0;
1535   mapping_t *m;
1536   uword *p;
1537
1538   if (vnet_lisp_enable_disable_status () == 0)
1539     {
1540       clib_warning ("LISP is disabled!");
1541       return VNET_API_ERROR_LISP_DISABLED;
1542     }
1543
1544   if (is_add)
1545     {
1546       if (lcm->nsh_map_index == (u32) ~ 0)
1547         {
1548           p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name);
1549           if (!p)
1550             {
1551               clib_warning ("locator-set %v doesn't exist", locator_set_name);
1552               return -1;
1553             }
1554           locator_set_index = p[0];
1555
1556           pool_get (lcm->mapping_pool, m);
1557           clib_memset (m, 0, sizeof *m);
1558           m->locator_set_index = locator_set_index;
1559           m->local = 1;
1560           m->nsh_set = 1;
1561           lcm->nsh_map_index = m - lcm->mapping_pool;
1562
1563           if (~0 == vnet_lisp_gpe_add_nsh_iface (lgm))
1564             return -1;
1565         }
1566     }
1567   else
1568     {
1569       if (lcm->nsh_map_index != (u32) ~ 0)
1570         {
1571           /* remove NSH mapping */
1572           pool_put_index (lcm->mapping_pool, lcm->nsh_map_index);
1573           lcm->nsh_map_index = ~0;
1574           vnet_lisp_gpe_del_nsh_iface (lgm);
1575         }
1576     }
1577   return 0;
1578 }
1579
1580 int
1581 vnet_lisp_pitr_set_locator_set (u8 * locator_set_name, u8 is_add)
1582 {
1583   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1584   u32 locator_set_index = ~0;
1585   mapping_t *m;
1586   uword *p;
1587
1588   if (vnet_lisp_enable_disable_status () == 0)
1589     {
1590       clib_warning ("LISP is disabled!");
1591       return VNET_API_ERROR_LISP_DISABLED;
1592     }
1593
1594   p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name);
1595   if (!p)
1596     {
1597       clib_warning ("locator-set %v doesn't exist", locator_set_name);
1598       return -1;
1599     }
1600   locator_set_index = p[0];
1601
1602   if (is_add)
1603     {
1604       pool_get (lcm->mapping_pool, m);
1605       m->locator_set_index = locator_set_index;
1606       m->local = 1;
1607       m->pitr_set = 1;
1608       lcm->pitr_map_index = m - lcm->mapping_pool;
1609     }
1610   else
1611     {
1612       /* remove pitr mapping */
1613       pool_put_index (lcm->mapping_pool, lcm->pitr_map_index);
1614       lcm->pitr_map_index = ~0;
1615     }
1616   return 0;
1617 }
1618
1619 int
1620 vnet_lisp_map_register_fallback_threshold_set (u32 value)
1621 {
1622   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1623   if (0 == value)
1624     {
1625       return VNET_API_ERROR_INVALID_ARGUMENT;
1626     }
1627
1628   lcm->max_expired_map_registers = value;
1629   return 0;
1630 }
1631
1632 u32
1633 vnet_lisp_map_register_fallback_threshold_get (void)
1634 {
1635   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1636   return lcm->max_expired_map_registers;
1637 }
1638
1639 /**
1640  * Configure Proxy-ETR
1641  *
1642  * @param ip PETR's IP address
1643  * @param is_add Flag that indicates if this is an addition or removal
1644  *
1645  * return 0 on success
1646  */
1647 int
1648 vnet_lisp_use_petr (ip_address_t * ip, u8 is_add)
1649 {
1650   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1651   u32 ls_index = ~0;
1652   mapping_t *m;
1653   vnet_lisp_add_del_locator_set_args_t _ls_args, *ls_args = &_ls_args;
1654   locator_t loc;
1655
1656   if (vnet_lisp_enable_disable_status () == 0)
1657     {
1658       clib_warning ("LISP is disabled!");
1659       return VNET_API_ERROR_LISP_DISABLED;
1660     }
1661
1662   clib_memset (ls_args, 0, sizeof (*ls_args));
1663
1664   if (is_add)
1665     {
1666       /* Create placeholder petr locator-set */
1667       clib_memset (&loc, 0, sizeof (loc));
1668       gid_address_from_ip (&loc.address, ip);
1669       loc.priority = 1;
1670       loc.state = loc.weight = 1;
1671       loc.local = 0;
1672
1673       ls_args->is_add = 1;
1674       ls_args->index = ~0;
1675       vec_add1 (ls_args->locators, loc);
1676       vnet_lisp_add_del_locator_set (ls_args, &ls_index);
1677
1678       /* Add petr mapping */
1679       pool_get (lcm->mapping_pool, m);
1680       m->locator_set_index = ls_index;
1681       lcm->petr_map_index = m - lcm->mapping_pool;
1682
1683       /* Enable use-petr */
1684       lcm->flags |= LISP_FLAG_USE_PETR;
1685     }
1686   else
1687     {
1688       m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index);
1689
1690       /* Remove petr locator */
1691       ls_args->is_add = 0;
1692       ls_args->index = m->locator_set_index;
1693       vnet_lisp_add_del_locator_set (ls_args, 0);
1694
1695       /* Remove petr mapping */
1696       pool_put_index (lcm->mapping_pool, lcm->petr_map_index);
1697
1698       /* Disable use-petr */
1699       lcm->flags &= ~LISP_FLAG_USE_PETR;
1700       lcm->petr_map_index = ~0;
1701     }
1702   return 0;
1703 }
1704
1705 /* cleans locator to locator-set data and removes locators not part of
1706  * any locator-set */
1707 static void
1708 clean_locator_to_locator_set (lisp_cp_main_t * lcm, u32 lsi)
1709 {
1710   u32 i, j, *loc_indexp, *ls_indexp, **ls_indexes, *to_be_deleted = 0;
1711   locator_set_t *ls = pool_elt_at_index (lcm->locator_set_pool, lsi);
1712   for (i = 0; i < vec_len (ls->locator_indices); i++)
1713     {
1714       loc_indexp = vec_elt_at_index (ls->locator_indices, i);
1715       ls_indexes = vec_elt_at_index (lcm->locator_to_locator_sets,
1716                                      loc_indexp[0]);
1717       for (j = 0; j < vec_len (ls_indexes[0]); j++)
1718         {
1719           ls_indexp = vec_elt_at_index (ls_indexes[0], j);
1720           if (ls_indexp[0] == lsi)
1721             break;
1722         }
1723
1724       /* delete index for removed locator-set */
1725       vec_del1 (ls_indexes[0], j);
1726
1727       /* delete locator if it's part of no locator-set */
1728       if (vec_len (ls_indexes[0]) == 0)
1729         {
1730           pool_put_index (lcm->locator_pool, loc_indexp[0]);
1731           vec_add1 (to_be_deleted, i);
1732         }
1733     }
1734
1735   if (to_be_deleted)
1736     {
1737       for (i = 0; i < vec_len (to_be_deleted); i++)
1738         {
1739           loc_indexp = vec_elt_at_index (to_be_deleted, i);
1740           vec_del1 (ls->locator_indices, loc_indexp[0]);
1741         }
1742       vec_free (to_be_deleted);
1743     }
1744 }
1745
1746 static inline uword *
1747 get_locator_set_index (vnet_lisp_add_del_locator_set_args_t * a, uword * p)
1748 {
1749   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1750
1751   ASSERT (a != NULL);
1752   ASSERT (p != NULL);
1753
1754   /* find locator-set */
1755   if (a->local)
1756     {
1757       ASSERT (a->name);
1758       p = hash_get_mem (lcm->locator_set_index_by_name, a->name);
1759     }
1760   else
1761     {
1762       *p = a->index;
1763     }
1764
1765   return p;
1766 }
1767
1768 static inline int
1769 is_locator_in_locator_set (lisp_cp_main_t * lcm, locator_set_t * ls,
1770                            locator_t * loc)
1771 {
1772   locator_t *itloc;
1773   u32 *locit;
1774
1775   ASSERT (ls != NULL);
1776   ASSERT (loc != NULL);
1777
1778   vec_foreach (locit, ls->locator_indices)
1779   {
1780     itloc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1781     if ((ls->local && itloc->sw_if_index == loc->sw_if_index) ||
1782         (!ls->local && !gid_address_cmp (&itloc->address, &loc->address)))
1783       {
1784         clib_warning ("Duplicate locator");
1785         return VNET_API_ERROR_VALUE_EXIST;
1786       }
1787   }
1788
1789   return 0;
1790 }
1791
1792 static void
1793 update_adjacencies_by_map_index (lisp_cp_main_t * lcm,
1794                                  u32 mapping_index, u8 remove_only)
1795 {
1796   fwd_entry_t *fwd;
1797   mapping_t *map;
1798   uword *fei = 0, *rmts_idxp = 0;
1799   u32 **rmts = 0, *remote_idxp = 0, *rmts_copy = 0;
1800   vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
1801   clib_memset (a, 0, sizeof (*a));
1802
1803   map = pool_elt_at_index (lcm->mapping_pool, mapping_index);
1804
1805   if (map->local)
1806     {
1807       rmts_idxp = hash_get (lcm->lcl_to_rmt_adjs_by_lcl_idx, mapping_index);
1808       if (rmts_idxp)
1809         {
1810           rmts =
1811             pool_elt_at_index (lcm->lcl_to_rmt_adjacencies, rmts_idxp[0]);
1812           rmts_copy = vec_dup (rmts[0]);
1813
1814           vec_foreach (remote_idxp, rmts_copy)
1815           {
1816             fei = hash_get (lcm->fwd_entry_by_mapping_index, remote_idxp[0]);
1817             if (!fei)
1818               continue;
1819
1820             fwd = pool_elt_at_index (lcm->fwd_entry_pool, fei[0]);
1821             a->is_add = 0;
1822             gid_address_copy (&a->leid, &fwd->leid);
1823             gid_address_copy (&a->reid, &fwd->reid);
1824             vnet_lisp_add_del_adjacency (a);
1825
1826             if (!remove_only)
1827               {
1828                 a->is_add = 1;
1829                 vnet_lisp_add_del_adjacency (a);
1830               }
1831           }
1832           vec_free (rmts_copy);
1833         }
1834     }
1835   else
1836     {
1837       fei = hash_get (lcm->fwd_entry_by_mapping_index, mapping_index);
1838       if (!fei)
1839         return;
1840
1841       fwd = pool_elt_at_index (lcm->fwd_entry_pool, fei[0]);
1842       a->is_add = 0;
1843       gid_address_copy (&a->leid, &fwd->leid);
1844       gid_address_copy (&a->reid, &fwd->reid);
1845       vnet_lisp_add_del_adjacency (a);
1846
1847       if (!remove_only)
1848         {
1849           a->is_add = 1;
1850           vnet_lisp_add_del_adjacency (a);
1851         }
1852     }
1853 }
1854
1855 static void
1856 update_fwd_entries_by_locator_set (lisp_cp_main_t * lcm,
1857                                    u32 ls_index, u8 remove_only)
1858 {
1859   u32 i, *map_indexp;
1860   u32 **eid_indexes;
1861
1862   if (vec_len (lcm->locator_set_to_eids) <= ls_index)
1863     return;
1864
1865   eid_indexes = vec_elt_at_index (lcm->locator_set_to_eids, ls_index);
1866
1867   for (i = 0; i < vec_len (eid_indexes[0]); i++)
1868     {
1869       map_indexp = vec_elt_at_index (eid_indexes[0], i);
1870       update_adjacencies_by_map_index (lcm, map_indexp[0], remove_only);
1871     }
1872 }
1873
1874 static inline void
1875 remove_locator_from_locator_set (locator_set_t * ls, u32 * locit,
1876                                  u32 ls_index, u32 loc_id)
1877 {
1878   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1879   u32 **ls_indexes = NULL;
1880
1881   ASSERT (ls != NULL);
1882   ASSERT (locit != NULL);
1883
1884   ls_indexes = vec_elt_at_index (lcm->locator_to_locator_sets, locit[0]);
1885   pool_put_index (lcm->locator_pool, locit[0]);
1886   vec_del1 (ls->locator_indices, loc_id);
1887   vec_del1 (ls_indexes[0], ls_index);
1888 }
1889
1890 int
1891 vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t * a,
1892                            locator_set_t * ls, u32 * ls_result)
1893 {
1894   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1895   locator_t *loc = NULL, *itloc = NULL;
1896   uword _p = (u32) ~ 0, *p = &_p;
1897   u32 loc_index = ~0, ls_index = ~0, *locit = NULL, **ls_indexes = NULL;
1898   u32 loc_id = ~0;
1899   int ret = 0;
1900
1901   ASSERT (a != NULL);
1902
1903   if (vnet_lisp_enable_disable_status () == 0)
1904     {
1905       clib_warning ("LISP is disabled!");
1906       return VNET_API_ERROR_LISP_DISABLED;
1907     }
1908
1909   p = get_locator_set_index (a, p);
1910   if (!p)
1911     {
1912       clib_warning ("locator-set %v doesn't exist", a->name);
1913       return VNET_API_ERROR_INVALID_ARGUMENT;
1914     }
1915
1916   if (ls == 0)
1917     {
1918       ls = pool_elt_at_index (lcm->locator_set_pool, p[0]);
1919       if (!ls)
1920         {
1921           clib_warning ("locator-set %d to be overwritten doesn't exist!",
1922                         p[0]);
1923           return VNET_API_ERROR_INVALID_ARGUMENT;
1924         }
1925     }
1926
1927   if (a->is_add)
1928     {
1929       if (ls_result)
1930         ls_result[0] = p[0];
1931
1932       /* allocate locators */
1933       vec_foreach (itloc, a->locators)
1934       {
1935         ret = is_locator_in_locator_set (lcm, ls, itloc);
1936         if (0 != ret)
1937           {
1938             return ret;
1939           }
1940
1941         pool_get (lcm->locator_pool, loc);
1942         loc[0] = itloc[0];
1943         loc_index = loc - lcm->locator_pool;
1944
1945         vec_add1 (ls->locator_indices, loc_index);
1946
1947         vec_validate (lcm->locator_to_locator_sets, loc_index);
1948         ls_indexes = vec_elt_at_index (lcm->locator_to_locator_sets,
1949                                        loc_index);
1950         vec_add1 (ls_indexes[0], p[0]);
1951       }
1952     }
1953   else
1954     {
1955       ls_index = p[0];
1956       u8 removed;
1957
1958       vec_foreach (itloc, a->locators)
1959       {
1960         removed = 0;
1961         loc_id = 0;
1962         vec_foreach (locit, ls->locator_indices)
1963         {
1964           loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1965
1966           if (loc->local && loc->sw_if_index == itloc->sw_if_index)
1967             {
1968               removed = 1;
1969               remove_locator_from_locator_set (ls, locit, ls_index, loc_id);
1970             }
1971           else if (0 == loc->local &&
1972                    !gid_address_cmp (&loc->address, &itloc->address))
1973             {
1974               removed = 1;
1975               remove_locator_from_locator_set (ls, locit, ls_index, loc_id);
1976             }
1977
1978           if (removed)
1979             {
1980               /* update fwd entries using this locator in DP */
1981               update_fwd_entries_by_locator_set (lcm, ls_index,
1982                                                  vec_len (ls->locator_indices)
1983                                                  == 0);
1984             }
1985
1986           loc_id++;
1987         }
1988       }
1989     }
1990
1991   return 0;
1992 }
1993
1994 int
1995 vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
1996                                u32 * ls_result)
1997 {
1998   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1999   locator_set_t *ls;
2000   uword _p = (u32) ~ 0, *p = &_p;
2001   u32 ls_index;
2002   u32 **eid_indexes;
2003   int ret = 0;
2004
2005   if (vnet_lisp_enable_disable_status () == 0)
2006     {
2007       clib_warning ("LISP is disabled!");
2008       return VNET_API_ERROR_LISP_DISABLED;
2009     }
2010
2011   if (a->is_add)
2012     {
2013       p = get_locator_set_index (a, p);
2014
2015       /* overwrite */
2016       if (p && p[0] != (u32) ~ 0)
2017         {
2018           ls = pool_elt_at_index (lcm->locator_set_pool, p[0]);
2019           if (!ls)
2020             {
2021               clib_warning ("locator-set %d to be overwritten doesn't exist!",
2022                             p[0]);
2023               return -1;
2024             }
2025
2026           /* clean locator to locator-set vectors and remove locators if
2027            * they're not part of another locator-set */
2028           clean_locator_to_locator_set (lcm, p[0]);
2029
2030           /* remove locator indices from locator set */
2031           vec_free (ls->locator_indices);
2032
2033           ls_index = p[0];
2034
2035           if (ls_result)
2036             ls_result[0] = p[0];
2037         }
2038       /* new locator-set */
2039       else
2040         {
2041           pool_get (lcm->locator_set_pool, ls);
2042           clib_memset (ls, 0, sizeof (*ls));
2043           ls_index = ls - lcm->locator_set_pool;
2044
2045           if (a->local)
2046             {
2047               ls->name = vec_dup (a->name);
2048
2049               if (!lcm->locator_set_index_by_name)
2050                 lcm->locator_set_index_by_name =
2051                   hash_create_vec ( /* size */ 0, sizeof (ls->name[0]),
2052                                    sizeof (uword));
2053               hash_set_mem (lcm->locator_set_index_by_name, ls->name,
2054                             ls_index);
2055
2056               /* mark as local locator-set */
2057               vec_add1 (lcm->local_locator_set_indexes, ls_index);
2058             }
2059           ls->local = a->local;
2060           if (ls_result)
2061             ls_result[0] = ls_index;
2062         }
2063
2064       ret = vnet_lisp_add_del_locator (a, ls, NULL);
2065       if (0 != ret)
2066         {
2067           return ret;
2068         }
2069     }
2070   else
2071     {
2072       p = get_locator_set_index (a, p);
2073       if (!p)
2074         {
2075           clib_warning ("locator-set %v doesn't exists", a->name);
2076           return -1;
2077         }
2078
2079       ls = pool_elt_at_index (lcm->locator_set_pool, p[0]);
2080       if (!ls)
2081         {
2082           clib_warning ("locator-set with index %d doesn't exists", p[0]);
2083           return -1;
2084         }
2085
2086       if (lcm->mreq_itr_rlocs == p[0])
2087         {
2088           clib_warning ("Can't delete the locator-set used to constrain "
2089                         "the itr-rlocs in map-requests!");
2090           return -1;
2091         }
2092
2093       if (vec_len (lcm->locator_set_to_eids) != 0)
2094         {
2095           eid_indexes = vec_elt_at_index (lcm->locator_set_to_eids, p[0]);
2096           if (vec_len (eid_indexes[0]) != 0)
2097             {
2098               clib_warning
2099                 ("Can't delete a locator that supports a mapping!");
2100               return -1;
2101             }
2102         }
2103
2104       /* clean locator to locator-sets data */
2105       clean_locator_to_locator_set (lcm, p[0]);
2106
2107       if (ls->local)
2108         {
2109           u32 it, lsi;
2110
2111           vec_foreach_index (it, lcm->local_locator_set_indexes)
2112           {
2113             lsi = vec_elt (lcm->local_locator_set_indexes, it);
2114             if (lsi == p[0])
2115               {
2116                 vec_del1 (lcm->local_locator_set_indexes, it);
2117                 break;
2118               }
2119           }
2120           hash_unset_mem (lcm->locator_set_index_by_name, ls->name);
2121         }
2122       vec_free (ls->name);
2123       vec_free (ls->locator_indices);
2124       pool_put (lcm->locator_set_pool, ls);
2125     }
2126   return 0;
2127 }
2128
2129 int
2130 vnet_lisp_rloc_probe_enable_disable (u8 is_enable)
2131 {
2132   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2133
2134   lcm->rloc_probing = is_enable;
2135   return 0;
2136 }
2137
2138 int
2139 vnet_lisp_map_register_enable_disable (u8 is_enable)
2140 {
2141   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2142
2143   lcm->map_registering = is_enable;
2144   return 0;
2145 }
2146
2147 static void
2148 lisp_cp_register_dst_port (vlib_main_t * vm)
2149 {
2150   udp_register_dst_port (vm, UDP_DST_PORT_lisp_cp,
2151                          lisp_cp_input_node.index, 1 /* is_ip4 */ );
2152   udp_register_dst_port (vm, UDP_DST_PORT_lisp_cp6,
2153                          lisp_cp_input_node.index, 0 /* is_ip4 */ );
2154 }
2155
2156 static void
2157 lisp_cp_unregister_dst_port (vlib_main_t * vm)
2158 {
2159   udp_unregister_dst_port (vm, UDP_DST_PORT_lisp_cp, 0 /* is_ip4 */ );
2160   udp_unregister_dst_port (vm, UDP_DST_PORT_lisp_cp6, 1 /* is_ip4 */ );
2161 }
2162
2163 /**
2164  * lisp_cp_enable_l2_l3_ifaces
2165  *
2166  * Enable all l2 and l3 ifaces
2167  */
2168 static void
2169 lisp_cp_enable_l2_l3_ifaces (lisp_cp_main_t * lcm, u8 with_default_route)
2170 {
2171   u32 vni, dp_table;
2172
2173   /* *INDENT-OFF* */
2174   hash_foreach(vni, dp_table, lcm->table_id_by_vni, ({
2175     dp_add_del_iface(lcm, vni, /* is_l2 */ 0, /* is_add */1,
2176                      with_default_route);
2177   }));
2178   hash_foreach(vni, dp_table, lcm->bd_id_by_vni, ({
2179     dp_add_del_iface(lcm, vni, /* is_l2 */ 1, 1,
2180                      with_default_route);
2181   }));
2182   /* *INDENT-ON* */
2183 }
2184
2185 static void
2186 lisp_cp_disable_l2_l3_ifaces (lisp_cp_main_t * lcm)
2187 {
2188   u32 **rmts;
2189
2190   /* clear interface table */
2191   hash_free (lcm->fwd_entry_by_mapping_index);
2192   pool_free (lcm->fwd_entry_pool);
2193   /* Clear state tracking rmt-lcl fwd entries */
2194   /* *INDENT-OFF* */
2195   pool_foreach (rmts, lcm->lcl_to_rmt_adjacencies)
2196   {
2197     vec_free(rmts[0]);
2198   }
2199   /* *INDENT-ON* */
2200   hash_free (lcm->lcl_to_rmt_adjs_by_lcl_idx);
2201   pool_free (lcm->lcl_to_rmt_adjacencies);
2202 }
2203
2204 clib_error_t *
2205 vnet_lisp_enable_disable (u8 is_enable)
2206 {
2207   clib_error_t *error = 0;
2208   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2209   vnet_lisp_gpe_enable_disable_args_t _a, *a = &_a;
2210
2211   a->is_en = is_enable;
2212   error = vnet_lisp_gpe_enable_disable (a);
2213   if (error)
2214     {
2215       return clib_error_return (0, "failed to %s data-plane!",
2216                                 a->is_en ? "enable" : "disable");
2217     }
2218
2219   /* decide what to do based on mode */
2220
2221   if (lcm->flags & LISP_FLAG_XTR_MODE)
2222     {
2223       if (is_enable)
2224         {
2225           lisp_cp_register_dst_port (lcm->vlib_main);
2226           lisp_cp_enable_l2_l3_ifaces (lcm, 1 /* with_default_route */ );
2227         }
2228       else
2229         {
2230           lisp_cp_unregister_dst_port (lcm->vlib_main);
2231           lisp_cp_disable_l2_l3_ifaces (lcm);
2232         }
2233     }
2234
2235   if (lcm->flags & LISP_FLAG_PETR_MODE)
2236     {
2237       /* if in xTR mode, the LISP ports were already (un)registered above */
2238       if (!(lcm->flags & LISP_FLAG_XTR_MODE))
2239         {
2240           if (is_enable)
2241             lisp_cp_register_dst_port (lcm->vlib_main);
2242           else
2243             lisp_cp_unregister_dst_port (lcm->vlib_main);
2244         }
2245     }
2246
2247   if (lcm->flags & LISP_FLAG_PITR_MODE)
2248     {
2249       if (is_enable)
2250         {
2251           /* install interfaces, but no default routes */
2252           lisp_cp_enable_l2_l3_ifaces (lcm, 0 /* with_default_route */ );
2253         }
2254       else
2255         {
2256           lisp_cp_disable_l2_l3_ifaces (lcm);
2257         }
2258     }
2259
2260   if (is_enable)
2261     vnet_lisp_create_retry_process (lcm);
2262
2263   /* update global flag */
2264   lcm->is_enabled = is_enable;
2265
2266   return 0;
2267 }
2268
2269 u8
2270 vnet_lisp_enable_disable_status (void)
2271 {
2272   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2273   return lcm->is_enabled;
2274 }
2275
2276 int
2277 vnet_lisp_add_del_map_resolver (vnet_lisp_add_del_map_resolver_args_t * a)
2278 {
2279   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2280   u32 i;
2281   lisp_msmr_t _mr, *mr = &_mr;
2282
2283   if (vnet_lisp_enable_disable_status () == 0)
2284     {
2285       clib_warning ("LISP is disabled!");
2286       return VNET_API_ERROR_LISP_DISABLED;
2287     }
2288
2289   if (a->is_add)
2290     {
2291
2292       if (get_map_resolver (&a->address))
2293         {
2294           clib_warning ("map-resolver %U already exists!", format_ip_address,
2295                         &a->address);
2296           return -1;
2297         }
2298
2299       clib_memset (mr, 0, sizeof (*mr));
2300       ip_address_copy (&mr->address, &a->address);
2301       vec_add1 (lcm->map_resolvers, *mr);
2302
2303       if (vec_len (lcm->map_resolvers) == 1)
2304         lcm->do_map_resolver_election = 1;
2305     }
2306   else
2307     {
2308       for (i = 0; i < vec_len (lcm->map_resolvers); i++)
2309         {
2310           mr = vec_elt_at_index (lcm->map_resolvers, i);
2311           if (!ip_address_cmp (&mr->address, &a->address))
2312             {
2313               if (!ip_address_cmp (&mr->address, &lcm->active_map_resolver))
2314                 lcm->do_map_resolver_election = 1;
2315
2316               vec_del1 (lcm->map_resolvers, i);
2317               break;
2318             }
2319         }
2320     }
2321   return 0;
2322 }
2323
2324 int
2325 vnet_lisp_map_register_set_ttl (u32 ttl)
2326 {
2327   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2328   lcm->map_register_ttl = ttl;
2329   return 0;
2330 }
2331
2332 u32
2333 vnet_lisp_map_register_get_ttl (void)
2334 {
2335   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2336   return lcm->map_register_ttl;
2337 }
2338
2339 int
2340 vnet_lisp_add_del_mreq_itr_rlocs (vnet_lisp_add_del_mreq_itr_rloc_args_t * a)
2341 {
2342   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2343   uword *p = 0;
2344
2345   if (vnet_lisp_enable_disable_status () == 0)
2346     {
2347       clib_warning ("LISP is disabled!");
2348       return VNET_API_ERROR_LISP_DISABLED;
2349     }
2350
2351   if (a->is_add)
2352     {
2353       p = hash_get_mem (lcm->locator_set_index_by_name, a->locator_set_name);
2354       if (!p)
2355         {
2356           clib_warning ("locator-set %v doesn't exist", a->locator_set_name);
2357           return VNET_API_ERROR_INVALID_ARGUMENT;
2358         }
2359
2360       lcm->mreq_itr_rlocs = p[0];
2361     }
2362   else
2363     {
2364       lcm->mreq_itr_rlocs = ~0;
2365     }
2366
2367   return 0;
2368 }
2369
2370 /* Statistics (not really errors) */
2371 #define foreach_lisp_cp_lookup_error           \
2372 _(DROP, "drop")                                \
2373 _(MAP_REQUESTS_SENT, "map-request sent")       \
2374 _(ARP_REPLY_TX, "ARP replies sent")            \
2375 _(NDP_NEIGHBOR_ADVERTISEMENT_TX,               \
2376   "neighbor advertisement sent")
2377
2378 static char *lisp_cp_lookup_error_strings[] = {
2379 #define _(sym,string) string,
2380   foreach_lisp_cp_lookup_error
2381 #undef _
2382 };
2383
2384 typedef enum
2385 {
2386 #define _(sym,str) LISP_CP_LOOKUP_ERROR_##sym,
2387   foreach_lisp_cp_lookup_error
2388 #undef _
2389     LISP_CP_LOOKUP_N_ERROR,
2390 } lisp_cp_lookup_error_t;
2391
2392 typedef enum
2393 {
2394   LISP_CP_LOOKUP_NEXT_DROP,
2395   LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX,
2396   LISP_CP_LOOKUP_N_NEXT,
2397 } lisp_cp_lookup_next_t;
2398
2399 typedef struct
2400 {
2401   gid_address_t dst_eid;
2402   ip_address_t map_resolver_ip;
2403 } lisp_cp_lookup_trace_t;
2404
2405 u8 *
2406 format_lisp_cp_lookup_trace (u8 * s, va_list * args)
2407 {
2408   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
2409   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
2410   lisp_cp_lookup_trace_t *t = va_arg (*args, lisp_cp_lookup_trace_t *);
2411
2412   s = format (s, "LISP-CP-LOOKUP: map-resolver: %U destination eid %U",
2413               format_ip_address, &t->map_resolver_ip, format_gid_address,
2414               &t->dst_eid);
2415   return s;
2416 }
2417
2418 int
2419 get_mr_and_local_iface_ip (lisp_cp_main_t * lcm, ip_address_t * mr_ip,
2420                            ip_address_t * sloc)
2421 {
2422   lisp_msmr_t *mrit;
2423   ip_address_t *a;
2424
2425   if (vec_len (lcm->map_resolvers) == 0)
2426     {
2427       clib_warning ("No map-resolver configured");
2428       return 0;
2429     }
2430
2431   /* find the first mr ip we have a route to and the ip of the
2432    * iface that has a route to it */
2433   vec_foreach (mrit, lcm->map_resolvers)
2434   {
2435     a = &mrit->address;
2436     if (0 != ip_fib_get_first_egress_ip_for_dst (lcm, a, sloc))
2437       {
2438         ip_address_copy (mr_ip, a);
2439
2440         /* also update globals */
2441         return 1;
2442       }
2443   }
2444
2445   clib_warning ("Can't find map-resolver and local interface ip!");
2446   return 0;
2447 }
2448
2449 static gid_address_t *
2450 build_itr_rloc_list (lisp_cp_main_t * lcm, locator_set_t * loc_set)
2451 {
2452   void *addr;
2453   u32 i;
2454   locator_t *loc;
2455   u32 *loc_indexp;
2456   ip_interface_address_t *ia = 0;
2457   gid_address_t gid_data, *gid = &gid_data;
2458   gid_address_t *rlocs = 0;
2459   ip_prefix_t *ippref = &gid_address_ippref (gid);
2460   ip_address_t *rloc = &ip_prefix_addr (ippref);
2461
2462   clib_memset (gid, 0, sizeof (gid[0]));
2463   gid_address_type (gid) = GID_ADDR_IP_PREFIX;
2464   for (i = 0; i < vec_len (loc_set->locator_indices); i++)
2465     {
2466       loc_indexp = vec_elt_at_index (loc_set->locator_indices, i);
2467       loc = pool_elt_at_index (lcm->locator_pool, loc_indexp[0]);
2468
2469       /* Add ipv4 locators first TODO sort them */
2470
2471       /* *INDENT-OFF* */
2472       foreach_ip_interface_address (&lcm->im4->lookup_main, ia,
2473                                     loc->sw_if_index, 1 /* unnumbered */,
2474       ({
2475         addr = ip_interface_address_get_address (&lcm->im4->lookup_main, ia);
2476         ip_address_set (rloc, addr, AF_IP4);
2477         ip_prefix_len (ippref) = 32;
2478         ip_prefix_normalize (ippref);
2479         vec_add1 (rlocs, gid[0]);
2480       }));
2481
2482       /* Add ipv6 locators */
2483       foreach_ip_interface_address (&lcm->im6->lookup_main, ia,
2484                                     loc->sw_if_index, 1 /* unnumbered */,
2485       ({
2486         addr = ip_interface_address_get_address (&lcm->im6->lookup_main, ia);
2487         ip_address_set (rloc, addr, AF_IP6);
2488         ip_prefix_len (ippref) = 128;
2489         ip_prefix_normalize (ippref);
2490         vec_add1 (rlocs, gid[0]);
2491       }));
2492       /* *INDENT-ON* */
2493
2494     }
2495   return rlocs;
2496 }
2497
2498 static vlib_buffer_t *
2499 build_map_request (lisp_cp_main_t * lcm, gid_address_t * deid,
2500                    ip_address_t * sloc, ip_address_t * rloc,
2501                    gid_address_t * itr_rlocs, u64 * nonce_res, u32 * bi_res)
2502 {
2503   vlib_buffer_t *b;
2504   u32 bi;
2505   vlib_main_t *vm = lcm->vlib_main;
2506
2507   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
2508     {
2509       clib_warning ("Can't allocate buffer for Map-Request!");
2510       return 0;
2511     }
2512
2513   b = vlib_get_buffer (vm, bi);
2514
2515   /* leave some space for the encap headers */
2516   vlib_buffer_make_headroom (b, MAX_LISP_MSG_ENCAP_LEN);
2517
2518   /* put lisp msg */
2519   lisp_msg_put_mreq (lcm, b, NULL, deid, itr_rlocs, 0 /* smr invoked */ ,
2520                      1 /* rloc probe */ , nonce_res);
2521
2522   /* push outer ip header */
2523   pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc,
2524                        rloc, 1);
2525
2526   bi_res[0] = bi;
2527
2528   return b;
2529 }
2530
2531 static vlib_buffer_t *
2532 build_encapsulated_map_request (lisp_cp_main_t * lcm,
2533                                 gid_address_t * seid, gid_address_t * deid,
2534                                 locator_set_t * loc_set, ip_address_t * mr_ip,
2535                                 ip_address_t * sloc, u8 is_smr_invoked,
2536                                 u64 * nonce_res, u32 * bi_res)
2537 {
2538   vlib_buffer_t *b;
2539   u32 bi;
2540   gid_address_t *rlocs = 0;
2541   vlib_main_t *vm = lcm->vlib_main;
2542
2543   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
2544     {
2545       clib_warning ("Can't allocate buffer for Map-Request!");
2546       return 0;
2547     }
2548
2549   b = vlib_get_buffer (vm, bi);
2550   b->flags = 0;
2551
2552   /* leave some space for the encap headers */
2553   vlib_buffer_make_headroom (b, MAX_LISP_MSG_ENCAP_LEN);
2554
2555   /* get rlocs */
2556   rlocs = build_itr_rloc_list (lcm, loc_set);
2557
2558   if (MR_MODE_SRC_DST == lcm->map_request_mode
2559       && GID_ADDR_SRC_DST != gid_address_type (deid))
2560     {
2561       gid_address_t sd;
2562       clib_memset (&sd, 0, sizeof (sd));
2563       build_src_dst (&sd, seid, deid);
2564       lisp_msg_put_mreq (lcm, b, seid, &sd, rlocs, is_smr_invoked,
2565                          0 /* rloc probe */ , nonce_res);
2566     }
2567   else
2568     {
2569       /* put lisp msg */
2570       lisp_msg_put_mreq (lcm, b, seid, deid, rlocs, is_smr_invoked,
2571                          0 /* rloc probe */ , nonce_res);
2572     }
2573
2574   /* push ecm: udp-ip-lisp */
2575   lisp_msg_push_ecm (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, seid, deid);
2576
2577   /* push outer ip header */
2578   pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc,
2579                        mr_ip, 1);
2580
2581   bi_res[0] = bi;
2582
2583   vec_free (rlocs);
2584   return b;
2585 }
2586
2587 static void
2588 reset_pending_mr_counters (pending_map_request_t * r)
2589 {
2590   r->time_to_expire = PENDING_MREQ_EXPIRATION_TIME;
2591   r->retries_num = 0;
2592 }
2593
2594 #define foreach_msmr \
2595   _(server) \
2596   _(resolver)
2597
2598 #define _(name) \
2599 static int                                                              \
2600 elect_map_ ## name (lisp_cp_main_t * lcm)                               \
2601 {                                                                       \
2602   lisp_msmr_t *mr;                                                      \
2603   vec_foreach (mr, lcm->map_ ## name ## s)                              \
2604   {                                                                     \
2605     if (!mr->is_down)                                                   \
2606       {                                                                 \
2607         ip_address_copy (&lcm->active_map_ ##name, &mr->address);       \
2608         lcm->do_map_ ## name ## _election = 0;                          \
2609         return 1;                                                       \
2610       }                                                                 \
2611   }                                                                     \
2612   return 0;                                                             \
2613 }
2614 foreach_msmr
2615 #undef _
2616   static void
2617 free_map_register_records (mapping_t * maps)
2618 {
2619   mapping_t *map;
2620   vec_foreach (map, maps) vec_free (map->locators);
2621
2622   vec_free (maps);
2623 }
2624
2625 static void
2626 add_locators (lisp_cp_main_t * lcm, mapping_t * m, u32 locator_set_index,
2627               ip_address_t * probed_loc)
2628 {
2629   u32 *li;
2630   locator_t *loc, new;
2631   ip_interface_address_t *ia = 0;
2632   void *addr;
2633   ip_address_t *new_ip = &gid_address_ip (&new.address);
2634
2635   m->locators = 0;
2636   locator_set_t *ls = pool_elt_at_index (lcm->locator_set_pool,
2637                                          locator_set_index);
2638   vec_foreach (li, ls->locator_indices)
2639   {
2640     loc = pool_elt_at_index (lcm->locator_pool, li[0]);
2641     new = loc[0];
2642     if (loc->local)
2643       {
2644           /* *INDENT-OFF* */
2645           foreach_ip_interface_address (&lcm->im4->lookup_main, ia,
2646                                         loc->sw_if_index, 1 /* unnumbered */,
2647           ({
2648             addr = ip_interface_address_get_address (&lcm->im4->lookup_main,
2649                                                      ia);
2650             ip_address_set (new_ip, addr, AF_IP4);
2651           }));
2652
2653           /* Add ipv6 locators */
2654           foreach_ip_interface_address (&lcm->im6->lookup_main, ia,
2655                                         loc->sw_if_index, 1 /* unnumbered */,
2656           ({
2657             addr = ip_interface_address_get_address (&lcm->im6->lookup_main,
2658                                                      ia);
2659             ip_address_set (new_ip, addr, AF_IP6);
2660           }));
2661           /* *INDENT-ON* */
2662
2663         if (probed_loc && ip_address_cmp (probed_loc, new_ip) == 0)
2664           new.probed = 1;
2665       }
2666     vec_add1 (m->locators, new);
2667   }
2668 }
2669
2670 static mapping_t *
2671 build_map_register_record_list (lisp_cp_main_t * lcm)
2672 {
2673   mapping_t *recs = 0, rec, *m;
2674
2675   /* *INDENT-OFF* */
2676   pool_foreach (m, lcm->mapping_pool)
2677   {
2678     /* for now build only local mappings */
2679     if (!m->local)
2680       continue;
2681
2682     rec = m[0];
2683     add_locators (lcm, &rec, m->locator_set_index, NULL);
2684     vec_add1 (recs, rec);
2685   }
2686   /* *INDENT-ON* */
2687
2688   return recs;
2689 }
2690
2691 static vnet_crypto_alg_t
2692 lisp_key_type_to_crypto_alg (lisp_key_type_t key_id)
2693 {
2694   switch (key_id)
2695     {
2696     case HMAC_SHA_1_96:
2697       return VNET_CRYPTO_ALG_HMAC_SHA1;
2698     case HMAC_SHA_256_128:
2699       return VNET_CRYPTO_ALG_HMAC_SHA256;
2700     default:
2701       clib_warning ("unsupported encryption key type: %d!", key_id);
2702       break;
2703     }
2704   return VNET_CRYPTO_ALG_NONE;
2705 }
2706
2707 static vnet_crypto_op_id_t
2708 lisp_key_type_to_crypto_op (lisp_key_type_t key_id)
2709 {
2710   switch (key_id)
2711     {
2712     case HMAC_SHA_1_96:
2713       return VNET_CRYPTO_OP_SHA1_HMAC;
2714     case HMAC_SHA_256_128:
2715       return VNET_CRYPTO_OP_SHA256_HMAC;
2716     default:
2717       clib_warning ("unsupported encryption key type: %d!", key_id);
2718       break;
2719     }
2720   return VNET_CRYPTO_OP_NONE;
2721 }
2722
2723 static int
2724 update_map_register_auth_data (map_register_hdr_t * map_reg_hdr,
2725                                lisp_key_type_t key_id, u8 * key,
2726                                u16 auth_data_len, u32 msg_len)
2727 {
2728   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
2729   MREG_KEY_ID (map_reg_hdr) = clib_host_to_net_u16 (key_id);
2730   MREG_AUTH_DATA_LEN (map_reg_hdr) = clib_host_to_net_u16 (auth_data_len);
2731   vnet_crypto_op_t _op, *op = &_op;
2732   vnet_crypto_key_index_t ki;
2733
2734   vnet_crypto_op_init (op, lisp_key_type_to_crypto_op (key_id));
2735   op->len = msg_len;
2736   op->digest = MREG_DATA (map_reg_hdr);
2737   op->src = (u8 *) map_reg_hdr;
2738   op->digest_len = 0;
2739   op->iv = 0;
2740
2741   ki = vnet_crypto_key_add (lcm->vlib_main,
2742                             lisp_key_type_to_crypto_alg (key_id), key,
2743                             vec_len (key));
2744
2745   op->key_index = ki;
2746
2747   vnet_crypto_process_ops (lcm->vlib_main, op, 1);
2748   vnet_crypto_key_del (lcm->vlib_main, ki);
2749
2750   return 0;
2751 }
2752
2753 static vlib_buffer_t *
2754 build_map_register (lisp_cp_main_t * lcm, ip_address_t * sloc,
2755                     ip_address_t * ms_ip, u64 * nonce_res, u8 want_map_notif,
2756                     mapping_t * records, lisp_key_type_t key_id, u8 * key,
2757                     u32 * bi_res)
2758 {
2759   void *map_reg_hdr;
2760   vlib_buffer_t *b;
2761   u32 bi, auth_data_len = 0, msg_len = 0;
2762   vlib_main_t *vm = lcm->vlib_main;
2763
2764   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
2765     {
2766       clib_warning ("Can't allocate buffer for Map-Register!");
2767       return 0;
2768     }
2769
2770   b = vlib_get_buffer (vm, bi);
2771
2772   /* leave some space for the encap headers */
2773   vlib_buffer_make_headroom (b, MAX_LISP_MSG_ENCAP_LEN);
2774
2775   auth_data_len = auth_data_len_by_key_id (key_id);
2776   map_reg_hdr = lisp_msg_put_map_register (b, records, want_map_notif,
2777                                            auth_data_len, nonce_res,
2778                                            &msg_len);
2779
2780   update_map_register_auth_data (map_reg_hdr, key_id, key, auth_data_len,
2781                                  msg_len);
2782
2783   /* push outer ip header */
2784   pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc,
2785                        ms_ip, 1);
2786
2787   bi_res[0] = bi;
2788   return b;
2789 }
2790
2791 #define _(name) \
2792 static int                                                              \
2793 get_egress_map_ ##name## _ip (lisp_cp_main_t * lcm, ip_address_t * ip)  \
2794 {                                                                       \
2795   lisp_msmr_t *mr;                                                      \
2796   while (lcm->do_map_ ## name ## _election                              \
2797          | (0 == ip_fib_get_first_egress_ip_for_dst                     \
2798             (lcm, &lcm->active_map_ ##name, ip)))                       \
2799     {                                                                   \
2800       if (0 == elect_map_ ## name (lcm))                                \
2801         /* all map resolvers/servers are down */                        \
2802         {                                                               \
2803           /* restart MR/MS checking by marking all of them up */        \
2804           vec_foreach (mr, lcm->map_ ## name ## s) mr->is_down = 0;     \
2805           return -1;                                                    \
2806         }                                                               \
2807     }                                                                   \
2808   return 0;                                                             \
2809 }
2810
2811 foreach_msmr
2812 #undef _
2813 /* CP output statistics */
2814 #define foreach_lisp_cp_output_error                  \
2815 _(MAP_REGISTERS_SENT, "map-registers sent")           \
2816 _(MAP_REQUESTS_SENT, "map-requests sent")             \
2817 _(RLOC_PROBES_SENT, "rloc-probes sent")
2818 static char *lisp_cp_output_error_strings[] = {
2819 #define _(sym,string) string,
2820   foreach_lisp_cp_output_error
2821 #undef _
2822 };
2823
2824 typedef enum
2825 {
2826 #define _(sym,str) LISP_CP_OUTPUT_ERROR_##sym,
2827   foreach_lisp_cp_output_error
2828 #undef _
2829     LISP_CP_OUTPUT_N_ERROR,
2830 } lisp_cp_output_error_t;
2831
2832 static uword
2833 lisp_cp_output (vlib_main_t * vm, vlib_node_runtime_t * node,
2834                 vlib_frame_t * from_frame)
2835 {
2836   return 0;
2837 }
2838
2839 /* placeholder node used only for statistics */
2840 /* *INDENT-OFF* */
2841 VLIB_REGISTER_NODE (lisp_cp_output_node) = {
2842   .function = lisp_cp_output,
2843   .name = "lisp-cp-output",
2844   .vector_size = sizeof (u32),
2845   .format_trace = format_lisp_cp_input_trace,
2846   .type = VLIB_NODE_TYPE_INTERNAL,
2847
2848   .n_errors = LISP_CP_OUTPUT_N_ERROR,
2849   .error_strings = lisp_cp_output_error_strings,
2850
2851   .n_next_nodes = LISP_CP_INPUT_N_NEXT,
2852
2853   .next_nodes = {
2854       [LISP_CP_INPUT_NEXT_DROP] = "error-drop",
2855   },
2856 };
2857 /* *INDENT-ON* */
2858
2859 static int
2860 send_rloc_probe (lisp_cp_main_t * lcm, gid_address_t * deid,
2861                  u32 local_locator_set_index, ip_address_t * sloc,
2862                  ip_address_t * rloc)
2863 {
2864   locator_set_t *ls;
2865   u32 bi;
2866   vlib_buffer_t *b;
2867   vlib_frame_t *f;
2868   u64 nonce = 0;
2869   u32 next_index, *to_next;
2870   gid_address_t *itr_rlocs;
2871
2872   ls = pool_elt_at_index (lcm->locator_set_pool, local_locator_set_index);
2873   itr_rlocs = build_itr_rloc_list (lcm, ls);
2874
2875   b = build_map_request (lcm, deid, sloc, rloc, itr_rlocs, &nonce, &bi);
2876   vec_free (itr_rlocs);
2877   if (!b)
2878     return -1;
2879
2880   vnet_buffer (b)->sw_if_index[VLIB_TX] = 0;
2881
2882   next_index = (ip_addr_version (rloc) == AF_IP4) ?
2883     ip4_lookup_node.index : ip6_lookup_node.index;
2884
2885   f = vlib_get_frame_to_node (lcm->vlib_main, next_index);
2886
2887   /* Enqueue the packet */
2888   to_next = vlib_frame_vector_args (f);
2889   to_next[0] = bi;
2890   f->n_vectors = 1;
2891   vlib_put_frame_to_node (lcm->vlib_main, next_index, f);
2892
2893   return 0;
2894 }
2895
2896 static int
2897 send_rloc_probes (lisp_cp_main_t * lcm)
2898 {
2899   u8 lprio = 0;
2900   mapping_t *lm;
2901   fwd_entry_t *e;
2902   locator_pair_t *lp;
2903   u32 si, rloc_probes_sent = 0;
2904
2905   /* *INDENT-OFF* */
2906   pool_foreach (e, lcm->fwd_entry_pool)
2907   {
2908     if (vec_len (e->locator_pairs) == 0)
2909       continue;
2910
2911     si = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &e->leid);
2912     if (~0 == si)
2913       {
2914         clib_warning ("internal error: cannot find local eid %U in "
2915                       "map-cache!", format_gid_address, &e->leid);
2916         continue;
2917       }
2918     lm = pool_elt_at_index (lcm->mapping_pool, si);
2919
2920     /* get the best (lowest) priority */
2921     lprio = e->locator_pairs[0].priority;
2922
2923     /* send rloc-probe for pair(s) with the best remote locator priority */
2924     vec_foreach (lp, e->locator_pairs)
2925       {
2926         if (lp->priority != lprio)
2927           break;
2928
2929         /* get first remote locator */
2930         send_rloc_probe (lcm, &e->reid, lm->locator_set_index, &lp->lcl_loc,
2931                          &lp->rmt_loc);
2932         rloc_probes_sent++;
2933       }
2934   }
2935   /* *INDENT-ON* */
2936
2937   vlib_node_increment_counter (vlib_get_main (), lisp_cp_output_node.index,
2938                                LISP_CP_OUTPUT_ERROR_RLOC_PROBES_SENT,
2939                                rloc_probes_sent);
2940   return 0;
2941 }
2942
2943 static int
2944 send_map_register (lisp_cp_main_t * lcm, u8 want_map_notif)
2945 {
2946   pending_map_register_t *pmr;
2947   u32 bi, map_registers_sent = 0;
2948   vlib_buffer_t *b;
2949   ip_address_t sloc;
2950   vlib_frame_t *f;
2951   u64 nonce = 0;
2952   u32 next_index, *to_next;
2953   mapping_t *records, *r, *group, *k;
2954
2955   if (get_egress_map_server_ip (lcm, &sloc) < 0)
2956     return -1;
2957
2958   records = build_map_register_record_list (lcm);
2959   if (!records)
2960     return -1;
2961
2962   vec_foreach (r, records)
2963   {
2964     u8 *key = r->key;
2965     u8 key_id = r->key_id;
2966
2967     if (!key)
2968       continue;                 /* no secret key -> map-register cannot be sent */
2969
2970     group = 0;
2971     vec_add1 (group, r[0]);
2972
2973     /* group mappings that share common key */
2974     for (k = r + 1; k < vec_end (records); k++)
2975       {
2976         if (k->key_id != r->key_id)
2977           continue;
2978
2979         if (vec_is_equal (k->key, r->key))
2980           {
2981             vec_add1 (group, k[0]);
2982             k->key = 0;         /* don't process this mapping again */
2983           }
2984       }
2985
2986     b = build_map_register (lcm, &sloc, &lcm->active_map_server, &nonce,
2987                             want_map_notif, group, key_id, key, &bi);
2988     vec_free (group);
2989     if (!b)
2990       continue;
2991
2992     vnet_buffer (b)->sw_if_index[VLIB_TX] = 0;
2993
2994     next_index = (ip_addr_version (&lcm->active_map_server) == AF_IP4) ?
2995       ip4_lookup_node.index : ip6_lookup_node.index;
2996
2997     f = vlib_get_frame_to_node (lcm->vlib_main, next_index);
2998
2999     /* Enqueue the packet */
3000     to_next = vlib_frame_vector_args (f);
3001     to_next[0] = bi;
3002     f->n_vectors = 1;
3003     vlib_put_frame_to_node (lcm->vlib_main, next_index, f);
3004     map_registers_sent++;
3005
3006     pool_get (lcm->pending_map_registers_pool, pmr);
3007     clib_memset (pmr, 0, sizeof (*pmr));
3008     pmr->time_to_expire = PENDING_MREG_EXPIRATION_TIME;
3009     hash_set (lcm->map_register_messages_by_nonce, nonce,
3010               pmr - lcm->pending_map_registers_pool);
3011   }
3012   free_map_register_records (records);
3013
3014   vlib_node_increment_counter (vlib_get_main (), lisp_cp_output_node.index,
3015                                LISP_CP_OUTPUT_ERROR_MAP_REGISTERS_SENT,
3016                                map_registers_sent);
3017
3018   return 0;
3019 }
3020
3021 #define send_encapsulated_map_request(lcm, seid, deid, smr) \
3022   _send_encapsulated_map_request(lcm, seid, deid, smr, 0)
3023
3024 #define resend_encapsulated_map_request(lcm, seid, deid, smr) \
3025   _send_encapsulated_map_request(lcm, seid, deid, smr, 1)
3026
3027 static int
3028 _send_encapsulated_map_request (lisp_cp_main_t * lcm,
3029                                 gid_address_t * seid, gid_address_t * deid,
3030                                 u8 is_smr_invoked, u8 is_resend)
3031 {
3032   u32 next_index, bi = 0, *to_next, map_index;
3033   vlib_buffer_t *b;
3034   vlib_frame_t *f;
3035   u64 nonce = 0;
3036   locator_set_t *loc_set;
3037   mapping_t *map;
3038   pending_map_request_t *pmr, *duplicate_pmr = 0;
3039   ip_address_t sloc;
3040   u32 ls_index;
3041
3042   /* if there is already a pending request remember it */
3043
3044   /* *INDENT-OFF* */
3045   pool_foreach (pmr, lcm->pending_map_requests_pool)
3046    {
3047     if (!gid_address_cmp (&pmr->src, seid)
3048         && !gid_address_cmp (&pmr->dst, deid))
3049       {
3050         duplicate_pmr = pmr;
3051         break;
3052       }
3053   }
3054   /* *INDENT-ON* */
3055
3056   if (!is_resend && duplicate_pmr)
3057     {
3058       /* don't send the request if there is a pending map request already */
3059       return 0;
3060     }
3061
3062   u8 pitr_mode = lcm->flags & LISP_FLAG_PITR_MODE;
3063
3064   /* get locator-set for seid */
3065   if (!pitr_mode && gid_address_type (deid) != GID_ADDR_NSH)
3066     {
3067       map_index = gid_dictionary_lookup (&lcm->mapping_index_by_gid, seid);
3068       if (map_index == ~0)
3069         {
3070           clib_warning ("No local mapping found in eid-table for %U!",
3071                         format_gid_address, seid);
3072           return -1;
3073         }
3074
3075       map = pool_elt_at_index (lcm->mapping_pool, map_index);
3076
3077       if (!map->local)
3078         {
3079           clib_warning
3080             ("Mapping found for src eid %U is not marked as local!",
3081              format_gid_address, seid);
3082           return -1;
3083         }
3084       ls_index = map->locator_set_index;
3085     }
3086   else
3087     {
3088       if (pitr_mode)
3089         {
3090           if (lcm->pitr_map_index != ~0)
3091             {
3092               map =
3093                 pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
3094               ls_index = map->locator_set_index;
3095             }
3096           else
3097             {
3098               return -1;
3099             }
3100         }
3101       else
3102         {
3103           if (lcm->nsh_map_index == (u32) ~ 0)
3104             {
3105               clib_warning ("No locator-set defined for NSH!");
3106               return -1;
3107             }
3108           else
3109             {
3110               map = pool_elt_at_index (lcm->mapping_pool, lcm->nsh_map_index);
3111               ls_index = map->locator_set_index;
3112             }
3113         }
3114     }
3115
3116   /* overwrite locator set if map-request itr-rlocs configured */
3117   if (~0 != lcm->mreq_itr_rlocs)
3118     {
3119       ls_index = lcm->mreq_itr_rlocs;
3120     }
3121
3122   loc_set = pool_elt_at_index (lcm->locator_set_pool, ls_index);
3123
3124   if (get_egress_map_resolver_ip (lcm, &sloc) < 0)
3125     {
3126       if (duplicate_pmr)
3127         duplicate_pmr->to_be_removed = 1;
3128       return -1;
3129     }
3130
3131   /* build the encapsulated map request */
3132   b = build_encapsulated_map_request (lcm, seid, deid, loc_set,
3133                                       &lcm->active_map_resolver,
3134                                       &sloc, is_smr_invoked, &nonce, &bi);
3135
3136   if (!b)
3137     return -1;
3138
3139   /* set fib index to default and lookup node */
3140   vnet_buffer (b)->sw_if_index[VLIB_TX] = 0;
3141   next_index = (ip_addr_version (&lcm->active_map_resolver) == AF_IP4) ?
3142     ip4_lookup_node.index : ip6_lookup_node.index;
3143
3144   f = vlib_get_frame_to_node (lcm->vlib_main, next_index);
3145
3146   /* Enqueue the packet */
3147   to_next = vlib_frame_vector_args (f);
3148   to_next[0] = bi;
3149   f->n_vectors = 1;
3150   vlib_put_frame_to_node (lcm->vlib_main, next_index, f);
3151
3152   vlib_node_increment_counter (vlib_get_main (), lisp_cp_output_node.index,
3153                                LISP_CP_OUTPUT_ERROR_MAP_REQUESTS_SENT, 1);
3154
3155   if (duplicate_pmr)
3156     /* if there is a pending request already update it */
3157     {
3158       if (clib_fifo_elts (duplicate_pmr->nonces) >= PENDING_MREQ_QUEUE_LEN)
3159         {
3160           /* remove the oldest nonce */
3161           u64 CLIB_UNUSED (tmp), *nonce_del;
3162           nonce_del = clib_fifo_head (duplicate_pmr->nonces);
3163           hash_unset (lcm->pending_map_requests_by_nonce, nonce_del[0]);
3164           clib_fifo_sub1 (duplicate_pmr->nonces, tmp);
3165         }
3166
3167       clib_fifo_add1 (duplicate_pmr->nonces, nonce);
3168       hash_set (lcm->pending_map_requests_by_nonce, nonce,
3169                 duplicate_pmr - lcm->pending_map_requests_pool);
3170     }
3171   else
3172     {
3173       /* add map-request to pending requests table */
3174       pool_get (lcm->pending_map_requests_pool, pmr);
3175       clib_memset (pmr, 0, sizeof (*pmr));
3176       gid_address_copy (&pmr->src, seid);
3177       gid_address_copy (&pmr->dst, deid);
3178       clib_fifo_add1 (pmr->nonces, nonce);
3179       pmr->is_smr_invoked = is_smr_invoked;
3180       reset_pending_mr_counters (pmr);
3181       hash_set (lcm->pending_map_requests_by_nonce, nonce,
3182                 pmr - lcm->pending_map_requests_pool);
3183     }
3184
3185   return 0;
3186 }
3187
3188 static void
3189 get_src_and_dst_ip (void *hdr, ip_address_t * src, ip_address_t * dst)
3190 {
3191   ip4_header_t *ip4 = hdr;
3192   ip6_header_t *ip6;
3193
3194   if ((ip4->ip_version_and_header_length & 0xF0) == 0x40)
3195     {
3196       ip_address_set (src, &ip4->src_address, AF_IP4);
3197       ip_address_set (dst, &ip4->dst_address, AF_IP4);
3198     }
3199   else
3200     {
3201       ip6 = hdr;
3202       ip_address_set (src, &ip6->src_address, AF_IP6);
3203       ip_address_set (dst, &ip6->dst_address, AF_IP6);
3204     }
3205 }
3206
3207 static u32
3208 lisp_get_vni_from_buffer_ip (lisp_cp_main_t * lcm, vlib_buffer_t * b,
3209                              u8 version)
3210 {
3211   uword *vnip;
3212   u32 vni = ~0, table_id = ~0;
3213
3214   table_id = fib_table_get_table_id_for_sw_if_index ((version ==
3215                                                       AF_IP4 ?
3216                                                       FIB_PROTOCOL_IP4 :
3217                                                       FIB_PROTOCOL_IP6),
3218                                                      vnet_buffer
3219                                                      (b)->sw_if_index
3220                                                      [VLIB_RX]);
3221
3222   vnip = hash_get (lcm->vni_by_table_id, table_id);
3223   if (vnip)
3224     vni = vnip[0];
3225   else
3226     clib_warning ("vrf %d is not mapped to any vni!", table_id);
3227
3228   return vni;
3229 }
3230
3231 always_inline u32
3232 lisp_get_bd_from_buffer_eth (vlib_buffer_t * b)
3233 {
3234   u32 sw_if_index0;
3235
3236   l2input_main_t *l2im = &l2input_main;
3237   l2_input_config_t *config;
3238   l2_bridge_domain_t *bd_config;
3239
3240   sw_if_index0 = vnet_buffer (b)->sw_if_index[VLIB_RX];
3241   config = vec_elt_at_index (l2im->configs, sw_if_index0);
3242   bd_config = vec_elt_at_index (l2im->bd_configs, config->bd_index);
3243
3244   return bd_config->bd_id;
3245 }
3246
3247 always_inline u32
3248 lisp_get_vni_from_buffer_eth (lisp_cp_main_t * lcm, vlib_buffer_t * b)
3249 {
3250   uword *vnip;
3251   u32 vni = ~0;
3252   u32 bd = lisp_get_bd_from_buffer_eth (b);
3253
3254   vnip = hash_get (lcm->vni_by_bd_id, bd);
3255   if (vnip)
3256     vni = vnip[0];
3257   else
3258     clib_warning ("bridge domain %d is not mapped to any vni!", bd);
3259
3260   return vni;
3261 }
3262
3263 void
3264 get_src_and_dst_eids_from_buffer (lisp_cp_main_t * lcm, vlib_buffer_t * b,
3265                                   gid_address_t * src, gid_address_t * dst,
3266                                   u16 type)
3267 {
3268   ethernet_header_t *eh;
3269   u32 vni = 0;
3270   icmp6_neighbor_discovery_ethernet_link_layer_address_option_t *opt;
3271
3272   clib_memset (src, 0, sizeof (*src));
3273   clib_memset (dst, 0, sizeof (*dst));
3274
3275   gid_address_type (dst) = GID_ADDR_NO_ADDRESS;
3276   gid_address_type (src) = GID_ADDR_NO_ADDRESS;
3277
3278   if (LISP_AFI_IP == type || LISP_AFI_IP6 == type)
3279     {
3280       ip4_header_t *ip;
3281       u8 version, preflen;
3282
3283       gid_address_type (src) = GID_ADDR_IP_PREFIX;
3284       gid_address_type (dst) = GID_ADDR_IP_PREFIX;
3285
3286       ip = vlib_buffer_get_current (b);
3287       get_src_and_dst_ip (ip, &gid_address_ip (src), &gid_address_ip (dst));
3288
3289       version = gid_address_ip_version (src);
3290       preflen = ip_address_max_len (version);
3291       gid_address_ippref_len (src) = preflen;
3292       gid_address_ippref_len (dst) = preflen;
3293
3294       vni = lisp_get_vni_from_buffer_ip (lcm, b, version);
3295       gid_address_vni (dst) = vni;
3296       gid_address_vni (src) = vni;
3297     }
3298   else if (LISP_AFI_MAC == type)
3299     {
3300       ethernet_arp_header_t *ah;
3301
3302       eh = vlib_buffer_get_current (b);
3303
3304       if (clib_net_to_host_u16 (eh->type) == ETHERNET_TYPE_ARP)
3305         {
3306           ah = (ethernet_arp_header_t *) (((u8 *) eh) + sizeof (*eh));
3307           gid_address_type (dst) = GID_ADDR_ARP;
3308
3309           if (clib_net_to_host_u16 (ah->opcode)
3310               != ETHERNET_ARP_OPCODE_request)
3311             {
3312               clib_memset (&gid_address_arp_ndp_ip (dst), 0,
3313                            sizeof (ip_address_t));
3314               ip_addr_version (&gid_address_arp_ndp_ip (dst)) = AF_IP4;
3315               gid_address_arp_ndp_bd (dst) = ~0;
3316               return;
3317             }
3318
3319           gid_address_arp_bd (dst) = lisp_get_bd_from_buffer_eth (b);
3320           clib_memcpy (&gid_address_arp_ip4 (dst),
3321                        &ah->ip4_over_ethernet[1].ip4, 4);
3322         }
3323       else
3324         {
3325           if (clib_net_to_host_u16 (eh->type) == ETHERNET_TYPE_IP6)
3326             {
3327               ip6_header_t *ip;
3328               ip = (ip6_header_t *) (eh + 1);
3329
3330               if (IP_PROTOCOL_ICMP6 == ip->protocol)
3331                 {
3332                   icmp6_neighbor_solicitation_or_advertisement_header_t *ndh;
3333                   ndh = ip6_next_header (ip);
3334                   if (ndh->icmp.type == ICMP6_neighbor_solicitation)
3335                     {
3336                       gid_address_type (dst) = GID_ADDR_NDP;
3337
3338                       /* check that source link layer address option is present */
3339                       opt = (void *) (ndh + 1);
3340                       if ((opt->header.type !=
3341                            ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address)
3342                           || (opt->header.n_data_u64s != 1))
3343                         {
3344                           clib_memset (&gid_address_arp_ndp_ip (dst), 0,
3345                                        sizeof (ip_address_t));
3346                           ip_addr_version (&gid_address_arp_ndp_ip (dst)) =
3347                             AF_IP6;
3348                           gid_address_arp_ndp_bd (dst) = ~0;
3349                           gid_address_type (src) = GID_ADDR_NO_ADDRESS;
3350                           return;
3351                         }
3352
3353                       gid_address_ndp_bd (dst) =
3354                         lisp_get_bd_from_buffer_eth (b);
3355                       ip_address_set (&gid_address_arp_ndp_ip (dst),
3356                                       &ndh->target_address, AF_IP6);
3357                       return;
3358                     }
3359                 }
3360             }
3361
3362           gid_address_type (src) = GID_ADDR_MAC;
3363           gid_address_type (dst) = GID_ADDR_MAC;
3364           mac_copy (&gid_address_mac (src), eh->src_address);
3365           mac_copy (&gid_address_mac (dst), eh->dst_address);
3366
3367           /* get vni */
3368           vni = lisp_get_vni_from_buffer_eth (lcm, b);
3369
3370           gid_address_vni (dst) = vni;
3371           gid_address_vni (src) = vni;
3372         }
3373     }
3374   else if (LISP_AFI_LCAF == type)
3375     {
3376       lisp_nsh_hdr_t *nh;
3377       eh = vlib_buffer_get_current (b);
3378
3379       if (clib_net_to_host_u16 (eh->type) == ETHERNET_TYPE_NSH)
3380         {
3381           nh = (lisp_nsh_hdr_t *) (((u8 *) eh) + sizeof (*eh));
3382           u32 spi = clib_net_to_host_u32 (nh->spi_si << 8);
3383           u8 si = (u8) clib_net_to_host_u32 (nh->spi_si);
3384           gid_address_nsh_spi (dst) = spi;
3385           gid_address_nsh_si (dst) = si;
3386
3387           gid_address_type (dst) = GID_ADDR_NSH;
3388           gid_address_type (src) = GID_ADDR_NSH;
3389         }
3390     }
3391 }
3392
3393 static uword
3394 lisp_cp_lookup_inline (vlib_main_t * vm,
3395                        vlib_node_runtime_t * node,
3396                        vlib_frame_t * from_frame, int overlay)
3397 {
3398   icmp6_neighbor_discovery_ethernet_link_layer_address_option_t *opt;
3399   u32 *from, *to_next, di, si;
3400   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3401   u32 next_index;
3402   uword n_left_from, n_left_to_next;
3403   vnet_main_t *vnm = vnet_get_main ();
3404
3405   from = vlib_frame_vector_args (from_frame);
3406   n_left_from = from_frame->n_vectors;
3407   next_index = node->cached_next_index;
3408
3409   while (n_left_from > 0)
3410     {
3411       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
3412
3413       while (n_left_from > 0 && n_left_to_next > 0)
3414         {
3415           u32 pi0, sw_if_index0, next0;
3416           u64 mac0;
3417           vlib_buffer_t *b0;
3418           gid_address_t src, dst;
3419           ethernet_arp_header_t *arp0;
3420           ethernet_header_t *eth0;
3421           vnet_hw_interface_t *hw_if0;
3422           ethernet_header_t *eh0;
3423           icmp6_neighbor_solicitation_or_advertisement_header_t *ndh;
3424           ip6_header_t *ip0;
3425
3426           pi0 = from[0];
3427           from += 1;
3428           n_left_from -= 1;
3429           to_next[0] = pi0;
3430           to_next += 1;
3431           n_left_to_next -= 1;
3432
3433           b0 = vlib_get_buffer (vm, pi0);
3434
3435           /* src/dst eid pair */
3436           get_src_and_dst_eids_from_buffer (lcm, b0, &src, &dst, overlay);
3437
3438           if (gid_address_type (&dst) == GID_ADDR_ARP)
3439             {
3440               mac0 = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst);
3441               if (GID_LOOKUP_MISS_L2 == mac0)
3442                 goto drop;
3443
3444               /* send ARP reply */
3445               sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
3446               vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index0;
3447
3448               hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
3449
3450               eth0 = vlib_buffer_get_current (b0);
3451               arp0 = (ethernet_arp_header_t *) (((u8 *) eth0)
3452                                                 + sizeof (*eth0));
3453               arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
3454               arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
3455               mac_address_from_u64 (&arp0->ip4_over_ethernet[0].mac, mac0);
3456               clib_memcpy (&arp0->ip4_over_ethernet[0].ip4,
3457                            &gid_address_arp_ip4 (&dst), 4);
3458
3459               /* Hardware must be ethernet-like. */
3460               ASSERT (vec_len (hw_if0->hw_address) == 6);
3461
3462               clib_memcpy (eth0->dst_address, eth0->src_address, 6);
3463               clib_memcpy (eth0->src_address, hw_if0->hw_address, 6);
3464
3465               b0->error = node->errors[LISP_CP_LOOKUP_ERROR_ARP_REPLY_TX];
3466               next0 = LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX;
3467               goto enqueue;
3468             }
3469           else if (gid_address_type (&dst) == GID_ADDR_NDP)
3470             {
3471               mac0 = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst);
3472               if (GID_LOOKUP_MISS_L2 == mac0)
3473                 goto drop;
3474
3475               sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
3476               vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index0;
3477
3478               eh0 = vlib_buffer_get_current (b0);
3479               ip0 = (ip6_header_t *) (eh0 + 1);
3480               ndh = ip6_next_header (ip0);
3481               int bogus_length;
3482               ip0->dst_address = ip0->src_address;
3483               ip0->src_address = ndh->target_address;
3484               ip0->hop_limit = 255;
3485               opt = (void *) (ndh + 1);
3486               opt->header.type =
3487                 ICMP6_NEIGHBOR_DISCOVERY_OPTION_target_link_layer_address;
3488               clib_memcpy (opt->ethernet_address, (u8 *) & mac0, 6);
3489               ndh->icmp.type = ICMP6_neighbor_advertisement;
3490               ndh->advertisement_flags = clib_host_to_net_u32
3491                 (ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_SOLICITED |
3492                  ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_OVERRIDE);
3493               ndh->icmp.checksum = 0;
3494               ndh->icmp.checksum =
3495                 ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip0,
3496                                                    &bogus_length);
3497               clib_memcpy (eh0->dst_address, eh0->src_address, 6);
3498               clib_memcpy (eh0->src_address, (u8 *) & mac0, 6);
3499               b0->error =
3500                 node->errors
3501                 [LISP_CP_LOOKUP_ERROR_NDP_NEIGHBOR_ADVERTISEMENT_TX];
3502               next0 = LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX;
3503               goto enqueue;
3504             }
3505
3506           /* if we have remote mapping for destination already in map-cache
3507              add forwarding tunnel directly. If not send a map-request */
3508           di = gid_dictionary_sd_lookup (&lcm->mapping_index_by_gid, &dst,
3509                                          &src);
3510           if (~0 != di)
3511             {
3512               mapping_t *m = vec_elt_at_index (lcm->mapping_pool, di);
3513               /* send a map-request also in case of negative mapping entry
3514                  with corresponding action */
3515               if (m->action == LISP_SEND_MAP_REQUEST)
3516                 {
3517                   /* send map-request */
3518                   queue_map_request (&src, &dst, 0 /* smr_invoked */ ,
3519                                      0 /* is_resend */ );
3520                 }
3521               else
3522                 {
3523                   if (GID_ADDR_NSH != gid_address_type (&dst))
3524                     {
3525                       si = gid_dictionary_lookup (&lcm->mapping_index_by_gid,
3526                                                   &src);
3527                     }
3528                   else
3529                     si = lcm->nsh_map_index;
3530
3531                   if (~0 != si)
3532                     {
3533                       dp_add_fwd_entry_from_mt (si, di);
3534                     }
3535                 }
3536             }
3537           else
3538             {
3539               /* send map-request */
3540               queue_map_request (&src, &dst, 0 /* smr_invoked */ ,
3541                                  0 /* is_resend */ );
3542             }
3543
3544         drop:
3545           b0->error = node->errors[LISP_CP_LOOKUP_ERROR_DROP];
3546           next0 = LISP_CP_LOOKUP_NEXT_DROP;
3547         enqueue:
3548           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
3549             {
3550               lisp_cp_lookup_trace_t *tr = vlib_add_trace (vm, node, b0,
3551                                                            sizeof (*tr));
3552
3553               clib_memset (tr, 0, sizeof (*tr));
3554               if ((gid_address_type (&dst) == GID_ADDR_NDP) ||
3555                   (gid_address_type (&dst) == GID_ADDR_ARP))
3556                 clib_memcpy (&tr->dst_eid, &dst, sizeof (gid_address_t));
3557               else
3558                 gid_address_copy (&tr->dst_eid, &dst);
3559               ip_address_copy (&tr->map_resolver_ip,
3560                                &lcm->active_map_resolver);
3561             }
3562           gid_address_free (&dst);
3563           gid_address_free (&src);
3564           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
3565                                            to_next,
3566                                            n_left_to_next, pi0, next0);
3567         }
3568
3569       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
3570     }
3571   return from_frame->n_vectors;
3572 }
3573
3574 static uword
3575 lisp_cp_lookup_ip4 (vlib_main_t * vm,
3576                     vlib_node_runtime_t * node, vlib_frame_t * from_frame)
3577 {
3578   return (lisp_cp_lookup_inline (vm, node, from_frame, LISP_AFI_IP));
3579 }
3580
3581 static uword
3582 lisp_cp_lookup_ip6 (vlib_main_t * vm,
3583                     vlib_node_runtime_t * node, vlib_frame_t * from_frame)
3584 {
3585   return (lisp_cp_lookup_inline (vm, node, from_frame, LISP_AFI_IP6));
3586 }
3587
3588 static uword
3589 lisp_cp_lookup_l2 (vlib_main_t * vm,
3590                    vlib_node_runtime_t * node, vlib_frame_t * from_frame)
3591 {
3592   return (lisp_cp_lookup_inline (vm, node, from_frame, LISP_AFI_MAC));
3593 }
3594
3595 static uword
3596 lisp_cp_lookup_nsh (vlib_main_t * vm,
3597                     vlib_node_runtime_t * node, vlib_frame_t * from_frame)
3598 {
3599   /* TODO decide if NSH should be propagated as LCAF or not */
3600   return (lisp_cp_lookup_inline (vm, node, from_frame, LISP_AFI_LCAF));
3601 }
3602
3603 /* *INDENT-OFF* */
3604 VLIB_REGISTER_NODE (lisp_cp_lookup_ip4_node) = {
3605   .function = lisp_cp_lookup_ip4,
3606   .name = "lisp-cp-lookup-ip4",
3607   .vector_size = sizeof (u32),
3608   .format_trace = format_lisp_cp_lookup_trace,
3609   .type = VLIB_NODE_TYPE_INTERNAL,
3610
3611   .n_errors = LISP_CP_LOOKUP_N_ERROR,
3612   .error_strings = lisp_cp_lookup_error_strings,
3613
3614   .n_next_nodes = LISP_CP_LOOKUP_N_NEXT,
3615
3616   .next_nodes = {
3617       [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop",
3618       [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output",
3619   },
3620 };
3621 /* *INDENT-ON* */
3622
3623 /* *INDENT-OFF* */
3624 VLIB_REGISTER_NODE (lisp_cp_lookup_ip6_node) = {
3625   .function = lisp_cp_lookup_ip6,
3626   .name = "lisp-cp-lookup-ip6",
3627   .vector_size = sizeof (u32),
3628   .format_trace = format_lisp_cp_lookup_trace,
3629   .type = VLIB_NODE_TYPE_INTERNAL,
3630
3631   .n_errors = LISP_CP_LOOKUP_N_ERROR,
3632   .error_strings = lisp_cp_lookup_error_strings,
3633
3634   .n_next_nodes = LISP_CP_LOOKUP_N_NEXT,
3635
3636   .next_nodes = {
3637       [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop",
3638       [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output",
3639   },
3640 };
3641 /* *INDENT-ON* */
3642
3643 /* *INDENT-OFF* */
3644 VLIB_REGISTER_NODE (lisp_cp_lookup_l2_node) = {
3645   .function = lisp_cp_lookup_l2,
3646   .name = "lisp-cp-lookup-l2",
3647   .vector_size = sizeof (u32),
3648   .format_trace = format_lisp_cp_lookup_trace,
3649   .type = VLIB_NODE_TYPE_INTERNAL,
3650
3651   .n_errors = LISP_CP_LOOKUP_N_ERROR,
3652   .error_strings = lisp_cp_lookup_error_strings,
3653
3654   .n_next_nodes = LISP_CP_LOOKUP_N_NEXT,
3655
3656   .next_nodes = {
3657       [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop",
3658       [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output",
3659   },
3660 };
3661 /* *INDENT-ON* */
3662
3663 /* *INDENT-OFF* */
3664 VLIB_REGISTER_NODE (lisp_cp_lookup_nsh_node) = {
3665   .function = lisp_cp_lookup_nsh,
3666   .name = "lisp-cp-lookup-nsh",
3667   .vector_size = sizeof (u32),
3668   .format_trace = format_lisp_cp_lookup_trace,
3669   .type = VLIB_NODE_TYPE_INTERNAL,
3670
3671   .n_errors = LISP_CP_LOOKUP_N_ERROR,
3672   .error_strings = lisp_cp_lookup_error_strings,
3673
3674   .n_next_nodes = LISP_CP_LOOKUP_N_NEXT,
3675
3676   .next_nodes = {
3677       [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop",
3678       [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output",
3679   },
3680 };
3681 /* *INDENT-ON* */
3682
3683 /* lisp_cp_input statistics */
3684 #define foreach_lisp_cp_input_error                               \
3685 _(DROP, "drop")                                                   \
3686 _(RLOC_PROBE_REQ_RECEIVED, "rloc-probe requests received")        \
3687 _(RLOC_PROBE_REP_RECEIVED, "rloc-probe replies received")         \
3688 _(MAP_NOTIFIES_RECEIVED, "map-notifies received")                 \
3689 _(MAP_REPLIES_RECEIVED, "map-replies received")
3690
3691 static char *lisp_cp_input_error_strings[] = {
3692 #define _(sym,string) string,
3693   foreach_lisp_cp_input_error
3694 #undef _
3695 };
3696
3697 typedef enum
3698 {
3699 #define _(sym,str) LISP_CP_INPUT_ERROR_##sym,
3700   foreach_lisp_cp_input_error
3701 #undef _
3702     LISP_CP_INPUT_N_ERROR,
3703 } lisp_cp_input_error_t;
3704
3705 typedef struct
3706 {
3707   gid_address_t dst_eid;
3708   ip4_address_t map_resolver_ip;
3709 } lisp_cp_input_trace_t;
3710
3711 u8 *
3712 format_lisp_cp_input_trace (u8 * s, va_list * args)
3713 {
3714   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
3715   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
3716   CLIB_UNUSED (lisp_cp_input_trace_t * t) =
3717     va_arg (*args, lisp_cp_input_trace_t *);
3718
3719   s = format (s, "LISP-CP-INPUT: TODO");
3720   return s;
3721 }
3722
3723 static void
3724 remove_expired_mapping (lisp_cp_main_t * lcm, u32 mi)
3725 {
3726   mapping_t *m;
3727   vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args;
3728   clib_memset (adj_args, 0, sizeof (adj_args[0]));
3729
3730   m = pool_elt_at_index (lcm->mapping_pool, mi);
3731
3732   gid_address_copy (&adj_args->reid, &m->eid);
3733   adj_args->is_add = 0;
3734   if (vnet_lisp_add_del_adjacency (adj_args))
3735     clib_warning ("failed to del adjacency!");
3736
3737   TW (tw_timer_stop) (&lcm->wheel, m->timer_handle);
3738   vnet_lisp_del_mapping (&m->eid, NULL);
3739 }
3740
3741 static void
3742 mapping_start_expiration_timer (lisp_cp_main_t * lcm, u32 mi,
3743                                 f64 expiration_time)
3744 {
3745   mapping_t *m;
3746   u64 now = clib_cpu_time_now ();
3747   u64 cpu_cps = lcm->vlib_main->clib_time.clocks_per_second;
3748   u64 exp_clock_time = now + expiration_time * cpu_cps;
3749
3750   m = pool_elt_at_index (lcm->mapping_pool, mi);
3751
3752   m->timer_set = 1;
3753   m->timer_handle = TW (tw_timer_start) (&lcm->wheel, mi, 0, exp_clock_time);
3754 }
3755
3756 static void
3757 process_expired_mapping (lisp_cp_main_t * lcm, u32 mi)
3758 {
3759   int rv;
3760   vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a;
3761   mapping_t *m = pool_elt_at_index (lcm->mapping_pool, mi);
3762   uword *fei;
3763   fwd_entry_t *fe;
3764   vlib_counter_t c;
3765   u8 have_stats = 0;
3766
3767   if (m->delete_after_expiration)
3768     {
3769       remove_expired_mapping (lcm, mi);
3770       return;
3771     }
3772
3773   fei = hash_get (lcm->fwd_entry_by_mapping_index, mi);
3774   if (!fei)
3775     return;
3776
3777   fe = pool_elt_at_index (lcm->fwd_entry_pool, fei[0]);
3778
3779   clib_memset (a, 0, sizeof (*a));
3780   a->rmt_eid = fe->reid;
3781   if (fe->is_src_dst)
3782     a->lcl_eid = fe->leid;
3783   a->vni = gid_address_vni (&fe->reid);
3784
3785   rv = vnet_lisp_gpe_get_fwd_stats (a, &c);
3786   if (0 == rv)
3787     have_stats = 1;
3788
3789   if (m->almost_expired)
3790     {
3791       m->almost_expired = 0;    /* reset flag */
3792       if (have_stats)
3793         {
3794           if (m->packets != c.packets)
3795             {
3796               /* mapping is in use, re-fetch */
3797               map_request_args_t mr_args;
3798               clib_memset (&mr_args, 0, sizeof (mr_args));
3799               mr_args.seid = fe->leid;
3800               mr_args.deid = fe->reid;
3801
3802               send_map_request_thread_fn (&mr_args);
3803             }
3804           else
3805             remove_expired_mapping (lcm, mi);
3806         }
3807       else
3808         remove_expired_mapping (lcm, mi);
3809     }
3810   else
3811     {
3812       m->almost_expired = 1;
3813       mapping_start_expiration_timer (lcm, mi, TIME_UNTIL_REFETCH_OR_DELETE);
3814
3815       if (have_stats)
3816         /* save counter */
3817         m->packets = c.packets;
3818       else
3819         m->delete_after_expiration = 1;
3820     }
3821 }
3822
3823 static void
3824 map_records_arg_free (map_records_arg_t * a)
3825 {
3826   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3827   mapping_t *m;
3828   vec_foreach (m, a->mappings)
3829   {
3830     vec_free (m->locators);
3831     gid_address_free (&m->eid);
3832   }
3833   pool_put (lcm->map_records_args_pool[vlib_get_thread_index ()], a);
3834 }
3835
3836 void *
3837 process_map_reply (map_records_arg_t * a)
3838 {
3839   mapping_t *m;
3840   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3841   u32 dst_map_index = 0;
3842   pending_map_request_t *pmr;
3843   u64 *noncep;
3844   uword *pmr_index;
3845   u8 is_changed = 0;
3846
3847   if (a->is_rloc_probe)
3848     goto done;
3849
3850   /* Check pending requests table and nonce */
3851   pmr_index = hash_get (lcm->pending_map_requests_by_nonce, a->nonce);
3852   if (!pmr_index)
3853     {
3854       clib_warning ("No pending map-request entry with nonce %lu!", a->nonce);
3855       goto done;
3856     }
3857   pmr = pool_elt_at_index (lcm->pending_map_requests_pool, pmr_index[0]);
3858
3859   vec_foreach (m, a->mappings)
3860   {
3861     vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
3862     clib_memset (m_args, 0, sizeof (m_args[0]));
3863     gid_address_copy (&m_args->eid, &m->eid);
3864     m_args->action = m->action;
3865     m_args->authoritative = m->authoritative;
3866     m_args->ttl = m->ttl;
3867     m_args->is_static = 0;
3868
3869     /* insert/update mappings cache */
3870     vnet_lisp_add_mapping (m_args, m->locators, &dst_map_index, &is_changed);
3871
3872     if (dst_map_index == (u32) ~ 0)
3873       continue;
3874
3875     if (is_changed)
3876       {
3877         /* try to program forwarding only if mapping saved or updated */
3878         vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args;
3879         clib_memset (adj_args, 0, sizeof (adj_args[0]));
3880
3881         gid_address_copy (&adj_args->leid, &pmr->src);
3882         gid_address_copy (&adj_args->reid, &m->eid);
3883         adj_args->is_add = 1;
3884
3885         if (vnet_lisp_add_del_adjacency (adj_args))
3886           clib_warning ("failed to add adjacency!");
3887       }
3888
3889     if ((u32) ~ 0 != m->ttl)
3890       mapping_start_expiration_timer (lcm, dst_map_index,
3891                                       (m->ttl == 0) ? 0 : MAPPING_TIMEOUT);
3892   }
3893
3894   /* remove pending map request entry */
3895
3896   /* *INDENT-OFF* */
3897   clib_fifo_foreach (noncep, pmr->nonces, ({
3898     hash_unset(lcm->pending_map_requests_by_nonce, noncep[0]);
3899   }));
3900   /* *INDENT-ON* */
3901
3902   clib_fifo_free (pmr->nonces);
3903   pool_put (lcm->pending_map_requests_pool, pmr);
3904
3905 done:
3906   a->is_free = 1;
3907   return 0;
3908 }
3909
3910 static int
3911 is_auth_data_valid (map_notify_hdr_t * h, u32 msg_len,
3912                     lisp_key_type_t key_id, u8 * key)
3913 {
3914   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3915   u8 *auth_data = 0;
3916   u16 auth_data_len;
3917   int result;
3918   vnet_crypto_op_t _op, *op = &_op;
3919   vnet_crypto_key_index_t ki;
3920   u8 out[EVP_MAX_MD_SIZE] = { 0, };
3921
3922   auth_data_len = auth_data_len_by_key_id (key_id);
3923   if ((u16) ~ 0 == auth_data_len)
3924     {
3925       clib_warning ("invalid length for key_id %d!", key_id);
3926       return 0;
3927     }
3928
3929   /* save auth data */
3930   vec_validate (auth_data, auth_data_len - 1);
3931   clib_memcpy (auth_data, MNOTIFY_DATA (h), auth_data_len);
3932
3933   /* clear auth data */
3934   clib_memset (MNOTIFY_DATA (h), 0, auth_data_len);
3935
3936   vnet_crypto_op_init (op, lisp_key_type_to_crypto_op (key_id));
3937   op->len = msg_len;
3938   op->digest = out;
3939   op->src = (u8 *) h;
3940   op->digest_len = 0;
3941   op->iv = 0;
3942
3943   ki = vnet_crypto_key_add (lcm->vlib_main,
3944                             lisp_key_type_to_crypto_alg (key_id), key,
3945                             vec_len (key));
3946
3947   op->key_index = ki;
3948
3949   vnet_crypto_process_ops (lcm->vlib_main, op, 1);
3950   vnet_crypto_key_del (lcm->vlib_main, ki);
3951
3952   result = memcmp (out, auth_data, auth_data_len);
3953
3954   vec_free (auth_data);
3955
3956   return !result;
3957 }
3958
3959 static void
3960 process_map_notify (map_records_arg_t * a)
3961 {
3962   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3963   uword *pmr_index;
3964
3965   pmr_index = hash_get (lcm->map_register_messages_by_nonce, a->nonce);
3966   if (!pmr_index)
3967     {
3968       clib_warning ("No pending map-register entry with nonce %lu!",
3969                     a->nonce);
3970       return;
3971     }
3972
3973   a->is_free = 1;
3974   pool_put_index (lcm->pending_map_registers_pool, pmr_index[0]);
3975   hash_unset (lcm->map_register_messages_by_nonce, a->nonce);
3976
3977   /* reset map-notify counter */
3978   lcm->expired_map_registers = 0;
3979 }
3980
3981 static mapping_t *
3982 get_mapping (lisp_cp_main_t * lcm, gid_address_t * e)
3983 {
3984   u32 mi;
3985
3986   mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, e);
3987   if (~0 == mi)
3988     {
3989       clib_warning ("eid %U not found in map-cache!", unformat_gid_address,
3990                     e);
3991       return 0;
3992     }
3993   return pool_elt_at_index (lcm->mapping_pool, mi);
3994 }
3995
3996 /**
3997  * When map-notify is received it is necessary that all EIDs in the record
3998  * list share common key. The key is then used to verify authentication
3999  * data in map-notify message.
4000  */
4001 static int
4002 map_record_integrity_check (lisp_cp_main_t * lcm, mapping_t * maps,
4003                             u32 key_id, u8 ** key_out)
4004 {
4005   u32 i, len = vec_len (maps);
4006   mapping_t *m;
4007
4008   /* get key of the first mapping */
4009   m = get_mapping (lcm, &maps[0].eid);
4010   if (!m || !m->key)
4011     return -1;
4012
4013   key_out[0] = m->key;
4014
4015   for (i = 1; i < len; i++)
4016     {
4017       m = get_mapping (lcm, &maps[i].eid);
4018       if (!m || !m->key)
4019         return -1;
4020
4021       if (key_id != m->key_id || vec_cmp (m->key, key_out[0]))
4022         {
4023           clib_warning ("keys does not match! %v, %v", key_out[0], m->key);
4024           return -1;
4025         }
4026     }
4027   return 0;
4028 }
4029
4030 static int
4031 parse_map_records (vlib_buffer_t * b, map_records_arg_t * a, u8 count)
4032 {
4033   locator_t *locators = 0;
4034   u32 i, len;
4035   gid_address_t deid;
4036   mapping_t m;
4037   locator_t *loc;
4038
4039   clib_memset (&m, 0, sizeof (m));
4040
4041   /* parse record eid */
4042   for (i = 0; i < count; i++)
4043     {
4044       locators = 0;
4045       len = lisp_msg_parse_mapping_record (b, &deid, &locators, NULL);
4046       if (len == ~0)
4047         {
4048           clib_warning ("Failed to parse mapping record!");
4049           vec_foreach (loc, locators) locator_free (loc);
4050           vec_free (locators);
4051           return -1;
4052         }
4053
4054       m.locators = locators;
4055       gid_address_copy (&m.eid, &deid);
4056       vec_add1 (a->mappings, m);
4057     }
4058
4059   return 0;
4060 }
4061
4062 static map_records_arg_t *
4063 map_record_args_get ()
4064 {
4065   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4066   map_records_arg_t *rec;
4067
4068   /* Cleanup first */
4069   /* *INDENT-OFF* */
4070   pool_foreach (rec, lcm->map_records_args_pool[vlib_get_thread_index()])  {
4071     if (rec->is_free)
4072       map_records_arg_free (rec);
4073   }
4074   /* *INDENT-ON* */
4075
4076   pool_get (lcm->map_records_args_pool[vlib_get_thread_index ()], rec);
4077   return rec;
4078 }
4079
4080 static map_records_arg_t *
4081 parse_map_notify (vlib_buffer_t * b)
4082 {
4083   int rc = 0;
4084   map_notify_hdr_t *mnotif_hdr;
4085   lisp_key_type_t key_id;
4086   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4087   u8 *key = 0;
4088   gid_address_t deid;
4089   u16 auth_data_len = 0;
4090   u8 record_count;
4091   map_records_arg_t *a;
4092
4093   a = map_record_args_get ();
4094   clib_memset (a, 0, sizeof (*a));
4095   mnotif_hdr = vlib_buffer_get_current (b);
4096   vlib_buffer_pull (b, sizeof (*mnotif_hdr));
4097   clib_memset (&deid, 0, sizeof (deid));
4098
4099   a->nonce = MNOTIFY_NONCE (mnotif_hdr);
4100   key_id = clib_net_to_host_u16 (MNOTIFY_KEY_ID (mnotif_hdr));
4101   auth_data_len = auth_data_len_by_key_id (key_id);
4102
4103   /* advance buffer by authentication data */
4104   vlib_buffer_pull (b, auth_data_len);
4105
4106   record_count = MNOTIFY_REC_COUNT (mnotif_hdr);
4107   rc = parse_map_records (b, a, record_count);
4108   if (rc != 0)
4109     {
4110       map_records_arg_free (a);
4111       return 0;
4112     }
4113
4114   rc = map_record_integrity_check (lcm, a->mappings, key_id, &key);
4115   if (rc != 0)
4116     {
4117       map_records_arg_free (a);
4118       return 0;
4119     }
4120
4121   /* verify authentication data */
4122   if (!is_auth_data_valid (mnotif_hdr, vlib_buffer_get_tail (b)
4123                            - (u8 *) mnotif_hdr, key_id, key))
4124     {
4125       clib_warning ("Map-notify auth data verification failed for nonce "
4126                     "0x%lx!", a->nonce);
4127       map_records_arg_free (a);
4128       return 0;
4129     }
4130   return a;
4131 }
4132
4133 static vlib_buffer_t *
4134 build_map_reply (lisp_cp_main_t * lcm, ip_address_t * sloc,
4135                  ip_address_t * dst, u64 nonce, u8 probe_bit,
4136                  mapping_t * records, u16 dst_port, u32 * bi_res)
4137 {
4138   vlib_buffer_t *b;
4139   u32 bi;
4140   vlib_main_t *vm = lcm->vlib_main;
4141
4142   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
4143     {
4144       clib_warning ("Can't allocate buffer for Map-Register!");
4145       return 0;
4146     }
4147
4148   b = vlib_get_buffer (vm, bi);
4149
4150   /* leave some space for the encap headers */
4151   vlib_buffer_make_headroom (b, MAX_LISP_MSG_ENCAP_LEN);
4152
4153   lisp_msg_put_map_reply (b, records, nonce, probe_bit);
4154
4155   /* push outer ip header */
4156   pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, dst_port, sloc, dst, 1);
4157
4158   bi_res[0] = bi;
4159   return b;
4160 }
4161
4162 static int
4163 send_map_reply (lisp_cp_main_t * lcm, u32 mi, ip_address_t * dst,
4164                 u8 probe_bit, u64 nonce, u16 dst_port,
4165                 ip_address_t * probed_loc)
4166 {
4167   ip_address_t src;
4168   u32 bi;
4169   vlib_buffer_t *b;
4170   vlib_frame_t *f;
4171   u32 next_index, *to_next;
4172   mapping_t *records = 0, *m;
4173
4174   m = pool_elt_at_index (lcm->mapping_pool, mi);
4175   if (!m)
4176     return -1;
4177
4178   vec_add1 (records, m[0]);
4179   add_locators (lcm, &records[0], m->locator_set_index, probed_loc);
4180   clib_memset (&src, 0, sizeof (src));
4181
4182   if (!ip_fib_get_first_egress_ip_for_dst (lcm, dst, &src))
4183     {
4184       clib_warning ("can't find interface address for %U", format_ip_address,
4185                     dst);
4186       return -1;
4187     }
4188
4189   b = build_map_reply (lcm, &src, dst, nonce, probe_bit, records, dst_port,
4190                        &bi);
4191   if (!b)
4192     return -1;
4193   free_map_register_records (records);
4194
4195   vnet_buffer (b)->sw_if_index[VLIB_TX] = 0;
4196   next_index = (ip_addr_version (&lcm->active_map_resolver) == AF_IP4) ?
4197     ip4_lookup_node.index : ip6_lookup_node.index;
4198
4199   f = vlib_get_frame_to_node (lcm->vlib_main, next_index);
4200
4201   /* Enqueue the packet */
4202   to_next = vlib_frame_vector_args (f);
4203   to_next[0] = bi;
4204   f->n_vectors = 1;
4205   vlib_put_frame_to_node (lcm->vlib_main, next_index, f);
4206   return 0;
4207 }
4208
4209 static void
4210 find_ip_header (vlib_buffer_t * b, u8 ** ip_hdr)
4211 {
4212   const i32 start = vnet_buffer (b)->l3_hdr_offset;
4213   if (start < 0 && start < -sizeof (b->pre_data))
4214     {
4215       *ip_hdr = 0;
4216       return;
4217     }
4218
4219   *ip_hdr = b->data + start;
4220   if ((u8 *) * ip_hdr > (u8 *) vlib_buffer_get_current (b))
4221     *ip_hdr = 0;
4222 }
4223
4224 void
4225 process_map_request (vlib_main_t * vm, vlib_node_runtime_t * node,
4226                      lisp_cp_main_t * lcm, vlib_buffer_t * b)
4227 {
4228   u8 *ip_hdr = 0;
4229   ip_address_t *dst_loc = 0, probed_loc, src_loc;
4230   mapping_t m;
4231   map_request_hdr_t *mreq_hdr;
4232   gid_address_t src, dst;
4233   u64 nonce;
4234   u32 i, len = 0, rloc_probe_recv = 0;
4235   gid_address_t *itr_rlocs = 0;
4236
4237   mreq_hdr = vlib_buffer_get_current (b);
4238   if (!MREQ_SMR (mreq_hdr) && !MREQ_RLOC_PROBE (mreq_hdr))
4239     {
4240       clib_warning
4241         ("Only SMR Map-Requests and RLOC probe supported for now!");
4242       return;
4243     }
4244
4245   vlib_buffer_pull (b, sizeof (*mreq_hdr));
4246   nonce = MREQ_NONCE (mreq_hdr);
4247
4248   /* parse src eid */
4249   len = lisp_msg_parse_addr (b, &src);
4250   if (len == ~0)
4251     return;
4252
4253   len = lisp_msg_parse_itr_rlocs (b, &itr_rlocs,
4254                                   MREQ_ITR_RLOC_COUNT (mreq_hdr) + 1);
4255   if (len == ~0)
4256     goto done;
4257
4258   /* parse eid records and send SMR-invoked map-requests */
4259   for (i = 0; i < MREQ_REC_COUNT (mreq_hdr); i++)
4260     {
4261       clib_memset (&dst, 0, sizeof (dst));
4262       len = lisp_msg_parse_eid_rec (b, &dst);
4263       if (len == ~0)
4264         {
4265           clib_warning ("Can't parse map-request EID-record");
4266           goto done;
4267         }
4268
4269       if (MREQ_SMR (mreq_hdr))
4270         {
4271           /* send SMR-invoked map-requests */
4272           queue_map_request (&dst, &src, 1 /* invoked */ , 0 /* resend */ );
4273         }
4274       else if (MREQ_RLOC_PROBE (mreq_hdr))
4275         {
4276           find_ip_header (b, &ip_hdr);
4277           if (!ip_hdr)
4278             {
4279               clib_warning ("Cannot find the IP header!");
4280               goto done;
4281             }
4282           rloc_probe_recv++;
4283           clib_memset (&m, 0, sizeof (m));
4284           u32 mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst);
4285
4286           // TODO: select best locator; for now use the first one
4287           dst_loc = &gid_address_ip (&itr_rlocs[0]);
4288
4289           /* get src/dst IP addresses */
4290           get_src_and_dst_ip (ip_hdr, &src_loc, &probed_loc);
4291
4292           // TODO get source port from buffer
4293           u16 src_port = LISP_CONTROL_PORT;
4294
4295           send_map_reply (lcm, mi, dst_loc, 1 /* probe-bit */ , nonce,
4296                           src_port, &probed_loc);
4297         }
4298     }
4299
4300 done:
4301   vlib_node_increment_counter (vm, node->node_index,
4302                                LISP_CP_INPUT_ERROR_RLOC_PROBE_REQ_RECEIVED,
4303                                rloc_probe_recv);
4304   vec_free (itr_rlocs);
4305 }
4306
4307 map_records_arg_t *
4308 parse_map_reply (vlib_buffer_t * b)
4309 {
4310   locator_t probed;
4311   gid_address_t deid;
4312   void *h;
4313   u32 i, len = 0;
4314   mapping_t m;
4315   map_reply_hdr_t *mrep_hdr;
4316   map_records_arg_t *a;
4317
4318   a = map_record_args_get ();
4319   clib_memset (a, 0, sizeof (*a));
4320
4321   locator_t *locators;
4322
4323   mrep_hdr = vlib_buffer_get_current (b);
4324   a->nonce = MREP_NONCE (mrep_hdr);
4325   a->is_rloc_probe = MREP_RLOC_PROBE (mrep_hdr);
4326   if (!vlib_buffer_has_space (b, sizeof (*mrep_hdr)))
4327     {
4328       map_records_arg_free (a);
4329       return 0;
4330     }
4331   vlib_buffer_pull (b, sizeof (*mrep_hdr));
4332
4333   for (i = 0; i < MREP_REC_COUNT (mrep_hdr); i++)
4334     {
4335       clib_memset (&m, 0, sizeof (m));
4336       locators = 0;
4337       h = vlib_buffer_get_current (b);
4338
4339       m.ttl = clib_net_to_host_u32 (MAP_REC_TTL (h));
4340       m.action = MAP_REC_ACTION (h);
4341       m.authoritative = MAP_REC_AUTH (h);
4342
4343       len = lisp_msg_parse_mapping_record (b, &deid, &locators, &probed);
4344       if (len == ~0)
4345         {
4346           clib_warning ("Failed to parse mapping record!");
4347           map_records_arg_free (a);
4348           return 0;
4349         }
4350
4351       m.locators = locators;
4352       gid_address_copy (&m.eid, &deid);
4353       vec_add1 (a->mappings, m);
4354     }
4355   return a;
4356 }
4357
4358 static void
4359 queue_map_reply_for_processing (map_records_arg_t * a)
4360 {
4361   vl_api_rpc_call_main_thread (process_map_reply, (u8 *) a, sizeof (*a));
4362 }
4363
4364 static void
4365 queue_map_notify_for_processing (map_records_arg_t * a)
4366 {
4367   vl_api_rpc_call_main_thread (process_map_notify, (u8 *) a, sizeof (a[0]));
4368 }
4369
4370 static uword
4371 lisp_cp_input (vlib_main_t * vm, vlib_node_runtime_t * node,
4372                vlib_frame_t * from_frame)
4373 {
4374   u32 n_left_from, *from, *to_next_drop, rloc_probe_rep_recv = 0,
4375     map_notifies_recv = 0;
4376   lisp_msg_type_e type;
4377   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4378   map_records_arg_t *a;
4379
4380   from = vlib_frame_vector_args (from_frame);
4381   n_left_from = from_frame->n_vectors;
4382
4383
4384   while (n_left_from > 0)
4385     {
4386       u32 n_left_to_next_drop;
4387
4388       vlib_get_next_frame (vm, node, LISP_CP_INPUT_NEXT_DROP,
4389                            to_next_drop, n_left_to_next_drop);
4390       while (n_left_from > 0 && n_left_to_next_drop > 0)
4391         {
4392           u32 bi0;
4393           vlib_buffer_t *b0;
4394
4395           bi0 = from[0];
4396           from += 1;
4397           n_left_from -= 1;
4398           to_next_drop[0] = bi0;
4399           to_next_drop += 1;
4400           n_left_to_next_drop -= 1;
4401
4402           b0 = vlib_get_buffer (vm, bi0);
4403
4404           type = lisp_msg_type (vlib_buffer_get_current (b0));
4405           switch (type)
4406             {
4407             case LISP_MAP_REPLY:
4408               a = parse_map_reply (b0);
4409               if (a)
4410                 {
4411                   if (a->is_rloc_probe)
4412                     rloc_probe_rep_recv++;
4413                   queue_map_reply_for_processing (a);
4414                 }
4415               break;
4416             case LISP_MAP_REQUEST:
4417               process_map_request (vm, node, lcm, b0);
4418               break;
4419             case LISP_MAP_NOTIFY:
4420               a = parse_map_notify (b0);
4421               if (a)
4422                 {
4423                   map_notifies_recv++;
4424                   queue_map_notify_for_processing (a);
4425                 }
4426               break;
4427             default:
4428               clib_warning ("Unsupported LISP message type %d", type);
4429               break;
4430             }
4431
4432           b0->error = node->errors[LISP_CP_INPUT_ERROR_DROP];
4433
4434           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
4435             {
4436
4437             }
4438         }
4439
4440       vlib_put_next_frame (vm, node, LISP_CP_INPUT_NEXT_DROP,
4441                            n_left_to_next_drop);
4442     }
4443   vlib_node_increment_counter (vm, node->node_index,
4444                                LISP_CP_INPUT_ERROR_RLOC_PROBE_REP_RECEIVED,
4445                                rloc_probe_rep_recv);
4446   vlib_node_increment_counter (vm, node->node_index,
4447                                LISP_CP_INPUT_ERROR_MAP_NOTIFIES_RECEIVED,
4448                                map_notifies_recv);
4449   return from_frame->n_vectors;
4450 }
4451
4452 /* *INDENT-OFF* */
4453 VLIB_REGISTER_NODE (lisp_cp_input_node) = {
4454   .function = lisp_cp_input,
4455   .name = "lisp-cp-input",
4456   .vector_size = sizeof (u32),
4457   .format_trace = format_lisp_cp_input_trace,
4458   .type = VLIB_NODE_TYPE_INTERNAL,
4459
4460   .n_errors = LISP_CP_INPUT_N_ERROR,
4461   .error_strings = lisp_cp_input_error_strings,
4462
4463   .n_next_nodes = LISP_CP_INPUT_N_NEXT,
4464
4465   .next_nodes = {
4466       [LISP_CP_INPUT_NEXT_DROP] = "error-drop",
4467   },
4468 };
4469 /* *INDENT-ON* */
4470
4471 clib_error_t *
4472 lisp_cp_init (vlib_main_t * vm)
4473 {
4474   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4475   clib_error_t *error = 0;
4476   vlib_thread_main_t *vtm = vlib_get_thread_main ();
4477   u32 num_threads;
4478
4479   if ((error = vlib_call_init_function (vm, lisp_gpe_init)))
4480     return error;
4481
4482   lcm->im4 = &ip4_main;
4483   lcm->im6 = &ip6_main;
4484   lcm->vlib_main = vm;
4485   lcm->vnet_main = vnet_get_main ();
4486   lcm->mreq_itr_rlocs = ~0;
4487   lcm->flags = 0;
4488   lcm->pitr_map_index = ~0;
4489   lcm->petr_map_index = ~0;
4490   clib_memset (&lcm->active_map_resolver, 0,
4491                sizeof (lcm->active_map_resolver));
4492   clib_memset (&lcm->active_map_server, 0, sizeof (lcm->active_map_server));
4493
4494   gid_dictionary_init (&lcm->mapping_index_by_gid);
4495   lcm->do_map_resolver_election = 1;
4496   lcm->do_map_server_election = 1;
4497   lcm->map_request_mode = MR_MODE_DST_ONLY;
4498
4499   num_threads = 1 /* main thread */  + vtm->n_threads;
4500   vec_validate (lcm->map_records_args_pool, num_threads - 1);
4501
4502   /* default vrf mapped to vni 0 */
4503   hash_set (lcm->table_id_by_vni, 0, 0);
4504   hash_set (lcm->vni_by_table_id, 0, 0);
4505
4506   TW (tw_timer_wheel_init) (&lcm->wheel, 0 /* no callback */ ,
4507                             1e-3 /* timer period 1ms */ ,
4508                             ~0 /* max expirations per call */ );
4509   lcm->nsh_map_index = ~0;
4510   lcm->map_register_ttl = MAP_REGISTER_DEFAULT_TTL;
4511   lcm->max_expired_map_registers = MAX_EXPIRED_MAP_REGISTERS_DEFAULT;
4512   lcm->expired_map_registers = 0;
4513   lcm->transport_protocol = LISP_TRANSPORT_PROTOCOL_UDP;
4514   lcm->flags |= LISP_FLAG_XTR_MODE;
4515   return 0;
4516 }
4517
4518 static int
4519 lisp_stats_api_fill (lisp_cp_main_t * lcm, lisp_gpe_main_t * lgm,
4520                      lisp_api_stats_t * stat, lisp_stats_key_t * key,
4521                      u32 stats_index)
4522 {
4523   vlib_counter_t v;
4524   vlib_combined_counter_main_t *cm = &lgm->counters;
4525   lisp_gpe_fwd_entry_key_t fwd_key;
4526   const lisp_gpe_tunnel_t *lgt;
4527   fwd_entry_t *fe;
4528
4529   clib_memset (stat, 0, sizeof (*stat));
4530   clib_memset (&fwd_key, 0, sizeof (fwd_key));
4531
4532   fe = pool_elt_at_index (lcm->fwd_entry_pool, key->fwd_entry_index);
4533   ASSERT (fe != 0);
4534
4535   gid_to_dp_address (&fe->reid, &stat->deid);
4536   gid_to_dp_address (&fe->leid, &stat->seid);
4537   stat->vni = gid_address_vni (&fe->reid);
4538
4539   lgt = lisp_gpe_tunnel_get (key->tunnel_index);
4540   stat->loc_rloc = lgt->key->lcl;
4541   stat->rmt_rloc = lgt->key->rmt;
4542
4543   vlib_get_combined_counter (cm, stats_index, &v);
4544   stat->counters = v;
4545   return 1;
4546 }
4547
4548 lisp_api_stats_t *
4549 vnet_lisp_get_stats (void)
4550 {
4551   lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
4552   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4553   lisp_api_stats_t *stats = 0, stat;
4554   lisp_stats_key_t *key;
4555   u32 index;
4556
4557   /* *INDENT-OFF* */
4558   hash_foreach_mem (key, index, lgm->lisp_stats_index_by_key,
4559   {
4560     if (lisp_stats_api_fill (lcm, lgm, &stat, key, index))
4561       vec_add1 (stats, stat);
4562   });
4563   /* *INDENT-ON* */
4564
4565   return stats;
4566 }
4567
4568 static void *
4569 send_map_request_thread_fn (void *arg)
4570 {
4571   map_request_args_t *a = arg;
4572   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4573
4574   if (a->is_resend)
4575     resend_encapsulated_map_request (lcm, &a->seid, &a->deid, a->smr_invoked);
4576   else
4577     send_encapsulated_map_request (lcm, &a->seid, &a->deid, a->smr_invoked);
4578
4579   return 0;
4580 }
4581
4582 static int
4583 queue_map_request (gid_address_t * seid, gid_address_t * deid,
4584                    u8 smr_invoked, u8 is_resend)
4585 {
4586   map_request_args_t a;
4587
4588   a.is_resend = is_resend;
4589   gid_address_copy (&a.seid, seid);
4590   gid_address_copy (&a.deid, deid);
4591   a.smr_invoked = smr_invoked;
4592
4593   vl_api_rpc_call_main_thread (send_map_request_thread_fn,
4594                                (u8 *) & a, sizeof (a));
4595   return 0;
4596 }
4597
4598 /**
4599  * Take an action with a pending map request depending on expiration time
4600  * and re-try counters.
4601  */
4602 static void
4603 update_pending_request (pending_map_request_t * r, f64 dt)
4604 {
4605   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4606   lisp_msmr_t *mr;
4607
4608   if (r->time_to_expire - dt < 0)
4609     /* it's time to decide what to do with this pending request */
4610     {
4611       if (r->retries_num >= NUMBER_OF_RETRIES)
4612         /* too many retries -> assume current map resolver is not available */
4613         {
4614           mr = get_map_resolver (&lcm->active_map_resolver);
4615           if (!mr)
4616             {
4617               clib_warning ("Map resolver %U not found - probably deleted "
4618                             "by the user recently.", format_ip_address,
4619                             &lcm->active_map_resolver);
4620             }
4621           else
4622             {
4623               clib_warning ("map resolver %U is unreachable, ignoring",
4624                             format_ip_address, &lcm->active_map_resolver);
4625
4626               /* mark current map resolver unavailable so it won't be
4627                * selected next time */
4628               mr->is_down = 1;
4629               mr->last_update = vlib_time_now (lcm->vlib_main);
4630             }
4631
4632           reset_pending_mr_counters (r);
4633           elect_map_resolver (lcm);
4634
4635           /* try to find a next eligible map resolver and re-send */
4636           queue_map_request (&r->src, &r->dst, r->is_smr_invoked,
4637                              1 /* resend */ );
4638         }
4639       else
4640         {
4641           /* try again */
4642           queue_map_request (&r->src, &r->dst, r->is_smr_invoked,
4643                              1 /* resend */ );
4644           r->retries_num++;
4645           r->time_to_expire = PENDING_MREQ_EXPIRATION_TIME;
4646         }
4647     }
4648   else
4649     r->time_to_expire -= dt;
4650 }
4651
4652 static void
4653 remove_dead_pending_map_requests (lisp_cp_main_t * lcm)
4654 {
4655   u64 *nonce;
4656   pending_map_request_t *pmr;
4657   u32 *to_be_removed = 0, *pmr_index;
4658
4659   /* *INDENT-OFF* */
4660   pool_foreach (pmr, lcm->pending_map_requests_pool)
4661    {
4662     if (pmr->to_be_removed)
4663       {
4664         clib_fifo_foreach (nonce, pmr->nonces, ({
4665           hash_unset (lcm->pending_map_requests_by_nonce, nonce[0]);
4666         }));
4667
4668         vec_add1 (to_be_removed, pmr - lcm->pending_map_requests_pool);
4669       }
4670   }
4671   /* *INDENT-ON* */
4672
4673   vec_foreach (pmr_index, to_be_removed)
4674     pool_put_index (lcm->pending_map_requests_pool, pmr_index[0]);
4675
4676   vec_free (to_be_removed);
4677 }
4678
4679 static void
4680 update_rloc_probing (lisp_cp_main_t * lcm, f64 dt)
4681 {
4682   static f64 time_left = RLOC_PROBING_INTERVAL;
4683
4684   if (!lcm->is_enabled || !lcm->rloc_probing)
4685     return;
4686
4687   time_left -= dt;
4688   if (time_left <= 0)
4689     {
4690       time_left = RLOC_PROBING_INTERVAL;
4691       send_rloc_probes (lcm);
4692     }
4693 }
4694
4695 static int
4696 update_pending_map_register (pending_map_register_t * r, f64 dt, u8 * del_all)
4697 {
4698   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4699   lisp_msmr_t *ms;
4700   del_all[0] = 0;
4701
4702   r->time_to_expire -= dt;
4703
4704   if (r->time_to_expire < 0)
4705     {
4706       lcm->expired_map_registers++;
4707
4708       if (lcm->expired_map_registers >= lcm->max_expired_map_registers)
4709         {
4710           ms = get_map_server (&lcm->active_map_server);
4711           if (!ms)
4712             {
4713               clib_warning ("Map server %U not found - probably deleted "
4714                             "by the user recently.", format_ip_address,
4715                             &lcm->active_map_server);
4716             }
4717           else
4718             {
4719               clib_warning ("map server %U is unreachable, ignoring",
4720                             format_ip_address, &lcm->active_map_server);
4721
4722               /* mark current map server unavailable so it won't be
4723                * elected next time */
4724               ms->is_down = 1;
4725               ms->last_update = vlib_time_now (lcm->vlib_main);
4726             }
4727
4728           elect_map_server (lcm);
4729
4730           /* indication for deleting all pending map registers */
4731           del_all[0] = 1;
4732           lcm->expired_map_registers = 0;
4733           return 0;
4734         }
4735       else
4736         {
4737           /* delete pending map register */
4738           return 0;
4739         }
4740     }
4741   return 1;
4742 }
4743
4744 static void
4745 update_map_register (lisp_cp_main_t * lcm, f64 dt)
4746 {
4747   u32 *to_be_removed = 0, *pmr_index;
4748   static f64 time_left = QUICK_MAP_REGISTER_INTERVAL;
4749   static u64 mreg_sent_counter = 0;
4750
4751   pending_map_register_t *pmr;
4752   u8 del_all = 0;
4753
4754   if (!lcm->is_enabled || !lcm->map_registering)
4755     return;
4756
4757   /* *INDENT-OFF* */
4758   pool_foreach (pmr, lcm->pending_map_registers_pool)
4759    {
4760     if (!update_pending_map_register (pmr, dt, &del_all))
4761     {
4762       if (del_all)
4763         break;
4764       vec_add1 (to_be_removed, pmr - lcm->pending_map_registers_pool);
4765     }
4766   }
4767   /* *INDENT-ON* */
4768
4769   if (del_all)
4770     {
4771       /* delete all pending map register messages so they won't
4772        * trigger another map server election.. */
4773       pool_free (lcm->pending_map_registers_pool);
4774       hash_free (lcm->map_register_messages_by_nonce);
4775
4776       /* ..and trigger registration against next map server (if any) */
4777       time_left = 0;
4778     }
4779   else
4780     {
4781       vec_foreach (pmr_index, to_be_removed)
4782         pool_put_index (lcm->pending_map_registers_pool, pmr_index[0]);
4783     }
4784
4785   vec_free (to_be_removed);
4786
4787   time_left -= dt;
4788   if (time_left <= 0)
4789     {
4790       if (mreg_sent_counter >= QUICK_MAP_REGISTER_MSG_COUNT)
4791         time_left = MAP_REGISTER_INTERVAL;
4792       else
4793         {
4794           mreg_sent_counter++;
4795           time_left = QUICK_MAP_REGISTER_INTERVAL;
4796         }
4797       send_map_register (lcm, 1 /* want map notify */ );
4798     }
4799 }
4800
4801 static uword
4802 send_map_resolver_service (vlib_main_t * vm,
4803                            vlib_node_runtime_t * rt, vlib_frame_t * f)
4804 {
4805   u32 *expired = 0;
4806   f64 period = 2.0;
4807   pending_map_request_t *pmr;
4808   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4809
4810   while (1)
4811     {
4812       vlib_process_wait_for_event_or_clock (vm, period);
4813
4814       /* currently no signals are expected - just wait for clock */
4815       (void) vlib_process_get_events (vm, 0);
4816
4817       /* *INDENT-OFF* */
4818       pool_foreach (pmr, lcm->pending_map_requests_pool)
4819        {
4820         if (!pmr->to_be_removed)
4821           update_pending_request (pmr, period);
4822       }
4823       /* *INDENT-ON* */
4824
4825       remove_dead_pending_map_requests (lcm);
4826
4827       update_map_register (lcm, period);
4828       update_rloc_probing (lcm, period);
4829
4830       expired = TW (tw_timer_expire_timers_vec) (&lcm->wheel,
4831                                                  vlib_time_now (vm), expired);
4832       if (vec_len (expired) > 0)
4833         {
4834           u32 *mi = 0;
4835           vec_foreach (mi, expired)
4836           {
4837             process_expired_mapping (lcm, mi[0]);
4838           }
4839           _vec_len (expired) = 0;
4840         }
4841     }
4842
4843   /* unreachable */
4844   return 0;
4845 }
4846
4847 vnet_api_error_t
4848 vnet_lisp_stats_enable_disable (u8 enable)
4849 {
4850   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4851
4852   if (vnet_lisp_enable_disable_status () == 0)
4853     return VNET_API_ERROR_LISP_DISABLED;
4854
4855   if (enable)
4856     lcm->flags |= LISP_FLAG_STATS_ENABLED;
4857   else
4858     lcm->flags &= ~LISP_FLAG_STATS_ENABLED;
4859
4860   return 0;
4861 }
4862
4863 u8
4864 vnet_lisp_stats_enable_disable_state (void)
4865 {
4866   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4867
4868   if (vnet_lisp_enable_disable_status () == 0)
4869     return VNET_API_ERROR_LISP_DISABLED;
4870
4871   return lcm->flags & LISP_FLAG_STATS_ENABLED;
4872 }
4873
4874 void
4875 vnet_lisp_create_retry_process (lisp_cp_main_t * lcm)
4876 {
4877   if (lcm->retry_service_index)
4878     return;
4879
4880   lcm->retry_service_index = vlib_process_create (vlib_get_main (),
4881                                                   "lisp-retry-service",
4882                                                   send_map_resolver_service,
4883                                                   16 /* stack_bytes */ );
4884 }
4885
4886 u32
4887 vnet_lisp_set_transport_protocol (u8 protocol)
4888 {
4889   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4890
4891   if (protocol < LISP_TRANSPORT_PROTOCOL_UDP ||
4892       protocol > LISP_TRANSPORT_PROTOCOL_API)
4893     return VNET_API_ERROR_INVALID_ARGUMENT;
4894
4895   lcm->transport_protocol = protocol;
4896   return 0;
4897 }
4898
4899 lisp_transport_protocol_t
4900 vnet_lisp_get_transport_protocol (void)
4901 {
4902   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4903   return lcm->transport_protocol;
4904 }
4905
4906 int
4907 vnet_lisp_enable_disable_xtr_mode (u8 is_enabled)
4908 {
4909   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4910   u8 pitr_mode = lcm->flags & LISP_FLAG_PITR_MODE;
4911   u8 xtr_mode = lcm->flags & LISP_FLAG_XTR_MODE;
4912   u8 petr_mode = lcm->flags & LISP_FLAG_PETR_MODE;
4913
4914   if (pitr_mode && is_enabled)
4915     return VNET_API_ERROR_INVALID_ARGUMENT;
4916
4917   if (is_enabled && xtr_mode)
4918     return 0;
4919   if (!is_enabled && !xtr_mode)
4920     return 0;
4921
4922   if (is_enabled)
4923     {
4924       if (!petr_mode)
4925         {
4926           lisp_cp_register_dst_port (lcm->vlib_main);
4927         }
4928       lisp_cp_enable_l2_l3_ifaces (lcm, 1 /* with_default_route */ );
4929       lcm->flags |= LISP_FLAG_XTR_MODE;
4930     }
4931   else
4932     {
4933       if (!petr_mode)
4934         {
4935           lisp_cp_unregister_dst_port (lcm->vlib_main);
4936         }
4937       lisp_cp_disable_l2_l3_ifaces (lcm);
4938       lcm->flags &= ~LISP_FLAG_XTR_MODE;
4939     }
4940   return 0;
4941 }
4942
4943 int
4944 vnet_lisp_enable_disable_pitr_mode (u8 is_enabled)
4945 {
4946   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4947   u8 xtr_mode = lcm->flags & LISP_FLAG_XTR_MODE;
4948   u8 pitr_mode = lcm->flags & LISP_FLAG_PITR_MODE;
4949
4950   if (xtr_mode && is_enabled)
4951     return VNET_API_ERROR_INVALID_VALUE;
4952
4953   if (is_enabled && pitr_mode)
4954     return 0;
4955   if (!is_enabled && !pitr_mode)
4956     return 0;
4957
4958   if (is_enabled)
4959     {
4960       /* create iface, no default route */
4961       lisp_cp_enable_l2_l3_ifaces (lcm, 0 /* with_default_route */ );
4962       lcm->flags |= LISP_FLAG_PITR_MODE;
4963     }
4964   else
4965     {
4966       lisp_cp_disable_l2_l3_ifaces (lcm);
4967       lcm->flags &= ~LISP_FLAG_PITR_MODE;
4968     }
4969   return 0;
4970 }
4971
4972 int
4973 vnet_lisp_enable_disable_petr_mode (u8 is_enabled)
4974 {
4975   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4976   u8 xtr_mode = lcm->flags & LISP_FLAG_XTR_MODE;
4977   u8 petr_mode = lcm->flags & LISP_FLAG_PETR_MODE;
4978
4979   if (is_enabled && petr_mode)
4980     return 0;
4981   if (!is_enabled && !petr_mode)
4982     return 0;
4983
4984   if (is_enabled)
4985     {
4986       if (!xtr_mode)
4987         {
4988           lisp_cp_register_dst_port (lcm->vlib_main);
4989         }
4990       lcm->flags |= LISP_FLAG_PETR_MODE;
4991     }
4992   else
4993     {
4994       if (!xtr_mode)
4995         {
4996           lisp_cp_unregister_dst_port (lcm->vlib_main);
4997         }
4998       lcm->flags &= ~LISP_FLAG_PETR_MODE;
4999     }
5000   return 0;
5001 }
5002
5003 u8
5004 vnet_lisp_get_xtr_mode (void)
5005 {
5006   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
5007   return (lcm->flags & LISP_FLAG_XTR_MODE);
5008 }
5009
5010 u8
5011 vnet_lisp_get_pitr_mode (void)
5012 {
5013   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
5014   return (lcm->flags & LISP_FLAG_PITR_MODE);
5015 }
5016
5017 u8
5018 vnet_lisp_get_petr_mode (void)
5019 {
5020   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
5021   return (lcm->flags & LISP_FLAG_PETR_MODE);
5022 }
5023
5024 VLIB_INIT_FUNCTION (lisp_cp_init);
5025
5026 /*
5027  * fd.io coding-style-patch-verification: ON
5028  *
5029  * Local Variables:
5030  * eval: (c-set-style "gnu")
5031  * End:
5032  */