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/vnet_msg_enum.h>
  26
  27 #define vl_typedefs             /* define message structures */
  28 #include <vnet/vnet_all_api_h.h>
  29 #undef vl_typedefs
  30
  31 #define vl_endianfun            /* define message structures */
  32 #include <vnet/vnet_all_api_h.h>
  33 #undef vl_endianfun
  34
  35 /* instantiate all the print functions we know about */
  36 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  37 #define vl_printfun
  38 #include <vnet/vnet_all_api_h.h>
  39 #undef vl_printfun
  40
  41 #include <vlibapi/api_helper_macros.h>
  42
  43 #define foreach_session_api_msg                                         \
  44 _(MAP_ANOTHER_SEGMENT_REPLY, map_another_segment_reply)                 \
  45 _(APPLICATION_ATTACH, application_attach)                               \
  46 _(APP_ATTACH, app_attach)                                               \
  47 _(APPLICATION_DETACH, application_detach)                               \
  48 _(BIND_URI, bind_uri)                                                   \
  49 _(UNBIND_URI, unbind_uri)                                               \
  50 _(CONNECT_URI, connect_uri)                                             \
  51 _(DISCONNECT_SESSION, disconnect_session)                               \
  52 _(DISCONNECT_SESSION_REPLY, disconnect_session_reply)                   \
  53 _(BIND_SOCK, bind_sock)                                                 \
  54 _(UNBIND_SOCK, unbind_sock)                                             \
  55 _(CONNECT_SOCK, connect_sock)                                           \
  56 _(SESSION_ENABLE_DISABLE, session_enable_disable)                       \
  57 _(APP_NAMESPACE_ADD_DEL, app_namespace_add_del)                         \
  58 _(SESSION_RULE_ADD_DEL, session_rule_add_del)                           \
  59 _(SESSION_RULES_DUMP, session_rules_dump)                               \
  60 _(APPLICATION_TLS_CERT_ADD, application_tls_cert_add)                   \
  61 _(APPLICATION_TLS_KEY_ADD, application_tls_key_add)                     \
  62 _(APP_WORKER_ADD_DEL, app_worker_add_del)                               \
  63
  64 static int
  65 session_send_fds (vl_api_registration_t * reg, int fds[], int n_fds)
  66 {
  67   clib_error_t *error;
  68   if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
  69     {
  70       clib_warning ("can't send memfd fd");
  71       return -1;
  72     }
  73   error = vl_api_send_fd_msg (reg, fds, n_fds);
  74   if (error)
  75     {
  76       clib_error_report (error);
  77       return -1;
  78     }
  79   return 0;
  80 }
  81
  82 static int
  83 send_add_segment_callback (u32 api_client_index, u64 segment_handle)
  84 {
  85   int fds[SESSION_N_FD_TYPE], n_fds = 0;
  86   vl_api_map_another_segment_t *mp;
  87   vl_api_registration_t *reg;
  88   fifo_segment_t *fs;
  89   ssvm_private_t *sp;
  90   u8 fd_flags = 0;
  91
  92   reg = vl_mem_api_client_index_to_registration (api_client_index);
  93   if (!reg)
  94     {
  95       clib_warning ("no api registration for client: %u", api_client_index);
  96       return -1;
  97     }
  98
  99   fs = segment_manager_get_segment_w_handle (segment_handle);
 100   sp = &fs->ssvm;
 101   if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD)
 102     {
 103       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 104         {
 105           clib_warning ("can't send memfd fd");
 106           return -1;
 107         }
 108
 109       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 110       fds[n_fds] = sp->fd;
 111       n_fds += 1;
 112     }
 113
 114   mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
 115   clib_memset (mp, 0, sizeof (*mp));
 116   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MAP_ANOTHER_SEGMENT);
 117   mp->segment_size = sp->ssvm_size;
 118   mp->fd_flags = fd_flags;
 119   mp->segment_handle = clib_host_to_net_u64 (segment_handle);
 120   strncpy ((char *) mp->segment_name, (char *) sp->name,
 121            sizeof (mp->segment_name) - 1);
 122
 123   vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
 124
 125   if (n_fds)
 126     return session_send_fds (reg, fds, n_fds);
 127
 128   return 0;
 129 }
 130
 131 static int
 132 send_del_segment_callback (u32 api_client_index, u64 segment_handle)
 133 {
 134   vl_api_unmap_segment_t *mp;
 135   vl_api_registration_t *reg;
 136
 137   reg = vl_mem_api_client_index_to_registration (api_client_index);
 138   if (!reg)
 139     {
 140       clib_warning ("no registration: %u", api_client_index);
 141       return -1;
 142     }
 143
 144   mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
 145   clib_memset (mp, 0, sizeof (*mp));
 146   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_UNMAP_SEGMENT);
 147   mp->segment_handle = clib_host_to_net_u64 (segment_handle);
 148   vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
 149
 150   return 0;
 151 }
 152
 153 static int
 154 mq_try_lock_and_alloc_msg (svm_msg_q_t * app_mq, svm_msg_q_msg_t * msg)
 155 {
 156   int rv;
 157   u8 try = 0;
 158   while (try < 100)
 159     {
 160       rv = svm_msg_q_lock_and_alloc_msg_w_ring (app_mq,
 161                                                 SESSION_MQ_CTRL_EVT_RING,
 162                                                 SVM_Q_NOWAIT, msg);
 163       if (!rv)
 164         return 0;
 165       try++;
 166       usleep (1);
 167     }
 168   clib_warning ("failed to alloc msg");
 169   return -1;
 170 }
 171
 172 static int
 173 mq_send_session_accepted_cb (session_t * s)
 174 {
 175   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 176   svm_msg_q_msg_t _msg, *msg = &_msg;
 177   svm_msg_q_t *vpp_queue, *app_mq;
 178   session_t *listener;
 179   session_accepted_msg_t *mp;
 180   session_event_t *evt;
 181   application_t *app;
 182
 183   app = application_get (app_wrk->app_index);
 184   app_mq = app_wrk->event_queue;
 185   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 186     return -1;
 187
 188   evt = svm_msg_q_msg_data (app_mq, msg);
 189   clib_memset (evt, 0, sizeof (*evt));
 190   evt->event_type = SESSION_CTRL_EVT_ACCEPTED;
 191   mp = (session_accepted_msg_t *) evt->data;
 192   clib_memset (mp, 0, sizeof (*mp));
 193   mp->context = app->app_index;
 194   mp->server_rx_fifo = pointer_to_uword (s->rx_fifo);
 195   mp->server_tx_fifo = pointer_to_uword (s->tx_fifo);
 196   mp->segment_handle = session_segment_handle (s);
 197
 198   if (session_has_transport (s))
 199     {
 200       listener = listen_session_get_from_handle (s->listener_handle);
 201       mp->listener_handle = app_listen_session_handle (listener);
 202       if (application_is_proxy (app))
 203         {
 204           listener =
 205             app_worker_first_listener (app_wrk, session_get_fib_proto (s),
 206                                        session_get_transport_proto (s));
 207           if (listener)
 208             mp->listener_handle = listen_session_get_handle (listener);
 209         }
 210       vpp_queue = session_main_get_vpp_event_queue (s->thread_index);
 211       mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 212       mp->handle = session_handle (s);
 213
 214       session_get_endpoint (s, &mp->rmt, 0 /* is_lcl */ );
 215     }
 216   else
 217     {
 218       ct_connection_t *ct;
 219
 220       ct = (ct_connection_t *) session_get_transport (s);
 221       listener = listen_session_get_from_handle (s->listener_handle);
 222       mp->listener_handle = app_listen_session_handle (listener);
 223       mp->rmt.is_ip4 = session_type_is_ip4 (listener->session_type);
 224       mp->rmt.port = ct->c_rmt_port;
 225       mp->handle = session_handle (s);
 226       vpp_queue = session_main_get_vpp_event_queue (0);
 227       mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 228     }
 229   svm_msg_q_add_and_unlock (app_mq, msg);
 230
 231   return 0;
 232 }
 233
 234 static inline void
 235 mq_send_session_close_evt (app_worker_t * app_wrk, session_handle_t sh,
 236                            session_evt_type_t evt_type)
 237 {
 238   svm_msg_q_msg_t _msg, *msg = &_msg;
 239   session_disconnected_msg_t *mp;
 240   svm_msg_q_t *app_mq;
 241   session_event_t *evt;
 242
 243   app_mq = app_wrk->event_queue;
 244   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 245     return;
 246   evt = svm_msg_q_msg_data (app_mq, msg);
 247   clib_memset (evt, 0, sizeof (*evt));
 248   evt->event_type = evt_type;
 249   mp = (session_disconnected_msg_t *) evt->data;
 250   mp->handle = sh;
 251   mp->context = app_wrk->api_client_index;
 252   svm_msg_q_add_and_unlock (app_mq, msg);
 253 }
 254
 255 static inline void
 256 mq_notify_close_subscribers (u32 app_index, session_handle_t sh,
 257                              svm_fifo_t * f, session_evt_type_t evt_type)
 258 {
 259   app_worker_t *app_wrk;
 260   application_t *app;
 261   int i;
 262
 263   app = application_get (app_index);
 264   if (!app)
 265     return;
 266
 267   for (i = 0; i < f->n_subscribers; i++)
 268     {
 269       if (!(app_wrk = application_get_worker (app, f->subscribers[i])))
 270         continue;
 271       mq_send_session_close_evt (app_wrk, sh, SESSION_CTRL_EVT_DISCONNECTED);
 272     }
 273 }
 274
 275 static void
 276 mq_send_session_disconnected_cb (session_t * s)
 277 {
 278   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 279   session_handle_t sh = session_handle (s);
 280
 281   mq_send_session_close_evt (app_wrk, session_handle (s),
 282                              SESSION_CTRL_EVT_DISCONNECTED);
 283
 284   if (svm_fifo_n_subscribers (s->rx_fifo))
 285     mq_notify_close_subscribers (app_wrk->app_index, sh, s->rx_fifo,
 286                                  SESSION_CTRL_EVT_DISCONNECTED);
 287 }
 288
 289 static void
 290 mq_send_session_reset_cb (session_t * s)
 291 {
 292   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 293   session_handle_t sh = session_handle (s);
 294
 295   mq_send_session_close_evt (app_wrk, sh, SESSION_CTRL_EVT_RESET);
 296
 297   if (svm_fifo_n_subscribers (s->rx_fifo))
 298     mq_notify_close_subscribers (app_wrk->app_index, sh, s->rx_fifo,
 299                                  SESSION_CTRL_EVT_RESET);
 300 }
 301
 302 int
 303 mq_send_session_connected_cb (u32 app_wrk_index, u32 api_context,
 304                               session_t * s, u8 is_fail)
 305 {
 306   svm_msg_q_msg_t _msg, *msg = &_msg;
 307   session_connected_msg_t *mp;
 308   svm_msg_q_t *vpp_mq, *app_mq;
 309   transport_connection_t *tc;
 310   app_worker_t *app_wrk;
 311   session_event_t *evt;
 312
 313   app_wrk = app_worker_get (app_wrk_index);
 314   app_mq = app_wrk->event_queue;
 315   if (!app_mq)
 316     {
 317       clib_warning ("app %u with api index: %u not attached",
 318                     app_wrk->app_index, app_wrk->api_client_index);
 319       return -1;
 320     }
 321
 322   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 323     return -1;
 324
 325   evt = svm_msg_q_msg_data (app_mq, msg);
 326   clib_memset (evt, 0, sizeof (*evt));
 327   evt->event_type = SESSION_CTRL_EVT_CONNECTED;
 328   mp = (session_connected_msg_t *) evt->data;
 329   clib_memset (mp, 0, sizeof (*mp));
 330   mp->context = api_context;
 331
 332   if (is_fail)
 333     goto done;
 334
 335   if (session_has_transport (s))
 336     {
 337       tc = session_get_transport (s);
 338       if (!tc)
 339         {
 340           is_fail = 1;
 341           goto done;
 342         }
 343
 344       vpp_mq = session_main_get_vpp_event_queue (s->thread_index);
 345       mp->handle = session_handle (s);
 346       mp->vpp_event_queue_address = pointer_to_uword (vpp_mq);
 347
 348       session_get_endpoint (s, &mp->lcl, 1 /* is_lcl */ );
 349
 350       mp->server_rx_fifo = pointer_to_uword (s->rx_fifo);
 351       mp->server_tx_fifo = pointer_to_uword (s->tx_fifo);
 352       mp->segment_handle = session_segment_handle (s);
 353     }
 354   else
 355     {
 356       ct_connection_t *cct;
 357       session_t *ss;
 358
 359       cct = (ct_connection_t *) session_get_transport (s);
 360       mp->handle = session_handle (s);
 361       mp->lcl.port = cct->c_lcl_port;
 362       mp->lcl.is_ip4 = cct->c_is_ip4;
 363       vpp_mq = session_main_get_vpp_event_queue (0);
 364       mp->vpp_event_queue_address = pointer_to_uword (vpp_mq);
 365       mp->server_rx_fifo = pointer_to_uword (s->rx_fifo);
 366       mp->server_tx_fifo = pointer_to_uword (s->tx_fifo);
 367       mp->segment_handle = session_segment_handle (s);
 368       ss = ct_session_get_peer (s);
 369       mp->ct_rx_fifo = pointer_to_uword (ss->tx_fifo);
 370       mp->ct_tx_fifo = pointer_to_uword (ss->rx_fifo);
 371       mp->ct_segment_handle = session_segment_handle (ss);
 372     }
 373
 374 done:
 375   mp->retval = is_fail ?
 376     clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0;
 377
 378   svm_msg_q_add_and_unlock (app_mq, msg);
 379   return 0;
 380 }
 381
 382 int
 383 mq_send_session_bound_cb (u32 app_wrk_index, u32 api_context,
 384                           session_handle_t handle, int rv)
 385 {
 386   svm_msg_q_msg_t _msg, *msg = &_msg;
 387   svm_msg_q_t *app_mq, *vpp_evt_q;
 388   transport_endpoint_t tep;
 389   session_bound_msg_t *mp;
 390   app_worker_t *app_wrk;
 391   session_event_t *evt;
 392   app_listener_t *al;
 393   session_t *ls = 0;
 394   app_wrk = app_worker_get (app_wrk_index);
 395   app_mq = app_wrk->event_queue;
 396   if (!app_mq)
 397     {
 398       clib_warning ("app %u with api index: %u not attached",
 399                     app_wrk->app_index, app_wrk->api_client_index);
 400       return -1;
 401     }
 402
 403   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 404     return -1;
 405
 406   evt = svm_msg_q_msg_data (app_mq, msg);
 407   clib_memset (evt, 0, sizeof (*evt));
 408   evt->event_type = SESSION_CTRL_EVT_BOUND;
 409   mp = (session_bound_msg_t *) evt->data;
 410   mp->context = api_context;
 411
 412   if (rv)
 413     goto done;
 414
 415   mp->handle = handle;
 416   al = app_listener_get_w_handle (handle);
 417   if (al->session_index != SESSION_INVALID_INDEX)
 418     ls = app_listener_get_session (al);
 419   else
 420     ls = app_listener_get_local_session (al);
 421
 422   session_get_endpoint (ls, &tep, 1 /* is_lcl */ );
 423   mp->lcl_port = tep.port;
 424   mp->lcl_is_ip4 = tep.is_ip4;
 425   clib_memcpy_fast (mp->lcl_ip, &tep.ip, sizeof (tep.ip));
 426
 427   vpp_evt_q = session_main_get_vpp_event_queue (0);
 428   mp->vpp_evt_q = pointer_to_uword (vpp_evt_q);
 429
 430   if (session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
 431     {
 432       mp->rx_fifo = pointer_to_uword (ls->rx_fifo);
 433       mp->tx_fifo = pointer_to_uword (ls->tx_fifo);
 434     }
 435
 436 done:
 437   mp->retval = rv;
 438   svm_msg_q_add_and_unlock (app_mq, msg);
 439   return 0;
 440 }
 441
 442 void
 443 mq_send_unlisten_reply (app_worker_t * app_wrk, session_handle_t sh,
 444                         u32 context, int rv)
 445 {
 446   svm_msg_q_msg_t _msg, *msg = &_msg;
 447   session_unlisten_reply_msg_t *ump;
 448   svm_msg_q_t *app_mq;
 449   session_event_t *evt;
 450
 451   app_mq = app_wrk->event_queue;
 452   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 453     return;
 454
 455   evt = svm_msg_q_msg_data (app_mq, msg);
 456   clib_memset (evt, 0, sizeof (*evt));
 457   evt->event_type = SESSION_CTRL_EVT_UNLISTEN_REPLY;
 458   ump = (session_unlisten_reply_msg_t *) evt->data;
 459   ump->context = context;
 460   ump->handle = sh;
 461   ump->retval = rv;
 462   svm_msg_q_add_and_unlock (app_mq, msg);
 463 }
 464
 465 static void
 466 mq_send_session_migrate_cb (session_t * s, session_handle_t new_sh)
 467 {
 468   clib_warning ("not supported");
 469 }
 470
 471 static session_cb_vft_t session_mq_cb_vft = {
 472   .session_accept_callback = mq_send_session_accepted_cb,
 473   .session_disconnect_callback = mq_send_session_disconnected_cb,
 474   .session_connected_callback = mq_send_session_connected_cb,
 475   .session_reset_callback = mq_send_session_reset_cb,
 476   .session_migrate_callback = mq_send_session_migrate_cb,
 477   .add_segment_callback = send_add_segment_callback,
 478   .del_segment_callback = send_del_segment_callback,
 479 };
 480
 481 static void
 482 vl_api_session_enable_disable_t_handler (vl_api_session_enable_disable_t * mp)
 483 {
 484   vl_api_session_enable_disable_reply_t *rmp;
 485   vlib_main_t *vm = vlib_get_main ();
 486   int rv = 0;
 487
 488   vnet_session_enable_disable (vm, mp->is_enable);
 489   REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY);
 490 }
 491
 492 /* ### WILL BE DEPRECATED POST 20.01 ### */
 493 static void
 494 vl_api_application_attach_t_handler (vl_api_application_attach_t * mp)
 495 {
 496   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
 497   vl_api_application_attach_reply_t *rmp;
 498   ssvm_private_t *segp, *evt_q_segment;
 499   vnet_app_attach_args_t _a, *a = &_a;
 500   vl_api_registration_t *reg;
 501   u8 fd_flags = 0;
 502
 503   reg = vl_api_client_index_to_registration (mp->client_index);
 504   if (!reg)
 505     return;
 506
 507   if (session_main_is_enabled () == 0)
 508     {
 509       rv = VNET_API_ERROR_FEATURE_DISABLED;
 510       goto done;
 511     }
 512
 513   STATIC_ASSERT (sizeof (u64) * APP_OPTIONS_N_OPTIONS <=
 514                  sizeof (mp->options),
 515                  "Out of options, fix api message definition");
 516
 517   clib_memset (a, 0, sizeof (*a));
 518   a->api_client_index = mp->client_index;
 519   a->options = mp->options;
 520   a->session_cb_vft = &session_mq_cb_vft;
 521   if (mp->namespace_id_len > 64)
 522     {
 523       rv = VNET_API_ERROR_INVALID_VALUE;
 524       goto done;
 525     }
 526
 527   if (mp->namespace_id_len)
 528     {
 529       vec_validate (a->namespace_id, mp->namespace_id_len - 1);
 530       clib_memcpy_fast (a->namespace_id, mp->namespace_id,
 531                         mp->namespace_id_len);
 532     }
 533
 534   if ((rv = vnet_application_attach (a)))
 535     {
 536       clib_warning ("attach returned: %d", rv);
 537       vec_free (a->namespace_id);
 538       goto done;
 539     }
 540   vec_free (a->namespace_id);
 541
 542   /* Send event queues segment */
 543   if ((evt_q_segment = session_main_get_evt_q_segment ()))
 544     {
 545       fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
 546       fds[n_fds] = evt_q_segment->fd;
 547       n_fds += 1;
 548     }
 549   /* Send fifo segment fd if needed */
 550   if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
 551     {
 552       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 553       fds[n_fds] = a->segment->fd;
 554       n_fds += 1;
 555     }
 556   if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 557     {
 558       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
 559       fds[n_fds] = svm_msg_q_get_producer_eventfd (a->app_evt_q);
 560       n_fds += 1;
 561     }
 562
 563 done:
 564
 565   /* *INDENT-OFF* */
 566   REPLY_MACRO2 (VL_API_APPLICATION_ATTACH_REPLY, ({
 567     if (!rv)
 568       {
 569         segp = a->segment;
 570         rmp->app_index = clib_host_to_net_u32 (a->app_index);
 571         rmp->segment_name_length = 0;
 572         rmp->segment_size = segp->ssvm_size;
 573         if (vec_len (segp->name))
 574           {
 575             memcpy (rmp->segment_name, segp->name, vec_len (segp->name));
 576             rmp->segment_name_length = vec_len (segp->name);
 577           }
 578         rmp->app_event_queue_address = pointer_to_uword (a->app_evt_q);
 579         rmp->n_fds = n_fds;
 580         rmp->fd_flags = fd_flags;
 581         rmp->segment_handle = clib_host_to_net_u64 (a->segment_handle);
 582       }
 583   }));
 584   /* *INDENT-ON* */
 585
 586   if (n_fds)
 587     session_send_fds (reg, fds, n_fds);
 588 }
 589
 590 static void
 591 vl_api_app_attach_t_handler (vl_api_app_attach_t * mp)
 592 {
 593   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
 594   vl_api_app_attach_reply_t *rmp;
 595   ssvm_private_t *segp, *evt_q_segment;
 596   vnet_app_attach_args_t _a, *a = &_a;
 597   u8 fd_flags = 0, ctrl_thread;
 598   vl_api_registration_t *reg;
 599   svm_msg_q_t *ctrl_mq;
 600
 601   reg = vl_api_client_index_to_registration (mp->client_index);
 602   if (!reg)
 603     return;
 604
 605   if (session_main_is_enabled () == 0)
 606     {
 607       rv = VNET_API_ERROR_FEATURE_DISABLED;
 608       goto done;
 609     }
 610
 611   STATIC_ASSERT (sizeof (u64) * APP_OPTIONS_N_OPTIONS <=
 612                  sizeof (mp->options),
 613                  "Out of options, fix api message definition");
 614
 615   clib_memset (a, 0, sizeof (*a));
 616   a->api_client_index = mp->client_index;
 617   a->options = mp->options;
 618   a->session_cb_vft = &session_mq_cb_vft;
 619   if (mp->namespace_id_len > 64)
 620     {
 621       rv = VNET_API_ERROR_INVALID_VALUE;
 622       goto done;
 623     }
 624
 625   if (mp->namespace_id_len)
 626     {
 627       vec_validate (a->namespace_id, mp->namespace_id_len - 1);
 628       clib_memcpy_fast (a->namespace_id, mp->namespace_id,
 629                         mp->namespace_id_len);
 630     }
 631
 632   if ((rv = vnet_application_attach (a)))
 633     {
 634       clib_warning ("attach returned: %d", rv);
 635       vec_free (a->namespace_id);
 636       goto done;
 637     }
 638   vec_free (a->namespace_id);
 639
 640   /* Send event queues segment */
 641   if ((evt_q_segment = session_main_get_evt_q_segment ()))
 642     {
 643       fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
 644       fds[n_fds] = evt_q_segment->fd;
 645       n_fds += 1;
 646     }
 647   /* Send fifo segment fd if needed */
 648   if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
 649     {
 650       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 651       fds[n_fds] = a->segment->fd;
 652       n_fds += 1;
 653     }
 654   if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 655     {
 656       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
 657       fds[n_fds] = svm_msg_q_get_producer_eventfd (a->app_evt_q);
 658       n_fds += 1;
 659     }
 660
 661 done:
 662
 663   ctrl_thread = vlib_num_workers ()? 1 : 0;
 664   ctrl_mq = session_main_get_vpp_event_queue (ctrl_thread);
 665   /* *INDENT-OFF* */
 666   REPLY_MACRO2 (VL_API_APP_ATTACH_REPLY, ({
 667     if (!rv)
 668       {
 669         segp = a->segment;
 670         rmp->app_index = clib_host_to_net_u32 (a->app_index);
 671         rmp->app_mq = pointer_to_uword (a->app_evt_q);
 672         rmp->vpp_ctrl_mq = pointer_to_uword (ctrl_mq);
 673         rmp->vpp_ctrl_mq_thread = ctrl_thread;
 674         rmp->n_fds = n_fds;
 675         rmp->fd_flags = fd_flags;
 676         if (vec_len (segp->name))
 677           {
 678             memcpy (rmp->segment_name, segp->name, vec_len (segp->name));
 679             rmp->segment_name_length = vec_len (segp->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 /* ### WILL BE DEPRECATED POST 20.01 ### */
 692 static void
 693 vl_api_application_detach_t_handler (vl_api_application_detach_t * mp)
 694 {
 695   vl_api_application_detach_reply_t *rmp;
 696   int rv = VNET_API_ERROR_INVALID_VALUE_2;
 697   vnet_app_detach_args_t _a, *a = &_a;
 698   application_t *app;
 699
 700   if (session_main_is_enabled () == 0)
 701     {
 702       rv = VNET_API_ERROR_FEATURE_DISABLED;
 703       goto done;
 704     }
 705
 706   app = application_lookup (mp->client_index);
 707   if (app)
 708     {
 709       a->app_index = app->app_index;
 710       a->api_client_index = mp->client_index;
 711       rv = vnet_application_detach (a);
 712     }
 713
 714 done:
 715   REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY);
 716 }
 717
 718 /* ### WILL BE DEPRECATED POST 20.01 ### */
 719 static void
 720 vl_api_bind_uri_t_handler (vl_api_bind_uri_t * mp)
 721 {
 722   vl_api_bind_uri_reply_t *rmp;
 723   vnet_listen_args_t _a, *a = &_a;
 724   application_t *app = 0;
 725   app_worker_t *app_wrk;
 726   int rv;
 727
 728   if (session_main_is_enabled () == 0)
 729     {
 730       rv = VNET_API_ERROR_FEATURE_DISABLED;
 731       goto done;
 732     }
 733
 734   app = application_lookup (mp->client_index);
 735   if (app)
 736     {
 737       clib_memset (a, 0, sizeof (*a));
 738       a->uri = (char *) mp->uri;
 739       a->app_index = app->app_index;
 740       rv = vnet_bind_uri (a);
 741     }
 742   else
 743     {
 744       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 745     }
 746
 747 done:
 748
 749   REPLY_MACRO (VL_API_BIND_URI_REPLY);
 750
 751   if (app)
 752     {
 753       app_wrk = application_get_worker (app, 0);
 754       mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle,
 755                                 rv);
 756     }
 757 }
 758
 759 /* ### WILL BE DEPRECATED POST 20.01 ### */
 760 static void
 761 vl_api_unbind_uri_t_handler (vl_api_unbind_uri_t * mp)
 762 {
 763   vl_api_unbind_uri_reply_t *rmp;
 764   application_t *app;
 765   vnet_unlisten_args_t _a, *a = &_a;
 766   int rv;
 767
 768   if (session_main_is_enabled () == 0)
 769     {
 770       rv = VNET_API_ERROR_FEATURE_DISABLED;
 771       goto done;
 772     }
 773
 774   app = application_lookup (mp->client_index);
 775   if (app)
 776     {
 777       a->uri = (char *) mp->uri;
 778       a->app_index = app->app_index;
 779       a->wrk_map_index = 0;
 780       rv = vnet_unbind_uri (a);
 781     }
 782   else
 783     {
 784       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 785     }
 786
 787 done:
 788   REPLY_MACRO (VL_API_UNBIND_URI_REPLY);
 789 }
 790
 791 /* ### WILL BE DEPRECATED POST 20.01 ### */
 792 static void
 793 vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp)
 794 {
 795   vl_api_connect_uri_reply_t *rmp;
 796   vnet_connect_args_t _a, *a = &_a;
 797   application_t *app;
 798   int rv = 0;
 799
 800   if (session_main_is_enabled () == 0)
 801     {
 802       rv = VNET_API_ERROR_FEATURE_DISABLED;
 803       goto done;
 804     }
 805
 806   app = application_lookup (mp->client_index);
 807   if (app)
 808     {
 809       clib_memset (a, 0, sizeof (*a));
 810       a->uri = (char *) mp->uri;
 811       a->api_context = mp->context;
 812       a->app_index = app->app_index;
 813       if ((rv = vnet_connect_uri (a)))
 814         clib_warning ("connect_uri returned: %d", rv);
 815     }
 816   else
 817     {
 818       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 819     }
 820
 821   /*
 822    * Don't reply to stream (tcp) connects. The reply will come once
 823    * the connection is established. In case of the redirects, the reply
 824    * will come from the server app.
 825    */
 826   if (rv == 0)
 827     return;
 828
 829 done:
 830   REPLY_MACRO (VL_API_CONNECT_URI_REPLY);
 831 }
 832
 833 /* ### WILL BE DEPRECATED POST 20.01 ### */
 834 static void
 835 vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
 836 {
 837   vl_api_disconnect_session_reply_t *rmp;
 838   vnet_disconnect_args_t _a, *a = &_a;
 839   application_t *app;
 840   int rv = 0;
 841
 842   if (session_main_is_enabled () == 0)
 843     {
 844       rv = VNET_API_ERROR_FEATURE_DISABLED;
 845       goto done;
 846     }
 847
 848   app = application_lookup (mp->client_index);
 849   if (app)
 850     {
 851       a->handle = mp->handle;
 852       a->app_index = app->app_index;
 853       rv = vnet_disconnect_session (a);
 854     }
 855   else
 856     {
 857       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 858     }
 859
 860 done:
 861   REPLY_MACRO2 (VL_API_DISCONNECT_SESSION_REPLY, rmp->handle = mp->handle);
 862 }
 863
 864 /* ### WILL BE DEPRECATED POST 20.01 ### */
 865 static void
 866 vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
 867                                            mp)
 868 {
 869   vnet_disconnect_args_t _a, *a = &_a;
 870   application_t *app;
 871
 872   /* Client objected to disconnecting the session, log and continue */
 873   if (mp->retval)
 874     {
 875       clib_warning ("client retval %d", mp->retval);
 876       return;
 877     }
 878
 879   /* Disconnect has been confirmed. Confirm close to transport */
 880   app = application_lookup (mp->context);
 881   if (app)
 882     {
 883       a->handle = mp->handle;
 884       a->app_index = app->app_index;
 885       vnet_disconnect_session (a);
 886     }
 887 }
 888
 889 static void
 890 vl_api_map_another_segment_reply_t_handler (vl_api_map_another_segment_reply_t
 891                                             * mp)
 892 {
 893   clib_warning ("not implemented");
 894 }
 895
 896 /* ### WILL BE DEPRECATED POST 20.01 ### */
 897 static void
 898 vl_api_bind_sock_t_handler (vl_api_bind_sock_t * mp)
 899 {
 900   vnet_listen_args_t _a, *a = &_a;
 901   vl_api_bind_sock_reply_t *rmp;
 902   application_t *app = 0;
 903   app_worker_t *app_wrk;
 904   ip46_address_t *ip46;
 905   int rv = 0;
 906
 907   if (session_main_is_enabled () == 0)
 908     {
 909       rv = VNET_API_ERROR_FEATURE_DISABLED;
 910       goto done;
 911     }
 912
 913   app = application_lookup (mp->client_index);
 914   if (!app)
 915     {
 916       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 917       goto done;
 918     }
 919
 920   ip46 = (ip46_address_t *) mp->ip;
 921   clib_memset (a, 0, sizeof (*a));
 922   a->sep.is_ip4 = mp->is_ip4;
 923   a->sep.ip = *ip46;
 924   a->sep.port = mp->port;
 925   a->sep.fib_index = mp->vrf;
 926   a->sep.sw_if_index = ENDPOINT_INVALID_INDEX;
 927   a->sep.transport_proto = mp->proto;
 928   a->app_index = app->app_index;
 929   a->wrk_map_index = mp->wrk_index;
 930
 931   if ((rv = vnet_listen (a)))
 932     clib_warning ("listen returned: %d", rv);
 933
 934 done:
 935   /* Actual reply sent only over mq */
 936   REPLY_MACRO (VL_API_BIND_SOCK_REPLY);
 937
 938   if (app)
 939     {
 940       app_wrk = application_get_worker (app, mp->wrk_index);
 941       mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle,
 942                                 rv);
 943     }
 944 }
 945
 946 /* ### WILL BE DEPRECATED POST 20.01 ### */
 947 static void
 948 vl_api_unbind_sock_t_handler (vl_api_unbind_sock_t * mp)
 949 {
 950   vl_api_unbind_sock_reply_t *rmp;
 951   vnet_unlisten_args_t _a, *a = &_a;
 952   app_worker_t *app_wrk;
 953   application_t *app = 0;
 954   int rv = 0;
 955
 956   if (session_main_is_enabled () == 0)
 957     {
 958       rv = VNET_API_ERROR_FEATURE_DISABLED;
 959       goto done;
 960     }
 961
 962   app = application_lookup (mp->client_index);
 963   if (app)
 964     {
 965       a->app_index = app->app_index;
 966       a->handle = mp->handle;
 967       a->wrk_map_index = mp->wrk_index;
 968       if ((rv = vnet_unlisten (a)))
 969         clib_warning ("unlisten returned: %d", rv);
 970     }
 971
 972 done:
 973   REPLY_MACRO (VL_API_UNBIND_SOCK_REPLY);
 974
 975   app_wrk = application_get_worker (app, a->wrk_map_index);
 976   if (!app_wrk)
 977     return;
 978
 979   mq_send_unlisten_reply (app_wrk, mp->handle, mp->context, rv);
 980 }
 981
 982 /* ### WILL BE DEPRECATED POST 20.01 ### */
 983 static void
 984 vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp)
 985 {
 986   vl_api_connect_sock_reply_t *rmp;
 987   vnet_connect_args_t _a, *a = &_a;
 988   application_t *app = 0;
 989   int rv = 0;
 990
 991   if (session_main_is_enabled () == 0)
 992     {
 993       rv = VNET_API_ERROR_FEATURE_DISABLED;
 994       goto done;
 995     }
 996
 997   app = application_lookup (mp->client_index);
 998   if (app)
 999     {
1000       svm_queue_t *client_q;
1001       ip46_address_t *ip46 = (ip46_address_t *) mp->ip;
1002
1003       clib_memset (a, 0, sizeof (*a));
1004       client_q = vl_api_client_index_to_input_queue (mp->client_index);
1005       mp->client_queue_address = pointer_to_uword (client_q);
1006       a->sep.is_ip4 = mp->is_ip4;
1007       a->sep.ip = *ip46;
1008       a->sep.port = mp->port;
1009       a->sep.transport_proto = mp->proto;
1010       a->sep.peer.fib_index = mp->vrf;
1011       a->sep.peer.sw_if_index = ENDPOINT_INVALID_INDEX;
1012       a->sep_ext.parent_handle = mp->parent_handle;
1013       if (mp->hostname_len)
1014         {
1015           vec_validate (a->sep_ext.hostname, mp->hostname_len - 1);
1016           clib_memcpy_fast (a->sep_ext.hostname, mp->hostname,
1017                             mp->hostname_len);
1018         }
1019       a->api_context = mp->context;
1020       a->app_index = app->app_index;
1021       a->wrk_map_index = mp->wrk_index;
1022       if ((rv = vnet_connect (a)))
1023         clib_warning ("connect returned: %U", format_vnet_api_errno, rv);
1024       vec_free (a->sep_ext.hostname);
1025     }
1026   else
1027     {
1028       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1029     }
1030
1031   if (rv == 0)
1032     return;
1033
1034   /* Got some error, relay it */
1035
1036 done:
1037   REPLY_MACRO (VL_API_CONNECT_SOCK_REPLY);
1038
1039   if (app)
1040     {
1041       app_worker_t *app_wrk = application_get_worker (app, mp->wrk_index);
1042       mq_send_session_connected_cb (app_wrk->wrk_index, mp->context, 0, 1);
1043     }
1044 }
1045
1046 static void
1047 vl_api_app_worker_add_del_t_handler (vl_api_app_worker_add_del_t * mp)
1048 {
1049   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
1050   vl_api_app_worker_add_del_reply_t *rmp;
1051   vl_api_registration_t *reg;
1052   application_t *app;
1053   u8 fd_flags = 0;
1054
1055   if (!session_main_is_enabled ())
1056     {
1057       rv = VNET_API_ERROR_FEATURE_DISABLED;
1058       goto done;
1059     }
1060
1061   reg = vl_api_client_index_to_registration (mp->client_index);
1062   if (!reg)
1063     return;
1064
1065   app = application_get_if_valid (clib_net_to_host_u32 (mp->app_index));
1066   if (!app)
1067     {
1068       rv = VNET_API_ERROR_INVALID_VALUE;
1069       goto done;
1070     }
1071
1072   vnet_app_worker_add_del_args_t args = {
1073     .app_index = app->app_index,
1074     .wrk_map_index = clib_net_to_host_u32 (mp->wrk_index),
1075     .api_client_index = mp->client_index,
1076     .is_add = mp->is_add
1077   };
1078   rv = vnet_app_worker_add_del (&args);
1079   if (rv)
1080     {
1081       clib_warning ("app worker add/del returned: %d", rv);
1082       goto done;
1083     }
1084
1085   if (!mp->is_add)
1086     goto done;
1087
1088   /* Send fifo segment fd if needed */
1089   if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD)
1090     {
1091       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
1092       fds[n_fds] = args.segment->fd;
1093       n_fds += 1;
1094     }
1095   if (application_segment_manager_properties (app)->use_mq_eventfd)
1096     {
1097       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
1098       fds[n_fds] = svm_msg_q_get_producer_eventfd (args.evt_q);
1099       n_fds += 1;
1100     }
1101
1102   /* *INDENT-OFF* */
1103 done:
1104   REPLY_MACRO2 (VL_API_APP_WORKER_ADD_DEL_REPLY, ({
1105     rmp->is_add = mp->is_add;
1106     rmp->wrk_index = clib_host_to_net_u32 (args.wrk_map_index);
1107     rmp->segment_handle = clib_host_to_net_u64 (args.segment_handle);
1108     if (!rv && mp->is_add)
1109       {
1110         if (vec_len (args.segment->name))
1111           {
1112             memcpy (rmp->segment_name, args.segment->name,
1113                     vec_len (args.segment->name));
1114             rmp->segment_name_length = vec_len (args.segment->name);
1115           }
1116         rmp->app_event_queue_address = pointer_to_uword (args.evt_q);
1117         rmp->n_fds = n_fds;
1118         rmp->fd_flags = fd_flags;
1119       }
1120   }));
1121   /* *INDENT-ON* */
1122
1123   if (n_fds)
1124     session_send_fds (reg, fds, n_fds);
1125 }
1126
1127 static void
1128 vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp)
1129 {
1130   vl_api_app_namespace_add_del_reply_t *rmp;
1131   u32 appns_index = 0;
1132   u8 *ns_id = 0;
1133   int rv = 0;
1134   if (!session_main_is_enabled ())
1135     {
1136       rv = VNET_API_ERROR_FEATURE_DISABLED;
1137       goto done;
1138     }
1139
1140   if (mp->namespace_id_len > ARRAY_LEN (mp->namespace_id))
1141     {
1142       rv = VNET_API_ERROR_INVALID_VALUE;
1143       goto done;
1144     }
1145
1146   vec_validate (ns_id, mp->namespace_id_len - 1);
1147   clib_memcpy_fast (ns_id, mp->namespace_id, mp->namespace_id_len);
1148   vnet_app_namespace_add_del_args_t args = {
1149     .ns_id = ns_id,
1150     .secret = clib_net_to_host_u64 (mp->secret),
1151     .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index),
1152     .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id),
1153     .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id),
1154     .is_add = 1
1155   };
1156   rv = vnet_app_namespace_add_del (&args);
1157   if (!rv)
1158     {
1159       appns_index = app_namespace_index_from_id (ns_id);
1160       if (appns_index == APP_NAMESPACE_INVALID_INDEX)
1161         {
1162           clib_warning ("app ns lookup failed");
1163           rv = VNET_API_ERROR_UNSPECIFIED;
1164         }
1165     }
1166   vec_free (ns_id);
1167
1168   /* *INDENT-OFF* */
1169 done:
1170   REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({
1171     if (!rv)
1172       rmp->appns_index = clib_host_to_net_u32 (appns_index);
1173   }));
1174   /* *INDENT-ON* */
1175 }
1176
1177 static void
1178 vl_api_session_rule_add_del_t_handler (vl_api_session_rule_add_del_t * mp)
1179 {
1180   vl_api_session_rule_add_del_reply_t *rmp;
1181   session_rule_add_del_args_t args;
1182   session_rule_table_add_del_args_t *table_args = &args.table_args;
1183   u8 fib_proto;
1184   int rv = 0;
1185
1186   clib_memset (&args, 0, sizeof (args));
1187   fib_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
1188
1189   table_args->lcl.fp_len = mp->lcl_plen;
1190   table_args->lcl.fp_proto = fib_proto;
1191   table_args->rmt.fp_len = mp->rmt_plen;
1192   table_args->rmt.fp_proto = fib_proto;
1193   table_args->lcl_port = mp->lcl_port;
1194   table_args->rmt_port = mp->rmt_port;
1195   table_args->action_index = clib_net_to_host_u32 (mp->action_index);
1196   table_args->is_add = mp->is_add;
1197   mp->tag[sizeof (mp->tag) - 1] = 0;
1198   table_args->tag = format (0, "%s", mp->tag);
1199   args.appns_index = clib_net_to_host_u32 (mp->appns_index);
1200   args.scope = mp->scope;
1201   args.transport_proto = mp->transport_proto;
1202
1203   clib_memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr));
1204   clib_memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr));
1205   ip_set (&table_args->lcl.fp_addr, mp->lcl_ip, mp->is_ip4);
1206   ip_set (&table_args->rmt.fp_addr, mp->rmt_ip, mp->is_ip4);
1207   rv = vnet_session_rule_add_del (&args);
1208   if (rv)
1209     clib_warning ("rule add del returned: %d", rv);
1210   vec_free (table_args->tag);
1211   REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY);
1212 }
1213
1214 static void
1215 send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local,
1216                             u8 transport_proto, u32 appns_index, u8 * tag,
1217                             vl_api_registration_t * reg, u32 context)
1218 {
1219   vl_api_session_rules_details_t *rmp = 0;
1220   session_mask_or_match_4_t *match =
1221     (session_mask_or_match_4_t *) & rule->match;
1222   session_mask_or_match_4_t *mask =
1223     (session_mask_or_match_4_t *) & rule->mask;
1224
1225   rmp = vl_msg_api_alloc (sizeof (*rmp));
1226   clib_memset (rmp, 0, sizeof (*rmp));
1227   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1228   rmp->context = context;
1229
1230   rmp->is_ip4 = 1;
1231   clib_memcpy_fast (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1232   clib_memcpy_fast (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1233   rmp->lcl_plen = ip4_mask_to_preflen (&mask->lcl_ip);
1234   rmp->rmt_plen = ip4_mask_to_preflen (&mask->rmt_ip);
1235   rmp->lcl_port = match->lcl_port;
1236   rmp->rmt_port = match->rmt_port;
1237   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
1238   rmp->scope =
1239     is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
1240   rmp->transport_proto = transport_proto;
1241   rmp->appns_index = clib_host_to_net_u32 (appns_index);
1242   if (tag)
1243     {
1244       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
1245       rmp->tag[vec_len (tag)] = 0;
1246     }
1247
1248   vl_api_send_msg (reg, (u8 *) rmp);
1249 }
1250
1251 static void
1252 send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local,
1253                             u8 transport_proto, u32 appns_index, u8 * tag,
1254                             vl_api_registration_t * reg, u32 context)
1255 {
1256   vl_api_session_rules_details_t *rmp = 0;
1257   session_mask_or_match_6_t *match =
1258     (session_mask_or_match_6_t *) & rule->match;
1259   session_mask_or_match_6_t *mask =
1260     (session_mask_or_match_6_t *) & rule->mask;
1261
1262   rmp = vl_msg_api_alloc (sizeof (*rmp));
1263   clib_memset (rmp, 0, sizeof (*rmp));
1264   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1265   rmp->context = context;
1266
1267   rmp->is_ip4 = 0;
1268   clib_memcpy_fast (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1269   clib_memcpy_fast (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1270   rmp->lcl_plen = ip6_mask_to_preflen (&mask->lcl_ip);
1271   rmp->rmt_plen = ip6_mask_to_preflen (&mask->rmt_ip);
1272   rmp->lcl_port = match->lcl_port;
1273   rmp->rmt_port = match->rmt_port;
1274   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
1275   rmp->scope =
1276     is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
1277   rmp->transport_proto = transport_proto;
1278   rmp->appns_index = clib_host_to_net_u32 (appns_index);
1279   if (tag)
1280     {
1281       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
1282       rmp->tag[vec_len (tag)] = 0;
1283     }
1284
1285   vl_api_send_msg (reg, (u8 *) rmp);
1286 }
1287
1288 static void
1289 send_session_rules_table_details (session_rules_table_t * srt, u8 fib_proto,
1290                                   u8 tp, u8 is_local, u32 appns_index,
1291                                   vl_api_registration_t * reg, u32 context)
1292 {
1293   mma_rule_16_t *rule16;
1294   mma_rule_40_t *rule40;
1295   mma_rules_table_16_t *srt16;
1296   mma_rules_table_40_t *srt40;
1297   u32 ri;
1298
1299   if (is_local || fib_proto == FIB_PROTOCOL_IP4)
1300     {
1301       u8 *tag = 0;
1302       /* *INDENT-OFF* */
1303       srt16 = &srt->session_rules_tables_16;
1304       pool_foreach (rule16, srt16->rules, ({
1305         ri = mma_rules_table_rule_index_16 (srt16, rule16);
1306         tag = session_rules_table_rule_tag (srt, ri, 1);
1307         send_session_rule_details4 (rule16, is_local, tp, appns_index, tag,
1308                                     reg, context);
1309       }));
1310       /* *INDENT-ON* */
1311     }
1312   if (is_local || fib_proto == FIB_PROTOCOL_IP6)
1313     {
1314       u8 *tag = 0;
1315       /* *INDENT-OFF* */
1316       srt40 = &srt->session_rules_tables_40;
1317       pool_foreach (rule40, srt40->rules, ({
1318         ri = mma_rules_table_rule_index_40 (srt40, rule40);
1319         tag = session_rules_table_rule_tag (srt, ri, 1);
1320         send_session_rule_details6 (rule40, is_local, tp, appns_index, tag,
1321                                     reg, context);
1322       }));
1323       /* *INDENT-ON* */
1324     }
1325 }
1326
1327 static void
1328 vl_api_session_rules_dump_t_handler (vl_api_one_map_server_dump_t * mp)
1329 {
1330   vl_api_registration_t *reg;
1331   session_table_t *st;
1332   u8 tp;
1333
1334   reg = vl_api_client_index_to_registration (mp->client_index);
1335   if (!reg)
1336     return;
1337
1338   /* *INDENT-OFF* */
1339   session_table_foreach (st, ({
1340     for (tp = 0; tp < TRANSPORT_N_PROTO; tp++)
1341       {
1342         send_session_rules_table_details (&st->session_rules[tp],
1343                                           st->active_fib_proto, tp,
1344                                           st->is_local, st->appns_index, reg,
1345                                           mp->context);
1346       }
1347   }));
1348   /* *INDENT-ON* */
1349 }
1350
1351 static void
1352 vl_api_application_tls_cert_add_t_handler (vl_api_application_tls_cert_add_t *
1353                                            mp)
1354 {
1355   vl_api_app_namespace_add_del_reply_t *rmp;
1356   vnet_app_add_tls_cert_args_t _a, *a = &_a;
1357   clib_error_t *error;
1358   application_t *app;
1359   u32 cert_len;
1360   int rv = 0;
1361   if (!session_main_is_enabled ())
1362     {
1363       rv = VNET_API_ERROR_FEATURE_DISABLED;
1364       goto done;
1365     }
1366   if (!(app = application_lookup (mp->client_index)))
1367     {
1368       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1369       goto done;
1370     }
1371   clib_memset (a, 0, sizeof (*a));
1372   a->app_index = app->app_index;
1373   cert_len = clib_net_to_host_u16 (mp->cert_len);
1374   if (cert_len > 10000)
1375     {
1376       rv = VNET_API_ERROR_INVALID_VALUE;
1377       goto done;
1378     }
1379   vec_validate (a->cert, cert_len);
1380   clib_memcpy_fast (a->cert, mp->cert, cert_len);
1381   if ((error = vnet_app_add_tls_cert (a)))
1382     {
1383       rv = clib_error_get_code (error);
1384       clib_error_report (error);
1385     }
1386   vec_free (a->cert);
1387 done:
1388   REPLY_MACRO (VL_API_APPLICATION_TLS_CERT_ADD_REPLY);
1389 }
1390
1391 static void
1392 vl_api_application_tls_key_add_t_handler (vl_api_application_tls_key_add_t *
1393                                           mp)
1394 {
1395   vl_api_app_namespace_add_del_reply_t *rmp;
1396   vnet_app_add_tls_key_args_t _a, *a = &_a;
1397   clib_error_t *error;
1398   application_t *app;
1399   u32 key_len;
1400   int rv = 0;
1401   if (!session_main_is_enabled ())
1402     {
1403       rv = VNET_API_ERROR_FEATURE_DISABLED;
1404       goto done;
1405     }
1406   if (!(app = application_lookup (mp->client_index)))
1407     {
1408       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1409       goto done;
1410     }
1411   clib_memset (a, 0, sizeof (*a));
1412   a->app_index = app->app_index;
1413   key_len = clib_net_to_host_u16 (mp->key_len);
1414   if (key_len > 10000)
1415     {
1416       rv = VNET_API_ERROR_INVALID_VALUE;
1417       goto done;
1418     }
1419   vec_validate (a->key, key_len);
1420   clib_memcpy_fast (a->key, mp->key, key_len);
1421   if ((error = vnet_app_add_tls_key (a)))
1422     {
1423       rv = clib_error_get_code (error);
1424       clib_error_report (error);
1425     }
1426   vec_free (a->key);
1427 done:
1428   REPLY_MACRO (VL_API_APPLICATION_TLS_KEY_ADD_REPLY);
1429 }
1430
1431 static clib_error_t *
1432 application_reaper_cb (u32 client_index)
1433 {
1434   application_t *app = application_lookup (client_index);
1435   vnet_app_detach_args_t _a, *a = &_a;
1436   if (app)
1437     {
1438       a->app_index = app->app_index;
1439       a->api_client_index = client_index;
1440       vnet_application_detach (a);
1441     }
1442   return 0;
1443 }
1444
1445 VL_MSG_API_REAPER_FUNCTION (application_reaper_cb);
1446
1447 #define vl_msg_name_crc_list
1448 #include <vnet/vnet_all_api_h.h>
1449 #undef vl_msg_name_crc_list
1450
1451 static void
1452 setup_message_id_table (api_main_t * am)
1453 {
1454 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1455   foreach_vl_msg_name_crc_session;
1456 #undef _
1457 }
1458
1459 /*
1460  * session_api_hookup
1461  * Add uri's API message handlers to the table.
1462  * vlib has already mapped shared memory and
1463  * added the client registration handlers.
1464  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
1465  */
1466 static clib_error_t *
1467 session_api_hookup (vlib_main_t * vm)
1468 {
1469   api_main_t *am = &api_main;
1470
1471 #define _(N,n)                                                  \
1472     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1473                            vl_api_##n##_t_handler,              \
1474                            vl_noop_handler,                     \
1475                            vl_api_##n##_t_endian,               \
1476                            vl_api_##n##_t_print,                \
1477                            sizeof(vl_api_##n##_t), 1);
1478   foreach_session_api_msg;
1479 #undef _
1480
1481   /*
1482    * Messages which bounce off the data-plane to
1483    * an API client. Simply tells the message handling infra not
1484    * to free the message.
1485    *
1486    * Bounced message handlers MUST NOT block the data plane
1487    */
1488   am->message_bounce[VL_API_CONNECT_URI] = 1;
1489   am->message_bounce[VL_API_CONNECT_SOCK] = 1;
1490
1491   /*
1492    * Set up the (msg_name, crc, message-id) table
1493    */
1494   setup_message_id_table (am);
1495
1496   return 0;
1497 }
1498
1499 VLIB_API_INIT_FUNCTION (session_api_hookup);
1500
1501 /*
1502  * fd.io coding-style-patch-verification: ON
1503  *
1504  * Local Variables:
1505  * eval: (c-set-style "gnu")
1506  * End:
1507  */