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