src/vnet/lisp-cp/lisp_api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * lisp_api.c - lisp api
   4  *
   5  * Copyright (c) 2016 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <vnet/vnet.h>
  21 #include <vlibmemory/api.h>
  22
  23 #include <vnet/interface.h>
  24 #include <vnet/api_errno.h>
  25 #include <vnet/lisp-cp/control.h>
  26 #include <vnet/lisp-gpe/lisp_gpe.h>
  27
  28 #include <vnet/vnet_msg_enum.h>
  29
  30 #define vl_api_remote_locator_t_endian vl_noop_handler
  31 #define vl_api_remote_locator_t_print vl_noop_handler
  32 #define vl_api_local_locator_t_endian vl_noop_handler
  33 #define vl_api_local_locator_t_print vl_noop_handler
  34
  35 #define vl_api_lisp_add_del_locator_set_t_endian vl_noop_handler
  36 #define vl_api_lisp_add_del_locator_set_t_print vl_noop_handler
  37 #define vl_api_lisp_add_del_remote_mapping_t_endian vl_noop_handler
  38 #define vl_api_lisp_add_del_remote_mapping_t_print vl_noop_handler
  39
  40 #define vl_api_one_add_del_locator_set_t_endian vl_noop_handler
  41 #define vl_api_one_add_del_locator_set_t_print vl_noop_handler
  42 #define vl_api_one_add_del_remote_mapping_t_endian vl_noop_handler
  43 #define vl_api_one_add_del_remote_mapping_t_print vl_noop_handler
  44
  45 #define vl_typedefs             /* define message structures */
  46 #include <vnet/vnet_all_api_h.h>
  47 #undef vl_typedefs
  48
  49 #define vl_endianfun            /* define message structures */
  50 #include <vnet/vnet_all_api_h.h>
  51 #undef vl_endianfun
  52
  53 /* instantiate all the print functions we know about */
  54 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  55 #define vl_printfun
  56 #include <vnet/vnet_all_api_h.h>
  57 #undef vl_printfun
  58
  59 #include <vlibapi/api_helper_macros.h>
  60
  61 #define foreach_vpe_api_msg                             \
  62 _(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set)                   \
  63 _(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator)                           \
  64 _(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid)                       \
  65 _(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver)                 \
  66 _(LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server)                     \
  67 _(LISP_ENABLE_DISABLE, lisp_enable_disable)                             \
  68 _(LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable)       \
  69 _(LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable)   \
  70 _(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping)             \
  71 _(LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency)                       \
  72 _(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set)                 \
  73 _(LISP_MAP_REQUEST_MODE, lisp_map_request_mode)                         \
  74 _(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map)               \
  75 _(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump)                         \
  76 _(LISP_LOCATOR_DUMP, lisp_locator_dump)                                 \
  77 _(LISP_EID_TABLE_DUMP, lisp_eid_table_dump)                             \
  78 _(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump)                       \
  79 _(LISP_MAP_SERVER_DUMP, lisp_map_server_dump)                           \
  80 _(LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump)                     \
  81 _(LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump)                     \
  82 _(LISP_ADJACENCIES_GET, lisp_adjacencies_get)                           \
  83 _(SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state)               \
  84 _(SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state)           \
  85 _(SHOW_LISP_STATUS, show_lisp_status)                                   \
  86 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS,                                   \
  87   lisp_add_del_map_request_itr_rlocs)                                   \
  88 _(LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs)       \
  89 _(SHOW_LISP_PITR, show_lisp_pitr)                                       \
  90 _(SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode)               \
  91 _(LISP_USE_PETR, lisp_use_petr)                                         \
  92 _(SHOW_LISP_USE_PETR, show_lisp_use_petr)                               \
  93
  94 static locator_t *
  95 unformat_lisp_locs (vl_api_remote_locator_t * rmt_locs, u32 rloc_num)
  96 {
  97   u32 i;
  98   locator_t *locs = 0, loc;
  99   vl_api_remote_locator_t *r;
 100
 101   for (i = 0; i < rloc_num; i++)
 102     {
 103       /* remote locators */
 104       r = &rmt_locs[i];
 105       memset (&loc, 0, sizeof (loc));
 106       gid_address_ip_set (&loc.address, &r->addr, r->is_ip4 ? IP4 : IP6);
 107
 108       loc.priority = r->priority;
 109       loc.weight = r->weight;
 110
 111       vec_add1 (locs, loc);
 112     }
 113   return locs;
 114 }
 115
 116 static void
 117 vl_api_lisp_add_del_locator_set_t_handler (vl_api_lisp_add_del_locator_set_t *
 118                                            mp)
 119 {
 120   vl_api_lisp_add_del_locator_set_reply_t *rmp;
 121   int rv = 0;
 122   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
 123   locator_t locator;
 124   vl_api_local_locator_t *ls_loc;
 125   u32 ls_index = ~0, locator_num;
 126   u8 *locator_name = NULL;
 127   int i;
 128
 129   memset (a, 0, sizeof (a[0]));
 130
 131   mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
 132   locator_name = format (0, "%s", mp->locator_set_name);
 133   vec_terminate_c_string (locator_name);
 134
 135   a->name = locator_name;
 136   a->is_add = mp->is_add;
 137   a->local = 1;
 138   locator_num = clib_net_to_host_u32 (mp->locator_num);
 139
 140   memset (&locator, 0, sizeof (locator));
 141   for (i = 0; i < locator_num; i++)
 142     {
 143       ls_loc = &mp->locators[i];
 144       VALIDATE_SW_IF_INDEX (ls_loc);
 145
 146       locator.sw_if_index = htonl (ls_loc->sw_if_index);
 147       locator.priority = ls_loc->priority;
 148       locator.weight = ls_loc->weight;
 149       locator.local = 1;
 150       vec_add1 (a->locators, locator);
 151     }
 152
 153   rv = vnet_lisp_add_del_locator_set (a, &ls_index);
 154
 155   BAD_SW_IF_INDEX_LABEL;
 156
 157   vec_free (locator_name);
 158   vec_free (a->locators);
 159
 160   /* *INDENT-OFF* */
 161   REPLY_MACRO2 (VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY,
 162   ({
 163     rmp->ls_index = clib_host_to_net_u32 (ls_index);
 164   }));
 165   /* *INDENT-ON* */
 166 }
 167
 168 static void
 169 vl_api_lisp_add_del_locator_t_handler (vl_api_lisp_add_del_locator_t * mp)
 170 {
 171   vl_api_lisp_add_del_locator_reply_t *rmp;
 172   int rv = 0;
 173   locator_t locator, *locators = NULL;
 174   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
 175   u32 ls_index = ~0;
 176   u8 *locator_name = NULL;
 177
 178   memset (&locator, 0, sizeof (locator));
 179   memset (a, 0, sizeof (a[0]));
 180
 181   locator.sw_if_index = ntohl (mp->sw_if_index);
 182   locator.priority = mp->priority;
 183   locator.weight = mp->weight;
 184   locator.local = 1;
 185   vec_add1 (locators, locator);
 186
 187   mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
 188   locator_name = format (0, "%s", mp->locator_set_name);
 189   vec_terminate_c_string (locator_name);
 190
 191   a->name = locator_name;
 192   a->locators = locators;
 193   a->is_add = mp->is_add;
 194   a->local = 1;
 195
 196   rv = vnet_lisp_add_del_locator (a, NULL, &ls_index);
 197
 198   vec_free (locators);
 199   vec_free (locator_name);
 200
 201   REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCATOR_REPLY);
 202 }
 203
 204 static int
 205 unformat_lisp_eid_api (gid_address_t * dst, u32 vni, u8 type, void *src,
 206                        u8 len)
 207 {
 208   switch (type)
 209     {
 210     case 0:                     /* ipv4 */
 211       gid_address_type (dst) = GID_ADDR_IP_PREFIX;
 212       gid_address_ip_set (dst, src, IP4);
 213       gid_address_ippref_len (dst) = len;
 214       ip_prefix_normalize (&gid_address_ippref (dst));
 215       break;
 216     case 1:                     /* ipv6 */
 217       gid_address_type (dst) = GID_ADDR_IP_PREFIX;
 218       gid_address_ip_set (dst, src, IP6);
 219       gid_address_ippref_len (dst) = len;
 220       ip_prefix_normalize (&gid_address_ippref (dst));
 221       break;
 222     case 2:                     /* l2 mac */
 223       gid_address_type (dst) = GID_ADDR_MAC;
 224       clib_memcpy (&gid_address_mac (dst), src, 6);
 225       break;
 226     default:
 227       /* unknown type */
 228       return VNET_API_ERROR_INVALID_VALUE;
 229     }
 230
 231   gid_address_vni (dst) = vni;
 232
 233   return 0;
 234 }
 235
 236 static void
 237 vl_api_lisp_add_del_local_eid_t_handler (vl_api_lisp_add_del_local_eid_t * mp)
 238 {
 239   vl_api_lisp_add_del_local_eid_reply_t *rmp;
 240   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 241   int rv = 0;
 242   gid_address_t _eid, *eid = &_eid;
 243   uword *p = NULL;
 244   u32 locator_set_index = ~0, map_index = ~0;
 245   vnet_lisp_add_del_mapping_args_t _a, *a = &_a;
 246   u8 *name = NULL, *key = NULL;
 247   memset (a, 0, sizeof (a[0]));
 248   memset (eid, 0, sizeof (eid[0]));
 249
 250   rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
 251                               mp->eid_type, mp->eid, mp->prefix_len);
 252   if (rv)
 253     goto out;
 254
 255   mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
 256   name = format (0, "%s", mp->locator_set_name);
 257   vec_terminate_c_string (name);
 258   p = hash_get_mem (lcm->locator_set_index_by_name, name);
 259   if (!p)
 260     {
 261       rv = VNET_API_ERROR_INVALID_VALUE;
 262       goto out;
 263     }
 264   locator_set_index = p[0];
 265
 266   if (*mp->key)
 267     key = format (0, "%s", mp->key);
 268
 269   /* XXX treat batch configuration */
 270   a->is_add = mp->is_add;
 271   gid_address_copy (&a->eid, eid);
 272   a->locator_set_index = locator_set_index;
 273   a->local = 1;
 274   a->key = key;
 275   a->key_id = clib_net_to_host_u16 (mp->key_id);
 276
 277   rv = vnet_lisp_add_del_local_mapping (a, &map_index);
 278
 279 out:
 280   vec_free (name);
 281   vec_free (key);
 282   gid_address_free (&a->eid);
 283
 284   REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY);
 285 }
 286
 287 static void
 288   vl_api_lisp_eid_table_add_del_map_t_handler
 289   (vl_api_lisp_eid_table_add_del_map_t * mp)
 290 {
 291   vl_api_lisp_eid_table_add_del_map_reply_t *rmp;
 292   int rv = 0;
 293   rv = vnet_lisp_eid_table_map (clib_net_to_host_u32 (mp->vni),
 294                                 clib_net_to_host_u32 (mp->dp_table),
 295                                 mp->is_l2, mp->is_add);
 296 REPLY_MACRO (VL_API_LISP_EID_TABLE_ADD_DEL_MAP_REPLY)}
 297
 298 static void
 299 vl_api_lisp_add_del_map_server_t_handler (vl_api_lisp_add_del_map_server_t
 300                                           * mp)
 301 {
 302   vl_api_lisp_add_del_map_server_reply_t *rmp;
 303   int rv = 0;
 304   ip_address_t addr;
 305
 306   memset (&addr, 0, sizeof (addr));
 307
 308   ip_address_set (&addr, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
 309   rv = vnet_lisp_add_del_map_server (&addr, mp->is_add);
 310
 311   REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_SERVER_REPLY);
 312 }
 313
 314 static void
 315 vl_api_lisp_add_del_map_resolver_t_handler (vl_api_lisp_add_del_map_resolver_t
 316                                             * mp)
 317 {
 318   vl_api_lisp_add_del_map_resolver_reply_t *rmp;
 319   int rv = 0;
 320   vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
 321
 322   memset (a, 0, sizeof (a[0]));
 323
 324   a->is_add = mp->is_add;
 325   ip_address_set (&a->address, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
 326
 327   rv = vnet_lisp_add_del_map_resolver (a);
 328
 329   REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_RESOLVER_REPLY);
 330 }
 331
 332 static void
 333   vl_api_lisp_map_register_enable_disable_t_handler
 334   (vl_api_lisp_map_register_enable_disable_t * mp)
 335 {
 336   vl_api_lisp_map_register_enable_disable_reply_t *rmp;
 337   int rv = 0;
 338
 339   vnet_lisp_map_register_enable_disable (mp->is_enabled);
 340   REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
 341 }
 342
 343 static void
 344   vl_api_lisp_rloc_probe_enable_disable_t_handler
 345   (vl_api_lisp_rloc_probe_enable_disable_t * mp)
 346 {
 347   vl_api_lisp_rloc_probe_enable_disable_reply_t *rmp;
 348   int rv = 0;
 349
 350   vnet_lisp_rloc_probe_enable_disable (mp->is_enabled);
 351   REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
 352 }
 353
 354 static void
 355 vl_api_lisp_enable_disable_t_handler (vl_api_lisp_enable_disable_t * mp)
 356 {
 357   vl_api_lisp_enable_disable_reply_t *rmp;
 358   int rv = 0;
 359
 360   vnet_lisp_enable_disable (mp->is_en);
 361   REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
 362 }
 363
 364 static void
 365   vl_api_show_lisp_map_request_mode_t_handler
 366   (vl_api_show_lisp_map_request_mode_t * mp)
 367 {
 368   int rv = 0;
 369   vl_api_show_lisp_map_request_mode_reply_t *rmp;
 370
 371   /* *INDENT-OFF* */
 372   REPLY_MACRO2(VL_API_SHOW_LISP_MAP_REQUEST_MODE_REPLY,
 373   ({
 374     rmp->mode = vnet_lisp_get_map_request_mode ();
 375   }));
 376   /* *INDENT-ON* */
 377 }
 378
 379 static void
 380 vl_api_lisp_map_request_mode_t_handler (vl_api_lisp_map_request_mode_t * mp)
 381 {
 382   vl_api_lisp_map_request_mode_reply_t *rmp;
 383   int rv = 0;
 384
 385   rv = vnet_lisp_set_map_request_mode (mp->mode);
 386
 387   REPLY_MACRO (VL_API_LISP_MAP_REQUEST_MODE_REPLY);
 388 }
 389
 390 static void
 391 vl_api_lisp_pitr_set_locator_set_t_handler (vl_api_lisp_pitr_set_locator_set_t
 392                                             * mp)
 393 {
 394   vl_api_lisp_pitr_set_locator_set_reply_t *rmp;
 395   int rv = 0;
 396   u8 *ls_name = 0;
 397
 398   mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
 399   ls_name = format (0, "%s", mp->ls_name);
 400   vec_terminate_c_string (ls_name);
 401   rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
 402   vec_free (ls_name);
 403
 404   REPLY_MACRO (VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
 405 }
 406
 407 static void
 408 vl_api_lisp_use_petr_t_handler (vl_api_lisp_use_petr_t * mp)
 409 {
 410   vl_api_lisp_use_petr_reply_t *rmp;
 411   int rv = 0;
 412   ip_address_t addr;
 413
 414   ip_address_set (&addr, &mp->address, mp->is_ip4 ? IP4 : IP6);
 415   rv = vnet_lisp_use_petr (&addr, mp->is_add);
 416
 417   REPLY_MACRO (VL_API_LISP_USE_PETR_REPLY);
 418 }
 419
 420 static void
 421 vl_api_show_lisp_use_petr_t_handler (vl_api_show_lisp_use_petr_t * mp)
 422 {
 423   vl_api_show_lisp_use_petr_reply_t *rmp = NULL;
 424   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 425   mapping_t *m;
 426   locator_set_t *ls = 0;
 427   int rv = 0;
 428   locator_t *loc = 0;
 429   u8 status = 0;
 430   gid_address_t addr;
 431
 432   memset (&addr, 0, sizeof (addr));
 433   status = lcm->flags & LISP_FLAG_USE_PETR;
 434   if (status)
 435     {
 436       m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index);
 437       if (~0 != m->locator_set_index)
 438         {
 439           ls =
 440             pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
 441           loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
 442           gid_address_copy (&addr, &loc->address);
 443         }
 444     }
 445
 446   /* *INDENT-OFF* */
 447   REPLY_MACRO2 (VL_API_SHOW_LISP_USE_PETR_REPLY,
 448   {
 449     rmp->status = status;
 450     ip_address_t *ip = &gid_address_ip (&addr);
 451     switch (ip_addr_version (ip))
 452       {
 453       case IP4:
 454         clib_memcpy (rmp->address, &ip_addr_v4 (ip),
 455                      sizeof (ip_addr_v4 (ip)));
 456         break;
 457
 458       case IP6:
 459         clib_memcpy (rmp->address, &ip_addr_v6 (ip),
 460                      sizeof (ip_addr_v6 (ip)));
 461         break;
 462
 463       default:
 464         ASSERT (0);
 465       }
 466     rmp->is_ip4 = (gid_address_ip_version (&addr) == IP4);
 467   });
 468   /* *INDENT-ON* */
 469 }
 470
 471 static void
 472   vl_api_lisp_add_del_map_request_itr_rlocs_t_handler
 473   (vl_api_lisp_add_del_map_request_itr_rlocs_t * mp)
 474 {
 475   vl_api_lisp_add_del_map_request_itr_rlocs_reply_t *rmp;
 476   int rv = 0;
 477   u8 *locator_set_name = NULL;
 478   vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a;
 479
 480   mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
 481   locator_set_name = format (0, "%s", mp->locator_set_name);
 482   vec_terminate_c_string (locator_set_name);
 483
 484   a->is_add = mp->is_add;
 485   a->locator_set_name = locator_set_name;
 486
 487   rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
 488
 489   vec_free (locator_set_name);
 490
 491   REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY);
 492 }
 493
 494 static void
 495   vl_api_lisp_add_del_remote_mapping_t_handler
 496   (vl_api_lisp_add_del_remote_mapping_t * mp)
 497 {
 498   locator_t *rlocs = 0;
 499   vl_api_lisp_add_del_remote_mapping_reply_t *rmp;
 500   int rv = 0;
 501   gid_address_t _eid, *eid = &_eid;
 502   u32 rloc_num = clib_net_to_host_u32 (mp->rloc_num);
 503
 504   memset (eid, 0, sizeof (eid[0]));
 505
 506   rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
 507                               mp->eid_type, mp->eid, mp->eid_len);
 508   if (rv)
 509     goto send_reply;
 510
 511   rlocs = unformat_lisp_locs (mp->rlocs, rloc_num);
 512
 513   if (!mp->is_add)
 514     {
 515       vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 516       memset (a, 0, sizeof (*a));
 517       gid_address_copy (&a->reid, eid);
 518       a->is_add = 0;
 519       rv = vnet_lisp_add_del_adjacency (a);
 520       if (rv)
 521         {
 522           goto out;
 523         }
 524     }
 525
 526   /* NOTE: for now this works as a static remote mapping, i.e.,
 527    * not authoritative and ttl infinite. */
 528   if (mp->is_add)
 529     {
 530       vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
 531       memset (m_args, 0, sizeof (m_args[0]));
 532       gid_address_copy (&m_args->eid, eid);
 533       m_args->action = mp->action;
 534       m_args->is_static = 1;
 535       m_args->ttl = ~0;
 536       m_args->authoritative = 0;
 537       rv = vnet_lisp_add_mapping (m_args, rlocs, NULL, NULL);
 538     }
 539   else
 540     {
 541       rv = vnet_lisp_del_mapping (eid, NULL);
 542     }
 543
 544   if (mp->del_all)
 545     vnet_lisp_clear_all_remote_adjacencies ();
 546
 547 out:
 548   vec_free (rlocs);
 549 send_reply:
 550   REPLY_MACRO (VL_API_LISP_ADD_DEL_REMOTE_MAPPING_REPLY);
 551 }
 552
 553 static void
 554 vl_api_lisp_add_del_adjacency_t_handler (vl_api_lisp_add_del_adjacency_t * mp)
 555 {
 556   vl_api_lisp_add_del_adjacency_reply_t *rmp;
 557   vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 558
 559   int rv = 0;
 560   memset (a, 0, sizeof (a[0]));
 561
 562   rv = unformat_lisp_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
 563                               mp->eid_type, mp->leid, mp->leid_len);
 564   rv |= unformat_lisp_eid_api (&a->reid, clib_net_to_host_u32 (mp->vni),
 565                                mp->eid_type, mp->reid, mp->reid_len);
 566
 567   if (rv)
 568     goto send_reply;
 569
 570   a->is_add = mp->is_add;
 571   rv = vnet_lisp_add_del_adjacency (a);
 572
 573 send_reply:
 574   REPLY_MACRO (VL_API_LISP_ADD_DEL_ADJACENCY_REPLY);
 575 }
 576
 577 static void
 578 send_lisp_locator_details (lisp_cp_main_t * lcm,
 579                            locator_t * loc, vl_api_registration_t * reg,
 580                            u32 context)
 581 {
 582   vl_api_lisp_locator_details_t *rmp;
 583
 584   rmp = vl_msg_api_alloc (sizeof (*rmp));
 585   memset (rmp, 0, sizeof (*rmp));
 586   rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_DETAILS);
 587   rmp->context = context;
 588
 589   rmp->local = loc->local;
 590   if (loc->local)
 591     {
 592       rmp->sw_if_index = ntohl (loc->sw_if_index);
 593     }
 594   else
 595     {
 596       rmp->is_ipv6 = gid_address_ip_version (&loc->address);
 597       ip_address_copy_addr (rmp->ip_address, &gid_address_ip (&loc->address));
 598     }
 599   rmp->priority = loc->priority;
 600   rmp->weight = loc->weight;
 601
 602   vl_api_send_msg (reg, (u8 *) rmp);
 603 }
 604
 605 static void
 606 vl_api_lisp_locator_dump_t_handler (vl_api_lisp_locator_dump_t * mp)
 607 {
 608   u8 *ls_name = 0;
 609   vl_api_registration_t *reg = 0;
 610   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 611   locator_set_t *lsit = 0;
 612   locator_t *loc = 0;
 613   u32 ls_index = ~0, *locit = 0;
 614   uword *p = 0;
 615
 616   reg = vl_api_client_index_to_registration (mp->client_index);
 617   if (!reg)
 618     return;
 619
 620   if (mp->is_index_set)
 621     ls_index = htonl (mp->ls_index);
 622   else
 623     {
 624       /* make sure we get a proper C-string */
 625       mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
 626       ls_name = format (0, "%s", mp->ls_name);
 627       vec_terminate_c_string (ls_name);
 628       p = hash_get_mem (lcm->locator_set_index_by_name, ls_name);
 629       if (!p)
 630         goto out;
 631       ls_index = p[0];
 632     }
 633
 634   if (pool_is_free_index (lcm->locator_set_pool, ls_index))
 635     return;
 636
 637   lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
 638
 639   vec_foreach (locit, lsit->locator_indices)
 640   {
 641     loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
 642     send_lisp_locator_details (lcm, loc, reg, mp->context);
 643   };
 644 out:
 645   vec_free (ls_name);
 646 }
 647
 648 static void
 649 send_lisp_locator_set_details (lisp_cp_main_t * lcm,
 650                                locator_set_t * lsit,
 651                                vl_api_registration_t * reg, u32 context,
 652                                u32 ls_index)
 653 {
 654   vl_api_lisp_locator_set_details_t *rmp;
 655   u8 *str = 0;
 656
 657   rmp = vl_msg_api_alloc (sizeof (*rmp));
 658   memset (rmp, 0, sizeof (*rmp));
 659   rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
 660   rmp->context = context;
 661
 662   rmp->ls_index = htonl (ls_index);
 663   if (lsit->local)
 664     {
 665       ASSERT (lsit->name != NULL);
 666       strncpy ((char *) rmp->ls_name, (char *) lsit->name,
 667                vec_len (lsit->name));
 668     }
 669   else
 670     {
 671       str = format (0, "<remote-%d>", ls_index);
 672       strncpy ((char *) rmp->ls_name, (char *) str, vec_len (str));
 673       vec_free (str);
 674     }
 675
 676   vl_api_send_msg (reg, (u8 *) rmp);
 677 }
 678
 679 static void
 680 vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t * mp)
 681 {
 682   vl_api_registration_t *reg;
 683   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 684   locator_set_t *lsit = NULL;
 685   u8 filter;
 686
 687   reg = vl_api_client_index_to_registration (mp->client_index);
 688   if (!reg)
 689     return;
 690
 691   filter = mp->filter;
 692   /* *INDENT-OFF* */
 693   pool_foreach (lsit, lcm->locator_set_pool,
 694   ({
 695     if (filter && !((1 == filter && lsit->local) ||
 696                     (2 == filter && !lsit->local)))
 697       {
 698         continue;
 699       }
 700     send_lisp_locator_set_details (lcm, lsit, reg, mp->context,
 701                                    lsit - lcm->locator_set_pool);
 702   }));
 703   /* *INDENT-ON* */
 704 }
 705
 706 static void
 707 lisp_fid_put_api (u8 * dst, fid_address_t * src, u8 * prefix_length)
 708 {
 709   ASSERT (prefix_length);
 710   ip_prefix_t *ippref = &fid_addr_ippref (src);
 711
 712   switch (fid_addr_type (src))
 713     {
 714     case FID_ADDR_IP_PREF:
 715       if (ip_prefix_version (ippref) == IP4)
 716         clib_memcpy (dst, &ip_prefix_v4 (ippref), 4);
 717       else
 718         clib_memcpy (dst, &ip_prefix_v6 (ippref), 16);
 719       prefix_length[0] = ip_prefix_len (ippref);
 720       break;
 721
 722     case FID_ADDR_MAC:
 723       prefix_length[0] = 0;
 724       clib_memcpy (dst, fid_addr_mac (src), 6);
 725       break;
 726
 727     default:
 728       clib_warning ("Unknown FID type %d!", fid_addr_type (src));
 729       break;
 730     }
 731 }
 732
 733 static u8
 734 fid_type_to_api_type (fid_address_t * fid)
 735 {
 736   ip_prefix_t *ippref;
 737
 738   switch (fid_addr_type (fid))
 739     {
 740     case FID_ADDR_IP_PREF:
 741       ippref = &fid_addr_ippref (fid);
 742       if (ip_prefix_version (ippref) == IP4)
 743         return 0;
 744       else if (ip_prefix_version (ippref) == IP6)
 745         return 1;
 746       else
 747         return ~0;
 748
 749     case FID_ADDR_MAC:
 750       return 2;
 751     case FID_ADDR_NSH:
 752       return 3;
 753     }
 754
 755   return ~0;
 756 }
 757
 758 static void
 759 send_lisp_eid_table_details (mapping_t * mapit,
 760                              vl_api_registration_t * reg, u32 context,
 761                              u8 filter)
 762 {
 763   fid_address_t *fid;
 764   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 765   locator_set_t *ls = 0;
 766   vl_api_lisp_eid_table_details_t *rmp = NULL;
 767   gid_address_t *gid = NULL;
 768   u8 *mac = 0;
 769   ip_prefix_t *ip_prefix = NULL;
 770
 771   switch (filter)
 772     {
 773     case 0:                     /* all mappings */
 774       break;
 775
 776     case 1:                     /* local only */
 777       if (!mapit->local)
 778         return;
 779       break;
 780     case 2:                     /* remote only */
 781       if (mapit->local)
 782         return;
 783       break;
 784     default:
 785       clib_warning ("Filter error, unknown filter: %d", filter);
 786       return;
 787     }
 788
 789   /* don't send PITR generated mapping */
 790   if (mapit->pitr_set)
 791     return;
 792
 793   gid = &mapit->eid;
 794   ip_prefix = &gid_address_ippref (gid);
 795   mac = gid_address_mac (gid);
 796
 797   rmp = vl_msg_api_alloc (sizeof (*rmp));
 798   memset (rmp, 0, sizeof (*rmp));
 799   rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
 800
 801   ls = pool_elt_at_index (lcm->locator_set_pool, mapit->locator_set_index);
 802   if (vec_len (ls->locator_indices) == 0)
 803     rmp->locator_set_index = ~0;
 804   else
 805     rmp->locator_set_index = clib_host_to_net_u32 (mapit->locator_set_index);
 806
 807   rmp->is_local = mapit->local;
 808   rmp->ttl = clib_host_to_net_u32 (mapit->ttl);
 809   rmp->action = mapit->action;
 810   rmp->authoritative = mapit->authoritative;
 811
 812   switch (gid_address_type (gid))
 813     {
 814     case GID_ADDR_SRC_DST:
 815       rmp->is_src_dst = 1;
 816       fid = &gid_address_sd_src (gid);
 817       rmp->eid_type = fid_type_to_api_type (fid);
 818       lisp_fid_put_api (rmp->seid, &gid_address_sd_src (gid),
 819                         &rmp->seid_prefix_len);
 820       lisp_fid_put_api (rmp->eid, &gid_address_sd_dst (gid),
 821                         &rmp->eid_prefix_len);
 822       break;
 823     case GID_ADDR_IP_PREFIX:
 824       rmp->eid_prefix_len = ip_prefix_len (ip_prefix);
 825       if (ip_prefix_version (ip_prefix) == IP4)
 826         {
 827           rmp->eid_type = 0;    /* ipv4 type */
 828           clib_memcpy (rmp->eid, &ip_prefix_v4 (ip_prefix),
 829                        sizeof (ip_prefix_v4 (ip_prefix)));
 830         }
 831       else
 832         {
 833           rmp->eid_type = 1;    /* ipv6 type */
 834           clib_memcpy (rmp->eid, &ip_prefix_v6 (ip_prefix),
 835                        sizeof (ip_prefix_v6 (ip_prefix)));
 836         }
 837       break;
 838     case GID_ADDR_MAC:
 839       rmp->eid_type = 2;        /* l2 mac type */
 840       clib_memcpy (rmp->eid, mac, 6);
 841       break;
 842     default:
 843       ASSERT (0);
 844     }
 845   rmp->context = context;
 846   rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid));
 847   rmp->key_id = clib_host_to_net_u16 (mapit->key_id);
 848   memcpy (rmp->key, mapit->key, vec_len (mapit->key));
 849   vl_api_send_msg (reg, (u8 *) rmp);
 850 }
 851
 852 static void
 853 vl_api_lisp_eid_table_dump_t_handler (vl_api_lisp_eid_table_dump_t * mp)
 854 {
 855   u32 mi;
 856   vl_api_registration_t *reg;
 857   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 858   mapping_t *mapit = NULL;
 859   gid_address_t _eid, *eid = &_eid;
 860
 861   reg = vl_api_client_index_to_registration (mp->client_index);
 862   if (!reg)
 863     return;
 864
 865   if (mp->eid_set)
 866     {
 867       memset (eid, 0, sizeof (*eid));
 868
 869       unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
 870                              mp->eid_type, mp->eid, mp->prefix_length);
 871
 872       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid);
 873       if ((u32) ~ 0 == mi)
 874         return;
 875
 876       mapit = pool_elt_at_index (lcm->mapping_pool, mi);
 877       send_lisp_eid_table_details (mapit, reg, mp->context,
 878                                    0 /* ignore filter */ );
 879     }
 880   else
 881     {
 882       /* *INDENT-OFF* */
 883       pool_foreach (mapit, lcm->mapping_pool,
 884       ({
 885         send_lisp_eid_table_details(mapit, reg, mp->context,
 886                                     mp->filter);
 887       }));
 888       /* *INDENT-ON* */
 889     }
 890 }
 891
 892 static void
 893 send_lisp_map_server_details (ip_address_t * ip, vl_api_registration_t * reg,
 894                               u32 context)
 895 {
 896   vl_api_lisp_map_server_details_t *rmp = NULL;
 897
 898   rmp = vl_msg_api_alloc (sizeof (*rmp));
 899   memset (rmp, 0, sizeof (*rmp));
 900   rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_SERVER_DETAILS);
 901
 902   switch (ip_addr_version (ip))
 903     {
 904     case IP4:
 905       rmp->is_ipv6 = 0;
 906       clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
 907                    sizeof (ip_addr_v4 (ip)));
 908       break;
 909
 910     case IP6:
 911       rmp->is_ipv6 = 1;
 912       clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
 913                    sizeof (ip_addr_v6 (ip)));
 914       break;
 915
 916     default:
 917       ASSERT (0);
 918     }
 919   rmp->context = context;
 920
 921   vl_api_send_msg (reg, (u8 *) rmp);
 922 }
 923
 924 static void
 925 vl_api_lisp_map_server_dump_t_handler (vl_api_lisp_map_server_dump_t * mp)
 926 {
 927   vl_api_registration_t *reg;
 928   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 929   lisp_msmr_t *mr;
 930
 931   reg = vl_api_client_index_to_registration (mp->client_index);
 932   if (!reg)
 933     return;
 934
 935   vec_foreach (mr, lcm->map_servers)
 936   {
 937     send_lisp_map_server_details (&mr->address, reg, mp->context);
 938   }
 939 }
 940
 941 static void
 942 send_lisp_map_resolver_details (ip_address_t * ip,
 943                                 vl_api_registration_t * reg, u32 context)
 944 {
 945   vl_api_lisp_map_resolver_details_t *rmp = NULL;
 946
 947   rmp = vl_msg_api_alloc (sizeof (*rmp));
 948   memset (rmp, 0, sizeof (*rmp));
 949   rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_RESOLVER_DETAILS);
 950
 951   switch (ip_addr_version (ip))
 952     {
 953     case IP4:
 954       rmp->is_ipv6 = 0;
 955       clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
 956                    sizeof (ip_addr_v4 (ip)));
 957       break;
 958
 959     case IP6:
 960       rmp->is_ipv6 = 1;
 961       clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
 962                    sizeof (ip_addr_v6 (ip)));
 963       break;
 964
 965     default:
 966       ASSERT (0);
 967     }
 968   rmp->context = context;
 969
 970   vl_api_send_msg (reg, (u8 *) rmp);
 971 }
 972
 973 static void
 974 vl_api_lisp_map_resolver_dump_t_handler (vl_api_lisp_map_resolver_dump_t * mp)
 975 {
 976   vl_api_registration_t *reg;
 977   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 978   lisp_msmr_t *mr;
 979
 980   reg = vl_api_client_index_to_registration (mp->client_index);
 981   if (!reg)
 982     return;
 983
 984   vec_foreach (mr, lcm->map_resolvers)
 985   {
 986     send_lisp_map_resolver_details (&mr->address, reg, mp->context);
 987   }
 988 }
 989
 990 static void
 991 send_eid_table_map_pair (hash_pair_t * p, vl_api_registration_t * reg,
 992                          u32 context)
 993 {
 994   vl_api_lisp_eid_table_map_details_t *rmp = NULL;
 995
 996   rmp = vl_msg_api_alloc (sizeof (*rmp));
 997   memset (rmp, 0, sizeof (*rmp));
 998   rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_MAP_DETAILS);
 999
