src/vnet/session/session_api.c

   1 /*
   2  * Copyright (c) 2015-2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/vnet.h>
  17 #include <vlibmemory/api.h>
  18 #include <vnet/session/application.h>
  19
  20 #include <vnet/vnet_msg_enum.h>
  21 #include "application_interface.h"
  22
  23 #define vl_typedefs             /* define message structures */
  24 #include <vnet/vnet_all_api_h.h>
  25 #undef vl_typedefs
  26
  27 #define vl_endianfun            /* define message structures */
  28 #include <vnet/vnet_all_api_h.h>
  29 #undef vl_endianfun
  30
  31 /* instantiate all the print functions we know about */
  32 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  33 #define vl_printfun
  34 #include <vnet/vnet_all_api_h.h>
  35 #undef vl_printfun
  36
  37 #include <vlibapi/api_helper_macros.h>
  38
  39 #define foreach_session_api_msg                                         \
  40 _(MAP_ANOTHER_SEGMENT_REPLY, map_another_segment_reply)                 \
  41 _(APPLICATION_ATTACH, application_attach)                               \
  42 _(APPLICATION_DETACH, application_detach)                               \
  43 _(BIND_URI, bind_uri)                                                   \
  44 _(UNBIND_URI, unbind_uri)                                               \
  45 _(CONNECT_URI, connect_uri)                                             \
  46 _(DISCONNECT_SESSION, disconnect_session)                               \
  47 _(DISCONNECT_SESSION_REPLY, disconnect_session_reply)                   \
  48 _(ACCEPT_SESSION_REPLY, accept_session_reply)                           \
  49 _(RESET_SESSION_REPLY, reset_session_reply)                             \
  50 _(BIND_SOCK, bind_sock)                                                 \
  51 _(UNBIND_SOCK, unbind_sock)                                             \
  52 _(CONNECT_SOCK, connect_sock)                                           \
  53 _(SESSION_ENABLE_DISABLE, session_enable_disable)                       \
  54
  55 static int
  56 send_add_segment_callback (u32 api_client_index, const u8 * segment_name,
  57                            u32 segment_size)
  58 {
  59   vl_api_map_another_segment_t *mp;
  60   unix_shared_memory_queue_t *q;
  61
  62   q = vl_api_client_index_to_input_queue (api_client_index);
  63
  64   if (!q)
  65     return -1;
  66
  67   mp = vl_msg_api_alloc (sizeof (*mp));
  68   memset (mp, 0, sizeof (*mp));
  69   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MAP_ANOTHER_SEGMENT);
  70   mp->segment_size = segment_size;
  71   strncpy ((char *) mp->segment_name, (char *) segment_name,
  72            sizeof (mp->segment_name) - 1);
  73
  74   vl_msg_api_send_shmem (q, (u8 *) & mp);
  75
  76   return 0;
  77 }
  78
  79 static int
  80 send_session_accept_callback (stream_session_t * s)
  81 {
  82   vl_api_accept_session_t *mp;
  83   unix_shared_memory_queue_t *q, *vpp_queue;
  84   application_t *server = application_get (s->app_index);
  85   transport_connection_t *tc;
  86   transport_proto_vft_t *tp_vft;
  87   stream_session_t *listener;
  88
  89   q = vl_api_client_index_to_input_queue (server->api_client_index);
  90   vpp_queue = session_manager_get_vpp_event_queue (s->thread_index);
  91
  92   if (!q)
  93     return -1;
  94
  95   mp = vl_msg_api_alloc (sizeof (*mp));
  96   memset (mp, 0, sizeof (*mp));
  97
  98   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_ACCEPT_SESSION);
  99   mp->context = server->index;
 100   listener = listen_session_get (s->session_type, s->listener_index);
 101   tp_vft = session_get_transport_vft (s->session_type);
 102   tc = tp_vft->get_connection (s->connection_index, s->thread_index);
 103   mp->listener_handle = listen_session_get_handle (listener);
 104   mp->handle = stream_session_handle (s);
 105   mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
 106   mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
 107   mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 108   mp->port = tc->rmt_port;
 109   mp->is_ip4 = tc->is_ip4;
 110   clib_memcpy (&mp->ip, &tc->rmt_ip, sizeof (tc->rmt_ip));
 111   vl_msg_api_send_shmem (q, (u8 *) & mp);
 112
 113   return 0;
 114 }
 115
 116 static void
 117 send_session_disconnect_callback (stream_session_t * s)
 118 {
 119   vl_api_disconnect_session_t *mp;
 120   unix_shared_memory_queue_t *q;
 121   application_t *app = application_get (s->app_index);
 122
 123   q = vl_api_client_index_to_input_queue (app->api_client_index);
 124
 125   if (!q)
 126     return;
 127
 128   mp = vl_msg_api_alloc (sizeof (*mp));
 129   memset (mp, 0, sizeof (*mp));
 130   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_DISCONNECT_SESSION);
 131   mp->handle = stream_session_handle (s);
 132   vl_msg_api_send_shmem (q, (u8 *) & mp);
 133 }
 134
 135 static void
 136 send_session_reset_callback (stream_session_t * s)
 137 {
 138   vl_api_reset_session_t *mp;
 139   unix_shared_memory_queue_t *q;
 140   application_t *app = application_get (s->app_index);
 141
 142   q = vl_api_client_index_to_input_queue (app->api_client_index);
 143
 144   if (!q)
 145     return;
 146
 147   mp = vl_msg_api_alloc (sizeof (*mp));
 148   memset (mp, 0, sizeof (*mp));
 149   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_RESET_SESSION);
 150   mp->handle = stream_session_handle (s);
 151   vl_msg_api_send_shmem (q, (u8 *) & mp);
 152 }
 153
 154 static int
 155 send_session_connected_callback (u32 app_index, u32 api_context,
 156                                  stream_session_t * s, u8 is_fail)
 157 {
 158   vl_api_connect_uri_reply_t *mp;
 159   unix_shared_memory_queue_t *q;
 160   application_t *app;
 161   unix_shared_memory_queue_t *vpp_queue;
 162
 163   app = application_get (app_index);
 164   q = vl_api_client_index_to_input_queue (app->api_client_index);
 165
 166   if (!q)
 167     return -1;
 168
 169   mp = vl_msg_api_alloc (sizeof (*mp));
 170   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_CONNECT_URI_REPLY);
 171   mp->context = api_context;
 172   if (!is_fail)
 173     {
 174       vpp_queue = session_manager_get_vpp_event_queue (s->thread_index);
 175       mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
 176       mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
 177       mp->handle = stream_session_handle (s);
 178       mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 179       mp->retval = 0;
 180     }
 181   else
 182     {
 183       mp->retval = clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT_FAIL);
 184     }
 185
 186   vl_msg_api_send_shmem (q, (u8 *) & mp);
 187
 188   /* Remove client if connect failed */
 189   if (!is_fail)
 190     {
 191       s->session_state = SESSION_STATE_READY;
 192     }
 193
 194   return 0;
 195 }
 196
 197 /**
 198  * Redirect a connect_uri message to the indicated server.
 199  * Only sent if the server has bound the related port with
 200  * URI_OPTIONS_FLAGS_USE_FIFO
 201  */
 202 static int
 203 redirect_connect_callback (u32 server_api_client_index, void *mp_arg)
 204 {
 205   vl_api_connect_uri_t *mp = mp_arg;
 206   unix_shared_memory_queue_t *server_q, *client_q;
 207   vlib_main_t *vm = vlib_get_main ();
 208   f64 timeout = vlib_time_now (vm) + 0.5;
 209   application_t *app;
 210   int rv = 0;
 211
 212   server_q = vl_api_client_index_to_input_queue (server_api_client_index);
 213
 214   if (!server_q)
 215     {
 216       rv = VNET_API_ERROR_INVALID_VALUE;
 217       goto out;
 218     }
 219
 220   client_q = vl_api_client_index_to_input_queue (mp->client_index);
 221   if (!client_q)
 222     {
 223       rv = VNET_API_ERROR_INVALID_VALUE_2;
 224       goto out;
 225     }
 226
 227   /* Tell the server the client's API queue address, so it can reply */
 228   mp->client_queue_address = pointer_to_uword (client_q);
 229   app = application_lookup (mp->client_index);
 230   if (!app)
 231     {
 232       clib_warning ("no client application");
 233       return -1;
 234     }
 235
 236   mp->options[SESSION_OPTIONS_RX_FIFO_SIZE] = app->sm_properties.rx_fifo_size;
 237   mp->options[SESSION_OPTIONS_TX_FIFO_SIZE] = app->sm_properties.tx_fifo_size;
 238
 239   /*
 240    * Bounce message handlers MUST NOT block the data-plane.
 241    * Spin waiting for the queue lock, but
 242    */
 243
 244   while (vlib_time_now (vm) < timeout)
 245     {
 246       rv =
 247         unix_shared_memory_queue_add (server_q, (u8 *) & mp, 1 /*nowait */ );
 248       switch (rv)
 249         {
 250           /* correctly enqueued */
 251         case 0:
 252           return VNET_CONNECT_REDIRECTED;
 253
 254           /* continue spinning, wait for pthread_mutex_trylock to work */
 255         case -1:
 256           continue;
 257
 258           /* queue stuffed, drop the msg */
 259         case -2:
 260           rv = VNET_API_ERROR_QUEUE_FULL;
 261           goto out;
 262         }
 263     }
 264 out:
 265   /* Dispose of the message */
 266   vl_msg_api_free (mp);
 267   return rv;
 268 }
 269
 270 static session_cb_vft_t uri_session_cb_vft = {
 271   .session_accept_callback = send_session_accept_callback,
 272   .session_disconnect_callback = send_session_disconnect_callback,
 273   .session_connected_callback = send_session_connected_callback,
 274   .session_reset_callback = send_session_reset_callback,
 275   .add_segment_callback = send_add_segment_callback,
 276   .redirect_connect_callback = redirect_connect_callback
 277 };
 278
 279 static void
 280 vl_api_session_enable_disable_t_handler (vl_api_session_enable_disable_t * mp)
 281 {
 282   vl_api_session_enable_disable_reply_t *rmp;
 283   vlib_main_t *vm = vlib_get_main ();
 284   int rv = 0;
 285
 286   vnet_session_enable_disable (vm, mp->is_enable);
 287   REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY);
 288 }
 289
 290 static void
 291 vl_api_application_attach_t_handler (vl_api_application_attach_t * mp)
 292 {
 293   vl_api_application_attach_reply_t *rmp;
 294   vnet_app_attach_args_t _a, *a = &_a;
 295   int rv;
 296
 297   if (session_manager_is_enabled () == 0)
 298     {
 299       rv = VNET_API_ERROR_FEATURE_DISABLED;
 300       goto done;
 301     }
 302
 303   STATIC_ASSERT (sizeof (u64) * SESSION_OPTIONS_N_OPTIONS <=
 304                  sizeof (mp->options),
 305                  "Out of options, fix api message definition");
 306
 307   memset (a, 0, sizeof (*a));
 308
 309   a->api_client_index = mp->client_index;
 310   a->options = mp->options;
 311   a->session_cb_vft = &uri_session_cb_vft;
 312
 313   rv = vnet_application_attach (a);
 314
 315 done:
 316
 317   /* *INDENT-OFF* */
 318   REPLY_MACRO2 (VL_API_APPLICATION_ATTACH_REPLY, ({
 319     if (!rv)
 320       {
 321         rmp->segment_name_length = 0;
 322         /* $$$$ policy? */
 323         rmp->segment_size = a->segment_size;
 324         if (a->segment_name_length)
 325           {
 326             memcpy (rmp->segment_name, a->segment_name,
 327                     a->segment_name_length);
 328             rmp->segment_name_length = a->segment_name_length;
 329           }
 330         rmp->app_event_queue_address = a->app_event_queue_address;
 331       }
 332   }));
 333   /* *INDENT-ON* */
 334 }
 335
 336 static void
 337 vl_api_application_detach_t_handler (vl_api_application_detach_t * mp)
 338 {
 339   vl_api_application_detach_reply_t *rmp;
 340   int rv = VNET_API_ERROR_INVALID_VALUE_2;
 341   vnet_app_detach_args_t _a, *a = &_a;
 342   application_t *app;
 343
 344   if (session_manager_is_enabled () == 0)
 345     {
 346       rv = VNET_API_ERROR_FEATURE_DISABLED;
 347       goto done;
 348     }
 349
 350   app = application_lookup (mp->client_index);
 351   if (app)
 352     {
 353       a->app_index = app->index;
 354       rv = vnet_application_detach (a);
 355     }
 356
 357 done:
 358   REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY);
 359 }
 360
 361 static void
 362 vl_api_bind_uri_t_handler (vl_api_bind_uri_t * mp)
 363 {
 364   vl_api_bind_uri_reply_t *rmp;
 365   vnet_bind_args_t _a, *a = &_a;
 366   application_t *app;
 367   int rv;
 368
 369   if (session_manager_is_enabled () == 0)
 370     {
 371       rv = VNET_API_ERROR_FEATURE_DISABLED;
 372       goto done;
 373     }
 374
 375   app = application_lookup (mp->client_index);
 376   if (app)
 377     {
 378       memset (a, 0, sizeof (*a));
 379       a->uri = (char *) mp->uri;
 380       a->app_index = app->index;
 381       rv = vnet_bind_uri (a);
 382     }
 383   else
 384     {
 385       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 386     }
 387
 388 done:
 389   REPLY_MACRO (VL_API_BIND_URI_REPLY);
 390 }
 391
 392 static void
 393 vl_api_unbind_uri_t_handler (vl_api_unbind_uri_t * mp)
 394 {
 395   vl_api_unbind_uri_reply_t *rmp;
 396   application_t *app;
 397   vnet_unbind_args_t _a, *a = &_a;
 398   int rv;
 399
 400   if (session_manager_is_enabled () == 0)
 401     {
 402       rv = VNET_API_ERROR_FEATURE_DISABLED;
 403       goto done;
 404     }
 405
 406   app = application_lookup (mp->client_index);
 407   if (app)
 408     {
 409       a->uri = (char *) mp->uri;
 410       a->app_index = app->index;
 411       rv = vnet_unbind_uri (a);
 412     }
 413   else
 414     {
 415       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 416     }
 417
 418 done:
 419   REPLY_MACRO (VL_API_UNBIND_URI_REPLY);
 420 }
 421
 422 static void
 423 vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp)
 424 {
 425   vl_api_connect_uri_reply_t *rmp;
 426   vnet_connect_args_t _a, *a = &_a;
 427   application_t *app;
 428   int rv;
 429
 430   if (session_manager_is_enabled () == 0)
 431     {
 432       rv = VNET_API_ERROR_FEATURE_DISABLED;
 433       goto done;
 434     }
 435
 436   app = application_lookup (mp->client_index);
 437   if (app)
 438     {
 439       a->uri = (char *) mp->uri;
 440       a->api_context = mp->context;
 441       a->app_index = app->index;
 442       a->mp = mp;
 443       rv = vnet_connect_uri (a);
 444     }
 445   else
 446     {
 447       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 448     }
 449
 450   if (rv == 0 || rv == VNET_CONNECT_REDIRECTED)
 451     return;
 452
 453   /* Got some error, relay it */
 454
 455 done:
 456   /* *INDENT-OFF* */
 457   REPLY_MACRO (VL_API_CONNECT_URI_REPLY);
 458   /* *INDENT-ON* */
 459 }
 460
 461 static void
 462 vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
 463 {
 464   vl_api_disconnect_session_reply_t *rmp;
 465   vnet_disconnect_args_t _a, *a = &_a;
 466   application_t *app;
 467   int rv = 0;
 468
 469   if (session_manager_is_enabled () == 0)
 470     {
 471       rv = VNET_API_ERROR_FEATURE_DISABLED;
 472       goto done;
 473     }
 474
 475   app = application_lookup (mp->client_index);
 476   if (app)
 477     {
 478       a->handle = mp->handle;
 479       a->app_index = app->index;
 480       rv = vnet_disconnect_session (a);
 481     }
 482   else
 483     {
 484       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 485     }
 486
 487 done:
 488   REPLY_MACRO (VL_API_DISCONNECT_SESSION_REPLY);
 489 }
 490
 491 static void
 492 vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
 493                                            mp)
 494 {
 495   vnet_disconnect_args_t _a, *a = &_a;
 496   application_t *app;
 497
 498   /* Client objected to disconnecting the session, log and continue */
 499   if (mp->retval)
 500     {
 501       clib_warning ("client retval %d", mp->retval);
 502       return;
 503     }
 504
 505   /* Disconnect has been confirmed. Confirm close to transport */
 506   app = application_lookup (mp->client_index);
 507   if (app)
 508     {
 509       a->handle = mp->handle;
 510       a->app_index = app->index;
 511       vnet_disconnect_session (a);
 512     }
 513 }
 514
 515 static void
 516 vl_api_reset_session_reply_t_handler (vl_api_reset_session_reply_t * mp)
 517 {
 518   application_t *app;
 519   stream_session_t *s;
 520   u32 index, thread_index;
 521
 522   app = application_lookup (mp->client_index);
 523   if (!app)
 524     return;
 525
 526   stream_session_parse_handle (mp->handle, &index, &thread_index);
 527   s = stream_session_get_if_valid (index, thread_index);
 528   if (s == 0 || app->index != s->app_index)
 529     {
 530       clib_warning ("Invalid session!");
 531       return;
 532     }
 533
 534   /* Client objected to resetting the session, log and continue */
 535   if (mp->retval)
 536     {
 537       clib_warning ("client retval %d", mp->retval);
 538       return;
 539     }
 540
 541   /* This comes as a response to a reset, transport only waiting for
 542    * confirmation to remove connection state, no need to disconnect */
 543   stream_session_cleanup (s);
 544 }
 545
 546 static void
 547 vl_api_accept_session_reply_t_handler (vl_api_accept_session_reply_t * mp)
 548 {
 549   stream_session_t *s;
 550   u32 session_index, thread_index;
 551   vnet_disconnect_args_t _a, *a = &_a;
 552
 553   /* Server isn't interested, kill the session */
 554   if (mp->retval)
 555     {
 556       a->app_index = mp->context;
 557       a->handle = mp->handle;
 558       vnet_disconnect_session (a);
 559     }
 560   else
 561     {
 562       stream_session_parse_handle (mp->handle, &session_index, &thread_index);
 563       s = stream_session_get_if_valid (session_index, thread_index);
 564       if (!s)
 565         {
 566           clib_warning ("session doesn't exist");
 567           return;
 568         }
 569       if (s->app_index != mp->context)
 570         {
 571           clib_warning ("app doesn't own session");
 572           return;
 573         }
 574       /* XXX volatile? */
 575       s->session_state = SESSION_STATE_READY;
 576     }
 577 }
 578
 579 static void
 580 vl_api_map_another_segment_reply_t_handler (vl_api_map_another_segment_reply_t
 581                                             * mp)
 582 {
 583   clib_warning ("not implemented");
 584 }
 585
 586 static void
 587 vl_api_bind_sock_t_handler (vl_api_bind_sock_t * mp)
 588 {
 589   vl_api_bind_sock_reply_t *rmp;
 590   vnet_bind_args_t _a, *a = &_a;
 591   int rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 592   application_t *app;
 593
 594   if (session_manager_is_enabled () == 0)
 595     {
 596       rv = VNET_API_ERROR_FEATURE_DISABLED;
 597       goto done;
 598     }
 599
 600   app = application_lookup (mp->client_index);
 601   if (app)
 602     {
 603       memset (a, 0, sizeof (*a));
 604       clib_memcpy (&a->tep.ip, mp->ip, (mp->is_ip4 ?
 605                                         sizeof (ip4_address_t) :
 606                                         sizeof (ip6_address_t)));
 607       a->tep.is_ip4 = mp->is_ip4;
 608       a->tep.port = mp->port;
 609       a->tep.vrf = mp->vrf;
 610       a->app_index = app->index;
 611
 612       rv = vnet_bind (a);
 613     }
 614 done:
 615   REPLY_MACRO (VL_API_BIND_SOCK_REPLY);
 616 }
 617
 618 static void
 619 vl_api_unbind_sock_t_handler (vl_api_unbind_sock_t * mp)
 620 {
 621   vl_api_unbind_sock_reply_t *rmp;
 622   vnet_unbind_args_t _a, *a = &_a;
 623   application_t *app;
 624   int rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 625
 626   if (session_manager_is_enabled () == 0)
 627     {
 628       rv = VNET_API_ERROR_FEATURE_DISABLED;
 629       goto done;
 630     }
 631
 632   app = application_lookup (mp->client_index);
 633   if (app)
 634     {
 635       a->app_index = mp->client_index;
 636       a->handle = mp->handle;
 637       rv = vnet_unbind (a);
 638     }
 639
 640 done:
 641   REPLY_MACRO (VL_API_UNBIND_SOCK_REPLY);
 642 }
 643
 644 static void
 645 vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp)
 646 {
 647   vl_api_connect_sock_reply_t *rmp;
 648   vnet_connect_args_t _a, *a = &_a;
 649   application_t *app;
 650   int rv;
 651
 652   if (session_manager_is_enabled () == 0)
 653     {
 654       rv = VNET_API_ERROR_FEATURE_DISABLED;
 655       goto done;
 656     }
 657
 658   app = application_lookup (mp->client_index);
 659   if (app)
 660     {
 661       clib_memcpy (&a->tep.ip, mp->ip,
 662                    (mp->is_ip4 ? sizeof (ip4_address_t) :
 663                     sizeof (ip6_address_t)));
 664       a->api_context = mp->context;
 665       a->app_index = app->index;
 666       a->mp = mp;
 667       rv = vnet_connect (a);
 668     }
 669   else
 670     {
 671       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 672     }
 673
 674   if (rv == 0 || rv == VNET_CONNECT_REDIRECTED)
 675     return;
 676
 677   /* Got some error, relay it */
 678
 679 done:
 680   REPLY_MACRO (VL_API_CONNECT_URI_REPLY);
 681 }
 682
 683 static clib_error_t *
 684 application_reaper_cb (u32 client_index)
 685 {
 686   application_t *app = application_lookup (client_index);
 687   vnet_app_detach_args_t _a, *a = &_a;
 688   if (app)
 689     {
 690       a->app_index = app->index;
 691       vnet_application_detach (a);
 692     }
 693   return 0;
 694 }
 695
 696 VL_MSG_API_REAPER_FUNCTION (application_reaper_cb);
 697
 698 #define vl_msg_name_crc_list
 699 #include <vnet/vnet_all_api_h.h>
 700 #undef vl_msg_name_crc_list
 701
 702 static void
 703 setup_message_id_table (api_main_t * am)
 704 {
 705 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
 706   foreach_vl_msg_name_crc_session;
 707 #undef _
 708 }
 709
 710 /*
 711  * session_api_hookup
 712  * Add uri's API message handlers to the table.
 713  * vlib has alread mapped shared memory and
 714  * added the client registration handlers.
 715  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
 716  */
 717 static clib_error_t *
 718 session_api_hookup (vlib_main_t * vm)
 719 {
 720   api_main_t *am = &api_main;
 721
 722 #define _(N,n)                                                  \
 723     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 724                            vl_api_##n##_t_handler,              \
 725                            vl_noop_handler,                     \
 726                            vl_api_##n##_t_endian,               \
 727                            vl_api_##n##_t_print,                \
 728                            sizeof(vl_api_##n##_t), 1);
 729   foreach_session_api_msg;
 730 #undef _
 731
 732   /*
 733    * Messages which bounce off the data-plane to
 734    * an API client. Simply tells the message handling infra not
 735    * to free the message.
 736    *
 737    * Bounced message handlers MUST NOT block the data plane
 738    */
 739   am->message_bounce[VL_API_CONNECT_URI] = 1;
 740   am->message_bounce[VL_API_CONNECT_SOCK] = 1;
 741
 742   /*
 743    * Set up the (msg_name, crc, message-id) table
 744    */
 745   setup_message_id_table (am);
 746
 747   return 0;
 748 }
 749
 750 VLIB_API_INIT_FUNCTION (session_api_hookup);
 751
 752 /*
 753  * fd.io coding-style-patch-verification: ON
 754  *
 755  * Local Variables:
 756  * eval: (c-set-style "gnu")
 757  * End:
 758  */