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   svm_queue_t *q = NULL;
 424   vl_api_show_lisp_use_petr_reply_t *rmp = NULL;
 425   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 426   mapping_t *m;
 427   locator_set_t *ls = 0;
 428   int rv = 0;
 429   locator_t *loc = 0;
 430   u8 status = 0;
 431   gid_address_t addr;
 432
 433   q = vl_api_client_index_to_input_queue (mp->client_index);
 434   if (q == 0)
 435     {
 436       return;
 437     }
 438
 439   memset (&addr, 0, sizeof (addr));
 440   status = lcm->flags & LISP_FLAG_USE_PETR;
 441   if (status)
 442     {
 443       m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index);
 444       if (~0 != m->locator_set_index)
 445         {
 446           ls =
 447             pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
 448           loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
 449           gid_address_copy (&addr, &loc->address);
 450         }
 451     }
 452
 453   /* *INDENT-OFF* */
 454   REPLY_MACRO2 (VL_API_SHOW_LISP_USE_PETR_REPLY,
 455   {
 456     rmp->status = status;
 457     ip_address_t *ip = &gid_address_ip (&addr);
 458     switch (ip_addr_version (ip))
 459       {
 460       case IP4:
 461         clib_memcpy (rmp->address, &ip_addr_v4 (ip),
 462                      sizeof (ip_addr_v4 (ip)));
 463         break;
 464
 465       case IP6:
 466         clib_memcpy (rmp->address, &ip_addr_v6 (ip),
 467                      sizeof (ip_addr_v6 (ip)));
 468         break;
 469
 470       default:
 471         ASSERT (0);
 472       }
 473     rmp->is_ip4 = (gid_address_ip_version (&addr) == IP4);
 474   });
 475   /* *INDENT-ON* */
 476 }
 477
 478 static void
 479   vl_api_lisp_add_del_map_request_itr_rlocs_t_handler
 480   (vl_api_lisp_add_del_map_request_itr_rlocs_t * mp)
 481 {
 482   vl_api_lisp_add_del_map_request_itr_rlocs_reply_t *rmp;
 483   int rv = 0;
 484   u8 *locator_set_name = NULL;
 485   vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a;
 486
 487   mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
 488   locator_set_name = format (0, "%s", mp->locator_set_name);
 489   vec_terminate_c_string (locator_set_name);
 490
 491   a->is_add = mp->is_add;
 492   a->locator_set_name = locator_set_name;
 493
 494   rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
 495
 496   vec_free (locator_set_name);
 497
 498   REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY);
 499 }
 500
 501 static void
 502   vl_api_lisp_add_del_remote_mapping_t_handler
 503   (vl_api_lisp_add_del_remote_mapping_t * mp)
 504 {
 505   locator_t *rlocs = 0;
 506   vl_api_lisp_add_del_remote_mapping_reply_t *rmp;
 507   int rv = 0;
 508   gid_address_t _eid, *eid = &_eid;
 509   u32 rloc_num = clib_net_to_host_u32 (mp->rloc_num);
 510
 511   memset (eid, 0, sizeof (eid[0]));
 512
 513   rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
 514                               mp->eid_type, mp->eid, mp->eid_len);
 515   if (rv)
 516     goto send_reply;
 517
 518   rlocs = unformat_lisp_locs (mp->rlocs, rloc_num);
 519
 520   if (!mp->is_add)
 521     {
 522       vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 523       memset (a, 0, sizeof (*a));
 524       gid_address_copy (&a->reid, eid);
 525       a->is_add = 0;
 526       rv = vnet_lisp_add_del_adjacency (a);
 527       if (rv)
 528         {
 529           goto out;
 530         }
 531     }
 532
 533   /* NOTE: for now this works as a static remote mapping, i.e.,
 534    * not authoritative and ttl infinite. */
 535   if (mp->is_add)
 536     {
 537       vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
 538       memset (m_args, 0, sizeof (m_args[0]));
 539       gid_address_copy (&m_args->eid, eid);
 540       m_args->action = mp->action;
 541       m_args->is_static = 1;
 542       m_args->ttl = ~0;
 543       m_args->authoritative = 0;
 544       rv = vnet_lisp_add_mapping (m_args, rlocs, NULL, NULL);
 545     }
 546   else
 547     {
 548       rv = vnet_lisp_del_mapping (eid, NULL);
 549     }
 550
 551   if (mp->del_all)
 552     vnet_lisp_clear_all_remote_adjacencies ();
 553
 554 out:
 555   vec_free (rlocs);
 556 send_reply:
 557   REPLY_MACRO (VL_API_LISP_ADD_DEL_REMOTE_MAPPING_REPLY);
 558 }
 559
 560 static void
 561 vl_api_lisp_add_del_adjacency_t_handler (vl_api_lisp_add_del_adjacency_t * mp)
 562 {
 563   vl_api_lisp_add_del_adjacency_reply_t *rmp;
 564   vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 565
 566   int rv = 0;
 567   memset (a, 0, sizeof (a[0]));
 568
 569   rv = unformat_lisp_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
 570                               mp->eid_type, mp->leid, mp->leid_len);
 571   rv |= unformat_lisp_eid_api (&a->reid, clib_net_to_host_u32 (mp->vni),
 572                                mp->eid_type, mp->reid, mp->reid_len);
 573
 574   if (rv)
 575     goto send_reply;
 576
 577   a->is_add = mp->is_add;
 578   rv = vnet_lisp_add_del_adjacency (a);
 579
 580 send_reply:
 581   REPLY_MACRO (VL_API_LISP_ADD_DEL_ADJACENCY_REPLY);
 582 }
 583
 584 static void
 585 send_lisp_locator_details (lisp_cp_main_t * lcm,
 586                            locator_t * loc, svm_queue_t * q, u32 context)
 587 {
 588   vl_api_lisp_locator_details_t *rmp;
 589
 590   rmp = vl_msg_api_alloc (sizeof (*rmp));
 591   memset (rmp, 0, sizeof (*rmp));
 592   rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_DETAILS);
 593   rmp->context = context;
 594
 595   rmp->local = loc->local;
 596   if (loc->local)
 597     {
 598       rmp->sw_if_index = ntohl (loc->sw_if_index);
 599     }
 600   else
 601     {
 602       rmp->is_ipv6 = gid_address_ip_version (&loc->address);
 603       ip_address_copy_addr (rmp->ip_address, &gid_address_ip (&loc->address));
 604     }
 605   rmp->priority = loc->priority;
 606   rmp->weight = loc->weight;
 607
 608   vl_msg_api_send_shmem (q, (u8 *) & rmp);
 609 }
 610
 611 static void
 612 vl_api_lisp_locator_dump_t_handler (vl_api_lisp_locator_dump_t * mp)
 613 {
 614   u8 *ls_name = 0;
 615   svm_queue_t *q = 0;
 616   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 617   locator_set_t *lsit = 0;
 618   locator_t *loc = 0;
 619   u32 ls_index = ~0, *locit = 0;
 620   uword *p = 0;
 621
 622   q = vl_api_client_index_to_input_queue (mp->client_index);
 623   if (q == 0)
 624     {
 625       return;
 626     }
 627
 628   if (mp->is_index_set)
 629     ls_index = htonl (mp->ls_index);
 630   else
 631     {
 632       /* make sure we get a proper C-string */
 633       mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
 634       ls_name = format (0, "%s", mp->ls_name);
 635       vec_terminate_c_string (ls_name);
 636       p = hash_get_mem (lcm->locator_set_index_by_name, ls_name);
 637       if (!p)
 638         goto out;
 639       ls_index = p[0];
 640     }
 641
 642   if (pool_is_free_index (lcm->locator_set_pool, ls_index))
 643     return;
 644
 645   lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
 646
 647   vec_foreach (locit, lsit->locator_indices)
 648   {
 649     loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
 650     send_lisp_locator_details (lcm, loc, q, mp->context);
 651   };
 652 out:
 653   vec_free (ls_name);
 654 }
 655
 656 static void
 657 send_lisp_locator_set_details (lisp_cp_main_t * lcm,
 658                                locator_set_t * lsit,
 659                                svm_queue_t * q, u32 context, u32 ls_index)
 660 {
 661   vl_api_lisp_locator_set_details_t *rmp;
 662   u8 *str = 0;
 663
 664   rmp = vl_msg_api_alloc (sizeof (*rmp));
 665   memset (rmp, 0, sizeof (*rmp));
 666   rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
 667   rmp->context = context;
 668
 669   rmp->ls_index = htonl (ls_index);
 670   if (lsit->local)
 671     {
 672       ASSERT (lsit->name != NULL);
 673       strncpy ((char *) rmp->ls_name, (char *) lsit->name,
 674                vec_len (lsit->name));
 675     }
 676   else
 677     {
 678       str = format (0, "<remote-%d>", ls_index);
 679       strncpy ((char *) rmp->ls_name, (char *) str, vec_len (str));
 680       vec_free (str);
 681     }
 682
 683   vl_msg_api_send_shmem (q, (u8 *) & rmp);
 684 }
 685
 686 static void
 687 vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t * mp)
 688 {
 689   svm_queue_t *q = NULL;
 690   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 691   locator_set_t *lsit = NULL;
 692   u8 filter;
 693
 694   q = vl_api_client_index_to_input_queue (mp->client_index);
 695   if (q == 0)
 696     {
 697       return;
 698     }
 699
 700   filter = mp->filter;
 701   /* *INDENT-OFF* */
 702   pool_foreach (lsit, lcm->locator_set_pool,
 703   ({
 704     if (filter && !((1 == filter && lsit->local) ||
 705                     (2 == filter && !lsit->local)))
 706       {
 707         continue;
 708       }
 709     send_lisp_locator_set_details (lcm, lsit, q, mp->context,
 710                                    lsit - lcm->locator_set_pool);
 711   }));
 712   /* *INDENT-ON* */
 713 }
 714
 715 static void
 716 lisp_fid_put_api (u8 * dst, fid_address_t * src, u8 * prefix_length)
 717 {
 718   ASSERT (prefix_length);
 719   ip_prefix_t *ippref = &fid_addr_ippref (src);
 720
 721   switch (fid_addr_type (src))
 722     {
 723     case FID_ADDR_IP_PREF:
 724       if (ip_prefix_version (ippref) == IP4)
 725         clib_memcpy (dst, &ip_prefix_v4 (ippref), 4);
 726       else
 727         clib_memcpy (dst, &ip_prefix_v6 (ippref), 16);
 728       prefix_length[0] = ip_prefix_len (ippref);
 729       break;
 730
 731     case FID_ADDR_MAC:
 732       prefix_length[0] = 0;
 733       clib_memcpy (dst, fid_addr_mac (src), 6);
 734       break;
 735
 736     default:
 737       clib_warning ("Unknown FID type %d!", fid_addr_type (src));
 738       break;
 739     }
 740 }
 741
 742 static u8
 743 fid_type_to_api_type (fid_address_t * fid)
 744 {
 745   ip_prefix_t *ippref;
 746
 747   switch (fid_addr_type (fid))
 748     {
 749     case FID_ADDR_IP_PREF:
 750       ippref = &fid_addr_ippref (fid);
 751       if (ip_prefix_version (ippref) == IP4)
 752         return 0;
 753       else if (ip_prefix_version (ippref) == IP6)
 754         return 1;
 755       else
 756         return ~0;
 757
 758     case FID_ADDR_MAC:
 759       return 2;
 760     case FID_ADDR_NSH:
 761       return 3;
 762     }
 763
 764   return ~0;
 765 }
 766
 767 static void
 768 send_lisp_eid_table_details (mapping_t * mapit,
 769                              svm_queue_t * q, u32 context, u8 filter)
 770 {
 771   fid_address_t *fid;
 772   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 773   locator_set_t *ls = 0;
 774   vl_api_lisp_eid_table_details_t *rmp = NULL;
 775   gid_address_t *gid = NULL;
 776   u8 *mac = 0;
 777   ip_prefix_t *ip_prefix = NULL;
 778
 779   switch (filter)
 780     {
 781     case 0:                     /* all mappings */
 782       break;
 783
 784     case 1:                     /* local only */
 785       if (!mapit->local)
 786         return;
 787       break;
 788     case 2:                     /* remote only */
 789       if (mapit->local)
 790         return;
 791       break;
 792     default:
 793       clib_warning ("Filter error, unknown filter: %d", filter);
 794       return;
 795     }
 796
 797   /* don't send PITR generated mapping */
 798   if (mapit->pitr_set)
 799     return;
 800
 801   gid = &mapit->eid;
 802   ip_prefix = &gid_address_ippref (gid);
 803   mac = gid_address_mac (gid);
 804
 805   rmp = vl_msg_api_alloc (sizeof (*rmp));
 806   memset (rmp, 0, sizeof (*rmp));
 807   rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
 808
 809   ls = pool_elt_at_index (lcm->locator_set_pool, mapit->locator_set_index);
 810   if (vec_len (ls->locator_indices) == 0)
 811     rmp->locator_set_index = ~0;
 812   else
 813     rmp->locator_set_index = clib_host_to_net_u32 (mapit->locator_set_index);
 814
 815   rmp->is_local = mapit->local;
 816   rmp->ttl = clib_host_to_net_u32 (mapit->ttl);
 817   rmp->action = mapit->action;
 818   rmp->authoritative = mapit->authoritative;
 819
 820   switch (gid_address_type (gid))
 821     {
 822     case GID_ADDR_SRC_DST:
 823       rmp->is_src_dst = 1;
 824       fid = &gid_address_sd_src (gid);
 825       rmp->eid_type = fid_type_to_api_type (fid);
 826       lisp_fid_put_api (rmp->seid, &gid_address_sd_src (gid),
 827                         &rmp->seid_prefix_len);
 828       lisp_fid_put_api (rmp->eid, &gid_address_sd_dst (gid),
 829                         &rmp->eid_prefix_len);
 830       break;
 831     case GID_ADDR_IP_PREFIX:
 832       rmp->eid_prefix_len = ip_prefix_len (ip_prefix);
 833       if (ip_prefix_version (ip_prefix) == IP4)
 834         {
 835           rmp->eid_type = 0;    /* ipv4 type */
 836           clib_memcpy (rmp->eid, &ip_prefix_v4 (ip_prefix),
 837                        sizeof (ip_prefix_v4 (ip_prefix)));
 838         }
 839       else
 840         {
 841           rmp->eid_type = 1;    /* ipv6 type */
 842           clib_memcpy (rmp->eid, &ip_prefix_v6 (ip_prefix),
 843                        sizeof (ip_prefix_v6 (ip_prefix)));
 844         }
 845       break;
 846     case GID_ADDR_MAC:
 847       rmp->eid_type = 2;        /* l2 mac type */
 848       clib_memcpy (rmp->eid, mac, 6);
 849       break;
 850     default:
 851       ASSERT (0);
 852     }
 853   rmp->context = context;
 854   rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid));
 855   rmp->key_id = clib_host_to_net_u16 (mapit->key_id);
 856   memcpy (rmp->key, mapit->key, vec_len (mapit->key));
 857   vl_msg_api_send_shmem (q, (u8 *) & rmp);
 858 }
 859
 860 static void
 861 vl_api_lisp_eid_table_dump_t_handler (vl_api_lisp_eid_table_dump_t * mp)
 862 {
 863   u32 mi;
 864   svm_queue_t *q = NULL;
 865   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 866   mapping_t *mapit = NULL;
 867   gid_address_t _eid, *eid = &_eid;
 868
 869   q = vl_api_client_index_to_input_queue (mp->client_index);
 870   if (q == 0)
 871     {
 872       return;
 873     }
 874
 875   if (mp->eid_set)
 876     {
 877       memset (eid, 0, sizeof (*eid));
 878
 879       unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
 880                              mp->eid_type, mp->eid, mp->prefix_length);
 881
 882       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid);
 883       if ((u32) ~ 0 == mi)
 884         return;
 885
 886       mapit = pool_elt_at_index (lcm->mapping_pool, mi);
 887       send_lisp_eid_table_details (mapit, q, mp->context,
 888                                    0 /* ignore filter */ );
 889     }
 890   else
 891     {
 892       /* *INDENT-OFF* */
 893       pool_foreach (mapit, lcm->mapping_pool,
 894       ({
 895         send_lisp_eid_table_details(mapit, q, mp->context,
 896                                     mp->filter);
 897       }));
 898       /* *INDENT-ON* */
 899     }
 900 }
 901
 902 static void
 903 send_lisp_map_server_details (ip_address_t * ip, svm_queue_t * q, u32 context)
 904 {
 905   vl_api_lisp_map_server_details_t *rmp = NULL;
 906
 907   rmp = vl_msg_api_alloc (sizeof (*rmp));
 908   memset (rmp, 0, sizeof (*rmp));
 909   rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_SERVER_DETAILS);
 910
 911   switch (ip_addr_version (ip))
 912     {
 913     case IP4:
 914       rmp->is_ipv6 = 0;
 915       clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
 916                    sizeof (ip_addr_v4 (ip)));
 917       break;
 918
 919     case IP6:
 920       rmp->is_ipv6 = 1;
 921       clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
 922                    sizeof (ip_addr_v6 (ip)));
 923       break;
 924
 925     default:
 926       ASSERT (0);
 927     }
 928   rmp->context = context;
 929
 930   vl_msg_api_send_shmem (q, (u8 *) & rmp);
 931 }
 932
 933 static void
 934 vl_api_lisp_map_server_dump_t_handler (vl_api_lisp_map_server_dump_t * mp)
 935 {
 936   svm_queue_t *q = NULL;
 937   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 938   lisp_msmr_t *mr;
 939
 940   q = vl_api_client_index_to_input_queue (mp->client_index);
 941   if (q == 0)
 942     {
 943       return;
 944     }
 945
 946   vec_foreach (mr, lcm->map_servers)
 947   {
 948     send_lisp_map_server_details (&mr->address, q, mp->context);
 949   }
 950 }
 951
 952 static void
 953 send_lisp_map_resolver_details (ip_address_t * ip,
 954                                 svm_queue_t * q, u32 context)
 955 {
 956   vl_api_lisp_map_resolver_details_t *rmp = NULL;
 957
 958   rmp = vl_msg_api_alloc (sizeof (*rmp));
 959   memset (rmp, 0, sizeof (*rmp));
 960   rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_RESOLVER_DETAILS);
 961
 962   switch (ip_addr_version (ip))
 963     {
 964     case IP4:
 965       rmp->is_ipv6 = 0;
 966       clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
 967                    sizeof (ip_addr_v4 (ip)));
 968       break;
 969
 970     case IP6:
 971       rmp->is_ipv6 = 1;
 972       clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
 973                    sizeof (ip_addr_v6 (ip)));
 974       break;
 975
 976     default:
 977       ASSERT (0);
 978     }
 979   rmp->context = context;
 980
 981   vl_msg_api_send_shmem (q, (u8 *) & rmp);
 982 }
 983
 984 static void
 985 vl_api_lisp_map_resolver_dump_t_handler (vl_api_lisp_map_resolver_dump_t * mp)
 986 {
 987   svm_queue_t *q = NULL;
 988   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 989   lisp_msmr_t *mr;
 990
 991   q = vl_api_client_index_to_input_queue (mp->client_index);
 992   if (q == 0)
 993     {
 994       return;
 995     }
 996
 997   vec_foreach (mr, lcm->map_resolvers)
 998   {
 999     send_lisp_map_resolver_details (&mr->address, q, mp->context);
1000   }
1001 }
1002
1003 static void
1004 send_eid_table_map_pair (hash_pair_t * p, svm_queue_t * q, u32 context)
1005 {
1006   vl_api_lisp_eid_table_map_details_t *rmp = NULL;
1007
1008   rmp = vl_msg_api_alloc (sizeof (*rmp));
1009   memset (rmp, 0, sizeof (*rmp));
1010   rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_MAP_DETAILS);
1011
1012   rmp->vni = clib_host_to_net_u32 (p->key);
1013   rmp->dp_table = clib_host_to_net_u32 (p->value[0]);
1014   rmp->context = context;
1015   vl_msg_api_send_shmem (q, (u8 *) & rmp);
1016 }
1017
1018 static void
1019 vl_api_lisp_eid_table_map_dump_t_handler (vl_api_lisp_eid_table_map_dump_t *
1020                                           mp)
1021 {
1022   svm_queue_t *q = NULL;
1023   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1024   hash_pair_t *p;
1025   uword *vni_table = 0;
1026
1027   q = vl_api_client_index_to_input_queue (mp->client_index);
1028   if (q == 0)
1029     {
1030       return;
1031     }
1032
1033   if (mp->is_l2)
1034     {
1035       vni_table = lcm->bd_id_by_vni;
1036     }
1037   else
1038     {
1039       vni_table = lcm->table_id_by_vni;
1040     }
1041
1042   /* *INDENT-OFF* */
1043   hash_foreach_pair (p, vni_table,
1044   ({
1045     send_eid_table_map_pair (p, q, mp->context);
1046   }));
1047   /* *INDENT-ON* */
1048 }
1049
1050 static void
1051 send_eid_table_vni (u32 vni, svm_queue_t * q, u32 context)
1052 {
1053   vl_api_lisp_eid_table_vni_details_t *rmp = 0;
1054
1055   rmp = vl_msg_api_alloc (sizeof (*rmp));
1056   memset (rmp, 0, sizeof (*rmp));
1057   rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
1058   rmp->context = context;
1059   rmp->vni = clib_host_to_net_u32 (vni);
1060   vl_msg_api_send_shmem (q, (u8 *) & rmp);
1061 }
1062
1063 static void
1064 lisp_adjacency_copy (vl_api_lisp_adjacency_t * dst, lisp_adjacency_t * adjs)
1065 {
1066   lisp_adjacency_t *adj;
1067   vl_api_lisp_adjacency_t a;
1068   u32 i, n = vec_len (adjs);
1069
1070   for (i = 0; i < n; i++)
1071     {
1072       adj = vec_elt_at_index (adjs, i);
1073       memset (&a, 0, sizeof (a));
1074
1075       switch (gid_address_type (&adj->reid))
1076         {
1077         case GID_ADDR_IP_PREFIX:
1078           a.reid_prefix_len = gid_address_ippref_len (&adj->reid);
1079           a.leid_prefix_len = gid_address_ippref_len (&adj->leid);
1080           if (gid_address_ip_version (&adj->reid) == IP4)
1081             {
1082               a.eid_type = 0;   /* ipv4 type */
1083               clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 4);
1084               clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 4);
1085             }
1086           else
1087             {
1088               a.eid_type = 1;   /* ipv6 type */
1089               clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 16);
1090               clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 16);
1091             }
1092           break;
1093         case GID_ADDR_MAC:
1094           a.eid_type = 2;       /* l2 mac type */
1095           mac_copy (a.reid, gid_address_mac (&adj->reid));
1096           mac_copy (a.leid, gid_address_mac (&adj->leid));
1097           break;
1098         default:
1099           ASSERT (0);
1100         }
1101       dst[i] = a;
1102     }
1103 }
1104
1105 static void
1106   vl_api_show_lisp_rloc_probe_state_t_handler
1107   (vl_api_show_lisp_rloc_probe_state_t * mp)
1108 {
1109   vl_api_show_lisp_rloc_probe_state_reply_t *rmp = 0;
1110   int rv = 0;
1111
1112   /* *INDENT-OFF* */
1113   REPLY_MACRO2 (VL_API_SHOW_LISP_RLOC_PROBE_STATE_REPLY,
1114   {
1115     rmp->is_enabled = vnet_lisp_rloc_probe_state_get ();
1116   });
1117   /* *INDENT-ON* */
1118 }
1119
1120 static void
1121   vl_api_show_lisp_map_register_state_t_handler
1122   (vl_api_show_lisp_map_register_state_t * mp)
1123 {
1124   vl_api_show_lisp_map_register_state_reply_t *rmp = 0;
1125   int rv = 0;
1126
1127   /* *INDENT-OFF* */
1128   REPLY_MACRO2 (VL_API_SHOW_LISP_MAP_REGISTER_STATE_REPLY,
1129   {
1130     rmp->is_enabled = vnet_lisp_map_register_state_get ();
1131   });
1132   /* *INDENT-ON* */
1133 }
1134
1135 static void
1136 vl_api_lisp_adjacencies_get_t_handler (vl_api_lisp_adjacencies_get_t * mp)
1137 {
1138   vl_api_lisp_adjacencies_get_reply_t *rmp = 0;
1139   lisp_adjacency_t *adjs = 0;
1140   int rv = 0;
1141   u32 size = ~0;
1142   u32 vni = clib_net_to_host_u32 (mp->vni);
1143
1144   adjs = vnet_lisp_adjacencies_get_by_vni (vni);
1145   size = vec_len (adjs) * sizeof (vl_api_lisp_adjacency_t);
1146
1147   /* *INDENT-OFF* */
1148   REPLY_MACRO4 (VL_API_LISP_ADJACENCIES_GET_REPLY, size,
1149   {
1150     rmp->count = clib_host_to_net_u32 (vec_len (adjs));
1151     lisp_adjacency_copy (rmp->adjacencies, adjs);
1152   });
1153   /* *INDENT-ON* */
1154
1155   vec_free (adjs);
1156 }
1157
1158 static void
1159 vl_api_lisp_eid_table_vni_dump_t_handler (vl_api_lisp_eid_table_vni_dump_t *
1160                                           mp)
1161 {
1162   hash_pair_t *p;
1163   u32 *vnis = 0;
1164   svm_queue_t *q = 0;
1165   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1166
1167   q = vl_api_client_index_to_input_queue (mp->client_index);
1168   if (q == 0)
1169     {
1170       return;
1171     }
1172
1173   /* *INDENT-OFF* */
1174   hash_foreach_pair (p, lcm->table_id_by_vni,
1175   ({
1176     hash_set (vnis, p->key, 0);
1177   }));
1178
1179   hash_foreach_pair (p, lcm->bd_id_by_vni,
1180   ({
1181     hash_set (vnis, p->key, 0);
1182   }));
1183
1184   hash_foreach_pair (p, vnis,
1185   ({
1186     send_eid_table_vni (p->key, q, mp->context);
1187   }));
1188   /* *INDENT-ON* */
1189
1190   hash_free (vnis);
1191 }
1192
1193 static void
1194 vl_api_show_lisp_status_t_handler (vl_api_show_lisp_status_t * mp)
1195 {
1196   svm_queue_t *q = NULL;
1197   vl_api_show_lisp_status_reply_t *rmp = NULL;
1198   int rv = 0;
1199
1200   q = vl_api_client_index_to_input_queue (mp->client_index);
1201   if (q == 0)
1202     {
1203       return;
1204     }
1205
1206   /* *INDENT-OFF* */
1207   REPLY_MACRO2(VL_API_SHOW_LISP_STATUS_REPLY,
1208   ({
1209     rmp->gpe_status = vnet_lisp_gpe_enable_disable_status ();
1210     rmp->feature_status = vnet_lisp_enable_disable_status ();
1211   }));
1212   /* *INDENT-ON* */
1213 }
1214
1215 static void
1216   vl_api_lisp_get_map_request_itr_rlocs_t_handler
1217   (vl_api_lisp_get_map_request_itr_rlocs_t * mp)
1218 {
1219   svm_queue_t *q = NULL;
1220   vl_api_lisp_get_map_request_itr_rlocs_reply_t *rmp = NULL;
1221   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1222   locator_set_t *loc_set = 0;
1223   u8 *tmp_str = 0;
1224   int rv = 0;
1225
1226   q = vl_api_client_index_to_input_queue (mp->client_index);
1227   if (q == 0)
1228     {
1229       return;
1230     }
1231
1232   if (~0 == lcm->mreq_itr_rlocs)
1233     {
1234       tmp_str = format (0, " ");
1235     }
1236   else
1237     {
1238       loc_set =
1239         pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1240       tmp_str = format (0, "%s", loc_set->name);
1241     }
1242
1243   /* *INDENT-OFF* */
1244   REPLY_MACRO2(VL_API_LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY,
1245   ({
1246     strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1247             ARRAY_LEN(rmp->locator_set_name) - 1);
1248   }));
1249   /* *INDENT-ON* */
1250
1251   vec_free (tmp_str);
1252 }
1253
1254 static void
1255 vl_api_show_lisp_pitr_t_handler (vl_api_show_lisp_pitr_t * mp)
1256 {
1257   svm_queue_t *q = NULL;
1258   vl_api_show_lisp_pitr_reply_t *rmp = NULL;
1259   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1260   mapping_t *m;
1261   locator_set_t *ls = 0;
1262   u8 *tmp_str = 0;
1263   int rv = 0;
1264
1265   q = vl_api_client_index_to_input_queue (mp->client_index);
1266   if (q == 0)
1267     {
1268       return;
1269     }
1270
1271   u8 is_enabled = (lcm->flags & LISP_FLAG_PITR_MODE)
1272     && lcm->pitr_map_index != ~0;
1273
1274   if (!is_enabled)
1275     {
1276       tmp_str = format (0, "N/A");
1277     }
1278   else
1279     {
1280       m = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
1281       if (~0 != m->locator_set_index)
1282         {
1283           ls =
1284             pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
1285           tmp_str = format (0, "%s", ls->name);
1286         }
1287       else
1288         {
1289           tmp_str = format (0, "N/A");
1290         }
1291     }
1292   vec_add1 (tmp_str, 0);
1293
1294   /* *INDENT-OFF* */
1295   REPLY_MACRO2(VL_API_SHOW_LISP_PITR_REPLY,
1296   ({
1297     rmp->status = lcm->flags & LISP_FLAG_PITR_MODE;
1298     strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1299             ARRAY_LEN(rmp->locator_set_name) - 1);
1300   }));
1301   /* *INDENT-ON* */
1302 }
1303
1304 /*
1305  * lisp_api_hookup
1306  * Add vpe's API message handlers to the table.
1307  * vlib has alread mapped shared memory and
1308  * added the client registration handlers.
1309  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1310  */
1311 #define vl_msg_name_crc_list
1312 #include <vnet/vnet_all_api_h.h>
1313 #undef vl_msg_name_crc_list
1314
1315 static void
1316 setup_message_id_table (api_main_t * am)
1317 {
1318 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1319   foreach_vl_msg_name_crc_lisp;
1320 #undef _
1321 }
1322
1323 static clib_error_t *
1324 lisp_api_hookup (vlib_main_t * vm)
1325 {
1326   api_main_t *am = &api_main;
1327
1328 #define _(N,n)                                                  \
1329     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1330                            vl_api_##n##_t_handler,              \
1331                            vl_noop_handler,                     \
1332                            vl_api_##n##_t_endian,               \
1333                            vl_api_##n##_t_print,                \
1334                            sizeof(vl_api_##n##_t), 1);
1335   foreach_vpe_api_msg;
1336 #undef _
1337
1338   /*
1339    * Set up the (msg_name, crc, message-id) table
1340    */
1341   setup_message_id_table (am);
1342
1343   return 0;
1344 }
1345
1346 VLIB_API_INIT_FUNCTION (lisp_api_hookup);
1347
1348 /*
1349  * fd.io coding-style-patch-verification: ON
1350  *
1351  * Local Variables:
1352  * eval: (c-set-style "gnu")
1353  * End:
1354  */