1000   rmp->vni = clib_host_to_net_u32 (p->key);
1001   rmp->dp_table = clib_host_to_net_u32 (p->value[0]);
1002   rmp->context = context;
1003   vl_api_send_msg (reg, (u8 *) rmp);
1004 }
1005
1006 static void
1007 vl_api_lisp_eid_table_map_dump_t_handler (vl_api_lisp_eid_table_map_dump_t *
1008                                           mp)
1009 {
1010   vl_api_registration_t *reg;
1011   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1012   hash_pair_t *p;
1013   uword *vni_table = 0;
1014
1015   reg = vl_api_client_index_to_registration (mp->client_index);
1016   if (!reg)
1017     return;
1018
1019   if (mp->is_l2)
1020     {
1021       vni_table = lcm->bd_id_by_vni;
1022     }
1023   else
1024     {
1025       vni_table = lcm->table_id_by_vni;
1026     }
1027
1028   /* *INDENT-OFF* */
1029   hash_foreach_pair (p, vni_table,
1030   ({
1031     send_eid_table_map_pair (p, reg, mp->context);
1032   }));
1033   /* *INDENT-ON* */
1034 }
1035
1036 static void
1037 send_eid_table_vni (u32 vni, vl_api_registration_t * reg, u32 context)
1038 {
1039   vl_api_lisp_eid_table_vni_details_t *rmp = 0;
1040
1041   rmp = vl_msg_api_alloc (sizeof (*rmp));
1042   memset (rmp, 0, sizeof (*rmp));
1043   rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
1044   rmp->context = context;
1045   rmp->vni = clib_host_to_net_u32 (vni);
1046   vl_api_send_msg (reg, (u8 *) rmp);
1047 }
1048
1049 static void
1050 lisp_adjacency_copy (vl_api_lisp_adjacency_t * dst, lisp_adjacency_t * adjs)
1051 {
1052   lisp_adjacency_t *adj;
1053   vl_api_lisp_adjacency_t a;
1054   u32 i, n = vec_len (adjs);
1055
1056   for (i = 0; i < n; i++)
1057     {
1058       adj = vec_elt_at_index (adjs, i);
1059       memset (&a, 0, sizeof (a));
1060
1061       switch (gid_address_type (&adj->reid))
1062         {
1063         case GID_ADDR_IP_PREFIX:
1064           a.reid_prefix_len = gid_address_ippref_len (&adj->reid);
1065           a.leid_prefix_len = gid_address_ippref_len (&adj->leid);
1066           if (gid_address_ip_version (&adj->reid) == IP4)
1067             {
1068               a.eid_type = 0;   /* ipv4 type */
1069               clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 4);
1070               clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 4);
1071             }
1072           else
1073             {
1074               a.eid_type = 1;   /* ipv6 type */
1075               clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 16);
1076               clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 16);
1077             }
1078           break;
1079         case GID_ADDR_MAC:
1080           a.eid_type = 2;       /* l2 mac type */
1081           mac_copy (a.reid, gid_address_mac (&adj->reid));
1082           mac_copy (a.leid, gid_address_mac (&adj->leid));
1083           break;
1084         default:
1085           ASSERT (0);
1086         }
1087       dst[i] = a;
1088     }
1089 }
1090
1091 static void
1092   vl_api_show_lisp_rloc_probe_state_t_handler
1093   (vl_api_show_lisp_rloc_probe_state_t * mp)
1094 {
1095   vl_api_show_lisp_rloc_probe_state_reply_t *rmp = 0;
1096   int rv = 0;
1097
1098   /* *INDENT-OFF* */
1099   REPLY_MACRO2 (VL_API_SHOW_LISP_RLOC_PROBE_STATE_REPLY,
1100   {
1101     rmp->is_enabled = vnet_lisp_rloc_probe_state_get ();
1102   });
1103   /* *INDENT-ON* */
1104 }
1105
1106 static void
1107   vl_api_show_lisp_map_register_state_t_handler
1108   (vl_api_show_lisp_map_register_state_t * mp)
1109 {
1110   vl_api_show_lisp_map_register_state_reply_t *rmp = 0;
1111   int rv = 0;
1112
1113   /* *INDENT-OFF* */
1114   REPLY_MACRO2 (VL_API_SHOW_LISP_MAP_REGISTER_STATE_REPLY,
1115   {
1116     rmp->is_enabled = vnet_lisp_map_register_state_get ();
1117   });
1118   /* *INDENT-ON* */
1119 }
1120
1121 static void
1122 vl_api_lisp_adjacencies_get_t_handler (vl_api_lisp_adjacencies_get_t * mp)
1123 {
1124   vl_api_lisp_adjacencies_get_reply_t *rmp = 0;
1125   lisp_adjacency_t *adjs = 0;
1126   int rv = 0;
1127   u32 size = ~0;
1128   u32 vni = clib_net_to_host_u32 (mp->vni);
1129
1130   adjs = vnet_lisp_adjacencies_get_by_vni (vni);
1131   size = vec_len (adjs) * sizeof (vl_api_lisp_adjacency_t);
1132
1133   /* *INDENT-OFF* */
1134   REPLY_MACRO4 (VL_API_LISP_ADJACENCIES_GET_REPLY, size,
1135   {
1136     rmp->count = clib_host_to_net_u32 (vec_len (adjs));
1137     lisp_adjacency_copy (rmp->adjacencies, adjs);
1138   });
1139   /* *INDENT-ON* */
1140
1141   vec_free (adjs);
1142 }
1143
1144 static void
1145 vl_api_lisp_eid_table_vni_dump_t_handler (vl_api_lisp_eid_table_vni_dump_t *
1146                                           mp)
1147 {
1148   hash_pair_t *p;
1149   u32 *vnis = 0;
1150   vl_api_registration_t *reg = 0;
1151   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1152
1153   reg = vl_api_client_index_to_registration (mp->client_index);
1154   if (!reg)
1155     return;
1156
1157   /* *INDENT-OFF* */
1158   hash_foreach_pair (p, lcm->table_id_by_vni,
1159   ({
1160     hash_set (vnis, p->key, 0);
1161   }));
1162
1163   hash_foreach_pair (p, lcm->bd_id_by_vni,
1164   ({
1165     hash_set (vnis, p->key, 0);
1166   }));
1167
1168   hash_foreach_pair (p, vnis,
1169   ({
1170     send_eid_table_vni (p->key, reg, mp->context);
1171   }));
1172   /* *INDENT-ON* */
1173
1174   hash_free (vnis);
1175 }
1176
1177 static void
1178 vl_api_show_lisp_status_t_handler (vl_api_show_lisp_status_t * mp)
1179 {
1180   vl_api_show_lisp_status_reply_t *rmp = NULL;
1181   int rv = 0;
1182
1183   /* *INDENT-OFF* */
1184   REPLY_MACRO2(VL_API_SHOW_LISP_STATUS_REPLY,
1185   ({
1186     rmp->gpe_status = vnet_lisp_gpe_enable_disable_status ();
1187     rmp->feature_status = vnet_lisp_enable_disable_status ();
1188   }));
1189   /* *INDENT-ON* */
1190 }
1191
1192 static void
1193   vl_api_lisp_get_map_request_itr_rlocs_t_handler
1194   (vl_api_lisp_get_map_request_itr_rlocs_t * mp)
1195 {
1196   vl_api_lisp_get_map_request_itr_rlocs_reply_t *rmp = NULL;
1197   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1198   locator_set_t *loc_set = 0;
1199   u8 *tmp_str = 0;
1200   int rv = 0;
1201
1202   if (~0 == lcm->mreq_itr_rlocs)
1203     {
1204       tmp_str = format (0, " ");
1205     }
1206   else
1207     {
1208       loc_set =
1209         pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1210       tmp_str = format (0, "%s", loc_set->name);
1211     }
1212
1213   /* *INDENT-OFF* */
1214   REPLY_MACRO2(VL_API_LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY,
1215   ({
1216     strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1217             ARRAY_LEN(rmp->locator_set_name) - 1);
1218   }));
1219   /* *INDENT-ON* */
1220
1221   vec_free (tmp_str);
1222 }
1223
1224 static void
1225 vl_api_show_lisp_pitr_t_handler (vl_api_show_lisp_pitr_t * mp)
1226 {
1227   vl_api_show_lisp_pitr_reply_t *rmp = NULL;
1228   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1229   mapping_t *m;
1230   locator_set_t *ls = 0;
1231   u8 *tmp_str = 0;
1232   int rv = 0;
1233
1234   u8 is_enabled = (lcm->flags & LISP_FLAG_PITR_MODE)
1235     && lcm->pitr_map_index != ~0;
1236
1237   if (!is_enabled)
1238     {
1239       tmp_str = format (0, "N/A");
1240     }
1241   else
1242     {
1243       m = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
1244       if (~0 != m->locator_set_index)
1245         {
1246           ls =
1247             pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
1248           tmp_str = format (0, "%s", ls->name);
1249         }
1250       else
1251         {
1252           tmp_str = format (0, "N/A");
1253         }
1254     }
1255   vec_add1 (tmp_str, 0);
1256
1257   /* *INDENT-OFF* */
1258   REPLY_MACRO2(VL_API_SHOW_LISP_PITR_REPLY,
1259   ({
1260     rmp->status = lcm->flags & LISP_FLAG_PITR_MODE;
1261     strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1262             ARRAY_LEN(rmp->locator_set_name) - 1);
1263   }));
1264   /* *INDENT-ON* */
1265 }
1266
1267 /*
1268  * lisp_api_hookup
1269  * Add vpe's API message handlers to the table.
1270  * vlib has already mapped shared memory and
1271  * added the client registration handlers.
1272  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1273  */
1274 #define vl_msg_name_crc_list
1275 #include <vnet/vnet_all_api_h.h>
1276 #undef vl_msg_name_crc_list
1277
1278 static void
1279 setup_message_id_table (api_main_t * am)
1280 {
1281 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1282   foreach_vl_msg_name_crc_lisp;
1283 #undef _
1284 }
1285
1286 static clib_error_t *
1287 lisp_api_hookup (vlib_main_t * vm)
1288 {
1289   api_main_t *am = &api_main;
1290
1291 #define _(N,n)                                                  \
1292     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1293                            vl_api_##n##_t_handler,              \
1294                            vl_noop_handler,                     \
1295                            vl_api_##n##_t_endian,               \
1296                            vl_api_##n##_t_print,                \
1297                            sizeof(vl_api_##n##_t), 1);
1298   foreach_vpe_api_msg;
1299 #undef _
1300
1301   /*
1302    * Set up the (msg_name, crc, message-id) table
1303    */
1304   setup_message_id_table (am);
1305
1306   return 0;
1307 }
1308
1309 VLIB_API_INIT_FUNCTION (lisp_api_hookup);
1310
1311 /*
1312  * fd.io coding-style-patch-verification: ON
1313  *
1314  * Local Variables:
1315  * eval: (c-set-style "gnu")
1316  * End:
1317  */