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