src/vpp/api/api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * api.c - message handler registration
   4  *
   5  * Copyright (c) 2010-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 <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/types.h>
  24 #include <sys/mman.h>
  25 #include <sys/stat.h>
  26 #include <netinet/in.h>
  27 #include <signal.h>
  28 #include <pthread.h>
  29 #include <unistd.h>
  30 #include <time.h>
  31 #include <fcntl.h>
  32 #include <string.h>
  33 #include <pwd.h>
  34 #include <grp.h>
  35
  36 #include <vppinfra/clib.h>
  37 #include <vppinfra/vec.h>
  38 #include <vppinfra/hash.h>
  39 #include <vppinfra/bitmap.h>
  40 #include <vppinfra/fifo.h>
  41 #include <vppinfra/time.h>
  42 #include <vppinfra/mheap.h>
  43 #include <vppinfra/heap.h>
  44 #include <vppinfra/pool.h>
  45 #include <vppinfra/format.h>
  46 #include <vppinfra/error.h>
  47
  48 #include <vnet/api_errno.h>
  49 #include <vnet/vnet.h>
  50
  51 #include <vlib/vlib.h>
  52 #include <vlib/unix/unix.h>
  53 #include <vlibapi/api.h>
  54 #include <vlibmemory/api.h>
  55
  56 #undef BIHASH_TYPE
  57 #undef __included_bihash_template_h__
  58
  59 #include <vpp/stats/stats.h>
  60
  61 #include <vpp/api/vpe_msg_enum.h>
  62
  63 #define vl_typedefs             /* define message structures */
  64 #include <vpp/api/vpe_all_api_h.h>
  65 #undef vl_typedefs
  66 #define vl_endianfun            /* define message structures */
  67 #include <vpp/api/vpe_all_api_h.h>
  68 #undef vl_endianfun
  69 /* instantiate all the print functions we know about */
  70 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  71 #define vl_printfun
  72 #include <vpp/api/vpe_all_api_h.h>
  73 #undef vl_printfun
  74 #include <vlibapi/api_helper_macros.h>
  75
  76 #define foreach_vpe_api_msg                                             \
  77 _(CONTROL_PING, control_ping)                                           \
  78 _(CLI, cli)                                                             \
  79 _(CLI_INBAND, cli_inband)                                               \
  80 _(GET_NODE_INDEX, get_node_index)                                       \
  81 _(ADD_NODE_NEXT, add_node_next)                                         \
  82 _(SHOW_VERSION, show_version)                                           \
  83 _(GET_NODE_GRAPH, get_node_graph)                                       \
  84 _(GET_NEXT_INDEX, get_next_index)                                       \
  85
  86 #define QUOTE_(x) #x
  87 #define QUOTE(x) QUOTE_(x)
  88
  89 typedef enum
  90 {
  91   RESOLVE_IP4_ADD_DEL_ROUTE = 1,
  92   RESOLVE_IP6_ADD_DEL_ROUTE,
  93 } resolve_t;
  94
  95 extern vpe_api_main_t vpe_api_main;
  96
  97 /* Clean up all registrations belonging to the indicated client */
  98 static clib_error_t *
  99 memclnt_delete_callback (u32 client_index)
 100 {
 101   vpe_api_main_t *vam = &vpe_api_main;
 102   vpe_client_registration_t *rp;
 103   uword *p;
 104   int stats_memclnt_delete_callback (u32 client_index);
 105
 106   stats_memclnt_delete_callback (client_index);
 107
 108 #define _(a)                                                    \
 109     p = hash_get (vam->a##_registration_hash, client_index);    \
 110     if (p) {                                                    \
 111         rp = pool_elt_at_index (vam->a##_registrations, p[0]);  \
 112         pool_put (vam->a##_registrations, rp);                  \
 113         hash_unset (vam->a##_registration_hash, client_index);  \
 114     }
 115   foreach_registration_hash;
 116 #undef _
 117   return 0;
 118 }
 119
 120 VL_MSG_API_REAPER_FUNCTION (memclnt_delete_callback);
 121
 122 static void
 123 vl_api_control_ping_t_handler (vl_api_control_ping_t * mp)
 124 {
 125   vl_api_control_ping_reply_t *rmp;
 126   int rv = 0;
 127
 128   /* *INDENT-OFF* */
 129   REPLY_MACRO2(VL_API_CONTROL_PING_REPLY,
 130   ({
 131     rmp->vpe_pid = ntohl (getpid());
 132   }));
 133   /* *INDENT-ON* */
 134 }
 135
 136 static void
 137 shmem_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
 138 {
 139   u8 **shmem_vecp = (u8 **) arg;
 140   u8 *shmem_vec;
 141   void *oldheap;
 142   api_main_t *am = &api_main;
 143   u32 offset;
 144
 145   shmem_vec = *shmem_vecp;
 146
 147   offset = vec_len (shmem_vec);
 148
 149   pthread_mutex_lock (&am->vlib_rp->mutex);
 150   oldheap = svm_push_data_heap (am->vlib_rp);
 151
 152   vec_validate (shmem_vec, offset + buffer_bytes - 1);
 153
 154   clib_memcpy (shmem_vec + offset, buffer, buffer_bytes);
 155
 156   svm_pop_heap (oldheap);
 157   pthread_mutex_unlock (&am->vlib_rp->mutex);
 158
 159   *shmem_vecp = shmem_vec;
 160 }
 161
 162
 163 static void
 164 vl_api_cli_t_handler (vl_api_cli_t * mp)
 165 {
 166   vl_api_cli_reply_t *rp;
 167   vl_api_registration_t *reg;
 168   vlib_main_t *vm = vlib_get_main ();
 169   api_main_t *am = &api_main;
 170   unformat_input_t input;
 171   u8 *shmem_vec = 0;
 172   void *oldheap;
 173
 174   reg = vl_api_client_index_to_registration (mp->client_index);
 175   if (!reg)
 176     return;;
 177
 178   rp = vl_msg_api_alloc (sizeof (*rp));
 179   rp->_vl_msg_id = ntohs (VL_API_CLI_REPLY);
 180   rp->context = mp->context;
 181
 182   unformat_init_vector (&input, (u8 *) (uword) mp->cmd_in_shmem);
 183
 184   vlib_cli_input (vm, &input, shmem_cli_output, (uword) & shmem_vec);
 185
 186   pthread_mutex_lock (&am->vlib_rp->mutex);
 187   oldheap = svm_push_data_heap (am->vlib_rp);
 188
 189   vec_add1 (shmem_vec, 0);
 190
 191   svm_pop_heap (oldheap);
 192   pthread_mutex_unlock (&am->vlib_rp->mutex);
 193
 194   rp->reply_in_shmem = (uword) shmem_vec;
 195
 196   vl_api_send_msg (reg, (u8 *) rp);
 197 }
 198
 199 static void
 200 inband_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
 201 {
 202   u8 **mem_vecp = (u8 **) arg;
 203   u8 *mem_vec = *mem_vecp;
 204   u32 offset = vec_len (mem_vec);
 205
 206   vec_validate (mem_vec, offset + buffer_bytes - 1);
 207   clib_memcpy (mem_vec + offset, buffer, buffer_bytes);
 208   *mem_vecp = mem_vec;
 209 }
 210
 211 static void
 212 vl_api_cli_inband_t_handler (vl_api_cli_inband_t * mp)
 213 {
 214   vl_api_cli_inband_reply_t *rmp;
 215   int rv = 0;
 216   vlib_main_t *vm = vlib_get_main ();
 217   unformat_input_t input;
 218   u8 *out_vec = 0;
 219
 220   unformat_init_string (&input, (char *) mp->cmd, ntohl (mp->length));
 221   vlib_cli_input (vm, &input, inband_cli_output, (uword) & out_vec);
 222
 223   u32 len = vec_len (out_vec);
 224   /* *INDENT-OFF* */
 225   REPLY_MACRO3(VL_API_CLI_INBAND_REPLY, len,
 226   ({
 227     rmp->length = htonl (len);
 228     clib_memcpy (rmp->reply, out_vec, len);
 229   }));
 230   /* *INDENT-ON* */
 231   vec_free (out_vec);
 232 }
 233
 234 static void
 235 vl_api_show_version_t_handler (vl_api_show_version_t * mp)
 236 {
 237   vl_api_show_version_reply_t *rmp;
 238   int rv = 0;
 239   char *vpe_api_get_build_directory (void);
 240   char *vpe_api_get_version (void);
 241   char *vpe_api_get_build_date (void);
 242
 243   /* *INDENT-OFF* */
 244   REPLY_MACRO2(VL_API_SHOW_VERSION_REPLY,
 245   ({
 246     strncpy ((char *) rmp->program, "vpe", ARRAY_LEN(rmp->program)-1);
 247     strncpy ((char *) rmp->build_directory, vpe_api_get_build_directory(),
 248              ARRAY_LEN(rmp->build_directory)-1);
 249     strncpy ((char *) rmp->version, vpe_api_get_version(),
 250              ARRAY_LEN(rmp->version)-1);
 251     strncpy ((char *) rmp->build_date, vpe_api_get_build_date(),
 252              ARRAY_LEN(rmp->build_date)-1);
 253   }));
 254   /* *INDENT-ON* */
 255 }
 256
 257 static void
 258 vl_api_get_node_index_t_handler (vl_api_get_node_index_t * mp)
 259 {
 260   vlib_main_t *vm = vlib_get_main ();
 261   vl_api_get_node_index_reply_t *rmp;
 262   vlib_node_t *n;
 263   int rv = 0;
 264   u32 node_index = ~0;
 265
 266   n = vlib_get_node_by_name (vm, mp->node_name);
 267
 268   if (n == 0)
 269     rv = VNET_API_ERROR_NO_SUCH_NODE;
 270   else
 271     node_index = n->index;
 272
 273   /* *INDENT-OFF* */
 274   REPLY_MACRO2(VL_API_GET_NODE_INDEX_REPLY,
 275   ({
 276     rmp->node_index = ntohl(node_index);
 277   }));
 278   /* *INDENT-ON* */
 279 }
 280
 281 static void
 282 vl_api_get_next_index_t_handler (vl_api_get_next_index_t * mp)
 283 {
 284   vlib_main_t *vm = vlib_get_main ();
 285   vl_api_get_next_index_reply_t *rmp;
 286   vlib_node_t *node, *next_node;
 287   int rv = 0;
 288   u32 next_node_index = ~0, next_index = ~0;
 289   uword *p;
 290
 291   node = vlib_get_node_by_name (vm, mp->node_name);
 292
 293   if (node == 0)
 294     {
 295       rv = VNET_API_ERROR_NO_SUCH_NODE;
 296       goto out;
 297     }
 298
 299   next_node = vlib_get_node_by_name (vm, mp->next_name);
 300
 301   if (next_node == 0)
 302     {
 303       rv = VNET_API_ERROR_NO_SUCH_NODE2;
 304       goto out;
 305     }
 306   else
 307     next_node_index = next_node->index;
 308
 309   p = hash_get (node->next_slot_by_node, next_node_index);
 310
 311   if (p == 0)
 312     {
 313       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
 314       goto out;
 315     }
 316   else
 317     next_index = p[0];
 318
 319 out:
 320   /* *INDENT-OFF* */
 321   REPLY_MACRO2(VL_API_GET_NEXT_INDEX_REPLY,
 322   ({
 323     rmp->next_index = ntohl(next_index);
 324   }));
 325   /* *INDENT-ON* */
 326 }
 327
 328 static void
 329 vl_api_add_node_next_t_handler (vl_api_add_node_next_t * mp)
 330 {
 331   vlib_main_t *vm = vlib_get_main ();
 332   vl_api_add_node_next_reply_t *rmp;
 333   vlib_node_t *n, *next;
 334   int rv = 0;
 335   u32 next_index = ~0;
 336
 337   n = vlib_get_node_by_name (vm, mp->node_name);
 338
 339   if (n == 0)
 340     {
 341       rv = VNET_API_ERROR_NO_SUCH_NODE;
 342       goto out;
 343     }
 344
 345   next = vlib_get_node_by_name (vm, mp->next_name);
 346
 347   if (next == 0)
 348     rv = VNET_API_ERROR_NO_SUCH_NODE2;
 349   else
 350     next_index = vlib_node_add_next (vm, n->index, next->index);
 351
 352 out:
 353   /* *INDENT-OFF* */
 354   REPLY_MACRO2(VL_API_GET_NODE_INDEX_REPLY,
 355   ({
 356     rmp->next_index = ntohl(next_index);
 357   }));
 358   /* *INDENT-ON* */
 359 }
 360
 361 static void
 362 vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp)
 363 {
 364   int rv = 0;
 365   u8 *vector = 0;
 366   api_main_t *am = &api_main;
 367   vlib_main_t *vm = vlib_get_main ();
 368   void *oldheap;
 369   vl_api_get_node_graph_reply_t *rmp;
 370   static vlib_node_t ***node_dups;
 371   static vlib_main_t **stat_vms;
 372
 373   pthread_mutex_lock (&am->vlib_rp->mutex);
 374   oldheap = svm_push_data_heap (am->vlib_rp);
 375
 376   /*
 377    * Keep the number of memcpy ops to a minimum (e.g. 1).
 378    */
 379   vec_validate (vector, 16384);
 380   vec_reset_length (vector);
 381
 382   vlib_node_get_nodes (vm, 0 /* main threads */ ,
 383                        0 /* include stats */ ,
 384                        1 /* barrier sync */ ,
 385                        &node_dups, &stat_vms);
 386   vector = vlib_node_serialize (vm, node_dups, vector, 1 /* include nexts */ ,
 387                                 1 /* include stats */ );
 388
 389   svm_pop_heap (oldheap);
 390   pthread_mutex_unlock (&am->vlib_rp->mutex);
 391
 392   /* *INDENT-OFF* */
 393   REPLY_MACRO2(VL_API_GET_NODE_GRAPH_REPLY,
 394   ({
 395     rmp->reply_in_shmem = (uword) vector;
 396   }));
 397   /* *INDENT-ON* */
 398 }
 399
 400 #define BOUNCE_HANDLER(nn)                                              \
 401 static void vl_api_##nn##_t_handler (                                   \
 402     vl_api_##nn##_t *mp)                                                \
 403 {                                                                       \
 404     vpe_client_registration_t *reg;                                     \
 405     vpe_api_main_t * vam = &vpe_api_main;                               \
 406     svm_queue_t * q;                                     \
 407                                                                         \
 408     /* One registration only... */                                      \
 409     pool_foreach(reg, vam->nn##_registrations,                          \
 410     ({                                                                  \
 411         q = vl_api_client_index_to_input_queue (reg->client_index);     \
 412         if (q) {                                                        \
 413             /*                                                          \
 414              * If the queue is stuffed, turf the msg and complain       \
 415              * It's unlikely that the intended recipient is             \
 416              * alive; avoid deadlock at all costs.                      \
 417              */                                                         \
 418             if (q->cursize == q->maxsize) {                             \
 419                 clib_warning ("ERROR: receiver queue full, drop msg");  \
 420                 vl_msg_api_free (mp);                                   \
 421                 return;                                                 \
 422             }                                                           \
 423             vl_msg_api_send_shmem (q, (u8 *)&mp);                       \
 424             return;                                                     \
 425         }                                                               \
 426     }));                                                                \
 427     vl_msg_api_free (mp);                                               \
 428 }
 429
 430 static void setup_message_id_table (api_main_t * am);
 431
 432 /*
 433  * vpe_api_hookup
 434  * Add vpe's API message handlers to the table.
 435  * vlib has alread mapped shared memory and
 436  * added the client registration handlers.
 437  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
 438  */
 439 static clib_error_t *
 440 vpe_api_hookup (vlib_main_t * vm)
 441 {
 442   api_main_t *am = &api_main;
 443
 444 #define _(N,n)                                                  \
 445     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 446                            vl_api_##n##_t_handler,              \
 447                            vl_noop_handler,                     \
 448                            vl_api_##n##_t_endian,               \
 449                            vl_api_##n##_t_print,                \
 450                            sizeof(vl_api_##n##_t), 1);
 451   foreach_vpe_api_msg;
 452 #undef _
 453
 454   /*
 455    * Trace space for classifier mask+match
 456    */
 457   am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_TABLE].size += 5 * sizeof (u32x4);
 458   am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_SESSION].size
 459     += 5 * sizeof (u32x4);
 460
 461   /*
 462    * Thread-safe API messages
 463    */
 464   am->is_mp_safe[VL_API_IP_ADD_DEL_ROUTE] = 1;
 465   am->is_mp_safe[VL_API_GET_NODE_GRAPH] = 1;
 466
 467   /*
 468    * Set up the (msg_name, crc, message-id) table
 469    */
 470   setup_message_id_table (am);
 471
 472   return 0;
 473 }
 474
 475 VLIB_API_INIT_FUNCTION (vpe_api_hookup);
 476
 477 static clib_error_t *
 478 vpe_api_init (vlib_main_t * vm)
 479 {
 480   vpe_api_main_t *am = &vpe_api_main;
 481
 482   am->vlib_main = vm;
 483   am->vnet_main = vnet_get_main ();
 484 #define _(a)                                                    \
 485   am->a##_registration_hash = hash_create (0, sizeof (uword));
 486   foreach_registration_hash;
 487 #undef _
 488
 489   vl_set_memory_region_name ("/vpe-api");
 490   vl_mem_api_enable_disable (vm, 1 /* enable it */ );
 491
 492   return 0;
 493 }
 494
 495 VLIB_INIT_FUNCTION (vpe_api_init);
 496
 497
 498 static clib_error_t *
 499 api_segment_config (vlib_main_t * vm, unformat_input_t * input)
 500 {
 501   u8 *chroot_path;
 502   u64 baseva, size, pvt_heap_size;
 503   int uid, gid, rv;
 504   const int max_buf_size = 4096;
 505   char *s, *buf;
 506   struct passwd _pw, *pw;
 507   struct group _grp, *grp;
 508   clib_error_t *e;
 509   buf = vec_new (char, 128);
 510   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 511     {
 512       if (unformat (input, "prefix %s", &chroot_path))
 513         {
 514           vec_add1 (chroot_path, 0);
 515           vl_set_memory_root_path ((char *) chroot_path);
 516         }
 517       else if (unformat (input, "uid %d", &uid))
 518         vl_set_memory_uid (uid);
 519       else if (unformat (input, "gid %d", &gid))
 520         vl_set_memory_gid (gid);
 521       else if (unformat (input, "baseva %llx", &baseva))
 522         vl_set_global_memory_baseva (baseva);
 523       else if (unformat (input, "global-size %lldM", &size))
 524         vl_set_global_memory_size (size * (1ULL << 20));
 525       else if (unformat (input, "global-size %lldG", &size))
 526         vl_set_global_memory_size (size * (1ULL << 30));
 527       else if (unformat (input, "global-size %lld", &size))
 528         vl_set_global_memory_size (size);
 529       else if (unformat (input, "global-pvt-heap-size %lldM", &pvt_heap_size))
 530         vl_set_global_pvt_heap_size (pvt_heap_size * (1ULL << 20));
 531       else if (unformat (input, "global-pvt-heap-size size %lld",
 532                          &pvt_heap_size))
 533         vl_set_global_pvt_heap_size (pvt_heap_size);
 534       else if (unformat (input, "api-pvt-heap-size %lldM", &pvt_heap_size))
 535         vl_set_api_pvt_heap_size (pvt_heap_size * (1ULL << 20));
 536       else if (unformat (input, "api-pvt-heap-size size %lld",
 537                          &pvt_heap_size))
 538         vl_set_api_pvt_heap_size (pvt_heap_size);
 539       else if (unformat (input, "api-size %lldM", &size))
 540         vl_set_api_memory_size (size * (1ULL << 20));
 541       else if (unformat (input, "api-size %lldG", &size))
 542         vl_set_api_memory_size (size * (1ULL << 30));
 543       else if (unformat (input, "api-size %lld", &size))
 544         vl_set_api_memory_size (size);
 545       else if (unformat (input, "uid %s", &s))
 546         {
 547           /* lookup the username */
 548           pw = NULL;
 549           while (((rv =
 550                    getpwnam_r (s, &_pw, buf, vec_len (buf), &pw)) == ERANGE)
 551                  && (vec_len (buf) <= max_buf_size))
 552             {
 553               vec_resize (buf, vec_len (buf) * 2);
 554             }
 555           if (rv < 0)
 556             {
 557               e = clib_error_return_code (0, rv,
 558                                           CLIB_ERROR_ERRNO_VALID |
 559                                           CLIB_ERROR_FATAL,
 560                                           "cannot fetch username %s", s);
 561               vec_free (s);
 562               vec_free (buf);
 563               return e;
 564             }
 565           if (pw == NULL)
 566             {
 567               e =
 568                 clib_error_return_fatal (0, "username %s does not exist", s);
 569               vec_free (s);
 570               vec_free (buf);
 571               return e;
 572             }
 573           vec_free (s);
 574           vl_set_memory_uid (pw->pw_uid);
 575         }
 576       else if (unformat (input, "gid %s", &s))
 577         {
 578           /* lookup the group name */
 579           grp = NULL;
 580           while (((rv =
 581                    getgrnam_r (s, &_grp, buf, vec_len (buf), &grp)) == ERANGE)
 582                  && (vec_len (buf) <= max_buf_size))
 583             {
 584               vec_resize (buf, vec_len (buf) * 2);
 585             }
 586           if (rv != 0)
 587             {
 588               e = clib_error_return_code (0, rv,
 589                                           CLIB_ERROR_ERRNO_VALID |
 590                                           CLIB_ERROR_FATAL,
 591                                           "cannot fetch group %s", s);
 592               vec_free (s);
 593               vec_free (buf);
 594               return e;
 595             }
 596           if (grp == NULL)
 597             {
 598               e = clib_error_return_fatal (0, "group %s does not exist", s);
 599               vec_free (s);
 600               vec_free (buf);
 601               return e;
 602             }
 603           vec_free (s);
 604           vec_free (buf);
 605           vl_set_memory_gid (grp->gr_gid);
 606         }
 607       else
 608         return clib_error_return (0, "unknown input `%U'",
 609                                   format_unformat_error, input);
 610     }
 611   return 0;
 612 }
 613
 614 VLIB_EARLY_CONFIG_FUNCTION (api_segment_config, "api-segment");
 615
 616 void *
 617 get_unformat_vnet_sw_interface (void)
 618 {
 619   return (void *) &unformat_vnet_sw_interface;
 620 }
 621
 622 static u8 *
 623 format_arp_event (u8 * s, va_list * args)
 624 {
 625   vl_api_ip4_arp_event_t *event = va_arg (*args, vl_api_ip4_arp_event_t *);
 626
 627   s = format (s, "pid %d: ", ntohl (event->pid));
 628   s = format (s, "resolution for %U", format_ip4_address, &event->address);
 629   return s;
 630 }
 631
 632 static u8 *
 633 format_nd_event (u8 * s, va_list * args)
 634 {
 635   vl_api_ip6_nd_event_t *event = va_arg (*args, vl_api_ip6_nd_event_t *);
 636
 637   s = format (s, "pid %d: ", ntohl (event->pid));
 638   s = format (s, "resolution for %U", format_ip6_address, event->address);
 639   return s;
 640 }
 641
 642 static clib_error_t *
 643 show_ip_arp_nd_events_fn (vlib_main_t * vm,
 644                           unformat_input_t * input, vlib_cli_command_t * cmd)
 645 {
 646   vpe_api_main_t *am = &vpe_api_main;
 647   vl_api_ip4_arp_event_t *arp_event;
 648   vl_api_ip6_nd_event_t *nd_event;
 649
 650   if (pool_elts (am->arp_events) == 0 && pool_elts (am->nd_events) == 0 &&
 651       pool_elts (am->wc_ip4_arp_events_registrations) == 0 &&
 652       pool_elts (am->wc_ip6_nd_events_registrations) == 0)
 653     {
 654       vlib_cli_output (vm, "No active arp or nd event registrations");
 655       return 0;
 656     }
 657
 658   /* *INDENT-OFF* */
 659   pool_foreach (arp_event, am->arp_events,
 660   ({
 661     vlib_cli_output (vm, "%U", format_arp_event, arp_event);
 662   }));
 663
 664   vpe_client_registration_t *reg;
 665   pool_foreach(reg, am->wc_ip4_arp_events_registrations,
 666   ({
 667     vlib_cli_output (vm, "pid %d: bd mac/ip4 binding events",
 668                      ntohl (reg->client_pid));
 669   }));
 670
 671   pool_foreach (nd_event, am->nd_events,
 672   ({
 673     vlib_cli_output (vm, "%U", format_nd_event, nd_event);
 674   }));
 675
 676   pool_foreach(reg, am->wc_ip6_nd_events_registrations,
 677   ({
 678     vlib_cli_output (vm, "pid %d: bd mac/ip6 binding events",
 679                      ntohl (reg->client_pid));
 680   }));
 681   /* *INDENT-ON* */
 682
 683   return 0;
 684 }
 685
 686 /* *INDENT-OFF* */
 687 VLIB_CLI_COMMAND (show_ip_arp_nd_events, static) = {
 688   .path = "show arp-nd-event registrations",
 689   .function = show_ip_arp_nd_events_fn,
 690   .short_help = "Show ip4 arp and ip6 nd event registrations",
 691 };
 692 /* *INDENT-ON* */
 693
 694 #define vl_msg_name_crc_list
 695 #include <vpp/api/vpe_all_api_h.h>
 696 #undef vl_msg_name_crc_list
 697
 698 static void
 699 setup_message_id_table (api_main_t * am)
 700 {
 701 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
 702   foreach_vl_msg_name_crc_memclnt;
 703   foreach_vl_msg_name_crc_vpe;
 704 #undef _
 705
 706 #define vl_api_version_tuple(n,mj, mi, p) \
 707   vl_msg_api_add_version (am, #n, mj, mi, p);
 708 #include <vpp/api/vpe_all_api_h.h>
 709 #undef vl_api_version_tuple
 710 }
 711
 712
 713 /*
 714  * fd.io coding-style-patch-verification: ON
 715  *
 716  * Local Variables:
 717  * eval: (c-set-style "gnu")
 718  * End:
 719  */