src/vpp/api/api.c

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