vnet/vnet/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 <vnet/lisp-cp/control.h>
  17 #include <vnet/lisp-cp/packets.h>
  18 #include <vnet/lisp-cp/lisp_msg_serdes.h>
  19 #include <vnet/lisp-gpe/lisp_gpe.h>
  20
  21 static void
  22 add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index);
  23
  24 static void
  25 del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index);
  26
  27 static u8
  28 compare_locators (lisp_cp_main_t *lcm, u32 * old_ls_indexes,
  29                   locator_t * new_locators);
  30
  31 /* Stores mapping in map-cache. It does NOT program data plane forwarding for
  32  * remote/learned mappings. */
  33 int
  34 vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a,
  35                            u32 * map_index_result)
  36 {
  37   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
  38   u32 mi, * map_indexp, map_index, i;
  39   mapping_t * m, * old_map;
  40   u32 ** eid_indexes;
  41
  42   mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &a->deid);
  43   old_map = mi != ~0 ? pool_elt_at_index (lcm->mapping_pool, mi) : 0;
  44   if (a->is_add)
  45     {
  46       /* TODO check if overwriting and take appropriate actions */
  47       if (mi != GID_LOOKUP_MISS && !gid_address_cmp (&old_map->eid,
  48                                                      &a->deid))
  49         {
  50           clib_warning("eid %U found in the eid-table", format_ip_address,
  51                        &a->deid);
  52           return VNET_API_ERROR_VALUE_EXIST;
  53         }
  54
  55       pool_get(lcm->mapping_pool, m);
  56       m->eid = a->deid;
  57       m->locator_set_index = a->locator_set_index;
  58       m->ttl = a->ttl;
  59       m->action = a->action;
  60       m->local = a->local;
  61
  62       map_index = m - lcm->mapping_pool;
  63       gid_dictionary_add_del (&lcm->mapping_index_by_gid, &a->deid, map_index,
  64                               1);
  65
  66       if (pool_is_free_index(lcm->locator_set_pool, a->locator_set_index))
  67         {
  68           clib_warning("Locator set with index %d doesn't exist",
  69                        a->locator_set_index);
  70           return VNET_API_ERROR_INVALID_VALUE;
  71         }
  72
  73       /* add eid to list of eids supported by locator-set */
  74       vec_validate (lcm->locator_set_to_eids, a->locator_set_index);
  75       eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids,
  76                                      a->locator_set_index);
  77       vec_add1(eid_indexes[0], map_index);
  78
  79       if (a->local)
  80         {
  81           /* mark as local */
  82           vec_add1(lcm->local_mappings_indexes, map_index);
  83         }
  84       map_index_result[0] = map_index;
  85     }
  86   else
  87     {
  88       if (mi == GID_LOOKUP_MISS)
  89         {
  90           clib_warning("eid %U not found in the eid-table", format_ip_address,
  91                        &a->deid);
  92           return VNET_API_ERROR_INVALID_VALUE;
  93         }
  94
  95       /* clear locator-set to eids binding */
  96       eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids,
  97                                      a->locator_set_index);
  98       for (i = 0; i < vec_len(eid_indexes[0]); i++)
  99         {
 100           map_indexp = vec_elt_at_index(eid_indexes[0], i);
 101           if (map_indexp[0] == mi)
 102               break;
 103         }
 104       vec_del1(eid_indexes[0], i);
 105
 106       /* remove local mark if needed */
 107       m = pool_elt_at_index(lcm->mapping_pool, mi);
 108       if (m->local)
 109         {
 110           u32 k, * lm_indexp;
 111           for (k = 0; k < vec_len(lcm->local_mappings_indexes); k++)
 112             {
 113               lm_indexp = vec_elt_at_index(lcm->local_mappings_indexes, k);
 114               if (lm_indexp[0] == mi)
 115                 break;
 116             }
 117           vec_del1(lcm->local_mappings_indexes, k);
 118         }
 119       else
 120         {
 121           /* remove tunnel ??? */
 122         }
 123
 124       /* remove mapping from dictionary */
 125       gid_dictionary_add_del (&lcm->mapping_index_by_gid, &a->deid, 0, 0);
 126       pool_put_index (lcm->mapping_pool, mi);
 127     }
 128
 129   return 0;
 130 }
 131
 132 /* Stores mapping in map-cache and programs data plane for local mappings. */
 133 int
 134 vnet_lisp_add_del_local_mapping (vnet_lisp_add_del_mapping_args_t * a,
 135                                  u32 * map_index_result)
 136 {
 137   uword * table_id, * refc;
 138   u32 rv, vni;
 139   vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai;
 140   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
 141
 142   vni = gid_address_vni(&a->deid);
 143
 144   /* store/remove mapping from map-cache */
 145   rv = vnet_lisp_add_del_mapping (a, map_index_result);
 146   if (rv)
 147     return rv;
 148
 149   table_id = hash_get(lcm->table_id_by_vni, vni);
 150
 151   if (!table_id)
 152     {
 153       clib_warning ("vni %d not associated to a vrf!", vni);
 154       return VNET_API_ERROR_INVALID_VALUE;
 155     }
 156
 157   refc = hash_get(lcm->dp_if_refcount_by_vni, vni);
 158
 159   /* enable/disable data-plane interface */
 160   if (a->is_add)
 161     {
 162       /* create interface or update refcount */
 163       if (!refc)
 164         {
 165           ai->is_add = 1;
 166           ai->vni = vni;
 167           ai->table_id = table_id[0];
 168           vnet_lisp_gpe_add_del_iface (ai, 0);
 169
 170           /* counts the number of eids in a vni that use the interface */
 171           hash_set(lcm->dp_if_refcount_by_vni, vni, 1);
 172         }
 173       else
 174         {
 175           refc[0]++;
 176         }
 177     }
 178   else
 179     {
 180       /* since this is a remove for an existing eid, the iface should exist */
 181       ASSERT(refc != 0);
 182       refc[0]--;
 183
 184       /* remove iface if needed */
 185       if (refc[0] == 0)
 186         {
 187           ai->is_add = 0;
 188           ai->vni = vni;
 189           ai->table_id = table_id[0];
 190           vnet_lisp_gpe_add_del_iface (ai, 0);
 191           hash_unset (lcm->dp_if_refcount_by_vni, vni);
 192         }
 193     }
 194
 195   return rv;
 196 }
 197
 198 static clib_error_t *
 199 lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input,
 200                                    vlib_cli_command_t * cmd)
 201 {
 202   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
 203   unformat_input_t _line_input, * line_input = &_line_input;
 204   u8 is_add = 1;
 205   gid_address_t eid;
 206   ip_prefix_t * prefp = &gid_address_ippref(&eid);
 207   gid_address_t * eids = 0;
 208   clib_error_t * error = 0;
 209   u8 * locator_set_name = 0;
 210   u32 locator_set_index = 0, map_index = 0;
 211   uword * p;
 212   vnet_lisp_add_del_mapping_args_t _a, * a = &_a;
 213
 214   gid_address_type (&eid) = GID_ADDR_IP_PREFIX;
 215
 216   /* Get a line of input. */
 217   if (! unformat_user (input, unformat_line_input, line_input))
 218     return 0;
 219
 220   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 221     {
 222       if (unformat (line_input, "add"))
 223         is_add = 1;
 224       else if (unformat (line_input, "del"))
 225         is_add = 0;
 226       else if (unformat (line_input, "eid %U", unformat_ip_prefix, prefp))
 227         {
 228           vec_add1(eids, eid);
 229         }
 230       else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
 231         {
 232           p = hash_get_mem(lcm->locator_set_index_by_name, locator_set_name);
 233           if (!p)
 234             {
 235               error = clib_error_return(0, "locator-set %s doesn't exist",
 236                                         locator_set_name);
 237               goto done;
 238             }
 239           locator_set_index = p[0];
 240         }
 241       else
 242         {
 243           error = unformat_parse_error(line_input);
 244           goto done;
 245         }
 246     }
 247
 248   /* XXX treat batch configuration */
 249   a->deid = eid;
 250   a->is_add = is_add;
 251   a->locator_set_index = locator_set_index;
 252   a->local = 1;
 253
 254   vnet_lisp_add_del_local_mapping (a, &map_index);
 255  done:
 256   vec_free(eids);
 257   if (locator_set_name)
 258     vec_free (locator_set_name);
 259   return error;
 260 }
 261
 262 VLIB_CLI_COMMAND (lisp_add_del_local_eid_command) = {
 263     .path = "lisp eid-table",
 264     .short_help = "lisp eid-table add/del eid <eid> locator-set <locator-set>",
 265     .function = lisp_add_del_local_eid_command_fn,
 266 };
 267
 268 static int
 269 lisp_add_del_negative_static_mapping (gid_address_t * deid,
 270     vnet_lisp_add_del_locator_set_args_t * ls, u8 action, u8 is_add)
 271 {
 272   uword * p;
 273   mapping_t * map;
 274   u32 mi = ~0;
 275   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
 276   uword * refc;
 277   vnet_lisp_add_del_mapping_args_t _dm_args, * dm_args = &_dm_args;
 278   int rv = 0;
 279   u32 ls_index = 0, dst_map_index;
 280   vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai;
 281
 282   memset (dm_args, 0, sizeof (dm_args[0]));
 283   u32 vni = gid_address_vni (deid);
 284   refc = hash_get (lcm->dp_if_refcount_by_vni, vni);
 285
 286   p = hash_get (lcm->table_id_by_vni, vni);
 287   if (!p)
 288     {
 289       clib_warning ("vni %d not associated to a vrf!", vni);
 290       return VNET_API_ERROR_INVALID_VALUE;
 291     }
 292
 293   if (is_add)
 294     {
 295       vnet_lisp_add_del_locator_set (ls, &ls_index);
 296       /* add mapping */
 297       gid_address_copy (&dm_args->deid, deid);
 298       dm_args->is_add = 1;
 299       dm_args->action = action;
 300       dm_args->locator_set_index = ls_index;
 301
 302       /* create interface or update refcount */
 303       if (!refc)
 304         {
 305           vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai;
 306           ai->is_add = 1;
 307           ai->vni = vni;
 308           ai->table_id = p[0];
 309           vnet_lisp_gpe_add_del_iface (ai, 0);
 310
 311           /* counts the number of eids in a vni that use the interface */
 312           hash_set (lcm->dp_if_refcount_by_vni, vni, 1);
 313         }
 314       else
 315         refc[0]++;
 316
 317       rv = vnet_lisp_add_del_local_mapping (dm_args, &dst_map_index);
 318       if (!rv)
 319         add_fwd_entry (lcm, lcm->pitr_map_index, dst_map_index);
 320     }
 321   else
 322     {
 323       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, deid);
 324       if ((u32)~0 == mi)
 325         {
 326           clib_warning ("eid %U marked for removal, but not found in "
 327                         "map-cache!", unformat_gid_address, deid);
 328           return VNET_API_ERROR_INVALID_VALUE;
 329         }
 330
 331       /* delete forwarding entry */
 332       del_fwd_entry (lcm, 0, mi);
 333
 334       dm_args->is_add = 0;
 335       gid_address_copy (&dm_args->deid, deid);
 336       map = pool_elt_at_index (lcm->mapping_pool, mi);
 337       dm_args->locator_set_index = map->locator_set_index;
 338
 339       /* delete mapping associated to fwd entry */
 340       vnet_lisp_add_del_mapping (dm_args, 0);
 341
 342       refc = hash_get (lcm->dp_if_refcount_by_vni, vni);
 343       ASSERT(refc != 0);
 344       refc[0]--;
 345
 346       /* remove iface if needed */
 347       if (refc[0] == 0)
 348         {
 349           ai->is_add = 0;
 350           ai->vni = vni;
 351           ai->table_id = p[0];
 352           vnet_lisp_gpe_add_del_iface (ai, 0);
 353           hash_unset (lcm->dp_if_refcount_by_vni, vni);
 354         }
 355     }
 356   return rv;
 357 }
 358
 359 /**
 360  * Adds/removes/updates static remote mapping.
 361  *
 362  * This function also modifies forwarding entries if needed.
 363  *
 364  * @param deid destination EID
 365  * @param seid source EID
 366  * @param rlocs vector of remote locators
 367  * @param action action for negative map-reply
 368  * @param is_add add mapping if non-zero, delete otherwise
 369  * @param del_all if set, delete all remote mappings
 370  * @return return code
 371  */
 372 int
 373 vnet_lisp_add_del_remote_mapping (gid_address_t * deid, gid_address_t * seid,
 374                                   ip_address_t * rlocs, u8 action, u8 is_add,
 375                                   u8 del_all)
 376 {
 377   vnet_lisp_add_del_mapping_args_t _dm_args, * dm_args = &_dm_args;
 378   vnet_lisp_add_del_mapping_args_t _sm_args, * sm_args = &_sm_args;
 379   vnet_lisp_add_del_locator_set_args_t _ls, * ls = &_ls;
 380   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
 381   u32 mi, ls_index = 0, dst_map_index, src_map_index;
 382   locator_t loc;
 383   ip_address_t * dl;
 384   int rc = -1;
 385
 386   if (del_all)
 387     return vnet_lisp_clear_all_remote_mappings ();
 388
 389   memset (sm_args, 0, sizeof (sm_args[0]));
 390   memset (dm_args, 0, sizeof (dm_args[0]));
 391   memset (ls, 0, sizeof (ls[0]));
 392
 393   /* prepare remote locator set */
 394   vec_foreach (dl, rlocs)
 395     {
 396       memset (&loc, 0, sizeof (loc));
 397       gid_address_ip (&loc.address) = dl[0];
 398       vec_add1 (ls->locators, loc);
 399     }
 400   src_map_index = gid_dictionary_lookup (&lcm->mapping_index_by_gid, seid);
 401
 402   mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, deid);
 403   /* new mapping */
 404   if ((u32)~0 == mi)
 405     {
 406       ls->is_add = 1;
 407       ls->index = ~0;
 408
 409       /* process a negative mapping */
 410       if (0 == vec_len (rlocs))
 411         return lisp_add_del_negative_static_mapping (deid, ls,
 412                                                      action, is_add);
 413
 414       if ((u32)~0 == src_map_index)
 415         {
 416           clib_warning ("seid %U not found!", format_gid_address, seid);
 417           goto done;
 418         }
 419
 420       if (!is_add)
 421         {
 422           clib_warning ("deid %U marked for removal but not "
 423                         "found!", format_gid_address, deid);
 424           goto done;
 425         }
 426
 427       vnet_lisp_add_del_locator_set (ls, &ls_index);
 428
 429       /* add mapping */
 430       gid_address_copy (&dm_args->deid, deid);
 431       dm_args->is_add = 1;
 432       dm_args->action = action;
 433       dm_args->locator_set_index = ls_index;
 434       vnet_lisp_add_del_mapping (dm_args, &dst_map_index);
 435
 436       /* add fwd tunnel */
 437       add_fwd_entry (lcm, src_map_index, dst_map_index);
 438     }
 439   else
 440     {
 441       /* delete mapping */
 442       if (!is_add)
 443         {
 444           /* delete forwarding entry */
 445           del_fwd_entry (lcm, 0, mi);
 446           dm_args->is_add = 0;
 447           gid_address_copy (&dm_args->deid, deid);
 448           mapping_t * map = pool_elt_at_index (lcm->mapping_pool, mi);
 449           dm_args->locator_set_index = map->locator_set_index;
 450
 451           /* delete mapping associated to fwd entry */
 452           vnet_lisp_add_del_mapping (dm_args, 0);
 453
 454           ls->is_add = 0;
 455           ls->index = map->locator_set_index;
 456           /* delete locator set */
 457           vnet_lisp_add_del_locator_set (ls, 0);
 458         }
 459       /* update existing locator set */
 460       else
 461         {
 462           if ((u32)~0 == src_map_index)
 463             {
 464               clib_warning ("seid %U not found!", format_gid_address, seid);
 465               goto done;
 466             }
 467
 468           mapping_t * old_map;
 469           locator_set_t * old_ls;
 470           old_map = pool_elt_at_index (lcm->mapping_pool, mi);
 471
 472           /* update mapping attributes */
 473           old_map->action = action;
 474
 475           old_ls = pool_elt_at_index(lcm->locator_set_pool,
 476                                      old_map->locator_set_index);
 477           if (compare_locators (lcm, old_ls->locator_indices,
 478                                 ls->locators))
 479             {
 480               /* set locator-set index to overwrite */
 481               ls->is_add = 1;
 482               ls->index = old_map->locator_set_index;
 483               vnet_lisp_add_del_locator_set (ls, 0);
 484               add_fwd_entry (lcm, src_map_index, mi);
 485             }
 486         }
 487     }
 488   /* success */
 489   rc = 0;
 490 done:
 491   vec_free (ls->locators);
 492   return rc;
 493 }
 494
 495 int
 496 vnet_lisp_clear_all_remote_mappings (void)
 497 {
 498   int rv = 0;
 499   u32 mi, * map_indices = 0, * map_indexp;
 500   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
 501   vnet_lisp_add_del_mapping_args_t _dm_args, * dm_args = &_dm_args;
 502   vnet_lisp_add_del_locator_set_args_t _ls, * ls = &_ls;
 503
 504   pool_foreach_index (mi, lcm->mapping_pool,
 505     ({
 506       vec_add1 (map_indices, mi);
 507     }));
 508
 509   vec_foreach (map_indexp, map_indices)
 510     {
 511       mapping_t * map = pool_elt_at_index (lcm->mapping_pool, map_indexp[0]);
 512       if (!map->local)
 513         {
 514           del_fwd_entry (lcm, 0, map_indexp[0]);
 515
 516           dm_args->is_add = 0;
 517           gid_address_copy (&dm_args->deid, &map->eid);
 518           dm_args->locator_set_index = map->locator_set_index;
 519
 520           /* delete mapping associated to fwd entry */
 521           vnet_lisp_add_del_mapping (dm_args, 0);
 522
 523           ls->is_add = 0;
 524           ls->local = 0;
 525           ls->index = map->locator_set_index;
 526           /* delete locator set */
 527           rv = vnet_lisp_add_del_locator_set (ls, 0);
 528           if (rv != 0)
 529             goto cleanup;
 530         }
 531     }
 532
 533 cleanup:
 534   if (map_indices)
 535     vec_free (map_indices);
 536   return rv;
 537 }
 538
 539 /**
 540  * Handler for add/del remote mapping CLI.
 541  *
 542  * @param vm vlib context
 543  * @param input input from user
 544  * @param cmd cmd
 545  * @return pointer to clib error structure
 546  */
 547 static clib_error_t *
 548 lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
 549                                         unformat_input_t * input,
 550                                         vlib_cli_command_t * cmd)
 551 {
 552   clib_error_t * error = 0;
 553   unformat_input_t _line_input, * line_input = &_line_input;
 554   u8 is_add = 1, del_all = 0;
 555   ip_address_t rloc, * rlocs = 0;
 556   ip_prefix_t * deid_ippref, * seid_ippref;
 557   gid_address_t seid, deid;
 558   u8 deid_set = 0, seid_set = 0;
 559   u8 * s = 0;
 560   u32 vni, action = ~0;
 561
 562   /* Get a line of input. */
 563   if (! unformat_user (input, unformat_line_input, line_input))
 564     return 0;
 565
 566   memset (&deid, 0, sizeof (deid));
 567   memset (&seid, 0, sizeof (seid));
 568
 569   seid_ippref = &gid_address_ippref(&seid);
 570   deid_ippref = &gid_address_ippref(&deid);
 571
 572   gid_address_type (&deid) = GID_ADDR_IP_PREFIX;
 573   gid_address_type (&seid) = GID_ADDR_IP_PREFIX;
 574
 575   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 576     {
 577       if (unformat (line_input, "del-all"))
 578         del_all = 1;
 579       else if (unformat (line_input, "del"))
 580         is_add = 0;
 581       else if (unformat (line_input, "add"))
 582         ;
 583       else if (unformat (line_input, "deid %U",
 584                          unformat_ip_prefix, deid_ippref))
 585         {
 586           deid_set = 1;
 587         }
 588       else if (unformat (line_input, "vni %u", &vni))
 589         {
 590           gid_address_set_vni (&seid, vni);
 591           gid_address_set_vni (&deid, vni);
 592         }
 593       else if (unformat (line_input, "seid %U",
 594                          unformat_ip_prefix, seid_ippref))
 595         {
 596           seid_set = 1;
 597         }
 598       else if (unformat (line_input, "rloc %U", unformat_ip_address, &rloc))
 599         vec_add1 (rlocs, rloc);
 600       else if (unformat (line_input, "action %s", &s))
 601         {
 602           if (!strcmp ((char *)s, "no-action"))
 603             action = ACTION_NONE;
 604           if (!strcmp ((char *)s, "natively-forward"))
 605             action = ACTION_NATIVELY_FORWARDED;
 606           if (!strcmp ((char *)s, "send-map-request"))
 607             action = ACTION_SEND_MAP_REQUEST;
 608           else if (!strcmp ((char *)s, "drop"))
 609             action = ACTION_DROP;
 610           else
 611             {
 612               clib_warning ("invalid action: '%s'", s);
 613               goto done;
 614             }
 615         }
 616       else
 617         {
 618           clib_warning ("parse error");
 619           goto done;
 620         }
 621     }
 622
 623   if (!del_all)
 624     {
 625       if (!deid_set)
 626         {
 627           clib_warning ("missing deid!");
 628           goto done;
 629         }
 630
 631       /* if seid not set, make sure the ip version is the same as that of the
 632        * deid. This ensures the seid to be configured will be either 0/0 or
 633        * ::/0 */
 634       if (!seid_set)
 635         ip_prefix_version(seid_ippref) = ip_prefix_version(deid_ippref);
 636
 637       if (is_add &&
 638           (ip_prefix_version (deid_ippref) != ip_prefix_version(seid_ippref)))
 639         {
 640           clib_warning ("source and destination EIDs are not"
 641                         " in the same IP family!");
 642           goto done;
 643         }
 644
 645       if (is_add && (~0 == action)
 646           && 0 == vec_len (rlocs))
 647         {
 648           clib_warning ("no action set for negative map-reply!");
 649           goto done;
 650         }
 651     }
 652
 653   int rv = vnet_lisp_add_del_remote_mapping (&deid, &seid, rlocs,
 654                                              action, is_add, del_all);
 655   if (rv)
 656     clib_warning ("failed to %s remote mapping!",
 657                   is_add ? "add" : "delete");
 658
 659 done:
 660   unformat_free (line_input);
 661   if (s)
 662     vec_free (s);
 663   return error;
 664 }
 665
 666 VLIB_CLI_COMMAND (lisp_add_del_remote_mapping_command) = {
 667     .path = "lisp remote-mapping",
 668     .short_help = "lisp remote-mapping add|del [del-all] vni <vni>"
 669      "deid <dest-eid> seid <src-eid> [action <no-action|natively-forward|"
 670      "send-map-request|drop>] rloc <dst-locator> [rloc <dst-locator> ... ]",
 671     .function = lisp_add_del_remote_mapping_command_fn,
 672 };
 673
 674 static clib_error_t *
 675 lisp_show_map_resolvers_command_fn (vlib_main_t * vm,
 676                                     unformat_input_t * input,
 677                                     vlib_cli_command_t * cmd)
 678 {
 679   ip_address_t * addr;
 680   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
 681
 682   vec_foreach (addr, lcm->map_resolvers)
 683     {
 684       vlib_cli_output (vm, "%U", format_ip_address, addr);
 685     }
 686   return 0;
 687 }
 688
 689 VLIB_CLI_COMMAND (lisp_show_map_resolvers_command) = {
 690     .path = "show lisp map-resolvers",
 691     .short_help = "show lisp map-resolvers",
 692     .function = lisp_show_map_resolvers_command_fn,
 693 };
 694
 695 int
 696 vnet_lisp_pitr_set_locator_set (u8 * locator_set_name, u8 is_add)
 697 {
 698   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
 699   u32 locator_set_index = ~0;
 700   mapping_t * m;
 701   uword * p;
 702
 703   p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name);
 704   if (!p)
 705     {
 706       clib_warning ("locator-set %v doesn't exist", locator_set_name);
 707       return -1;
 708     }
 709   locator_set_index = p[0];
 710
 711   if (is_add)
 712     {
 713       pool_get (lcm->mapping_pool, m);
 714       m->locator_set_index = locator_set_index;
 715       m->local = 1;
 716       lcm->pitr_map_index = m - lcm->mapping_pool;
 717
 718       /* enable pitr mode */
 719       lcm->lisp_pitr = 1;
 720     }
 721   else
 722     {
 723       /* remove pitr mapping */
 724       pool_put_index (lcm->mapping_pool, lcm->pitr_map_index);
 725
 726       /* disable pitr mode */
 727       lcm->lisp_pitr = 0;
 728     }
 729   return 0;
 730 }
 731
 732 static clib_error_t *
 733 lisp_pitr_set_locator_set_command_fn (vlib_main_t * vm,
 734                                       unformat_input_t * input,
 735                                       vlib_cli_command_t * cmd)
 736 {
 737   u8 locator_name_set = 0;
 738   u8 * locator_set_name = 0;
 739   u8 is_add = 1;
 740   unformat_input_t _line_input, * line_input = &_line_input;
 741
 742   /* Get a line of input. */
 743   if (! unformat_user (input, unformat_line_input, line_input))
 744     return 0;
 745
 746   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 747     {
 748       if (unformat (line_input, "ls %_%v%_", &locator_set_name))
 749         locator_name_set = 1;
 750       else if (unformat (line_input, "disable"))
 751         is_add = 0;
 752       else
 753         return clib_error_return (0, "parse error");
 754     }
 755
 756   if (!locator_name_set)
 757     {
 758       clib_warning ("No locator set specified!");
 759       goto done;
 760     }
 761   vnet_lisp_pitr_set_locator_set (locator_set_name, is_add);
 762
 763 done:
 764   if (locator_set_name)
 765     vec_free (locator_set_name);
 766   return 0;
 767 }
 768
 769 VLIB_CLI_COMMAND (lisp_pitr_set_locator_set_command) = {
 770     .path = "lisp pitr",
 771     .short_help = "lisp pitr [disable] ls <locator-set-name>",
 772     .function = lisp_pitr_set_locator_set_command_fn,
 773 };
 774
 775 static clib_error_t *
 776 lisp_show_local_eid_table_command_fn (vlib_main_t * vm,
 777                                       unformat_input_t * input,
 778                                       vlib_cli_command_t * cmd)
 779 {
 780   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
 781   mapping_t * mapit;
 782
 783   vlib_cli_output (vm, "%=20s%=16s", "EID", "Locator");
 784   pool_foreach (mapit, lcm->mapping_pool,
 785   ({
 786     u8 * msg = 0;
 787     locator_set_t * ls = pool_elt_at_index (lcm->locator_set_pool,
 788                                             mapit->locator_set_index);
 789     vlib_cli_output (vm, "%-16U%16v", format_gid_address, &mapit->eid,
 790                      ls->name);
 791     vec_free (msg);
 792   }));
 793
 794   return 0;
 795 }
 796
 797 VLIB_CLI_COMMAND (lisp_cp_show_local_eid_table_command) = {
 798     .path = "show lisp eid-table",
 799     .short_help = "Shows local EID table",
 800     .function = lisp_show_local_eid_table_command_fn,
 801 };
 802
 803 /* cleans locator to locator-set data and removes locators not part of
 804  * any locator-set */
 805 static void
 806 clean_locator_to_locator_set (lisp_cp_main_t * lcm, u32 lsi)
 807 {
 808   u32 i, j, *loc_indexp, *ls_indexp, **ls_indexes, *to_be_deleted = 0;
 809   locator_set_t * ls = pool_elt_at_index(lcm->locator_set_pool, lsi);
 810   for (i = 0; i < vec_len(ls->locator_indices); i++)
 811     {
 812       loc_indexp = vec_elt_at_index(ls->locator_indices, i);
 813       ls_indexes = vec_elt_at_index(lcm->locator_to_locator_sets,
 814                                     loc_indexp[0]);
 815       for (j = 0; j < vec_len(ls_indexes[0]); j++)
 816         {
 817           ls_indexp = vec_elt_at_index(ls_indexes[0], j);
 818           if (ls_indexp[0] == lsi)
 819             break;
 820         }
 821
 822       /* delete index for removed locator-set*/
 823       vec_del1(ls_indexes[0], j);
 824
 825       /* delete locator if it's part of no locator-set */
 826       if (vec_len (ls_indexes[0]) == 0)
 827         {
 828           pool_put_index (lcm->locator_pool, loc_indexp[0]);
 829           vec_add1 (to_be_deleted, i);
 830         }
 831     }
 832
 833   if (to_be_deleted)
 834     {
 835       for (i = 0; i < vec_len (to_be_deleted); i++)
 836         {
 837           loc_indexp = vec_elt_at_index (to_be_deleted, i);
 838           vec_del1 (ls->locator_indices, loc_indexp[0]);
 839         }
 840       vec_free (to_be_deleted);
 841     }
 842 }
 843
 844 static inline
 845 uword *get_locator_set_index(vnet_lisp_add_del_locator_set_args_t * a,
 846                              uword * p)
 847 {
 848   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
 849
 850   ASSERT(a != NULL);
 851   ASSERT(p != NULL);
 852
 853   /* find locator-set */
 854   if (a->local)
 855     {
 856       p = hash_get_mem(lcm->locator_set_index_by_name, a->name);
 857     }
 858   else
 859     {
 860       *p = a->index;
 861     }
 862
 863   return p;
 864 }
 865
 866 static inline
 867 int is_locator_in_locator_set(lisp_cp_main_t * lcm, locator_set_t * ls,
 868                               locator_t * loc)
 869 {
 870   locator_t * itloc;
 871   u32 * locit;
 872
 873   ASSERT(ls != NULL);
 874   ASSERT(loc != NULL);
 875
 876   vec_foreach(locit, ls->locator_indices)
 877     {
 878       itloc = pool_elt_at_index(lcm->locator_pool, locit[0]);
 879       if (itloc->sw_if_index == loc->sw_if_index ||
 880           !gid_address_cmp(&itloc->address, &loc->address))
 881         {
 882           clib_warning("Duplicate locator");
 883           return VNET_API_ERROR_VALUE_EXIST;
 884         }
 885     }
 886
 887   return 0;
 888 }
 889
 890 static inline
 891 void remove_locator_from_locator_set(locator_set_t * ls, u32 * locit,
 892                                      u32 ls_index, u32 loc_id)
 893 {
 894   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
 895   u32 ** ls_indexes = NULL;
 896
 897   ASSERT(ls != NULL);
 898   ASSERT(locit != NULL);
 899
 900   ls_indexes = vec_elt_at_index(lcm->locator_to_locator_sets,
 901                                 locit[0]);
 902   pool_put_index(lcm->locator_pool, locit[0]);
 903   vec_del1(ls->locator_indices, loc_id);
 904   vec_del1(ls_indexes[0], ls_index);
 905 }
 906
 907 int
 908 vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t * a,
 909                            locator_set_t * ls, u32 * ls_result)
 910 {
 911   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
 912   locator_t * loc = NULL, *itloc = NULL;
 913   uword _p = (u32)~0, * p = &_p;
 914   u32 loc_index = ~0, ls_index = ~0, * locit = NULL, ** ls_indexes = NULL;
 915   u32 loc_id = ~0;
 916   int ret = 0;
 917
 918   ASSERT(a != NULL);
 919
 920   p = get_locator_set_index(a, p);
 921   if (!p)
 922     {
 923       clib_warning("locator-set %v doesn't exist", a->name);
 924       return VNET_API_ERROR_INVALID_ARGUMENT;
 925     }
 926
 927   if (ls == 0)
 928     {
 929       ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
 930       if (!ls)
 931         {
 932           clib_warning("locator-set %d to be overwritten doesn't exist!",
 933                        p[0]);
 934           return VNET_API_ERROR_INVALID_ARGUMENT;
 935         }
 936     }
 937
 938   if (a->is_add)
 939     {
 940
 941         if (ls_result)
 942           ls_result[0] = p[0];
 943
 944         /* allocate locators */
 945         vec_foreach (itloc, a->locators)
 946           {
 947             ret = is_locator_in_locator_set(lcm, ls, itloc);
 948             if (0 != ret)
 949               {
 950                 return ret;
 951               }
 952
 953             pool_get(lcm->locator_pool, loc);
 954             loc[0] = itloc[0];
 955             loc_index = loc - lcm->locator_pool;
 956
 957             vec_add1(ls->locator_indices, loc_index);
 958
 959             vec_validate (lcm->locator_to_locator_sets, loc_index);
 960             ls_indexes = vec_elt_at_index(lcm->locator_to_locator_sets,
 961                                           loc_index);
 962             vec_add1(ls_indexes[0], ls_index);
 963           }
 964       }
 965     else
 966       {
 967         ls_index = p[0];
 968
 969         itloc = a->locators;
 970         loc_id = 0;
 971         vec_foreach (locit, ls->locator_indices)
 972           {
 973             loc = pool_elt_at_index(lcm->locator_pool, locit[0]);
 974
 975             if (loc->local && loc->sw_if_index == itloc->sw_if_index)
 976               {
 977                 remove_locator_from_locator_set(ls, locit,
 978                                                 ls_index, loc_id);
 979               }
 980             if (0 == loc->local &&
 981                 !gid_address_cmp(&loc->address, &itloc->address))
 982               {
 983                 remove_locator_from_locator_set(ls, locit,
 984                                                 ls_index, loc_id);
 985               }
 986
 987             loc_id++;
 988           }
 989       }
 990
 991   return 0;
 992 }
 993
 994 int
 995 vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a,
 996                                u32 * ls_result)
 997 {
 998   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
 999   locator_set_t * ls;
1000   uword _p = (u32)~0, * p = &_p;
1001   u32 ls_index;
1002   u32 ** eid_indexes;
1003   int ret = 0;
1004
1005   if (a->is_add)
1006     {
1007       p = get_locator_set_index(a, p);
1008
1009       /* overwrite */
1010       if (p && p[0] != (u32)~0)
1011         {
1012           ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
1013           if (!ls)
1014             {
1015               clib_warning("locator-set %d to be overwritten doesn't exist!",
1016                            p[0]);
1017               return -1;
1018             }
1019
1020           /* clean locator to locator-set vectors and remove locators if
1021            * they're not part of another locator-set */
1022           clean_locator_to_locator_set (lcm, p[0]);
1023
1024           /* remove locator indices from locator set */
1025           vec_free(ls->locator_indices);
1026
1027           ls_index = p[0];
1028
1029           if (ls_result)
1030             ls_result[0] = p[0];
1031         }
1032       /* new locator-set */
1033       else
1034         {
1035           pool_get(lcm->locator_set_pool, ls);
1036           memset(ls, 0, sizeof(*ls));
1037           ls_index = ls - lcm->locator_set_pool;
1038
1039           if (a->local)
1040             {
1041               ls->name = vec_dup(a->name);
1042
1043               if (!lcm->locator_set_index_by_name)
1044                 lcm->locator_set_index_by_name = hash_create_vec(
1045                     /* size */0, sizeof(ls->name[0]), sizeof(uword));
1046               hash_set_mem(lcm->locator_set_index_by_name, ls->name, ls_index);
1047
1048               /* mark as local locator-set */
1049               vec_add1(lcm->local_locator_set_indexes, ls_index);
1050             }
1051           ls->local = a->local;
1052           if (ls_result)
1053             ls_result[0] = ls_index;
1054         }
1055
1056       ret = vnet_lisp_add_del_locator(a, ls, NULL);
1057       if (0 != ret)
1058         {
1059           return ret;
1060         }
1061     }
1062   else
1063     {
1064       p = get_locator_set_index(a, p);
1065       if (!p)
1066         {
1067           clib_warning("locator-set %v doesn't exists", a->name);
1068           return -1;
1069         }
1070
1071       ls = pool_elt_at_index(lcm->locator_set_pool, p[0]);
1072       if (!ls)
1073         {
1074           clib_warning("locator-set with index %d doesn't exists", p[0]);
1075           return -1;
1076         }
1077
1078       if (lcm->mreq_itr_rlocs == p[0])
1079         {
1080           clib_warning ("Can't delete the locator-set used to constrain "
1081                         "the itr-rlocs in map-requests!");
1082           return -1;
1083         }
1084
1085       if (vec_len(lcm->locator_set_to_eids) != 0)
1086       {
1087           eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids, p[0]);
1088           if (vec_len(eid_indexes[0]) != 0)
1089           {
1090               clib_warning ("Can't delete a locator that supports a mapping!");
1091               return -1;
1092           }
1093       }
1094
1095       /* clean locator to locator-sets data */
1096       clean_locator_to_locator_set (lcm, p[0]);
1097
1098       if (ls->local)
1099         {
1100           u32 it, lsi;
1101
1102           vec_foreach_index(it, lcm->local_locator_set_indexes)
1103           {
1104             lsi = vec_elt(lcm->local_locator_set_indexes, it);
1105             if (lsi == p[0])
1106               {
1107                 vec_del1(lcm->local_locator_set_indexes, it);
1108                 break;
1109               }
1110           }
1111           hash_unset_mem(lcm->locator_set_index_by_name, ls->name);
1112         }
1113       vec_free(ls->name);
1114       vec_free(ls->locator_indices);
1115       pool_put(lcm->locator_set_pool, ls);
1116     }
1117   return 0;
1118 }
1119
1120 clib_error_t *
1121 vnet_lisp_enable_disable (u8 is_enabled)
1122 {
1123   vnet_lisp_gpe_add_del_iface_args_t _ai, * ai= &_ai;
1124   uword * table_id, * refc;
1125   u32 i;
1126   clib_error_t * error = 0;
1127   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
1128   vnet_lisp_gpe_enable_disable_args_t _a, * a = &_a;
1129
1130   a->is_en = is_enabled;
1131   error = vnet_lisp_gpe_enable_disable (a);
1132   if (error)
1133     {
1134       return clib_error_return (0, "failed to %s data-plane!",
1135                                 a->is_en ? "enable" : "disable");
1136     }
1137
1138   if (is_enabled)
1139     {
1140       /* enable all ifaces */
1141       for (i = 0; i < vec_len (lcm->local_mappings_indexes); i++)
1142         {
1143           mapping_t * m = vec_elt_at_index (lcm->mapping_pool, i);
1144           ai->is_add = 1;
1145           ai->vni = gid_address_vni (&m->eid);
1146
1147           refc = hash_get (lcm->dp_if_refcount_by_vni, ai->vni);
1148           if (!refc)
1149             {
1150               table_id = hash_get (lcm->table_id_by_vni, ai->vni);
1151               if (table_id)
1152                 {
1153                   ai->table_id = table_id[0];
1154                   /* enables interface and adds defaults */
1155                   vnet_lisp_gpe_add_del_iface (ai, 0);
1156                 }
1157               else
1158                 return clib_error_return (0, "no table_id found for vni %u!",
1159                                           ai->vni);
1160
1161               hash_set (lcm->dp_if_refcount_by_vni, ai->vni, 1);
1162             }
1163           else
1164             {
1165               refc[0]++;
1166             }
1167         }
1168     }
1169   else
1170     {
1171       /* clear refcount table */
1172       hash_free (lcm->dp_if_refcount_by_vni);
1173       hash_free (lcm->fwd_entry_by_mapping_index);
1174       pool_free (lcm->fwd_entry_pool);
1175     }
1176
1177   /* update global flag */
1178   lcm->is_enabled = is_enabled;
1179
1180   return 0;
1181 }
1182
1183 static clib_error_t *
1184 lisp_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input,
1185                                    vlib_cli_command_t * cmd)
1186 {
1187   unformat_input_t _line_input, * line_input = &_line_input;
1188   u8 is_enabled = 0;
1189   u8 is_set = 0;
1190
1191   /* Get a line of input. */
1192   if (! unformat_user (input, unformat_line_input, line_input))
1193     return 0;
1194
1195   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1196     {
1197       if (unformat (line_input, "enable"))
1198         {
1199           is_set = 1;
1200           is_enabled = 1;
1201         }
1202       else if (unformat (line_input, "disable"))
1203         is_set = 1;
1204       else
1205         {
1206           return clib_error_return (0, "parse error: '%U'",
1207                                    format_unformat_error, line_input);
1208         }
1209     }
1210
1211   if (!is_set)
1212       return clib_error_return (0, "state not set");
1213
1214   return vnet_lisp_enable_disable (is_enabled);
1215 }
1216
1217 VLIB_CLI_COMMAND (lisp_cp_enable_disable_command) = {
1218     .path = "lisp",
1219     .short_help = "lisp [enable|disable]",
1220     .function = lisp_enable_disable_command_fn,
1221 };
1222
1223 u8
1224 vnet_lisp_enable_disable_status (void)
1225 {
1226   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
1227   return lcm->is_enabled;
1228 }
1229
1230 static u8 *
1231 format_lisp_status (u8 * s, va_list * args)
1232 {
1233   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
1234   return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled");
1235 }
1236
1237 static clib_error_t *
1238 lisp_show_status_command_fn (vlib_main_t * vm, unformat_input_t * input,
1239                              vlib_cli_command_t * cmd)
1240 {
1241   u8 * msg = 0;
1242   msg = format (msg, "feature: %U\ngpe: %U\n",
1243                 format_lisp_status, format_vnet_lisp_gpe_status);
1244   vlib_cli_output (vm, "%v", msg);
1245   vec_free (msg);
1246   return 0;
1247 }
1248
1249 VLIB_CLI_COMMAND (lisp_show_status_command) = {
1250     .path = "show lisp status",
1251     .short_help = "show lisp status",
1252     .function = lisp_show_status_command_fn,
1253 };
1254 static clib_error_t *
1255 lisp_add_del_locator_set_command_fn (vlib_main_t * vm, unformat_input_t * input,
1256                                      vlib_cli_command_t * cmd)
1257 {
1258   lisp_gpe_main_t * lgm = &lisp_gpe_main;
1259   vnet_main_t * vnm = lgm->vnet_main;
1260   unformat_input_t _line_input, * line_input = &_line_input;
1261   u8 is_add = 1;
1262   clib_error_t * error = 0;
1263   u8 * locator_set_name = 0;
1264   locator_t locator, * locators = 0;
1265   vnet_lisp_add_del_locator_set_args_t _a, * a = &_a;
1266   u32 ls_index = 0;
1267
1268   memset(&locator, 0, sizeof(locator));
1269   memset(a, 0, sizeof(a[0]));
1270
1271   /* Get a line of input. */
1272   if (! unformat_user (input, unformat_line_input, line_input))
1273     return 0;
1274
1275   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1276     {
1277       if (unformat (line_input, "add %_%v%_", &locator_set_name))
1278         is_add = 1;
1279       else if (unformat (line_input, "del %_%v%_", &locator_set_name))
1280         is_add = 0;
1281       else if (unformat (line_input, "iface %U p %d w %d",
1282                          unformat_vnet_sw_interface, vnm, &locator.sw_if_index,
1283                          &locator.priority, &locator.weight))
1284         {
1285           locator.local = 1;
1286           vec_add1(locators, locator);
1287         }
1288       else
1289         {
1290           error = unformat_parse_error(line_input);
1291           goto done;
1292         }
1293     }
1294
1295   a->name = locator_set_name;
1296   a->locators = locators;
1297   a->is_add = is_add;
1298   a->local = 1;
1299
1300   vnet_lisp_add_del_locator_set(a, &ls_index);
1301
1302  done:
1303   vec_free(locators);
1304   if (locator_set_name)
1305     vec_free (locator_set_name);
1306   return error;
1307 }
1308
1309 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_set_command) = {
1310     .path = "lisp locator-set",
1311     .short_help = "lisp locator-set add/del <name> iface <iface-name> "
1312         "p <priority> w <weight>",
1313     .function = lisp_add_del_locator_set_command_fn,
1314 };
1315
1316 static clib_error_t *
1317 lisp_cp_show_locator_sets_command_fn (vlib_main_t * vm,
1318                                       unformat_input_t * input,
1319                                       vlib_cli_command_t * cmd)
1320 {
1321   locator_set_t * lsit;
1322   locator_t * loc;
1323   u32 * locit;
1324   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
1325
1326   vlib_cli_output (vm, "%=20s%=16s%=16s%=16s", "Locator-set", "Locator",
1327                    "Priority", "Weight");
1328   pool_foreach (lsit, lcm->locator_set_pool,
1329   ({
1330     u8 * msg = 0;
1331     msg = format (msg, "%-16v", lsit->name);
1332     vec_foreach (locit, lsit->locator_indices)
1333       {
1334         loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1335         if (loc->local)
1336           msg = format (msg, "%16d%16d%16d", loc->sw_if_index, loc->priority,
1337                         loc->weight);
1338         else
1339           msg = format (msg, "%16U%16d%16d", format_gid_address, &loc->address,
1340                         loc->priority, loc->weight);
1341       }
1342     vlib_cli_output (vm, "%v", msg);
1343     vec_free (msg);
1344   }));
1345   return 0;
1346 }
1347
1348 VLIB_CLI_COMMAND (lisp_cp_show_locator_sets_command) = {
1349     .path = "show lisp locator-set",
1350     .short_help = "Shows locator-sets",
1351     .function = lisp_cp_show_locator_sets_command_fn,
1352 };
1353
1354 int
1355 vnet_lisp_add_del_map_resolver (vnet_lisp_add_del_map_resolver_args_t * a)
1356 {
1357   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
1358   ip_address_t * addr;
1359   u32 i;
1360
1361   if (a->is_add)
1362     {
1363       vec_foreach(addr, lcm->map_resolvers)
1364         {
1365           if (!ip_address_cmp (addr, &a->address))
1366             {
1367               clib_warning("map-resolver %U already exists!", format_ip_address,
1368                            &a->address);
1369               return -1;
1370             }
1371         }
1372       vec_add1(lcm->map_resolvers, a->address);
1373     }
1374   else
1375     {
1376       for (i = 0; i < vec_len(lcm->map_resolvers); i++)
1377         {
1378           addr = vec_elt_at_index(lcm->map_resolvers, i);
1379           if (!ip_address_cmp (addr, &a->address))
1380             {
1381               vec_delete(lcm->map_resolvers, 1, i);
1382               break;
1383             }
1384         }
1385     }
1386   return 0;
1387 }
1388
1389 static clib_error_t *
1390 lisp_add_del_map_resolver_command_fn (vlib_main_t * vm,
1391                                          unformat_input_t * input,
1392                                          vlib_cli_command_t * cmd)
1393 {
1394   unformat_input_t _line_input, * line_input = &_line_input;
1395   u8 is_add = 1;
1396   ip_address_t ip_addr;
1397   clib_error_t * error = 0;
1398   vnet_lisp_add_del_map_resolver_args_t _a, * a = &_a;
1399
1400   /* Get a line of input. */
1401   if (! unformat_user (input, unformat_line_input, line_input))
1402     return 0;
1403
1404   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1405     {
1406       if (unformat (line_input, "add"))
1407         is_add = 1;
1408       else if (unformat (line_input, "del"))
1409         is_add = 0;
1410       else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
1411         ;
1412       else
1413         {
1414           error = unformat_parse_error(line_input);
1415           goto done;
1416         }
1417     }
1418   a->is_add = is_add;
1419   a->address = ip_addr;
1420   vnet_lisp_add_del_map_resolver (a);
1421
1422  done:
1423   return error;
1424 }
1425
1426 VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = {
1427     .path = "lisp map-resolver",
1428     .short_help = "lisp map-resolver add/del <ip_address>",
1429     .function = lisp_add_del_map_resolver_command_fn,
1430 };
1431
1432 int
1433 vnet_lisp_add_del_mreq_itr_rlocs (vnet_lisp_add_del_mreq_itr_rloc_args_t * a)
1434 {
1435   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
1436   uword * p = 0;
1437
1438   //TODO: Wait for merge https://gerrit.fd.io/r/#/c/1427/
1439 //   if (vnet_lisp_enable_disable_status () == 0)
1440 //     {
1441 //       clib_warning ("LISP is disabled!");
1442 //       return VNET_API_ERROR_LISP_DISABLED;
1443 //     }
1444
1445   if (a->is_add)
1446     {
1447       p = hash_get_mem(lcm->locator_set_index_by_name, a->locator_set_name);
1448       if (!p)
1449         {
1450           clib_warning("locator-set %v doesn't exist", a->locator_set_name);
1451           return VNET_API_ERROR_INVALID_ARGUMENT;
1452         }
1453
1454       lcm->mreq_itr_rlocs = p[0];
1455     }
1456   else
1457     {
1458       lcm->mreq_itr_rlocs = ~0;
1459     }
1460
1461   return 0;
1462 }
1463
1464 static clib_error_t *
1465 lisp_add_del_mreq_itr_rlocs_command_fn(vlib_main_t * vm,
1466                                        unformat_input_t * input,
1467                                        vlib_cli_command_t * cmd)
1468 {
1469   unformat_input_t _line_input, * line_input = &_line_input;
1470   u8 is_add = 1;
1471   u8 * locator_set_name = 0;
1472   clib_error_t * error = 0;
1473   int rv = 0;
1474   vnet_lisp_add_del_mreq_itr_rloc_args_t _a, * a = &_a;
1475
1476   /* Get a line of input. */
1477   if (! unformat_user (input, unformat_line_input, line_input))
1478     return 0;
1479
1480   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1481     {
1482       if (unformat (line_input, "del"))
1483         is_add = 0;
1484       else if (unformat (line_input, "add %s", &locator_set_name))
1485         is_add = 1;
1486       else
1487         {
1488           error = unformat_parse_error(line_input);
1489           goto done;
1490         }
1491     }
1492
1493   a->is_add = is_add;
1494   a->locator_set_name = locator_set_name;
1495   rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
1496   if (0 != rv)
1497     {
1498       error = clib_error_return(0, "failed to %s map-request itr-rlocs!",
1499                                 is_add ? "add" : "delete");
1500     }
1501
1502   vec_free(locator_set_name);
1503
1504  done:
1505   return error;
1506
1507 }
1508
1509 VLIB_CLI_COMMAND (lisp_add_del_map_request_command) = {
1510     .path = "lisp map-request itr-rlocs",
1511     .short_help = "lisp map-request itr-rlocs add/del <locator_set_name>",
1512     .function = lisp_add_del_mreq_itr_rlocs_command_fn,
1513 };
1514
1515 static clib_error_t *
1516 lisp_show_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
1517                                     unformat_input_t * input,
1518                                     vlib_cli_command_t * cmd)
1519 {
1520   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
1521   locator_set_t * loc_set;
1522
1523   vlib_cli_output (vm, "%=20s", "itr-rlocs");
1524
1525   if (~0 == lcm->mreq_itr_rlocs)
1526     {
1527       return 0;
1528     }
1529
1530   loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1531
1532   vlib_cli_output (vm, "%=20s", loc_set->name);
1533
1534   return 0;
1535 }
1536
1537 VLIB_CLI_COMMAND (lisp_show_map_request_command) = {
1538     .path = "show lisp map-request itr-rlocs",
1539     .short_help = "Shows map-request itr-rlocs",
1540     .function = lisp_show_mreq_itr_rlocs_command_fn,
1541 };
1542
1543 /* Statistics (not really errors) */
1544 #define foreach_lisp_cp_lookup_error           \
1545 _(DROP, "drop")                                \
1546 _(MAP_REQUESTS_SENT, "map-request sent")
1547
1548 static char * lisp_cp_lookup_error_strings[] = {
1549 #define _(sym,string) string,
1550   foreach_lisp_cp_lookup_error
1551 #undef _
1552 };
1553
1554 typedef enum
1555 {
1556 #define _(sym,str) LISP_CP_LOOKUP_ERROR_##sym,
1557     foreach_lisp_cp_lookup_error
1558 #undef _
1559     LISP_CP_LOOKUP_N_ERROR,
1560 } lisp_cp_lookup_error_t;
1561
1562 typedef enum
1563 {
1564   LISP_CP_LOOKUP_NEXT_DROP,
1565   LISP_CP_LOOKUP_NEXT_IP4_LOOKUP,
1566   LISP_CP_LOOKUP_NEXT_IP6_LOOKUP,
1567   LISP_CP_LOOKUP_N_NEXT,
1568 } lisp_cp_lookup_next_t;
1569
1570 typedef struct
1571 {
1572   gid_address_t dst_eid;
1573   ip_address_t map_resolver_ip;
1574 } lisp_cp_lookup_trace_t;
1575
1576 u8 *
1577 format_lisp_cp_lookup_trace (u8 * s, va_list * args)
1578 {
1579   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1580   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1581   lisp_cp_lookup_trace_t * t = va_arg (*args, lisp_cp_lookup_trace_t *);
1582
1583   s = format (s, "LISP-CP-LOOKUP: map-resolver: %U destination eid %U",
1584               format_ip_address, &t->map_resolver_ip, format_gid_address,
1585               &t->dst_eid);
1586   return s;
1587 }
1588
1589 ip_interface_address_t *
1590 ip_interface_get_first_interface_address (ip_lookup_main_t *lm, u32 sw_if_index,
1591                                           u8 loop)
1592 {
1593   vnet_main_t *vnm = vnet_get_main ();
1594   vnet_sw_interface_t * swif = vnet_get_sw_interface (vnm, sw_if_index);
1595   if (loop && swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
1596     sw_if_index = swif->unnumbered_sw_if_index;
1597   u32 ia =
1598       (vec_len((lm)->if_address_pool_index_by_sw_if_index) > (sw_if_index)) ?
1599           vec_elt((lm)->if_address_pool_index_by_sw_if_index, (sw_if_index)) :
1600           (u32) ~0;
1601   return pool_elt_at_index((lm)->if_address_pool, ia);
1602 }
1603
1604 void *
1605 ip_interface_get_first_address (ip_lookup_main_t * lm, u32 sw_if_index,
1606                                 u8 version)
1607 {
1608   ip_interface_address_t * ia;
1609
1610   ia = ip_interface_get_first_interface_address (lm, sw_if_index, 1);
1611   if (!ia)
1612     return 0;
1613   return ip_interface_address_get_address (lm, ia);
1614 }
1615
1616 int
1617 ip_interface_get_first_ip_address (lisp_cp_main_t * lcm, u32 sw_if_index,
1618                                    u8 version, ip_address_t * result)
1619 {
1620   ip_lookup_main_t * lm;
1621   void * addr;
1622
1623   lm = (version == IP4) ? &lcm->im4->lookup_main : &lcm->im6->lookup_main;
1624   addr = ip_interface_get_first_address (lm, sw_if_index, version);
1625   if (!addr)
1626     return 0;
1627
1628   ip_address_set (result, addr, version);
1629   return 1;
1630 }
1631
1632 static u32
1633 ip_fib_lookup_with_table (lisp_cp_main_t * lcm, u32 fib_index,
1634                           ip_address_t * dst)
1635 {
1636   if (ip_addr_version (dst) == IP4)
1637       return ip4_fib_lookup_with_table (lcm->im4, fib_index, &ip_addr_v4(dst),
1638                                         0);
1639   else
1640       return ip6_fib_lookup_with_table (lcm->im6, fib_index, &ip_addr_v6(dst));
1641 }
1642
1643 u32
1644 ip_fib_get_egress_iface_for_dst_with_lm (lisp_cp_main_t * lcm,
1645                                          ip_address_t * dst,
1646                                          ip_lookup_main_t * lm)
1647 {
1648   u32 adj_index;
1649   ip_adjacency_t * adj;
1650
1651   adj_index = ip_fib_lookup_with_table (lcm, 0, dst);
1652   adj = ip_get_adjacency (lm, adj_index);
1653
1654   if (adj == 0)
1655     return ~0;
1656
1657   /* we only want outgoing routes */
1658   if (adj->lookup_next_index != IP_LOOKUP_NEXT_ARP
1659       && adj->lookup_next_index != IP_LOOKUP_NEXT_REWRITE)
1660     return ~0;
1661
1662   return adj->rewrite_header.sw_if_index;
1663 }
1664
1665 /**
1666  * Find the sw_if_index of the interface that would be used to egress towards
1667  * dst.
1668  */
1669 u32
1670 ip_fib_get_egress_iface_for_dst (lisp_cp_main_t * lcm, ip_address_t * dst)
1671 {
1672   ip_lookup_main_t * lm;
1673
1674   lm = ip_addr_version (dst) == IP4 ?
1675       &lcm->im4->lookup_main : &lcm->im6->lookup_main;
1676
1677   return ip_fib_get_egress_iface_for_dst_with_lm (lcm, dst, lm);
1678 }
1679
1680 /**
1681  * Find first IP of the interface that would be used to egress towards dst.
1682  * Returns 1 if the address is found 0 otherwise.
1683  */
1684 int
1685 ip_fib_get_first_egress_ip_for_dst (lisp_cp_main_t * lcm, ip_address_t * dst,
1686                                     ip_address_t * result)
1687 {
1688   u32 si;
1689   ip_lookup_main_t * lm;
1690   void * addr = 0;
1691   u8 ipver;
1692
1693   ASSERT(result != 0);
1694
1695   ipver = ip_addr_version(dst);
1696
1697   lm = (ipver == IP4) ? &lcm->im4->lookup_main : &lcm->im6->lookup_main;
1698   si = ip_fib_get_egress_iface_for_dst_with_lm (lcm, dst, lm);
1699
1700   if ((u32) ~0 == si)
1701     return 0;
1702
1703   /* find the first ip address */
1704   addr = ip_interface_get_first_address (lm, si, ipver);
1705   if (0 == addr)
1706     return 0;
1707
1708   ip_address_set (result, addr, ipver);
1709   return 1;
1710 }
1711
1712 int
1713 get_mr_and_local_iface_ip (lisp_cp_main_t * lcm, ip_address_t * mr_ip,
1714                            ip_address_t * sloc)
1715 {
1716   ip_address_t * mrit;
1717
1718   if (vec_len(lcm->map_resolvers) == 0)
1719     {
1720       clib_warning("No map-resolver configured");
1721       return 0;
1722     }
1723
1724   /* find the first mr ip we have a route to and the ip of the
1725    * iface that has a route to it */
1726   vec_foreach(mrit, lcm->map_resolvers)
1727     {
1728       if (0 != ip_fib_get_first_egress_ip_for_dst (lcm, mrit, sloc)) {
1729           ip_address_copy(mr_ip, mrit);
1730           return 1;
1731       }
1732     }
1733
1734   clib_warning("Can't find map-resolver and local interface ip!");
1735   return 0;
1736 }
1737
1738 static gid_address_t *
1739 build_itr_rloc_list (lisp_cp_main_t * lcm, locator_set_t * loc_set)
1740 {
1741   void * addr;
1742   u32 i;
1743   locator_t * loc;
1744   u32 * loc_indexp;
1745   ip_interface_address_t * ia = 0;
1746   gid_address_t gid_data, * gid = &gid_data;
1747   gid_address_t * rlocs = 0;
1748   ip_prefix_t * ippref = &gid_address_ippref (gid);
1749   ip_address_t * rloc = &ip_prefix_addr (ippref);
1750
1751   gid_address_type (gid) = GID_ADDR_IP_PREFIX;
1752   for (i = 0; i < vec_len(loc_set->locator_indices); i++)
1753     {
1754       loc_indexp = vec_elt_at_index(loc_set->locator_indices, i);
1755       loc = pool_elt_at_index (lcm->locator_pool, loc_indexp[0]);
1756
1757       /* Add ipv4 locators first TODO sort them */
1758       foreach_ip_interface_address (&lcm->im4->lookup_main, ia,
1759                                     loc->sw_if_index, 1 /* unnumbered */,
1760       ({
1761         addr = ip_interface_address_get_address (&lcm->im4->lookup_main, ia);
1762         ip_address_set (rloc, addr, IP4);
1763         ip_prefix_len (ippref) = 32;
1764         vec_add1 (rlocs, gid[0]);
1765       }));
1766
1767       /* Add ipv6 locators */
1768       foreach_ip_interface_address (&lcm->im6->lookup_main, ia,
1769                                     loc->sw_if_index, 1 /* unnumbered */,
1770       ({
1771         addr = ip_interface_address_get_address (&lcm->im6->lookup_main, ia);
1772         ip_address_set (rloc, addr, IP6);
1773         ip_prefix_len (ippref) = 128;
1774         vec_add1 (rlocs, gid[0]);
1775       }));
1776     }
1777   return rlocs;
1778 }
1779
1780 static vlib_buffer_t *
1781 build_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
1782                                 gid_address_t * seid, gid_address_t * deid,
1783                                 locator_set_t * loc_set, ip_address_t * mr_ip,
1784                                 ip_address_t * sloc, u8 is_smr_invoked,
1785                                 u64 *nonce_res, u32 * bi_res)
1786 {
1787   vlib_buffer_t * b;
1788   u32 bi;
1789   gid_address_t * rlocs = 0;
1790
1791   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
1792     {
1793       clib_warning ("Can't allocate buffer for Map-Request!");
1794       return 0;
1795     }
1796
1797   b = vlib_get_buffer (vm, bi);
1798
1799   /* leave some space for the encap headers */
1800   vlib_buffer_make_headroom (b, MAX_LISP_MSG_ENCAP_LEN);
1801
1802   /* get rlocs */
1803   rlocs = build_itr_rloc_list (lcm, loc_set);
1804
1805   /* put lisp msg */
1806   lisp_msg_put_mreq (lcm, b, seid, deid, rlocs, is_smr_invoked, nonce_res);
1807
1808   /* push ecm: udp-ip-lisp */
1809   lisp_msg_push_ecm (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, seid, deid);
1810
1811   /* push outer ip header */
1812   pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc,
1813                        mr_ip);
1814
1815   bi_res[0] = bi;
1816
1817   vec_free(rlocs);
1818   return b;
1819 }
1820
1821 static void
1822 send_encapsulated_map_request (vlib_main_t * vm, lisp_cp_main_t *lcm,
1823                                gid_address_t * seid, gid_address_t * deid,
1824                                u8 is_smr_invoked)
1825 {
1826   u32 next_index, bi = 0, * to_next, map_index;
1827   vlib_buffer_t * b;
1828   vlib_frame_t * f;
1829   u64 nonce = 0;
1830   locator_set_t * loc_set;
1831   mapping_t * map;
1832   pending_map_request_t * pmr;
1833   ip_address_t mr_ip, sloc;
1834   u32 ls_index;
1835
1836   /* get locator-set for seid */
1837   if (!lcm->lisp_pitr)
1838     {
1839       map_index = gid_dictionary_lookup (&lcm->mapping_index_by_gid, seid);
1840       if (map_index == ~0)
1841         {
1842           clib_warning("No local mapping found in eid-table for %U!",
1843                        format_gid_address, seid);
1844           return;
1845         }
1846
1847       map = pool_elt_at_index (lcm->mapping_pool, map_index);
1848
1849       if (!map->local)
1850         {
1851           clib_warning("Mapping found for src eid %U is not marked as local!",
1852                        format_gid_address, seid);
1853           return;
1854         }
1855       ls_index = map->locator_set_index;
1856     }
1857   else
1858     {
1859       map_index = lcm->pitr_map_index;
1860       map = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
1861       ls_index = map->locator_set_index;
1862     }
1863
1864   /* overwrite locator set if map-request itr-rlocs configured */
1865   if (~0 != lcm->mreq_itr_rlocs)
1866     {
1867       ls_index = lcm->mreq_itr_rlocs;
1868     }
1869
1870   loc_set = pool_elt_at_index (lcm->locator_set_pool, ls_index);
1871
1872   /* get local iface ip to use in map-request */
1873   if (0 == get_mr_and_local_iface_ip (lcm, &mr_ip, &sloc))
1874     return;
1875
1876   /* build the encapsulated map request */
1877   b = build_encapsulated_map_request (vm, lcm, seid, deid, loc_set, &mr_ip,
1878                                       &sloc, is_smr_invoked, &nonce, &bi);
1879
1880   if (!b)
1881     return;
1882
1883   /* set fib index and lookup node */
1884   vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0;
1885   next_index = (ip_addr_version(&mr_ip) == IP4) ?
1886       ip4_lookup_node.index : ip6_lookup_node.index;
1887
1888   f = vlib_get_frame_to_node (vm, next_index);
1889
1890   /* Enqueue the packet */
1891   to_next = vlib_frame_vector_args (f);
1892   to_next[0] = bi;
1893   f->n_vectors = 1;
1894   vlib_put_frame_to_node (vm, next_index, f);
1895
1896   /* add map-request to pending requests table */
1897   pool_get(lcm->pending_map_requests_pool, pmr);
1898   gid_address_copy (&pmr->src, seid);
1899   gid_address_copy (&pmr->dst, deid);
1900   pmr->src_mapping_index = map_index;
1901   hash_set(lcm->pending_map_requests_by_nonce, nonce,
1902            pmr - lcm->pending_map_requests_pool);
1903 }
1904
1905 static void
1906 get_src_and_dst (void *hdr, ip_address_t * src, ip_address_t *dst)
1907 {
1908   ip4_header_t * ip4 = hdr;
1909   ip6_header_t * ip6;
1910
1911   if ((ip4->ip_version_and_header_length & 0xF0) == 0x40)
1912     {
1913       ip_address_set(src, &ip4->src_address, IP4);
1914       ip_address_set(dst, &ip4->dst_address, IP4);
1915     }
1916   else
1917     {
1918       ip6 = hdr;
1919       ip_address_set(src, &ip6->src_address, IP6);
1920       ip_address_set(dst, &ip6->dst_address, IP6);
1921     }
1922 }
1923
1924 static uword
1925 lisp_cp_lookup (vlib_main_t * vm, vlib_node_runtime_t * node,
1926               vlib_frame_t * from_frame)
1927 {
1928   u32 * from, * to_next_drop, di, si;
1929   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main();
1930   u32 pkts_mapped = 0;
1931   uword n_left_from, n_left_to_next_drop;
1932
1933   from = vlib_frame_vector_args (from_frame);
1934   n_left_from = from_frame->n_vectors;
1935
1936   while (n_left_from > 0)
1937     {
1938       vlib_get_next_frame (vm, node, LISP_CP_LOOKUP_NEXT_DROP,
1939                            to_next_drop, n_left_to_next_drop);
1940
1941       while (n_left_from > 0 && n_left_to_next_drop > 0)
1942         {
1943           u32 pi0;
1944           vlib_buffer_t * p0;
1945           ip4_header_t * ip0;
1946           gid_address_t src, dst;
1947           ip_prefix_t * spref, * dpref;
1948
1949           gid_address_type (&src) = GID_ADDR_IP_PREFIX;
1950           spref = &gid_address_ippref(&src);
1951           gid_address_type (&dst) = GID_ADDR_IP_PREFIX;
1952           dpref = &gid_address_ippref(&dst);
1953
1954           pi0 = from[0];
1955           from += 1;
1956           n_left_from -= 1;
1957           to_next_drop[0] = pi0;
1958           to_next_drop += 1;
1959           n_left_to_next_drop -= 1;
1960
1961           p0 = vlib_get_buffer (vm, pi0);
1962           p0->error = node->errors[LISP_CP_LOOKUP_ERROR_DROP];
1963
1964           /* src/dst eid pair */
1965           ip0 = vlib_buffer_get_current (p0);
1966           get_src_and_dst (ip0, &ip_prefix_addr(spref), &ip_prefix_addr(dpref));
1967           ip_prefix_len(spref) = ip_address_max_len (ip_prefix_version(spref));
1968           ip_prefix_len(dpref) = ip_address_max_len (ip_prefix_version(dpref));
1969
1970           /* if we have remote mapping for destination already in map-chache
1971              add forwarding tunnel directly. If not send a map-request */
1972           di = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst);
1973           if (~0 != di)
1974             {
1975               mapping_t * m =  vec_elt_at_index (lcm->mapping_pool, di);
1976               /* send a map-request also in case of negative mapping entry
1977                 with corresponding action */
1978               if (m->action == ACTION_SEND_MAP_REQUEST)
1979                 {
1980                   /* send map-request */
1981                   send_encapsulated_map_request (vm, lcm, &src, &dst, 0);
1982                   pkts_mapped++;
1983                 }
1984               else
1985                 {
1986                   si =  gid_dictionary_lookup (&lcm->mapping_index_by_gid,
1987                                                &src);
1988                   if (~0 != si)
1989                     {
1990                       add_fwd_entry (lcm, si, di);
1991                     }
1992                 }
1993             }
1994           else
1995             {
1996               /* send map-request */
1997               send_encapsulated_map_request (vm, lcm, &src, &dst, 0);
1998               pkts_mapped++;
1999             }
2000
2001           if (PREDICT_FALSE(p0->flags & VLIB_BUFFER_IS_TRACED))
2002             {
2003               lisp_cp_lookup_trace_t *tr = vlib_add_trace (vm, node, p0,
2004                                                           sizeof(*tr));
2005
2006               memset(tr, 0, sizeof(*tr));
2007               gid_address_copy (&tr->dst_eid, &dst);
2008               if (vec_len(lcm->map_resolvers) > 0)
2009                 {
2010                   clib_memcpy (&tr->map_resolver_ip,
2011                                vec_elt_at_index(lcm->map_resolvers, 0),
2012                                sizeof(ip_address_t));
2013                 }
2014             }
2015         }
2016
2017       vlib_put_next_frame (vm, node, LISP_CP_LOOKUP_NEXT_DROP, n_left_to_next_drop);
2018     }
2019   vlib_node_increment_counter (vm, node->node_index,
2020                                LISP_CP_LOOKUP_ERROR_MAP_REQUESTS_SENT,
2021                                pkts_mapped);
2022   return from_frame->n_vectors;
2023 }
2024
2025 VLIB_REGISTER_NODE (lisp_cp_lookup_node) = {
2026   .function = lisp_cp_lookup,
2027   .name = "lisp-cp-lookup",
2028   .vector_size = sizeof (u32),
2029   .format_trace = format_lisp_cp_lookup_trace,
2030   .type = VLIB_NODE_TYPE_INTERNAL,
2031
2032   .n_errors = LISP_CP_LOOKUP_N_ERROR,
2033   .error_strings = lisp_cp_lookup_error_strings,
2034
2035   .n_next_nodes = LISP_CP_LOOKUP_N_NEXT,
2036
2037   .next_nodes = {
2038       [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop",
2039       [LISP_CP_LOOKUP_NEXT_IP4_LOOKUP] = "ip4-lookup",
2040       [LISP_CP_LOOKUP_NEXT_IP6_LOOKUP] = "ip6-lookup",
2041   },
2042 };
2043
2044 /* lisp_cp_input statistics */
2045 #define foreach_lisp_cp_input_error                   \
2046 _(DROP, "drop")                                        \
2047 _(MAP_REPLIES_RECEIVED, "map-replies received")
2048
2049 static char * lisp_cp_input_error_strings[] = {
2050 #define _(sym,string) string,
2051   foreach_lisp_cp_input_error
2052 #undef _
2053 };
2054
2055 typedef enum
2056 {
2057 #define _(sym,str) LISP_CP_INPUT_ERROR_##sym,
2058     foreach_lisp_cp_input_error
2059 #undef _
2060     LISP_CP_INPUT_N_ERROR,
2061 } lisp_cp_input_error_t;
2062
2063 typedef enum
2064 {
2065   LISP_CP_INPUT_NEXT_DROP,
2066   LISP_CP_INPUT_N_NEXT,
2067 } lisp_cp_input_next_t;
2068
2069 typedef struct
2070 {
2071   gid_address_t dst_eid;
2072   ip4_address_t map_resolver_ip;
2073 } lisp_cp_input_trace_t;
2074
2075 u8 *
2076 format_lisp_cp_input_trace (u8 * s, va_list * args)
2077 {
2078   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
2079   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
2080   CLIB_UNUSED(lisp_cp_input_trace_t * t) = va_arg (*args, lisp_cp_input_trace_t *);
2081
2082   s = format (s, "LISP-CP-INPUT: TODO");
2083   return s;
2084 }
2085
2086 static void
2087 del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index,
2088                u32 dst_map_index)
2089 {
2090   vnet_lisp_gpe_add_del_fwd_entry_args_t _a, * a = &_a;
2091   fwd_entry_t * fe = 0;
2092   uword * feip = 0;
2093   memset(a, 0, sizeof(*a));
2094
2095   feip = hash_get(lcm->fwd_entry_by_mapping_index, dst_map_index);
2096   if (!feip)
2097     return;
2098
2099   fe = pool_elt_at_index(lcm->fwd_entry_pool, feip[0]);
2100
2101   /* delete dp fwd entry */
2102   u32 sw_if_index;
2103   a->is_add = 0;
2104   a->dlocator = fe->dst_loc;
2105   a->slocator = fe->src_loc;
2106   a->vni = gid_address_vni(&a->deid);
2107   gid_address_copy(&a->deid, &fe->deid);
2108
2109   vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index);
2110
2111   /* delete entry in fwd table */
2112   hash_unset(lcm->fwd_entry_by_mapping_index, dst_map_index);
2113   pool_put(lcm->fwd_entry_pool, fe);
2114 }
2115
2116 /**
2117  * Finds first remote locator with best (lowest) priority that has a local
2118  * peer locator with an underlying route to it.
2119  *
2120  */
2121 static u32
2122 get_locator_pair (lisp_cp_main_t* lcm, mapping_t * lcl_map, mapping_t * rmt_map,
2123                   ip_address_t * lcl_loc, ip_address_t * rmt_loc)
2124 {
2125   u32 i, minp = ~0, limitp = 0, li, check_index = 0, done = 0, esi;
2126   locator_set_t * rmt_ls, * lcl_ls;
2127   ip_address_t _lcl, * lcl = &_lcl;
2128   locator_t * l, * rmt = 0;
2129   uword * checked = 0;
2130
2131   rmt_ls = pool_elt_at_index(lcm->locator_set_pool, rmt_map->locator_set_index);
2132   lcl_ls = pool_elt_at_index(lcm->locator_set_pool, lcl_map->locator_set_index);
2133
2134   if (!rmt_ls || vec_len(rmt_ls->locator_indices) == 0)
2135     return 0;
2136
2137   while (!done)
2138     {
2139       /* find unvisited remote locator with best priority */
2140       for (i = 0; i < vec_len(rmt_ls->locator_indices); i++)
2141         {
2142           if (0 != hash_get(checked, i))
2143             continue;
2144
2145           li = vec_elt(rmt_ls->locator_indices, i);
2146           l = pool_elt_at_index(lcm->locator_pool, li);
2147
2148           /* we don't support non-IP locators for now */
2149           if (gid_address_type(&l->address) != GID_ADDR_IP_PREFIX)
2150             continue;
2151
2152           if (l->priority < minp && l->priority >= limitp)
2153             {
2154               minp = l->priority;
2155               rmt = l;
2156               check_index = i;
2157             }
2158         }
2159       /* check if a local locator with a route to remote locator exists */
2160       if (rmt != 0)
2161         {
2162           esi = ip_fib_get_egress_iface_for_dst (
2163               lcm, &gid_address_ip(&rmt->address));
2164           if ((u32) ~0 == esi)
2165             continue;
2166
2167           for (i = 0; i < vec_len(lcl_ls->locator_indices); i++)
2168             {
2169               li = vec_elt (lcl_ls->locator_indices, i);
2170               locator_t * sl = pool_elt_at_index (lcm->locator_pool, li);
2171
2172               /* found local locator */
2173               if (sl->sw_if_index == esi)
2174                 {
2175                   if (0 == ip_interface_get_first_ip_address (lcm,
2176                              sl->sw_if_index,
2177                              gid_address_ip_version(&rmt->address), lcl))
2178                     continue;
2179
2180                   ip_address_copy(rmt_loc, &gid_address_ip(&rmt->address));
2181                   ip_address_copy(lcl_loc, lcl);
2182                   done = 2;
2183                 }
2184             }
2185
2186           /* skip this remote locator in next searches */
2187           limitp = minp;
2188           hash_set(checked, check_index, 1);
2189         }
2190       else
2191         done = 1;
2192     }
2193   hash_free(checked);
2194   return (done == 2) ? 1 : 0;
2195 }
2196
2197 static void
2198 add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index)
2199 {
2200   mapping_t * src_map, * dst_map;
2201   u32 sw_if_index;
2202   uword * feip = 0, * tidp;
2203   fwd_entry_t* fe;
2204   vnet_lisp_gpe_add_del_fwd_entry_args_t _a, * a = &_a;
2205
2206   memset (a, 0, sizeof(*a));
2207
2208   /* remove entry if it already exists */
2209   feip = hash_get (lcm->fwd_entry_by_mapping_index, dst_map_index);
2210   if (feip)
2211     del_fwd_entry (lcm, src_map_index, dst_map_index);
2212
2213   src_map = pool_elt_at_index (lcm->mapping_pool, src_map_index);
2214   dst_map = pool_elt_at_index (lcm->mapping_pool, dst_map_index);
2215
2216   gid_address_copy (&a->deid, &dst_map->eid);
2217   a->vni = gid_address_vni(&a->deid);
2218
2219   tidp = hash_get(lcm->table_id_by_vni, a->vni);
2220   if (!tidp)
2221     {
2222       clib_warning("vni %d not associated to a vrf!", a->vni);
2223       return;
2224     }
2225   a->table_id = tidp[0];
2226
2227   /* insert data plane forwarding entry */
2228   a->is_add = 1;
2229
2230   /* find best locator pair that 1) verifies LISP policy 2) are connected */
2231   if (0 == get_locator_pair (lcm, src_map, dst_map, &a->slocator, &a->dlocator))
2232     {
2233       /* negative entry */
2234       a->is_negative = 1;
2235       a->action = dst_map->action;
2236     }
2237
2238   /* TODO remove */
2239   u8 ipver = ip_prefix_version(&gid_address_ippref(&a->deid));
2240   a->decap_next_index = (ipver == IP4) ?
2241           LISP_GPE_INPUT_NEXT_IP4_INPUT : LISP_GPE_INPUT_NEXT_IP6_INPUT;
2242
2243   vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index);
2244
2245   /* add tunnel to fwd entry table XXX check return value from DP insertion */
2246   pool_get (lcm->fwd_entry_pool, fe);
2247   fe->dst_loc = a->dlocator;
2248   fe->src_loc = a->slocator;
2249   gid_address_copy (&fe->deid, &a->deid);
2250   hash_set (lcm->fwd_entry_by_mapping_index, dst_map_index,
2251             fe - lcm->fwd_entry_pool);
2252 }
2253
2254 /* return 0 if the two locator sets are identical 1 otherwise */
2255 static u8
2256 compare_locators (lisp_cp_main_t *lcm, u32 * old_ls_indexes,
2257                   locator_t * new_locators)
2258 {
2259   u32 i, old_li;
2260   locator_t * old_loc, * new_loc;
2261
2262   if (vec_len (old_ls_indexes) != vec_len(new_locators))
2263     return 1;
2264
2265   for (i = 0; i < vec_len(new_locators); i++)
2266     {
2267       old_li = vec_elt(old_ls_indexes, i);
2268       old_loc = pool_elt_at_index(lcm->locator_pool, old_li);
2269
2270       new_loc = vec_elt_at_index(new_locators, i);
2271
2272       if (locator_cmp (old_loc, new_loc))
2273         return 1;
2274     }
2275   return 0;
2276 }
2277
2278 void
2279 process_map_reply (lisp_cp_main_t * lcm, vlib_buffer_t * b)
2280 {
2281   mapping_t * old_map;
2282   locator_t * loc;
2283   u32 len = 0, i, ls_index = 0;
2284   void * h;
2285   vnet_lisp_add_del_locator_set_args_t _ls_arg, * ls_arg = &_ls_arg;
2286   vnet_lisp_add_del_mapping_args_t _m_args, * m_args = &_m_args;
2287   pending_map_request_t * pmr;
2288   locator_t probed;
2289   map_reply_hdr_t * mrep_hdr;
2290   u64 nonce;
2291   u32 dst_map_index, mi;
2292   uword * pmr_index;
2293
2294   mrep_hdr = vlib_buffer_get_current (b);
2295
2296   /* Check pending requests table and nonce */
2297   nonce = MREP_NONCE(mrep_hdr);
2298   pmr_index = hash_get(lcm->pending_map_requests_by_nonce, nonce);
2299   if (!pmr_index)
2300     {
2301       clib_warning("No pending map-request entry with nonce %lu!", nonce);
2302       return;
2303     }
2304   pmr = pool_elt_at_index(lcm->pending_map_requests_pool, pmr_index[0]);
2305
2306   vlib_buffer_pull (b, sizeof(*mrep_hdr));
2307
2308   for (i = 0; i < MREP_REC_COUNT(mrep_hdr); i++)
2309     {
2310       memset (ls_arg, 0, sizeof(*ls_arg));
2311       memset (m_args, 0, sizeof(*m_args));
2312
2313       h = vlib_buffer_get_current (b);
2314       m_args->ttl = clib_net_to_host_u32 (MAP_REC_TTL(h));
2315       m_args->action = MAP_REC_ACTION(h);
2316       m_args->authoritative = MAP_REC_AUTH(h);
2317
2318       len = lisp_msg_parse_mapping_record (b, &m_args->deid, &ls_arg->locators,
2319                                            &probed);
2320       if (len == ~0)
2321         {
2322           clib_warning ("Failed to parse mapping record!");
2323           vec_foreach (loc, ls_arg->locators)
2324             {
2325               locator_free (loc);
2326             }
2327           vec_free(ls_arg->locators);
2328           return;
2329         }
2330
2331       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &m_args->deid);
2332       old_map = mi != ~0 ? pool_elt_at_index(lcm->mapping_pool, mi) : 0;
2333
2334       /* if mapping already exists, decide if locators (and forwarding) should
2335        * be updated and be done */
2336       if (old_map != 0 && !gid_address_cmp (&old_map->eid, &m_args->deid))
2337         {
2338           locator_set_t * old_ls;
2339
2340           /* update mapping attributes */
2341           old_map->action = m_args->action;
2342           old_map->authoritative = m_args->authoritative;
2343           old_map->ttl = m_args->ttl;
2344
2345           old_ls = pool_elt_at_index(lcm->locator_set_pool,
2346                                      old_map->locator_set_index);
2347           /* if the two locators are not equal, update them and forwarding
2348            * otherwise there's nothing to be done */
2349           if (compare_locators (lcm, old_ls->locator_indices, ls_arg->locators))
2350             {
2351               /* set locator-set index to overwrite */
2352               ls_arg->is_add = 1;
2353               ls_arg->index = old_map->locator_set_index;
2354               vnet_lisp_add_del_locator_set (ls_arg, 0);
2355               add_fwd_entry (lcm, pmr->src_mapping_index, mi);
2356             }
2357         }
2358       /* new mapping */
2359       else
2360         {
2361           /* add locator-set */
2362           ls_arg->is_add = 1;
2363           ls_arg->index = ~0;
2364           vnet_lisp_add_del_locator_set (ls_arg, &ls_index);
2365
2366           /* add mapping */
2367           m_args->is_add = 1;
2368           m_args->locator_set_index = ls_index;
2369           vnet_lisp_add_del_mapping (m_args, &dst_map_index);
2370
2371           /* add forwarding tunnel */
2372           add_fwd_entry (lcm, pmr->src_mapping_index, dst_map_index);
2373         }
2374       vec_free(ls_arg->locators);
2375     }
2376
2377   /* remove pending map request entry */
2378   hash_unset(lcm->pending_map_requests_by_nonce, nonce);
2379   pool_put(lcm->pending_map_requests_pool, pmr);
2380 }
2381
2382 void
2383 process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, vlib_buffer_t * b)
2384 {
2385   map_request_hdr_t * mreq_hdr;
2386   gid_address_t src, dst;
2387 //  u64 nonce;
2388   u32 i, len = 0;
2389   gid_address_t * itr_rlocs = 0, * rloc;
2390
2391   mreq_hdr = vlib_buffer_get_current (b);
2392   vlib_buffer_pull (b, sizeof(*mreq_hdr));
2393
2394 //  nonce = MREQ_NONCE(mreq_hdr);
2395
2396   if (!MREQ_SMR(mreq_hdr)) {
2397       clib_warning("Only SMR Map-Requests supported for now!");
2398       return;
2399   }
2400
2401   /* parse src eid */
2402   len = lisp_msg_parse_addr (b, &src);
2403   if (len == ~0)
2404     return;
2405
2406   /* for now we don't do anything with the itr's rlocs */
2407   len = lisp_msg_parse_itr_rlocs (b, &itr_rlocs, MREQ_ITR_RLOC_COUNT(mreq_hdr) + 1);
2408   if (len == ~0)
2409     return;
2410
2411   /* TODO: RLOCs are currently unused, so free them for now */
2412   vec_foreach (rloc, itr_rlocs)
2413     {
2414       gid_address_free (rloc);
2415     }
2416
2417   /* parse eid records and send SMR-invoked map-requests */
2418   for (i = 0; i < MREQ_REC_COUNT(mreq_hdr); i++)
2419     {
2420       memset(&dst, 0, sizeof(dst));
2421       len = lisp_msg_parse_eid_rec (b, &dst);
2422       if (len == ~0)
2423         {
2424           clib_warning("Can't parse map-request EID-record");
2425           return;
2426         }
2427       /* send SMR-invoked map-requests */
2428       send_encapsulated_map_request (vm, lcm, &dst, &src, /* invoked */ 1);
2429     }
2430 }
2431
2432 static uword
2433 lisp_cp_input (vlib_main_t * vm, vlib_node_runtime_t * node,
2434                vlib_frame_t * from_frame)
2435 {
2436   u32 n_left_from, * from, * to_next_drop;
2437   lisp_msg_type_e type;
2438   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
2439
2440   from = vlib_frame_vector_args (from_frame);
2441   n_left_from = from_frame->n_vectors;
2442
2443
2444   while (n_left_from > 0)
2445     {
2446       u32 n_left_to_next_drop;
2447
2448       vlib_get_next_frame (vm, node, LISP_CP_INPUT_NEXT_DROP,
2449                            to_next_drop, n_left_to_next_drop);
2450       while (n_left_from > 0 && n_left_to_next_drop > 0)
2451         {
2452           u32 bi0;
2453           vlib_buffer_t * b0;
2454
2455           bi0 = from[0];
2456           from += 1;
2457           n_left_from -= 1;
2458           to_next_drop[0] = bi0;
2459           to_next_drop += 1;
2460           n_left_to_next_drop -= 1;
2461
2462           b0 = vlib_get_buffer (vm, bi0);
2463
2464           type = lisp_msg_type(vlib_buffer_get_current (b0));
2465           switch (type)
2466             {
2467             case LISP_MAP_REPLY:
2468               process_map_reply (lcm, b0);
2469               break;
2470             case LISP_MAP_REQUEST:
2471               process_map_request(vm, lcm, b0);
2472               break;
2473             default:
2474               clib_warning("Unsupported LISP message type %d", type);
2475               break;
2476             }
2477
2478           b0->error = node->errors[LISP_CP_INPUT_ERROR_DROP];
2479
2480           if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
2481             {
2482
2483             }
2484         }
2485
2486       vlib_put_next_frame (vm, node, LISP_CP_INPUT_NEXT_DROP, n_left_to_next_drop);
2487     }
2488   return from_frame->n_vectors;
2489 }
2490
2491 VLIB_REGISTER_NODE (lisp_cp_input_node) = {
2492   .function = lisp_cp_input,
2493   .name = "lisp-cp-input",
2494   .vector_size = sizeof (u32),
2495   .format_trace = format_lisp_cp_input_trace,
2496   .type = VLIB_NODE_TYPE_INTERNAL,
2497
2498   .n_errors = LISP_CP_INPUT_N_ERROR,
2499   .error_strings = lisp_cp_input_error_strings,
2500
2501   .n_next_nodes = LISP_CP_INPUT_N_NEXT,
2502
2503   .next_nodes = {
2504       [LISP_CP_INPUT_NEXT_DROP] = "error-drop",
2505   },
2506 };
2507
2508 clib_error_t *
2509 lisp_cp_init (vlib_main_t *vm)
2510 {
2511   lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
2512   clib_error_t * error = 0;
2513
2514   if ((error = vlib_call_init_function (vm, lisp_gpe_init)))
2515     return error;
2516
2517   lcm->im4 = &ip4_main;
2518   lcm->im6 = &ip6_main;
2519   lcm->vlib_main = vm;
2520   lcm->vnet_main = vnet_get_main();
2521   lcm->mreq_itr_rlocs = ~0;
2522
2523   gid_dictionary_init (&lcm->mapping_index_by_gid);
2524
2525   /* default vrf mapped to vni 0 */
2526   hash_set(lcm->table_id_by_vni, 0, 0);
2527
2528   udp_register_dst_port (vm, UDP_DST_PORT_lisp_cp,
2529                          lisp_cp_input_node.index, 1 /* is_ip4 */);
2530   udp_register_dst_port (vm, UDP_DST_PORT_lisp_cp6,
2531                          lisp_cp_input_node.index, 0 /* is_ip4 */);
2532
2533   return 0;
2534 }
2535
2536 VLIB_INIT_FUNCTION(lisp_cp_init);