src/vnet/session/session_api.c

   1 /*
   2  * Copyright (c) 2015-2019 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 #include <vnet/session/application_interface.h>
  20 #include <vnet/session/application_local.h>
  21 #include <vnet/session/session_rules_table.h>
  22 #include <vnet/session/session_table.h>
  23 #include <vnet/session/session.h>
  24
  25 #include <vnet/ip/ip_types_api.h>
  26
  27 #include <vnet/vnet_msg_enum.h>
  28
  29 #define vl_typedefs             /* define message structures */
  30 #include <vnet/vnet_all_api_h.h>
  31 #undef vl_typedefs
  32
  33 #define vl_endianfun            /* define message structures */
  34 #include <vnet/vnet_all_api_h.h>
  35 #undef vl_endianfun
  36
  37 /* instantiate all the print functions we know about */
  38 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  39 #define vl_printfun
  40 #include <vnet/vnet_all_api_h.h>
  41 #undef vl_printfun
  42
  43 #include <vlibapi/api_helper_macros.h>
  44
  45 #define foreach_session_api_msg                                         \
  46 _(APP_ATTACH, app_attach)                                               \
  47 _(APPLICATION_DETACH, application_detach)                               \
  48 _(SESSION_ENABLE_DISABLE, session_enable_disable)                       \
  49 _(APP_NAMESPACE_ADD_DEL, app_namespace_add_del)                         \
  50 _(SESSION_RULE_ADD_DEL, session_rule_add_del)                           \
  51 _(SESSION_RULES_DUMP, session_rules_dump)                               \
  52 _(APPLICATION_TLS_CERT_ADD, application_tls_cert_add)                   \
  53 _(APPLICATION_TLS_KEY_ADD, application_tls_key_add)                     \
  54 _(APP_ADD_CERT_KEY_PAIR, app_add_cert_key_pair)                         \
  55 _(APP_DEL_CERT_KEY_PAIR, app_del_cert_key_pair)                         \
  56 _(APP_WORKER_ADD_DEL, app_worker_add_del)                               \
  57
  58 static transport_proto_t
  59 api_session_transport_proto_decode (const vl_api_transport_proto_t * api_tp)
  60 {
  61   switch (*api_tp)
  62     {
  63     case TRANSPORT_PROTO_API_TCP:
  64       return TRANSPORT_PROTO_TCP;
  65     case TRANSPORT_PROTO_API_UDP:
  66       return TRANSPORT_PROTO_UDP;
  67     case TRANSPORT_PROTO_API_TLS:
  68       return TRANSPORT_PROTO_TLS;
  69     case TRANSPORT_PROTO_API_UDPC:
  70       return TRANSPORT_PROTO_UDPC;
  71     case TRANSPORT_PROTO_API_QUIC:
  72       return TRANSPORT_PROTO_QUIC;
  73     default:
  74       return TRANSPORT_PROTO_NONE;
  75     }
  76 }
  77
  78 static vl_api_transport_proto_t
  79 api_session_transport_proto_encode (const transport_proto_t tp)
  80 {
  81   switch (tp)
  82     {
  83     case TRANSPORT_PROTO_TCP:
  84       return TRANSPORT_PROTO_API_TCP;
  85     case TRANSPORT_PROTO_UDP:
  86       return TRANSPORT_PROTO_API_UDP;
  87     case TRANSPORT_PROTO_TLS:
  88       return TRANSPORT_PROTO_API_TLS;
  89     case TRANSPORT_PROTO_UDPC:
  90       return TRANSPORT_PROTO_API_UDPC;
  91     case TRANSPORT_PROTO_QUIC:
  92       return TRANSPORT_PROTO_API_QUIC;
  93     default:
  94       return TRANSPORT_PROTO_API_NONE;
  95     }
  96 }
  97
  98 static int
  99 session_send_fds (vl_api_registration_t * reg, int fds[], int n_fds)
 100 {
 101   clib_error_t *error;
 102   if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 103     {
 104       clib_warning ("can't send memfd fd");
 105       return -1;
 106     }
 107   error = vl_api_send_fd_msg (reg, fds, n_fds);
 108   if (error)
 109     {
 110       clib_error_report (error);
 111       return -1;
 112     }
 113   return 0;
 114 }
 115
 116 static int
 117 mq_try_lock_and_alloc_msg (svm_msg_q_t * app_mq, svm_msg_q_msg_t * msg)
 118 {
 119   int rv;
 120   u8 try = 0;
 121   while (try < 100)
 122     {
 123       rv = svm_msg_q_lock_and_alloc_msg_w_ring (app_mq,
 124                                                 SESSION_MQ_CTRL_EVT_RING,
 125                                                 SVM_Q_NOWAIT, msg);
 126       if (!rv)
 127         return 0;
 128       try++;
 129       usleep (1);
 130     }
 131   clib_warning ("failed to alloc msg");
 132   return -1;
 133 }
 134
 135 static int
 136 mq_send_session_accepted_cb (session_t * s)
 137 {
 138   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 139   svm_msg_q_msg_t _msg, *msg = &_msg;
 140   svm_msg_q_t *vpp_queue, *app_mq;
 141   session_t *listener;
 142   session_accepted_msg_t *mp;
 143   session_event_t *evt;
 144   application_t *app;
 145
 146   app = application_get (app_wrk->app_index);
 147   app_mq = app_wrk->event_queue;
 148   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 149     return -1;
 150
 151   evt = svm_msg_q_msg_data (app_mq, msg);
 152   clib_memset (evt, 0, sizeof (*evt));
 153   evt->event_type = SESSION_CTRL_EVT_ACCEPTED;
 154   mp = (session_accepted_msg_t *) evt->data;
 155   clib_memset (mp, 0, sizeof (*mp));
 156   mp->context = app->app_index;
 157   mp->server_rx_fifo = pointer_to_uword (s->rx_fifo);
 158   mp->server_tx_fifo = pointer_to_uword (s->tx_fifo);
 159   mp->segment_handle = session_segment_handle (s);
 160   mp->flags = s->flags;
 161
 162   if (session_has_transport (s))
 163     {
 164       listener = listen_session_get_from_handle (s->listener_handle);
 165       mp->listener_handle = app_listen_session_handle (listener);
 166       if (application_is_proxy (app))
 167         {
 168           listener =
 169             app_worker_first_listener (app_wrk, session_get_fib_proto (s),
 170                                        session_get_transport_proto (s));
 171           if (listener)
 172             mp->listener_handle = listen_session_get_handle (listener);
 173         }
 174       vpp_queue = session_main_get_vpp_event_queue (s->thread_index);
 175       mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 176       mp->handle = session_handle (s);
 177
 178       session_get_endpoint (s, &mp->rmt, 0 /* is_lcl */ );
 179     }
 180   else
 181     {
 182       ct_connection_t *ct;
 183
 184       ct = (ct_connection_t *) session_get_transport (s);
 185       listener = listen_session_get_from_handle (s->listener_handle);
 186       mp->listener_handle = app_listen_session_handle (listener);
 187       mp->rmt.is_ip4 = session_type_is_ip4 (listener->session_type);
 188       mp->rmt.port = ct->c_rmt_port;
 189       mp->handle = session_handle (s);
 190       vpp_queue = session_main_get_vpp_event_queue (0);
 191       mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 192     }
 193   svm_msg_q_add_and_unlock (app_mq, msg);
 194
 195   return 0;
 196 }
 197
 198 static inline void
 199 mq_send_session_close_evt (app_worker_t * app_wrk, session_handle_t sh,
 200                            session_evt_type_t evt_type)
 201 {
 202   svm_msg_q_msg_t _msg, *msg = &_msg;
 203   session_disconnected_msg_t *mp;
 204   svm_msg_q_t *app_mq;
 205   session_event_t *evt;
 206
 207   app_mq = app_wrk->event_queue;
 208   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 209     return;
 210   evt = svm_msg_q_msg_data (app_mq, msg);
 211   clib_memset (evt, 0, sizeof (*evt));
 212   evt->event_type = evt_type;
 213   mp = (session_disconnected_msg_t *) evt->data;
 214   mp->handle = sh;
 215   mp->context = app_wrk->api_client_index;
 216   svm_msg_q_add_and_unlock (app_mq, msg);
 217 }
 218
 219 static inline void
 220 mq_notify_close_subscribers (u32 app_index, session_handle_t sh,
 221                              svm_fifo_t * f, session_evt_type_t evt_type)
 222 {
 223   app_worker_t *app_wrk;
 224   application_t *app;
 225   int i;
 226
 227   app = application_get (app_index);
 228   if (!app)
 229     return;
 230
 231   for (i = 0; i < f->n_subscribers; i++)
 232     {
 233       if (!(app_wrk = application_get_worker (app, f->subscribers[i])))
 234         continue;
 235       mq_send_session_close_evt (app_wrk, sh, SESSION_CTRL_EVT_DISCONNECTED);
 236     }
 237 }
 238
 239 static void
 240 mq_send_session_disconnected_cb (session_t * s)
 241 {
 242   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 243   session_handle_t sh = session_handle (s);
 244
 245   mq_send_session_close_evt (app_wrk, session_handle (s),
 246                              SESSION_CTRL_EVT_DISCONNECTED);
 247
 248   if (svm_fifo_n_subscribers (s->rx_fifo))
 249     mq_notify_close_subscribers (app_wrk->app_index, sh, s->rx_fifo,
 250                                  SESSION_CTRL_EVT_DISCONNECTED);
 251 }
 252
 253 static void
 254 mq_send_session_reset_cb (session_t * s)
 255 {
 256   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 257   session_handle_t sh = session_handle (s);
 258
 259   mq_send_session_close_evt (app_wrk, sh, SESSION_CTRL_EVT_RESET);
 260
 261   if (svm_fifo_n_subscribers (s->rx_fifo))
 262     mq_notify_close_subscribers (app_wrk->app_index, sh, s->rx_fifo,
 263                                  SESSION_CTRL_EVT_RESET);
 264 }
 265
 266 int
 267 mq_send_session_connected_cb (u32 app_wrk_index, u32 api_context,
 268                               session_t * s, u8 is_fail)
 269 {
 270   svm_msg_q_msg_t _msg, *msg = &_msg;
 271   session_connected_msg_t *mp;
 272   svm_msg_q_t *vpp_mq, *app_mq;
 273   transport_connection_t *tc;
 274   app_worker_t *app_wrk;
 275   session_event_t *evt;
 276
 277   app_wrk = app_worker_get (app_wrk_index);
 278   app_mq = app_wrk->event_queue;
 279   if (!app_mq)
 280     {
 281       clib_warning ("app %u with api index: %u not attached",
 282                     app_wrk->app_index, app_wrk->api_client_index);
 283       return -1;
 284     }
 285
 286   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 287     return -1;
 288
 289   evt = svm_msg_q_msg_data (app_mq, msg);
 290   clib_memset (evt, 0, sizeof (*evt));
 291   evt->event_type = SESSION_CTRL_EVT_CONNECTED;
 292   mp = (session_connected_msg_t *) evt->data;
 293   clib_memset (mp, 0, sizeof (*mp));
 294   mp->context = api_context;
 295
 296   if (is_fail)
 297     goto done;
 298
 299   if (session_has_transport (s))
 300     {
 301       tc = session_get_transport (s);
 302       if (!tc)
 303         {
 304           is_fail = 1;
 305           goto done;
 306         }
 307
 308       vpp_mq = session_main_get_vpp_event_queue (s->thread_index);
 309       mp->handle = session_handle (s);
 310       mp->vpp_event_queue_address = pointer_to_uword (vpp_mq);
 311
 312       session_get_endpoint (s, &mp->lcl, 1 /* is_lcl */ );
 313
 314       mp->server_rx_fifo = pointer_to_uword (s->rx_fifo);
 315       mp->server_tx_fifo = pointer_to_uword (s->tx_fifo);
 316       mp->segment_handle = session_segment_handle (s);
 317     }
 318   else
 319     {
 320       ct_connection_t *cct;
 321       session_t *ss;
 322
 323       cct = (ct_connection_t *) session_get_transport (s);
 324       mp->handle = session_handle (s);
 325       mp->lcl.port = cct->c_lcl_port;
 326       mp->lcl.is_ip4 = cct->c_is_ip4;
 327       vpp_mq = session_main_get_vpp_event_queue (0);
 328       mp->vpp_event_queue_address = pointer_to_uword (vpp_mq);
 329       mp->server_rx_fifo = pointer_to_uword (s->rx_fifo);
 330       mp->server_tx_fifo = pointer_to_uword (s->tx_fifo);
 331       mp->segment_handle = session_segment_handle (s);
 332       ss = ct_session_get_peer (s);
 333       mp->ct_rx_fifo = pointer_to_uword (ss->tx_fifo);
 334       mp->ct_tx_fifo = pointer_to_uword (ss->rx_fifo);
 335       mp->ct_segment_handle = session_segment_handle (ss);
 336     }
 337
 338 done:
 339   mp->retval = is_fail ?
 340     clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0;
 341
 342   svm_msg_q_add_and_unlock (app_mq, msg);
 343   return 0;
 344 }
 345
 346 int
 347 mq_send_session_bound_cb (u32 app_wrk_index, u32 api_context,
 348                           session_handle_t handle, int rv)
 349 {
 350   svm_msg_q_msg_t _msg, *msg = &_msg;
 351   svm_msg_q_t *app_mq, *vpp_evt_q;
 352   transport_endpoint_t tep;
 353   session_bound_msg_t *mp;
 354   app_worker_t *app_wrk;
 355   session_event_t *evt;
 356   app_listener_t *al;
 357   session_t *ls = 0;
 358   app_wrk = app_worker_get (app_wrk_index);
 359   app_mq = app_wrk->event_queue;
 360   if (!app_mq)
 361     {
 362       clib_warning ("app %u with api index: %u not attached",
 363                     app_wrk->app_index, app_wrk->api_client_index);
 364       return -1;
 365     }
 366
 367   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 368     return -1;
 369
 370   evt = svm_msg_q_msg_data (app_mq, msg);
 371   clib_memset (evt, 0, sizeof (*evt));
 372   evt->event_type = SESSION_CTRL_EVT_BOUND;
 373   mp = (session_bound_msg_t *) evt->data;
 374   mp->context = api_context;
 375
 376   if (rv)
 377     goto done;
 378
 379   mp->handle = handle;
 380   al = app_listener_get_w_handle (handle);
 381   if (al->session_index != SESSION_INVALID_INDEX)
 382     ls = app_listener_get_session (al);
 383   else
 384     ls = app_listener_get_local_session (al);
 385
 386   session_get_endpoint (ls, &tep, 1 /* is_lcl */ );
 387   mp->lcl_port = tep.port;
 388   mp->lcl_is_ip4 = tep.is_ip4;
 389   clib_memcpy_fast (mp->lcl_ip, &tep.ip, sizeof (tep.ip));
 390
 391   vpp_evt_q = session_main_get_vpp_event_queue (0);
 392   mp->vpp_evt_q = pointer_to_uword (vpp_evt_q);
 393
 394   if (session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
 395     {
 396       mp->rx_fifo = pointer_to_uword (ls->rx_fifo);
 397       mp->tx_fifo = pointer_to_uword (ls->tx_fifo);
 398     }
 399
 400 done:
 401   mp->retval = rv;
 402   svm_msg_q_add_and_unlock (app_mq, msg);
 403   return 0;
 404 }
 405
 406 void
 407 mq_send_unlisten_reply (app_worker_t * app_wrk, session_handle_t sh,
 408                         u32 context, int rv)
 409 {
 410   svm_msg_q_msg_t _msg, *msg = &_msg;
 411   session_unlisten_reply_msg_t *ump;
 412   svm_msg_q_t *app_mq;
 413   session_event_t *evt;
 414
 415   app_mq = app_wrk->event_queue;
 416   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 417     return;
 418
 419   evt = svm_msg_q_msg_data (app_mq, msg);
 420   clib_memset (evt, 0, sizeof (*evt));
 421   evt->event_type = SESSION_CTRL_EVT_UNLISTEN_REPLY;
 422   ump = (session_unlisten_reply_msg_t *) evt->data;
 423   ump->context = context;
 424   ump->handle = sh;
 425   ump->retval = rv;
 426   svm_msg_q_add_and_unlock (app_mq, msg);
 427 }
 428
 429 static void
 430 mq_send_session_migrate_cb (session_t * s, session_handle_t new_sh)
 431 {
 432   svm_msg_q_msg_t _msg, *msg = &_msg;
 433   session_migrated_msg_t *mp;
 434   svm_msg_q_t *vpp_evt_q;
 435   app_worker_t *app_wrk;
 436   session_event_t *evt;
 437   svm_msg_q_t *app_mq;
 438
 439   app_wrk = app_worker_get (s->app_wrk_index);
 440   app_mq = app_wrk->event_queue;
 441   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 442     return;
 443
 444   evt = svm_msg_q_msg_data (app_mq, msg);
 445   clib_memset (evt, 0, sizeof (*evt));
 446   evt->event_type = SESSION_CTRL_EVT_MIGRATED;
 447   mp = (session_migrated_msg_t *) evt->data;
 448   mp->handle = session_handle (s);
 449   mp->new_handle = new_sh;
 450   mp->vpp_thread_index = session_thread_from_handle (new_sh);
 451   vpp_evt_q = session_main_get_vpp_event_queue (mp->vpp_thread_index);
 452   mp->vpp_evt_q = pointer_to_uword (vpp_evt_q);
 453   svm_msg_q_add_and_unlock (app_mq, msg);
 454 }
 455
 456 static int
 457 mq_send_add_segment_cb (u32 app_wrk_index, u64 segment_handle)
 458 {
 459   int fds[SESSION_N_FD_TYPE], n_fds = 0;
 460   svm_msg_q_msg_t _msg, *msg = &_msg;
 461   session_app_add_segment_msg_t *mp;
 462   vl_api_registration_t *reg;
 463   app_worker_t *app_wrk;
 464   session_event_t *evt;
 465   svm_msg_q_t *app_mq;
 466   fifo_segment_t *fs;
 467   ssvm_private_t *sp;
 468   u8 fd_flags = 0;
 469
 470   app_wrk = app_worker_get (app_wrk_index);
 471
 472   reg = vl_mem_api_client_index_to_registration (app_wrk->api_client_index);
 473   if (!reg)
 474     {
 475       clib_warning ("no api registration for client: %u",
 476                     app_wrk->api_client_index);
 477       return -1;
 478     }
 479
 480   fs = segment_manager_get_segment_w_handle (segment_handle);
 481   sp = &fs->ssvm;
 482   if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD)
 483     {
 484       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 485         {
 486           clib_warning ("can't send memfd fd");
 487           return -1;
 488         }
 489
 490       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 491       fds[n_fds] = sp->fd;
 492       n_fds += 1;
 493     }
 494
 495   app_mq = app_wrk->event_queue;
 496   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 497     return -1;
 498
 499   if (n_fds)
 500     session_send_fds (reg, fds, n_fds);
 501
 502   evt = svm_msg_q_msg_data (app_mq, msg);
 503   clib_memset (evt, 0, sizeof (*evt));
 504   evt->event_type = SESSION_CTRL_EVT_APP_ADD_SEGMENT;
 505   mp = (session_app_add_segment_msg_t *) evt->data;
 506   clib_memset (mp, 0, sizeof (*mp));
 507   mp->segment_size = sp->ssvm_size;
 508   mp->fd_flags = fd_flags;
 509   mp->segment_handle = segment_handle;
 510   strncpy ((char *) mp->segment_name, (char *) sp->name,
 511            sizeof (mp->segment_name) - 1);
 512
 513   svm_msg_q_add_and_unlock (app_mq, msg);
 514
 515   return 0;
 516 }
 517
 518 static int
 519 mq_send_del_segment_cb (u32 app_wrk_index, u64 segment_handle)
 520 {
 521   svm_msg_q_msg_t _msg, *msg = &_msg;
 522   session_app_del_segment_msg_t *mp;
 523   vl_api_registration_t *reg;
 524   app_worker_t *app_wrk;
 525   session_event_t *evt;
 526   svm_msg_q_t *app_mq;
 527
 528   app_wrk = app_worker_get (app_wrk_index);
 529   reg = vl_mem_api_client_index_to_registration (app_wrk->api_client_index);
 530   if (!reg)
 531     {
 532       clib_warning ("no registration: %u", app_wrk->api_client_index);
 533       return -1;
 534     }
 535
 536   app_mq = app_wrk->event_queue;
 537   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 538     return -1;
 539
 540   evt = svm_msg_q_msg_data (app_mq, msg);
 541   clib_memset (evt, 0, sizeof (*evt));
 542   evt->event_type = SESSION_CTRL_EVT_APP_DEL_SEGMENT;
 543   mp = (session_app_del_segment_msg_t *) evt->data;
 544   clib_memset (mp, 0, sizeof (*mp));
 545   mp->segment_handle = segment_handle;
 546   svm_msg_q_add_and_unlock (app_mq, msg);
 547
 548   return 0;
 549 }
 550
 551 static void
 552 mq_send_session_cleanup_cb (session_t * s, session_cleanup_ntf_t ntf)
 553 {
 554   svm_msg_q_msg_t _msg, *msg = &_msg;
 555   session_cleanup_msg_t *mp;
 556   svm_msg_q_t *app_mq;
 557   session_event_t *evt;
 558   app_worker_t *app_wrk;
 559
 560   /* Only propagate session cleanup notification */
 561   if (ntf == SESSION_CLEANUP_TRANSPORT)
 562     return;
 563
 564   app_wrk = app_worker_get_if_valid (s->app_wrk_index);
 565   if (!app_wrk)
 566     return;
 567
 568   app_mq = app_wrk->event_queue;
 569   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 570     return;
 571
 572   evt = svm_msg_q_msg_data (app_mq, msg);
 573   clib_memset (evt, 0, sizeof (*evt));
 574   evt->event_type = SESSION_CTRL_EVT_CLEANUP;
 575   mp = (session_cleanup_msg_t *) evt->data;
 576   mp->handle = session_handle (s);
 577   svm_msg_q_add_and_unlock (app_mq, msg);
 578 }
 579
 580 static session_cb_vft_t session_mq_cb_vft = {
 581   .session_accept_callback = mq_send_session_accepted_cb,
 582   .session_disconnect_callback = mq_send_session_disconnected_cb,
 583   .session_connected_callback = mq_send_session_connected_cb,
 584   .session_reset_callback = mq_send_session_reset_cb,
 585   .session_migrate_callback = mq_send_session_migrate_cb,
 586   .session_cleanup_callback = mq_send_session_cleanup_cb,
 587   .add_segment_callback = mq_send_add_segment_cb,
 588   .del_segment_callback = mq_send_del_segment_cb,
 589 };
 590
 591 static void
 592 vl_api_session_enable_disable_t_handler (vl_api_session_enable_disable_t * mp)
 593 {
 594   vl_api_session_enable_disable_reply_t *rmp;
 595   vlib_main_t *vm = vlib_get_main ();
 596   int rv = 0;
 597
 598   vnet_session_enable_disable (vm, mp->is_enable);
 599   REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY);
 600 }
 601
 602 static void
 603 vl_api_app_attach_t_handler (vl_api_app_attach_t * mp)
 604 {
 605   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
 606   vl_api_app_attach_reply_t *rmp;
 607   ssvm_private_t *segp, *evt_q_segment;
 608   vnet_app_attach_args_t _a, *a = &_a;
 609   u8 fd_flags = 0, ctrl_thread;
 610   vl_api_registration_t *reg;
 611   svm_msg_q_t *ctrl_mq;
 612
 613   reg = vl_api_client_index_to_registration (mp->client_index);
 614   if (!reg)
 615     return;
 616
 617   if (session_main_is_enabled () == 0)
 618     {
 619       rv = VNET_API_ERROR_FEATURE_DISABLED;
 620       goto done;
 621     }
 622
 623   STATIC_ASSERT (sizeof (u64) * APP_OPTIONS_N_OPTIONS <=
 624                  sizeof (mp->options),
 625                  "Out of options, fix api message definition");
 626
 627   clib_memset (a, 0, sizeof (*a));
 628   a->api_client_index = mp->client_index;
 629   a->options = mp->options;
 630   a->session_cb_vft = &session_mq_cb_vft;
 631
 632   a->namespace_id = vl_api_from_api_to_new_vec (&mp->namespace_id);
 633
 634   if ((rv = vnet_application_attach (a)))
 635     {
 636       clib_warning ("attach returned: %d", rv);
 637       vec_free (a->namespace_id);
 638       goto done;
 639     }
 640   vec_free (a->namespace_id);
 641
 642   /* Send event queues segment */
 643   if ((evt_q_segment = session_main_get_evt_q_segment ()))
 644     {
 645       fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
 646       fds[n_fds] = evt_q_segment->fd;
 647       n_fds += 1;
 648     }
 649   /* Send fifo segment fd if needed */
 650   if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
 651     {
 652       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 653       fds[n_fds] = a->segment->fd;
 654       n_fds += 1;
 655     }
 656   if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 657     {
 658       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
 659       fds[n_fds] = svm_msg_q_get_producer_eventfd (a->app_evt_q);
 660       n_fds += 1;
 661     }
 662
 663 done:
 664   /* *INDENT-OFF* */
 665   REPLY_MACRO2 (VL_API_APP_ATTACH_REPLY, ({
 666     if (!rv)
 667       {
 668         ctrl_thread = vlib_num_workers () ? 1 : 0;
 669         ctrl_mq = session_main_get_vpp_event_queue (ctrl_thread);
 670         segp = a->segment;
 671         rmp->app_index = clib_host_to_net_u32 (a->app_index);
 672         rmp->app_mq = pointer_to_uword (a->app_evt_q);
 673         rmp->vpp_ctrl_mq = pointer_to_uword (ctrl_mq);
 674         rmp->vpp_ctrl_mq_thread = ctrl_thread;
 675         rmp->n_fds = n_fds;
 676         rmp->fd_flags = fd_flags;
 677         if (vec_len (segp->name))
 678           {
 679             vl_api_vec_to_api_string (segp->name, &rmp->segment_name);
 680           }
 681         rmp->segment_size = segp->ssvm_size;
 682         rmp->segment_handle = clib_host_to_net_u64 (a->segment_handle);
 683       }
 684   }));
 685   /* *INDENT-ON* */
 686
 687   if (n_fds)
 688     session_send_fds (reg, fds, n_fds);
 689 }
 690
 691 static void
 692 vl_api_app_worker_add_del_t_handler (vl_api_app_worker_add_del_t * mp)
 693 {
 694   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
 695   vl_api_app_worker_add_del_reply_t *rmp;
 696   vl_api_registration_t *reg;
 697   application_t *app;
 698   u8 fd_flags = 0;
 699
 700   if (session_main_is_enabled () == 0)
 701     {
 702       rv = VNET_API_ERROR_FEATURE_DISABLED;
 703       goto done;
 704     }
 705
 706   reg = vl_api_client_index_to_registration (mp->client_index);
 707   if (!reg)
 708     return;
 709
 710   app = application_get_if_valid (clib_net_to_host_u32 (mp->app_index));
 711   if (!app)
 712     {
 713       rv = VNET_API_ERROR_INVALID_VALUE;
 714       goto done;
 715     }
 716
 717   vnet_app_worker_add_del_args_t args = {
 718     .app_index = app->app_index,
 719     .wrk_map_index = clib_net_to_host_u32 (mp->wrk_index),
 720     .api_client_index = mp->client_index,
 721     .is_add = mp->is_add
 722   };
 723   rv = vnet_app_worker_add_del (&args);
 724   if (rv)
 725     {
 726       clib_warning ("app worker add/del returned: %d", rv);
 727       goto done;
 728     }
 729
 730   if (!mp->is_add)
 731     goto done;
 732
 733   /* Send fifo segment fd if needed */
 734   if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD)
 735     {
 736       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 737       fds[n_fds] = args.segment->fd;
 738       n_fds += 1;
 739     }
 740   if (application_segment_manager_properties (app)->use_mq_eventfd)
 741     {
 742       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
 743       fds[n_fds] = svm_msg_q_get_producer_eventfd (args.evt_q);
 744       n_fds += 1;
 745     }
 746
 747   /* *INDENT-OFF* */
 748 done:
 749   REPLY_MACRO2 (VL_API_APP_WORKER_ADD_DEL_REPLY, ({
 750     rmp->is_add = mp->is_add;
 751     rmp->wrk_index = clib_host_to_net_u32 (args.wrk_map_index);
 752     rmp->segment_handle = clib_host_to_net_u64 (args.segment_handle);
 753     if (!rv && mp->is_add)
 754       {
 755         if (vec_len (args.segment->name))
 756           {
 757             vl_api_vec_to_api_string (args.segment->name, &rmp->segment_name);
 758           }
 759         rmp->app_event_queue_address = pointer_to_uword (args.evt_q);
 760         rmp->n_fds = n_fds;
 761         rmp->fd_flags = fd_flags;
 762       }
 763   }));
 764   /* *INDENT-ON* */
 765
 766   if (n_fds)
 767     session_send_fds (reg, fds, n_fds);
 768 }
 769
 770 static void
 771 vl_api_application_detach_t_handler (vl_api_application_detach_t * mp)
 772 {
 773   vl_api_application_detach_reply_t *rmp;
 774   int rv = VNET_API_ERROR_INVALID_VALUE_2;
 775   vnet_app_detach_args_t _a, *a = &_a;
 776   application_t *app;
 777
 778   if (session_main_is_enabled () == 0)
 779     {
 780       rv = VNET_API_ERROR_FEATURE_DISABLED;
 781       goto done;
 782     }
 783
 784   app = application_lookup (mp->client_index);
 785   if (app)
 786     {
 787       a->app_index = app->app_index;
 788       a->api_client_index = mp->client_index;
 789       rv = vnet_application_detach (a);
 790     }
 791
 792 done:
 793   REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY);
 794 }
 795
 796 static void
 797 vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp)
 798 {
 799   vl_api_app_namespace_add_del_reply_t *rmp;
 800   u32 appns_index = 0;
 801   u8 *ns_id = 0;
 802   int rv = 0;
 803   if (session_main_is_enabled () == 0)
 804     {
 805       rv = VNET_API_ERROR_FEATURE_DISABLED;
 806       goto done;
 807     }
 808
 809   ns_id = vl_api_from_api_to_new_vec (&mp->namespace_id);
 810
 811   vnet_app_namespace_add_del_args_t args = {
 812     .ns_id = ns_id,
 813     .secret = clib_net_to_host_u64 (mp->secret),
 814     .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index),
 815     .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id),
 816     .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id),
 817     .is_add = 1
 818   };
 819   rv = vnet_app_namespace_add_del (&args);
 820   if (!rv)
 821     {
 822       appns_index = app_namespace_index_from_id (ns_id);
 823       if (appns_index == APP_NAMESPACE_INVALID_INDEX)
 824         {
 825           clib_warning ("app ns lookup failed");
 826           rv = VNET_API_ERROR_UNSPECIFIED;
 827         }
 828     }
 829   vec_free (ns_id);
 830
 831   /* *INDENT-OFF* */
 832 done:
 833   REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({
 834     if (!rv)
 835       rmp->appns_index = clib_host_to_net_u32 (appns_index);
 836   }));
 837   /* *INDENT-ON* */
 838 }
 839
 840 static void
 841 vl_api_session_rule_add_del_t_handler (vl_api_session_rule_add_del_t * mp)
 842 {
 843   vl_api_session_rule_add_del_reply_t *rmp;
 844   session_rule_add_del_args_t args;
 845   session_rule_table_add_del_args_t *table_args = &args.table_args;
 846   int rv = 0;
 847
 848   clib_memset (&args, 0, sizeof (args));
 849
 850   ip_prefix_decode (&mp->lcl, &table_args->lcl);
 851   ip_prefix_decode (&mp->rmt, &table_args->rmt);
 852
 853   table_args->lcl_port = mp->lcl_port;
 854   table_args->rmt_port = mp->rmt_port;
 855   table_args->action_index = clib_net_to_host_u32 (mp->action_index);
 856   table_args->is_add = mp->is_add;
 857   mp->tag[sizeof (mp->tag) - 1] = 0;
 858   table_args->tag = format (0, "%s", mp->tag);
 859   args.appns_index = clib_net_to_host_u32 (mp->appns_index);
 860   args.scope = mp->scope;
 861   args.transport_proto =
 862     api_session_transport_proto_decode (&mp->transport_proto) ==
 863     TRANSPORT_PROTO_UDP ? 1 : 0;
 864
 865   rv = vnet_session_rule_add_del (&args);
 866   if (rv)
 867     clib_warning ("rule add del returned: %d", rv);
 868   vec_free (table_args->tag);
 869   REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY);
 870 }
 871
 872 static void
 873 send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local,
 874                             u8 transport_proto, u32 appns_index, u8 * tag,
 875                             vl_api_registration_t * reg, u32 context)
 876 {
 877   vl_api_session_rules_details_t *rmp = 0;
 878   session_mask_or_match_4_t *match =
 879     (session_mask_or_match_4_t *) & rule->match;
 880   session_mask_or_match_4_t *mask =
 881     (session_mask_or_match_4_t *) & rule->mask;
 882   fib_prefix_t lcl, rmt;
 883
 884   rmp = vl_msg_api_alloc (sizeof (*rmp));
 885   clib_memset (rmp, 0, sizeof (*rmp));
 886   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
 887   rmp->context = context;
 888
 889   clib_memset (&lcl, 0, sizeof (lcl));
 890   clib_memset (&rmt, 0, sizeof (rmt));
 891   ip_set (&lcl.fp_addr, &match->lcl_ip, 1);
 892   ip_set (&rmt.fp_addr, &match->rmt_ip, 1);
 893   lcl.fp_len = ip4_mask_to_preflen (&mask->lcl_ip);
 894   rmt.fp_len = ip4_mask_to_preflen (&mask->rmt_ip);
 895
 896   ip_prefix_encode (&lcl, &rmp->lcl);
 897   ip_prefix_encode (&rmt, &rmp->rmt);
 898   rmp->lcl_port = match->lcl_port;
 899   rmp->rmt_port = match->rmt_port;
 900   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
 901   rmp->scope =
 902     is_local ? SESSION_RULE_SCOPE_API_LOCAL : SESSION_RULE_SCOPE_API_GLOBAL;
 903   rmp->transport_proto = api_session_transport_proto_encode (transport_proto);
 904   rmp->appns_index = clib_host_to_net_u32 (appns_index);
 905   if (tag)
 906     {
 907       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
 908       rmp->tag[vec_len (tag)] = 0;
 909     }
 910
 911   vl_api_send_msg (reg, (u8 *) rmp);
 912 }
 913
 914 static void
 915 send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local,
 916                             u8 transport_proto, u32 appns_index, u8 * tag,
 917                             vl_api_registration_t * reg, u32 context)
 918 {
 919   vl_api_session_rules_details_t *rmp = 0;
 920   session_mask_or_match_6_t *match =
 921     (session_mask_or_match_6_t *) & rule->match;
 922   session_mask_or_match_6_t *mask =
 923     (session_mask_or_match_6_t *) & rule->mask;
 924   fib_prefix_t lcl, rmt;
 925
 926   rmp = vl_msg_api_alloc (sizeof (*rmp));
 927   clib_memset (rmp, 0, sizeof (*rmp));
 928   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
 929   rmp->context = context;
 930
 931   clib_memset (&lcl, 0, sizeof (lcl));
 932   clib_memset (&rmt, 0, sizeof (rmt));
 933   ip_set (&lcl.fp_addr, &match->lcl_ip, 0);
 934   ip_set (&rmt.fp_addr, &match->rmt_ip, 0);
 935   lcl.fp_len = ip6_mask_to_preflen (&mask->lcl_ip);
 936   rmt.fp_len = ip6_mask_to_preflen (&mask->rmt_ip);
 937
 938   ip_prefix_encode (&lcl, &rmp->lcl);
 939   ip_prefix_encode (&rmt, &rmp->rmt);
 940   rmp->lcl_port = match->lcl_port;
 941   rmp->rmt_port = match->rmt_port;
 942   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
 943   rmp->scope =
 944     is_local ? SESSION_RULE_SCOPE_API_LOCAL : SESSION_RULE_SCOPE_API_GLOBAL;
 945   rmp->transport_proto = api_session_transport_proto_encode (transport_proto);
 946   rmp->appns_index = clib_host_to_net_u32 (appns_index);
 947   if (tag)
 948     {
 949       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
 950       rmp->tag[vec_len (tag)] = 0;
 951     }
 952
 953   vl_api_send_msg (reg, (u8 *) rmp);
 954 }
 955
 956 static void
 957 send_session_rules_table_details (session_rules_table_t * srt, u8 fib_proto,
 958                                   u8 tp, u8 is_local, u32 appns_index,
 959                                   vl_api_registration_t * reg, u32 context)
 960 {
 961   mma_rule_16_t *rule16;
 962   mma_rule_40_t *rule40;
 963   mma_rules_table_16_t *srt16;
 964   mma_rules_table_40_t *srt40;
 965   u32 ri;
 966
 967   if (is_local || fib_proto == FIB_PROTOCOL_IP4)
 968     {
 969       u8 *tag = 0;
 970       /* *INDENT-OFF* */
 971       srt16 = &srt->session_rules_tables_16;
 972       pool_foreach (rule16, srt16->rules, ({
 973         ri = mma_rules_table_rule_index_16 (srt16, rule16);
 974         tag = session_rules_table_rule_tag (srt, ri, 1);
 975         send_session_rule_details4 (rule16, is_local, tp, appns_index, tag,
 976                                     reg, context);
 977       }));
 978       /* *INDENT-ON* */
 979     }
 980   if (is_local || fib_proto == FIB_PROTOCOL_IP6)
 981     {
 982       u8 *tag = 0;
 983       /* *INDENT-OFF* */
 984       srt40 = &srt->session_rules_tables_40;
 985       pool_foreach (rule40, srt40->rules, ({
 986         ri = mma_rules_table_rule_index_40 (srt40, rule40);
 987         tag = session_rules_table_rule_tag (srt, ri, 1);
 988         send_session_rule_details6 (rule40, is_local, tp, appns_index, tag,
 989                                     reg, context);
 990       }));
 991       /* *INDENT-ON* */
 992     }
 993 }
 994
 995 static void
 996 vl_api_session_rules_dump_t_handler (vl_api_one_map_server_dump_t * mp)
 997 {
 998   vl_api_registration_t *reg;
 999   session_table_t *st;
1000   u8 tp;
1001
1002   reg = vl_api_client_index_to_registration (mp->client_index);
1003   if (!reg)
1004     return;
1005
1006   /* *INDENT-OFF* */
1007   session_table_foreach (st, ({
1008     for (tp = 0; tp < TRANSPORT_N_PROTOS; tp++)
1009       {
1010         send_session_rules_table_details (&st->session_rules[tp],
1011                                           st->active_fib_proto, tp,
1012                                           st->is_local, st->appns_index, reg,
1013                                           mp->context);
1014       }
1015   }));
1016   /* *INDENT-ON* */
1017 }
1018
1019 static void
1020 vl_api_app_add_cert_key_pair_t_handler (vl_api_app_add_cert_key_pair_t * mp)
1021 {
1022   vl_api_app_add_cert_key_pair_reply_t *rmp;
1023   vnet_app_add_cert_key_pair_args_t _a, *a = &_a;
1024   u32 certkey_len, key_len, cert_len;
1025   int rv = 0;
1026   if (session_main_is_enabled () == 0)
1027     {
1028       rv = VNET_API_ERROR_FEATURE_DISABLED;
1029       goto done;
1030     }
1031
1032   cert_len = clib_net_to_host_u16 (mp->cert_len);
1033   if (cert_len > 10000)
1034     {
1035       rv = VNET_API_ERROR_INVALID_VALUE;
1036       goto done;
1037     }
1038
1039   certkey_len = clib_net_to_host_u16 (mp->certkey_len);
1040   if (certkey_len < cert_len)
1041     {
1042       rv = VNET_API_ERROR_INVALID_VALUE;
1043       goto done;
1044     }
1045
1046   key_len = certkey_len - cert_len;
1047   if (key_len > 10000)
1048     {
1049       rv = VNET_API_ERROR_INVALID_VALUE;
1050       goto done;
1051     }
1052
1053   clib_memset (a, 0, sizeof (*a));
1054   vec_validate (a->cert, cert_len);
1055   vec_validate (a->key, key_len);
1056   clib_memcpy_fast (a->cert, mp->certkey, cert_len);
1057   clib_memcpy_fast (a->key, mp->certkey + cert_len, key_len);
1058   rv = vnet_app_add_cert_key_pair (a);
1059   vec_free (a->cert);
1060   vec_free (a->key);
1061
1062 done:
1063   /* *INDENT-OFF* */
1064   REPLY_MACRO2 (VL_API_APP_ADD_CERT_KEY_PAIR_REPLY, ({
1065     if (!rv)
1066       rmp->index = clib_host_to_net_u32 (a->index);
1067   }));
1068   /* *INDENT-ON* */
1069 }
1070
1071 static void
1072 vl_api_app_del_cert_key_pair_t_handler (vl_api_app_del_cert_key_pair_t * mp)
1073 {
1074   vl_api_app_del_cert_key_pair_reply_t *rmp;
1075   u32 ckpair_index;
1076   int rv = 0;
1077   if (session_main_is_enabled () == 0)
1078     {
1079       rv = VNET_API_ERROR_FEATURE_DISABLED;
1080       goto done;
1081     }
1082   ckpair_index = clib_net_to_host_u32 (mp->index);
1083   rv = vnet_app_del_cert_key_pair (ckpair_index);
1084
1085 done:
1086   REPLY_MACRO (VL_API_APP_DEL_CERT_KEY_PAIR_REPLY);
1087 }
1088
1089 /* ### WILL BE DEPRECATED POST 20.01 ### */
1090 static void
1091 vl_api_application_tls_cert_add_t_handler (vl_api_application_tls_cert_add_t *
1092                                            mp)
1093 {
1094   vl_api_application_tls_cert_add_reply_t *rmp;
1095   app_cert_key_pair_t *ckpair;
1096   application_t *app;
1097   u32 cert_len;
1098   int rv = 0;
1099   if (session_main_is_enabled () == 0)
1100     {
1101       rv = VNET_API_ERROR_FEATURE_DISABLED;
1102       goto done;
1103     }
1104   if (!(app = application_lookup (mp->client_index)))
1105     {
1106       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1107       goto done;
1108     }
1109   cert_len = clib_net_to_host_u16 (mp->cert_len);
1110   if (cert_len > 10000)
1111     {
1112       rv = VNET_API_ERROR_INVALID_VALUE;
1113       goto done;
1114     }
1115   ckpair = app_cert_key_pair_get_default ();
1116   vec_validate (ckpair->cert, cert_len);
1117   clib_memcpy_fast (ckpair->cert, mp->cert, cert_len);
1118
1119 done:
1120   REPLY_MACRO (VL_API_APPLICATION_TLS_CERT_ADD_REPLY);
1121 }
1122
1123 /* ### WILL BE DEPRECATED POST 20.01 ### */
1124 static void
1125 vl_api_application_tls_key_add_t_handler (vl_api_application_tls_key_add_t *
1126                                           mp)
1127 {
1128   vl_api_application_tls_key_add_reply_t *rmp;
1129   app_cert_key_pair_t *ckpair;
1130   application_t *app;
1131   u32 key_len;
1132   int rv = 0;
1133   if (session_main_is_enabled () == 0)
1134     {
1135       rv = VNET_API_ERROR_FEATURE_DISABLED;
1136       goto done;
1137     }
1138   if (!(app = application_lookup (mp->client_index)))
1139     {
1140       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1141       goto done;
1142     }
1143   key_len = clib_net_to_host_u16 (mp->key_len);
1144   if (key_len > 10000)
1145     {
1146       rv = VNET_API_ERROR_INVALID_VALUE;
1147       goto done;
1148     }
1149   ckpair = app_cert_key_pair_get_default ();
1150   vec_validate (ckpair->key, key_len);
1151   clib_memcpy_fast (ckpair->key, mp->key, key_len);
1152 done:
1153   REPLY_MACRO (VL_API_APPLICATION_TLS_KEY_ADD_REPLY);
1154 }
1155
1156 static clib_error_t *
1157 application_reaper_cb (u32 client_index)
1158 {
1159   application_t *app = application_lookup (client_index);
1160   vnet_app_detach_args_t _a, *a = &_a;
1161   if (app)
1162     {
1163       a->app_index = app->app_index;
1164       a->api_client_index = client_index;
1165       vnet_application_detach (a);
1166     }
1167   return 0;
1168 }
1169
1170 VL_MSG_API_REAPER_FUNCTION (application_reaper_cb);
1171
1172 #define vl_msg_name_crc_list
1173 #include <vnet/vnet_all_api_h.h>
1174 #undef vl_msg_name_crc_list
1175
1176 static void
1177 setup_message_id_table (api_main_t * am)
1178 {
1179 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1180   foreach_vl_msg_name_crc_session;
1181 #undef _
1182 }
1183
1184 /*
1185  * session_api_hookup
1186  * Add uri's API message handlers to the table.
1187  * vlib has already mapped shared memory and
1188  * added the client registration handlers.
1189  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
1190  */
1191 static clib_error_t *
1192 session_api_hookup (vlib_main_t * vm)
1193 {
1194   api_main_t *am = vlibapi_get_main ();
1195
1196 #define _(N,n)                                                  \
1197     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1198                            vl_api_##n##_t_handler,              \
1199                            vl_noop_handler,                     \
1200                            vl_api_##n##_t_endian,               \
1201                            vl_api_##n##_t_print,                \
1202                            sizeof(vl_api_##n##_t), 1);
1203   foreach_session_api_msg;
1204 #undef _
1205
1206   /*
1207    * Set up the (msg_name, crc, message-id) table
1208    */
1209   setup_message_id_table (am);
1210
1211   return 0;
1212 }
1213
1214 VLIB_API_INIT_FUNCTION (session_api_hookup);
1215
1216 /*
1217  * fd.io coding-style-patch-verification: ON
1218  *
1219  * Local Variables:
1220  * eval: (c-set-style "gnu")
1221  * End:
1222  */