src/vlibapi/api_shared.c

   1 /*
   2  *------------------------------------------------------------------
   3  * api_shared.c - API message handling, common code for both clients
   4  * and the vlib process itself.
   5  *
   6  *
   7  * Copyright (c) 2009 Cisco and/or its affiliates.
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at:
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *------------------------------------------------------------------
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stddef.h>
  25 #include <string.h>
  26 #include <vppinfra/format.h>
  27 #include <vppinfra/byte_order.h>
  28 #include <vppinfra/error.h>
  29 #include <vlib/vlib.h>
  30 #include <vlib/unix/unix.h>
  31 #include <vlibapi/api.h>
  32 #include <vppinfra/elog.h>
  33 #include <vppinfra/callback.h>
  34
  35 /* *INDENT-OFF* */
  36 api_main_t api_global_main =
  37   {
  38     .region_name = "/unset",
  39     .api_uid = -1,
  40     .api_gid = -1,
  41   };
  42 /* *INDENT-ON* */
  43
  44 /* Please use vlibapi_get_main() to access my_api_main */
  45 __thread api_main_t *my_api_main = &api_global_main;
  46
  47 void
  48 vl_msg_api_set_global_main (void *am_arg)
  49 {
  50   ASSERT (am_arg);
  51   my_api_main = (api_main_t *) am_arg;
  52 }
  53
  54 void
  55 vl_msg_api_increment_missing_client_counter (void)
  56 {
  57   api_main_t *am = vlibapi_get_main ();
  58   am->missing_clients++;
  59 }
  60
  61 int
  62 vl_msg_api_rx_trace_enabled (api_main_t * am)
  63 {
  64   return (am->rx_trace && am->rx_trace->enabled);
  65 }
  66
  67 int
  68 vl_msg_api_tx_trace_enabled (api_main_t * am)
  69 {
  70   return (am->tx_trace && am->tx_trace->enabled);
  71 }
  72
  73 /*
  74  * vl_msg_api_trace
  75  */
  76 void
  77 vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg)
  78 {
  79   u8 **this_trace;
  80   u8 **old_trace;
  81   u8 *msg_copy;
  82   u32 length;
  83   trace_cfg_t *cfgp;
  84   u16 msg_id = clib_net_to_host_u16 (*((u16 *) msg));
  85   msgbuf_t *header = (msgbuf_t *) (((u8 *) msg) - offsetof (msgbuf_t, data));
  86
  87   cfgp = am->api_trace_cfg + msg_id;
  88
  89   if (!cfgp || !cfgp->trace_enable)
  90     return;
  91
  92   msg_copy = 0;
  93
  94   if (tp->nitems == 0)
  95     {
  96       clib_warning ("tp->nitems is 0");
  97       return;
  98     }
  99
 100   if (vec_len (tp->traces) < tp->nitems)
 101     {
 102       vec_add1 (tp->traces, 0);
 103       this_trace = tp->traces + vec_len (tp->traces) - 1;
 104     }
 105   else
 106     {
 107       tp->wrapped = 1;
 108       old_trace = tp->traces + tp->curindex++;
 109       if (tp->curindex == tp->nitems)
 110         tp->curindex = 0;
 111       /* Reuse the trace record, may save some memory allocator traffic */
 112       msg_copy = *old_trace;
 113       vec_reset_length (msg_copy);
 114       this_trace = old_trace;
 115     }
 116
 117   length = clib_net_to_host_u32 (header->data_len);
 118
 119   vec_validate (msg_copy, length - 1);
 120   clib_memcpy_fast (msg_copy, msg, length);
 121   *this_trace = msg_copy;
 122 }
 123
 124 int
 125 vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
 126                         int onoff)
 127 {
 128   vl_api_trace_t *tp;
 129   int rv;
 130
 131   switch (which)
 132     {
 133     case VL_API_TRACE_TX:
 134       tp = am->tx_trace;
 135       if (tp == 0)
 136         {
 137           vl_msg_api_trace_configure (am, which, 1024);
 138           tp = am->tx_trace;
 139         }
 140       break;
 141
 142     case VL_API_TRACE_RX:
 143       tp = am->rx_trace;
 144       if (tp == 0)
 145         {
 146           vl_msg_api_trace_configure (am, which, 1024);
 147           tp = am->rx_trace;
 148         }
 149       break;
 150
 151     default:
 152       /* duh? */
 153       return -1;
 154     }
 155
 156   /* Configured? */
 157   if (tp == 0 || tp->nitems == 0)
 158     return -1;
 159
 160   rv = tp->enabled;
 161   tp->enabled = onoff;
 162
 163   return rv;
 164 }
 165
 166 int
 167 vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which)
 168 {
 169   vl_api_trace_t *tp;
 170   int i;
 171
 172   switch (which)
 173     {
 174     case VL_API_TRACE_TX:
 175       tp = am->tx_trace;
 176       break;
 177
 178     case VL_API_TRACE_RX:
 179       tp = am->rx_trace;
 180       break;
 181
 182     default:
 183       /* duh? */
 184       return -1;
 185     }
 186
 187   /* Configured? */
 188   if (!tp || tp->nitems == 0)
 189     return -1;
 190
 191   tp->curindex = 0;
 192   tp->wrapped = 0;
 193
 194   for (i = 0; i < vec_len (tp->traces); i++)
 195     {
 196       vec_free (tp->traces[i]);
 197     }
 198   vec_free (tp->traces);
 199
 200   return 0;
 201 }
 202
 203 u8 *
 204 vl_api_serialize_message_table (api_main_t * am, u8 * vector)
 205 {
 206   serialize_main_t _sm, *sm = &_sm;
 207   hash_pair_t *hp;
 208   u32 nmsg = hash_elts (am->msg_index_by_name_and_crc);
 209
 210   serialize_open_vector (sm, vector);
 211
 212   /* serialize the count */
 213   serialize_integer (sm, nmsg, sizeof (u32));
 214
 215   /* *INDENT-OFF* */
 216   hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
 217   ({
 218     serialize_likely_small_unsigned_integer (sm, hp->value[0]);
 219     serialize_cstring (sm, (char *) hp->key);
 220   }));
 221   /* *INDENT-ON* */
 222
 223   return serialize_close_vector (sm);
 224 }
 225
 226 static int
 227 vl_msg_api_trace_write_one (api_main_t *am, u8 *msg, FILE *fp)
 228 {
 229   u8 *tmpmem = 0;
 230   int tlen, slen;
 231   cJSON *(*tojson_fn) (void *);
 232
 233   u32 msg_length = vec_len (msg);
 234   vec_validate (tmpmem, msg_length - 1);
 235   clib_memcpy_fast (tmpmem, msg, msg_length);
 236   u16 id = clib_net_to_host_u16 (*((u16 *) msg));
 237
 238   void (*endian_fp) (void *);
 239   endian_fp = am->msg_endian_handlers[id];
 240   (*endian_fp) (tmpmem);
 241
 242   if (id < vec_len (am->msg_tojson_handlers) && am->msg_tojson_handlers[id])
 243     {
 244       tojson_fn = am->msg_tojson_handlers[id];
 245       cJSON *o = tojson_fn (tmpmem);
 246       char *s = cJSON_Print (o);
 247       slen = strlen (s);
 248       tlen = fwrite (s, 1, slen, fp);
 249       cJSON_free (s);
 250       cJSON_Delete (o);
 251       vec_free (tmpmem);
 252       if (tlen != slen)
 253         {
 254           fformat (stderr, "writing to file error\n");
 255           return -11;
 256         }
 257     }
 258   else
 259     fformat (stderr, "  [no registered tojson fn]\n");
 260
 261   return 0;
 262 }
 263
 264 #define vl_msg_fwrite(_s, _f) fwrite (_s, 1, sizeof (_s) - 1, _f)
 265
 266 typedef struct
 267 {
 268   FILE *fp;
 269   u32 n_traces;
 270   u32 i;
 271 } vl_msg_write_json_args_t;
 272
 273 static int
 274 vl_msg_write_json_fn (u8 *msg, void *ctx)
 275 {
 276   vl_msg_write_json_args_t *arg = ctx;
 277   FILE *fp = arg->fp;
 278   api_main_t *am = vlibapi_get_main ();
 279   int rc = vl_msg_api_trace_write_one (am, msg, fp);
 280   if (rc < 0)
 281     return rc;
 282
 283   if (arg->i < arg->n_traces - 1)
 284     vl_msg_fwrite (",\n", fp);
 285   arg->i++;
 286   return 0;
 287 }
 288
 289 static int
 290 vl_msg_api_trace_write_json (api_main_t *am, vl_api_trace_t *tp, FILE *fp)
 291 {
 292   vl_msg_write_json_args_t args;
 293   clib_memset (&args, 0, sizeof (args));
 294   args.fp = fp;
 295   args.n_traces = vec_len (tp->traces);
 296   vl_msg_fwrite ("[\n", fp);
 297
 298   int rv = vl_msg_traverse_trace (tp, vl_msg_write_json_fn, &args);
 299   if (rv < 0)
 300     return rv;
 301
 302   vl_msg_fwrite ("]", fp);
 303   return 0;
 304 }
 305
 306 int
 307 vl_msg_traverse_trace (vl_api_trace_t *tp, vl_msg_traverse_trace_fn fn,
 308                        void *ctx)
 309 {
 310   int i;
 311   u8 *msg;
 312   int rv = 0;
 313
 314   /* No-wrap case */
 315   if (tp->wrapped == 0)
 316     {
 317       for (i = 0; i < vec_len (tp->traces); i++)
 318         {
 319           /*sa_ignore NO_NULL_CHK */
 320           msg = tp->traces[i];
 321           if (!msg)
 322             continue;
 323
 324           rv = fn (msg, ctx);
 325           if (rv < 0)
 326             return rv;
 327         }
 328     }
 329   else
 330     {
 331       /* Wrap case: write oldest -> end of buffer */
 332       for (i = tp->curindex; i < vec_len (tp->traces); i++)
 333         {
 334           msg = tp->traces[i];
 335           if (!msg)
 336             continue;
 337
 338           rv = fn (msg, ctx);
 339           if (rv < 0)
 340             return rv;
 341         }
 342       /* write beginning of buffer -> oldest-1 */
 343       for (i = 0; i < tp->curindex; i++)
 344         {
 345           /*sa_ignore NO_NULL_CHK */
 346           msg = tp->traces[i];
 347           if (!msg)
 348             continue;
 349
 350           rv = fn (msg, ctx);
 351           if (rv < 0)
 352             return rv;
 353         }
 354     }
 355   return 0;
 356 }
 357
 358 static int
 359 vl_api_msg_write_fn (u8 *msg, void *ctx)
 360 {
 361   FILE *fp = ctx;
 362   u32 msg_length = clib_host_to_net_u32 (vec_len (msg));
 363   if (fwrite (&msg_length, 1, sizeof (msg_length), fp) != sizeof (msg_length))
 364     {
 365       return (-14);
 366     }
 367   if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 368     {
 369       return (-14);
 370     }
 371   return 0;
 372 }
 373
 374 int
 375 vl_msg_api_trace_save (api_main_t *am, vl_api_trace_which_t which, FILE *fp,
 376                        u8 is_json)
 377 {
 378   vl_api_trace_t *tp;
 379   vl_api_trace_file_header_t fh;
 380
 381   switch (which)
 382     {
 383     case VL_API_TRACE_TX:
 384       tp = am->tx_trace;
 385       break;
 386
 387     case VL_API_TRACE_RX:
 388       tp = am->rx_trace;
 389       break;
 390
 391     default:
 392       /* duh? */
 393       return -1;
 394     }
 395
 396   /* Configured, data present? */
 397   if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
 398     return -1;
 399
 400   /* "Dare to be stupid" check */
 401   if (fp == 0)
 402     {
 403       return -2;
 404     }
 405
 406   if (is_json)
 407     return vl_msg_api_trace_write_json (am, tp, fp);
 408
 409   /* Write the file header */
 410   fh.wrapped = tp->wrapped;
 411   fh.nitems = clib_host_to_net_u32 (vec_len (tp->traces));
 412
 413   u8 *m = vl_api_serialize_message_table (am, 0);
 414   fh.msgtbl_size = clib_host_to_net_u32 (vec_len (m));
 415
 416   if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
 417     {
 418       return (-10);
 419     }
 420
 421   /* Write the message table */
 422   if (fwrite (m, vec_len (m), 1, fp) != 1)
 423     {
 424       return (-14);
 425     }
 426   vec_free (m);
 427
 428   return vl_msg_traverse_trace (tp, vl_api_msg_write_fn, fp);
 429 }
 430
 431 int
 432 vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
 433                             u32 nitems)
 434 {
 435   vl_api_trace_t *tp;
 436   int was_on = 0;
 437
 438   switch (which)
 439     {
 440     case VL_API_TRACE_TX:
 441       tp = am->tx_trace;
 442       if (tp == 0)
 443         {
 444           vec_validate (am->tx_trace, 0);
 445           tp = am->tx_trace;
 446         }
 447       break;
 448
 449     case VL_API_TRACE_RX:
 450       tp = am->rx_trace;
 451       if (tp == 0)
 452         {
 453           vec_validate (am->rx_trace, 0);
 454           tp = am->rx_trace;
 455         }
 456
 457       break;
 458
 459     default:
 460       return -1;
 461
 462     }
 463
 464   if (tp->enabled)
 465     {
 466       was_on = vl_msg_api_trace_onoff (am, which, 0);
 467     }
 468   if (tp->traces)
 469     {
 470       vl_msg_api_trace_free (am, which);
 471     }
 472
 473   clib_memset (tp, 0, sizeof (*tp));
 474
 475   if (clib_arch_is_big_endian)
 476     {
 477       tp->endian = VL_API_BIG_ENDIAN;
 478     }
 479   else
 480     {
 481       tp->endian = VL_API_LITTLE_ENDIAN;
 482     }
 483
 484   tp->nitems = nitems;
 485   if (was_on)
 486     {
 487       (void) vl_msg_api_trace_onoff (am, which, was_on);
 488     }
 489   return 0;
 490 }
 491
 492 void
 493 vl_msg_api_barrier_sync (void)
 494 {
 495 }
 496
 497 void
 498 vl_msg_api_barrier_release (void)
 499 {
 500 }
 501
 502 always_inline void
 503 msg_handler_internal (api_main_t *am, void *the_msg, uword msg_len,
 504                       int trace_it, int do_it, int free_it)
 505 {
 506   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 507   u8 *(*print_fp) (void *, void *);
 508
 509   if (PREDICT_FALSE (am->elog_trace_api_messages))
 510     {
 511       /* *INDENT-OFF* */
 512       ELOG_TYPE_DECLARE (e) =
 513         {
 514           .format = "api-msg: %s",
 515           .format_args = "T4",
 516         };
 517       /* *INDENT-ON* */
 518       struct
 519       {
 520         u32 c;
 521       } *ed;
 522       ed = ELOG_DATA (am->elog_main, e);
 523       if (id < vec_len (am->msg_names) && am->msg_names[id])
 524         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 525       else
 526         ed->c = elog_string (am->elog_main, "BOGUS");
 527     }
 528
 529   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 530     {
 531       if (trace_it)
 532         vl_msg_api_trace (am, am->rx_trace, the_msg);
 533
 534       if (am->msg_print_flag)
 535         {
 536           fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
 537           print_fp = (void *) am->msg_print_handlers[id];
 538           if (print_fp == 0)
 539             {
 540               fformat (stdout, "  [no registered print fn]\n");
 541             }
 542           else
 543             {
 544               (*print_fp) (the_msg, stdout);
 545             }
 546         }
 547
 548       uword calc_size = 0;
 549       uword (*calc_size_fp) (void *);
 550       calc_size_fp = am->msg_calc_size_funcs[id];
 551       ASSERT (NULL != calc_size_fp);
 552       if (calc_size_fp)
 553         {
 554           calc_size = (*calc_size_fp) (the_msg);
 555           ASSERT (calc_size <= msg_len);
 556           if (calc_size > msg_len)
 557             {
 558               clib_warning (
 559                 "Truncated message '%s' (id %u) received, calculated size "
 560                 "%lu is bigger than actual size %llu, message dropped.",
 561                 am->msg_names[id], id, calc_size, msg_len);
 562             }
 563         }
 564       else
 565         {
 566           clib_warning ("Message '%s' (id %u) has NULL calc_size_func, cannot "
 567                         "verify message size is correct",
 568                         am->msg_names[id], id);
 569         }
 570
 571       /* don't process message if it's truncated, otherwise byte swaps
 572        * and stuff could corrupt memory even beyond message if it's malicious
 573        * e.g. VLA length field set to 1M elements, but VLA empty */
 574       if (do_it && calc_size <= msg_len)
 575         {
 576
 577           if (!am->is_mp_safe[id])
 578             {
 579               vl_msg_api_barrier_trace_context (am->msg_names[id]);
 580               vl_msg_api_barrier_sync ();
 581             }
 582
 583           if (am->is_autoendian[id])
 584             {
 585               void (*endian_fp) (void *);
 586               endian_fp = am->msg_endian_handlers[id];
 587               (*endian_fp) (the_msg);
 588             }
 589
 590           if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 591             clib_call_callbacks (am->perf_counter_cbs, am, id,
 592                                  0 /* before */ );
 593
 594           (*am->msg_handlers[id]) (the_msg);
 595
 596           if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 597             clib_call_callbacks (am->perf_counter_cbs, am, id,
 598                                  1 /* after */ );
 599
 600           if (!am->is_mp_safe[id])
 601             vl_msg_api_barrier_release ();
 602         }
 603     }
 604   else
 605     {
 606       clib_warning ("no handler for msg id %d", id);
 607     }
 608
 609   if (free_it)
 610     vl_msg_api_free (the_msg);
 611
 612   if (PREDICT_FALSE (am->elog_trace_api_messages))
 613     {
 614       /* *INDENT-OFF* */
 615       ELOG_TYPE_DECLARE (e) =
 616         {
 617           .format = "api-msg-done(%s): %s",
 618           .format_args = "t4T4",
 619           .n_enum_strings = 2,
 620           .enum_strings =
 621           {
 622             "barrier",
 623             "mp-safe",
 624           }
 625         };
 626       /* *INDENT-ON* */
 627
 628       struct
 629       {
 630         u32 barrier;
 631         u32 c;
 632       } *ed;
 633       ed = ELOG_DATA (am->elog_main, e);
 634       if (id < vec_len (am->msg_names) && am->msg_names[id])
 635         {
 636           ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 637           ed->barrier = !am->is_mp_safe[id];
 638         }
 639       else
 640         {
 641           ed->c = elog_string (am->elog_main, "BOGUS");
 642           ed->barrier = 0;
 643         }
 644     }
 645 }
 646
 647 void (*vl_msg_api_fuzz_hook) (u16, void *);
 648
 649 /* This is only to be called from a vlib/vnet app */
 650 void
 651 vl_msg_api_handler_with_vm_node (api_main_t * am, svm_region_t * vlib_rp,
 652                                  void *the_msg, vlib_main_t * vm,
 653                                  vlib_node_runtime_t * node, u8 is_private)
 654 {
 655   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 656   u8 *(*handler) (void *, void *, void *);
 657   u8 *(*print_fp) (void *, void *);
 658   svm_region_t *old_vlib_rp;
 659   void *save_shmem_hdr;
 660   int is_mp_safe = 1;
 661
 662   if (PREDICT_FALSE (am->elog_trace_api_messages))
 663     {
 664       /* *INDENT-OFF* */
 665       ELOG_TYPE_DECLARE (e) =
 666         {
 667           .format = "api-msg: %s",
 668           .format_args = "T4",
 669         };
 670       /* *INDENT-ON* */
 671       struct
 672       {
 673         u32 c;
 674       } *ed;
 675       ed = ELOG_DATA (am->elog_main, e);
 676       if (id < vec_len (am->msg_names) && am->msg_names[id])
 677         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 678       else
 679         ed->c = elog_string (am->elog_main, "BOGUS");
 680     }
 681
 682   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 683     {
 684       handler = (void *) am->msg_handlers[id];
 685
 686       if (PREDICT_FALSE (am->rx_trace && am->rx_trace->enabled))
 687         vl_msg_api_trace (am, am->rx_trace, the_msg);
 688
 689       if (PREDICT_FALSE (am->msg_print_flag))
 690         {
 691           fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
 692           print_fp = (void *) am->msg_print_handlers[id];
 693           if (print_fp == 0)
 694             {
 695               fformat (stdout, "  [no registered print fn for msg %d]\n", id);
 696             }
 697           else
 698             {
 699               (*print_fp) (the_msg, vm);
 700             }
 701         }
 702       is_mp_safe = am->is_mp_safe[id];
 703
 704       if (!is_mp_safe)
 705         {
 706           vl_msg_api_barrier_trace_context (am->msg_names[id]);
 707           vl_msg_api_barrier_sync ();
 708         }
 709       if (is_private)
 710         {
 711           old_vlib_rp = am->vlib_rp;
 712           save_shmem_hdr = am->shmem_hdr;
 713           am->vlib_rp = vlib_rp;
 714           am->shmem_hdr = (void *) vlib_rp->user_ctx;
 715         }
 716
 717       if (PREDICT_FALSE (vl_msg_api_fuzz_hook != 0))
 718         (*vl_msg_api_fuzz_hook) (id, the_msg);
 719
 720       if (am->is_autoendian[id])
 721         {
 722           void (*endian_fp) (void *);
 723           endian_fp = am->msg_endian_handlers[id];
 724           (*endian_fp) (the_msg);
 725         }
 726       if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 727         clib_call_callbacks (am->perf_counter_cbs, am, id, 0 /* before */ );
 728
 729       (*handler) (the_msg, vm, node);
 730
 731       if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 732         clib_call_callbacks (am->perf_counter_cbs, am, id, 1 /* after */ );
 733       if (is_private)
 734         {
 735           am->vlib_rp = old_vlib_rp;
 736           am->shmem_hdr = save_shmem_hdr;
 737         }
 738       if (!is_mp_safe)
 739         vl_msg_api_barrier_release ();
 740     }
 741   else
 742     {
 743       clib_warning ("no handler for msg id %d", id);
 744     }
 745
 746   /*
 747    * Special-case, so we can e.g. bounce messages off the vnet
 748    * main thread without copying them...
 749    */
 750   if (id >= vec_len (am->message_bounce) || !(am->message_bounce[id]))
 751     {
 752       if (is_private)
 753         {
 754           old_vlib_rp = am->vlib_rp;
 755           save_shmem_hdr = am->shmem_hdr;
 756           am->vlib_rp = vlib_rp;
 757           am->shmem_hdr = (void *) vlib_rp->user_ctx;
 758         }
 759       vl_msg_api_free (the_msg);
 760       if (is_private)
 761         {
 762           am->vlib_rp = old_vlib_rp;
 763           am->shmem_hdr = save_shmem_hdr;
 764         }
 765     }
 766
 767   if (PREDICT_FALSE (am->elog_trace_api_messages))
 768     {
 769       /* *INDENT-OFF* */
 770       ELOG_TYPE_DECLARE (e) =
 771         {
 772           .format = "api-msg-done(%s): %s",
 773           .format_args = "t4T4",
 774           .n_enum_strings = 2,
 775           .enum_strings =
 776           {
 777             "barrier",
 778             "mp-safe",
 779           }
 780         };
 781       /* *INDENT-ON* */
 782
 783       struct
 784       {
 785         u32 barrier;
 786         u32 c;
 787       } *ed;
 788       ed = ELOG_DATA (am->elog_main, e);
 789       if (id < vec_len (am->msg_names) && am->msg_names[id])
 790         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 791       else
 792         ed->c = elog_string (am->elog_main, "BOGUS");
 793       ed->barrier = is_mp_safe;
 794     }
 795 }
 796
 797 void
 798 vl_msg_api_handler (void *the_msg, uword msg_len)
 799 {
 800   api_main_t *am = vlibapi_get_main ();
 801
 802   msg_handler_internal (am, the_msg, msg_len,
 803                         (am->rx_trace && am->rx_trace->enabled) /* trace_it */,
 804                         1 /* do_it */, 1 /* free_it */);
 805 }
 806
 807 void
 808 vl_msg_api_handler_no_free (void *the_msg, uword msg_len)
 809 {
 810   api_main_t *am = vlibapi_get_main ();
 811   msg_handler_internal (am, the_msg, msg_len,
 812                         (am->rx_trace && am->rx_trace->enabled) /* trace_it */,
 813                         1 /* do_it */, 0 /* free_it */);
 814 }
 815
 816 void
 817 vl_msg_api_handler_no_trace_no_free (void *the_msg, uword msg_len)
 818 {
 819   api_main_t *am = vlibapi_get_main ();
 820   msg_handler_internal (am, the_msg, msg_len, 0 /* trace_it */, 1 /* do_it */,
 821                         0 /* free_it */);
 822 }
 823
 824 /*
 825  * Add a trace record to the API message trace buffer, if
 826  * API message tracing is enabled. Handy for adding sufficient
 827  * data to the trace to reproduce autonomous state, as opposed to
 828  * state downloaded via control-plane API messages. Example: the NAT
 829  * application creates database entries based on packet traffic, not
 830  * control-plane messages.
 831  *
 832  */
 833 void
 834 vl_msg_api_trace_only (void *the_msg, uword msg_len)
 835 {
 836   api_main_t *am = vlibapi_get_main ();
 837
 838   msg_handler_internal (am, the_msg, msg_len,
 839                         (am->rx_trace && am->rx_trace->enabled) /* trace_it */,
 840                         0 /* do_it */, 0 /* free_it */);
 841 }
 842
 843 void
 844 vl_msg_api_cleanup_handler (void *the_msg)
 845 {
 846   api_main_t *am = vlibapi_get_main ();
 847   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 848
 849   if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
 850     {
 851       clib_warning ("_vl_msg_id too large: %d\n", id);
 852       return;
 853     }
 854   if (am->msg_cleanup_handlers[id])
 855     (*am->msg_cleanup_handlers[id]) (the_msg);
 856
 857   vl_msg_api_free (the_msg);
 858 }
 859
 860 /*
 861  * vl_msg_api_replay_handler
 862  */
 863 void
 864 vl_msg_api_replay_handler (void *the_msg)
 865 {
 866   api_main_t *am = vlibapi_get_main ();
 867
 868   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 869
 870   if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
 871     {
 872       clib_warning ("_vl_msg_id too large: %d\n", id);
 873       return;
 874     }
 875   /* do NOT trace the message... */
 876   if (am->msg_handlers[id])
 877     (*am->msg_handlers[id]) (the_msg);
 878   /* do NOT free the message buffer... */
 879 }
 880
 881 u32
 882 vl_msg_api_get_msg_length (void *msg_arg)
 883 {
 884   return vl_msg_api_get_msg_length_inline (msg_arg);
 885 }
 886
 887 /*
 888  * vl_msg_api_socket_handler
 889  */
 890 void
 891 vl_msg_api_socket_handler (void *the_msg, uword msg_len)
 892 {
 893   api_main_t *am = vlibapi_get_main ();
 894
 895   msg_handler_internal (am, the_msg, msg_len,
 896                         (am->rx_trace && am->rx_trace->enabled) /* trace_it */,
 897                         1 /* do_it */, 0 /* free_it */);
 898 }
 899
 900 #define foreach_msg_api_vector                                                \
 901   _ (msg_names)                                                               \
 902   _ (msg_handlers)                                                            \
 903   _ (msg_cleanup_handlers)                                                    \
 904   _ (msg_endian_handlers)                                                     \
 905   _ (msg_print_handlers)                                                      \
 906   _ (msg_print_json_handlers)                                                 \
 907   _ (msg_tojson_handlers)                                                     \
 908   _ (msg_fromjson_handlers)                                                   \
 909   _ (msg_calc_size_funcs)                                                     \
 910   _ (api_trace_cfg)                                                           \
 911   _ (message_bounce)                                                          \
 912   _ (is_mp_safe)                                                              \
 913   _ (is_autoendian)
 914
 915 void
 916 vl_msg_api_config (vl_msg_api_msg_config_t * c)
 917 {
 918   api_main_t *am = vlibapi_get_main ();
 919
 920   /*
 921    * This happens during the java core tests if the message
 922    * dictionary is missing newly added xxx_reply_t messages.
 923    * Should never happen, but since I shot myself in the foot once
 924    * this way, I thought I'd make it easy to debug if I ever do
 925    * it again... (;-)...
 926    */
 927   if (c->id == 0)
 928     {
 929       if (c->name)
 930         clib_warning ("Trying to register %s with a NULL msg id!", c->name);
 931       else
 932         clib_warning ("Trying to register a NULL msg with a NULL msg id!");
 933       clib_warning ("Did you forget to call setup_message_id_table?");
 934       return;
 935     }
 936
 937 #define _(a) vec_validate (am->a, c->id);
 938   foreach_msg_api_vector;
 939 #undef _
 940
 941   if (am->msg_handlers[c->id] && am->msg_handlers[c->id] != c->handler)
 942     clib_warning
 943       ("BUG: re-registering 'vl_api_%s_t_handler'."
 944        "Handler was %llx, replaced by %llx",
 945        c->name, am->msg_handlers[c->id], c->handler);
 946
 947   am->msg_names[c->id] = c->name;
 948   am->msg_handlers[c->id] = c->handler;
 949   am->msg_cleanup_handlers[c->id] = c->cleanup;
 950   am->msg_endian_handlers[c->id] = c->endian;
 951   am->msg_print_handlers[c->id] = c->print;
 952   am->msg_print_json_handlers[c->id] = c->print_json;
 953   am->msg_tojson_handlers[c->id] = c->tojson;
 954   am->msg_fromjson_handlers[c->id] = c->fromjson;
 955   am->msg_calc_size_funcs[c->id] = c->calc_size;
 956   am->message_bounce[c->id] = c->message_bounce;
 957   am->is_mp_safe[c->id] = c->is_mp_safe;
 958   am->is_autoendian[c->id] = c->is_autoendian;
 959
 960   am->api_trace_cfg[c->id].size = c->size;
 961   am->api_trace_cfg[c->id].trace_enable = c->traced;
 962   am->api_trace_cfg[c->id].replay_enable = c->replay;
 963
 964   if (!am->msg_id_by_name)
 965     am->msg_id_by_name = hash_create_string (0, sizeof (uword));
 966
 967   hash_set_mem (am->msg_id_by_name, c->name, c->id);
 968 }
 969
 970 /*
 971  * vl_msg_api_set_handlers
 972  * preserve the old API for a while
 973  */
 974 void
 975 vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
 976                          void *endian, void *print, int size, int traced,
 977                          void *print_json, void *tojson, void *fromjson,
 978                          void *calc_size)
 979 {
 980   vl_msg_api_msg_config_t cfg;
 981   vl_msg_api_msg_config_t *c = &cfg;
 982
 983   clib_memset (c, 0, sizeof (*c));
 984
 985   c->id = id;
 986   c->name = name;
 987   c->handler = handler;
 988   c->cleanup = cleanup;
 989   c->endian = endian;
 990   c->print = print;
 991   c->traced = traced;
 992   c->replay = 1;
 993   c->message_bounce = 0;
 994   c->is_mp_safe = 0;
 995   c->is_autoendian = 0;
 996   c->tojson = tojson;
 997   c->fromjson = fromjson;
 998   c->print_json = print_json;
 999   c->calc_size = calc_size;
1000   vl_msg_api_config (c);
1001 }
1002
1003 void
1004 vl_msg_api_clean_handlers (int msg_id)
1005 {
1006   vl_msg_api_msg_config_t cfg;
1007   vl_msg_api_msg_config_t *c = &cfg;
1008
1009   clib_memset (c, 0, sizeof (*c));
1010
1011   c->id = msg_id;
1012   vl_msg_api_config (c);
1013 }
1014
1015 void
1016 vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
1017 {
1018   api_main_t *am = vlibapi_get_main ();
1019   ASSERT (msg_id > 0);
1020
1021   vec_validate (am->msg_cleanup_handlers, msg_id);
1022   am->msg_cleanup_handlers[msg_id] = fp;
1023 }
1024
1025 void
1026 vl_msg_api_queue_handler (svm_queue_t * q)
1027 {
1028   uword msg;
1029
1030   while (!svm_queue_sub (q, (u8 *) &msg, SVM_Q_WAIT, 0))
1031     {
1032       msgbuf_t *msgbuf = (msgbuf_t *) ((u8 *) msg - offsetof (msgbuf_t, data));
1033       vl_msg_api_handler ((void *) msg, ntohl (msgbuf->data_len));
1034     }
1035 }
1036
1037 u32
1038 vl_msg_api_max_length (void *mp)
1039 {
1040   msgbuf_t *mb;
1041   u32 data_len = ~0;
1042
1043   /* Work out the maximum sane message length, and return it */
1044   if (PREDICT_TRUE (mp != 0))
1045     {
1046       mb = (msgbuf_t *) (((u8 *) mp) - offsetof (msgbuf_t, data));
1047       data_len = clib_net_to_host_u32 (mb->data_len);
1048     }
1049   return data_len;
1050 }
1051
1052 vl_api_trace_t *
1053 vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
1054 {
1055   switch (which)
1056     {
1057     case VL_API_TRACE_RX:
1058       return am->rx_trace;
1059     case VL_API_TRACE_TX:
1060       return am->tx_trace;
1061     default:
1062       return 0;
1063     }
1064 }
1065
1066 void
1067 vl_noop_handler (void *mp)
1068 {
1069 }
1070
1071
1072 static u8 post_mortem_dump_enabled;
1073
1074 void
1075 vl_msg_api_post_mortem_dump_enable_disable (int enable)
1076 {
1077   post_mortem_dump_enabled = enable;
1078 }
1079
1080 void
1081 vl_msg_api_post_mortem_dump (void)
1082 {
1083   api_main_t *am = vlibapi_get_main ();
1084   FILE *fp;
1085   char filename[64];
1086   int rv;
1087
1088   if (post_mortem_dump_enabled == 0)
1089     return;
1090
1091   snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
1092             getpid ());
1093
1094   fp = fopen (filename, "w");
1095   if (fp == NULL)
1096     {
1097       rv = write (2, "Couldn't create ", 16);
1098       rv = write (2, filename, strlen (filename));
1099       rv = write (2, "\n", 1);
1100       return;
1101     }
1102   rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp, 0);
1103   fclose (fp);
1104   if (rv < 0)
1105     {
1106       rv = write (2, "Failed to save post-mortem API trace to ", 40);
1107       rv = write (2, filename, strlen (filename));
1108       rv = write (2, "\n", 1);
1109     }
1110
1111 }
1112
1113 /* Layered message handling support */
1114
1115 void
1116 vl_msg_api_set_first_available_msg_id (u16 first_avail)
1117 {
1118   api_main_t *am = vlibapi_get_main ();
1119
1120   am->first_available_msg_id = first_avail;
1121 }
1122
1123 u16
1124 vl_msg_api_get_msg_ids (const char *name, int n)
1125 {
1126   api_main_t *am = vlibapi_get_main ();
1127   u8 *name_copy;
1128   vl_api_msg_range_t *rp;
1129   uword *p;
1130   u16 rv;
1131
1132   if (am->msg_range_by_name == 0)
1133     am->msg_range_by_name = hash_create_string (0, sizeof (uword));
1134
1135   name_copy = format (0, "%s%c", name, 0);
1136
1137   p = hash_get_mem (am->msg_range_by_name, name_copy);
1138   if (p)
1139     {
1140       clib_warning ("WARNING: duplicate message range registration for '%s'",
1141                     name_copy);
1142       vec_free (name_copy);
1143       return ((u16) ~ 0);
1144     }
1145
1146   if (n < 0 || n > 1024)
1147     {
1148       clib_warning
1149         ("WARNING: bad number of message-IDs (%d) requested by '%s'",
1150          n, name_copy);
1151       vec_free (name_copy);
1152       return ((u16) ~ 0);
1153     }
1154
1155   vec_add2 (am->msg_ranges, rp, 1);
1156
1157   rv = rp->first_msg_id = am->first_available_msg_id;
1158   am->first_available_msg_id += n;
1159   rp->last_msg_id = am->first_available_msg_id - 1;
1160   rp->name = name_copy;
1161
1162   hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
1163
1164   return rv;
1165 }
1166
1167 void
1168 vl_msg_api_add_msg_name_crc (api_main_t * am, const char *string, u32 id)
1169 {
1170   uword *p;
1171
1172   if (am->msg_index_by_name_and_crc == 0)
1173     am->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword));
1174
1175   p = hash_get_mem (am->msg_index_by_name_and_crc, string);
1176   if (p)
1177     {
1178       clib_warning ("attempt to redefine '%s' ignored...", string);
1179       return;
1180     }
1181
1182   hash_set_mem (am->msg_index_by_name_and_crc, string, id);
1183 }
1184
1185 void
1186 vl_msg_api_add_version (api_main_t * am, const char *string,
1187                         u32 major, u32 minor, u32 patch)
1188 {
1189   api_version_t version = {.major = major,.minor = minor,.patch = patch };
1190   ASSERT (strlen (string) < 64);
1191   strncpy (version.name, string, 64 - 1);
1192   vec_add1 (am->api_version_list, version);
1193 }
1194
1195 u32
1196 vl_msg_api_get_msg_index (u8 * name_and_crc)
1197 {
1198   api_main_t *am = vlibapi_get_main ();
1199   uword *p;
1200
1201   if (am->msg_index_by_name_and_crc)
1202     {
1203       p = hash_get_mem (am->msg_index_by_name_and_crc, name_and_crc);
1204       if (p)
1205         return p[0];
1206     }
1207   return ~0;
1208 }
1209
1210 void *
1211 vl_msg_push_heap_w_region (svm_region_t * vlib_rp)
1212 {
1213   pthread_mutex_lock (&vlib_rp->mutex);
1214   return svm_push_data_heap (vlib_rp);
1215 }
1216
1217 void *
1218 vl_msg_push_heap (void)
1219 {
1220   api_main_t *am = vlibapi_get_main ();
1221   return vl_msg_push_heap_w_region (am->vlib_rp);
1222 }
1223
1224 void
1225 vl_msg_pop_heap_w_region (svm_region_t * vlib_rp, void *oldheap)
1226 {
1227   svm_pop_heap (oldheap);
1228   pthread_mutex_unlock (&vlib_rp->mutex);
1229 }
1230
1231 void
1232 vl_msg_pop_heap (void *oldheap)
1233 {
1234   api_main_t *am = vlibapi_get_main ();
1235   vl_msg_pop_heap_w_region (am->vlib_rp, oldheap);
1236 }
1237
1238 /* Must be nul terminated */
1239 int
1240 vl_api_c_string_to_api_string (const char *buf, vl_api_string_t * str)
1241 {
1242   /* copy without nul terminator */
1243   u32 len = strlen (buf);
1244   if (len > 0)
1245     clib_memcpy_fast (str->buf, buf, len);
1246   str->length = htonl (len);
1247   return len + sizeof (u32);
1248 }
1249
1250 /* Must NOT be nul terminated */
1251 int
1252 vl_api_vec_to_api_string (const u8 * vec, vl_api_string_t * str)
1253 {
1254   u32 len = vec_len (vec);
1255   clib_memcpy (str->buf, vec, len);
1256   str->length = htonl (len);
1257   return len + sizeof (u32);
1258 }
1259
1260 u32
1261 vl_api_string_len (vl_api_string_t * astr)
1262 {
1263   return clib_net_to_host_u32 (astr->length);
1264 }
1265
1266 u8 *
1267 vl_api_format_string (u8 * s, va_list * args)
1268 {
1269   vl_api_string_t *a = va_arg (*args, vl_api_string_t *);
1270   vec_add (s, a->buf, clib_net_to_host_u32 (a->length));
1271   return s;
1272 }
1273
1274 /*
1275  * Returns a new vector. Remember to free it after use.
1276  * NOT nul terminated.
1277  */
1278 u8 *
1279 vl_api_from_api_to_new_vec (void *mp, vl_api_string_t * astr)
1280 {
1281   u8 *v = 0;
1282
1283   if (vl_msg_api_max_length (mp) < clib_net_to_host_u32 (astr->length))
1284     return format (0, "insane astr->length %u%c",
1285                    clib_net_to_host_u32 (astr->length), 0);
1286   vec_add (v, astr->buf, clib_net_to_host_u32 (astr->length));
1287   return v;
1288 }
1289
1290 /*
1291  * Returns a new vector. Remember to free it after use.
1292  * Nul terminated.
1293  */
1294 char *
1295 vl_api_from_api_to_new_c_string (vl_api_string_t * astr)
1296 {
1297   char *v = 0;
1298   if (clib_net_to_host_u32 (astr->length) > 0)
1299     {
1300       vec_add (v, astr->buf, clib_net_to_host_u32 (astr->length));
1301       vec_add1 (v, 0);
1302     }
1303   return v;
1304 }
1305
1306 void
1307 vl_api_set_elog_main (elog_main_t * m)
1308 {
1309   api_main_t *am = vlibapi_get_main ();
1310   am->elog_main = m;
1311 }
1312
1313 int
1314 vl_api_set_elog_trace_api_messages (int enable)
1315 {
1316   int rv;
1317   api_main_t *am = vlibapi_get_main ();
1318
1319   rv = am->elog_trace_api_messages;
1320   am->elog_trace_api_messages = enable;
1321   return rv;
1322 }
1323
1324 int
1325 vl_api_get_elog_trace_api_messages (void)
1326 {
1327   api_main_t *am = vlibapi_get_main ();
1328
1329   return am->elog_trace_api_messages;
1330 }
1331
1332 /*
1333  * fd.io coding-style-patch-verification: ON
1334  *
1335  * Local Variables:
1336  * eval: (c-set-style "gnu")
1337  * End:
1338  */