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   else
 972     {
 973       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 974     }
 975
 976 done:
 977   REPLY_MACRO (VL_API_UNBIND_SOCK_REPLY);
 978
 979   if (!app)
 980     return;
 981
 982   app_wrk = application_get_worker (app, a->wrk_map_index);
 983   if (!app_wrk)
 984     return;
 985
 986   mq_send_unlisten_reply (app_wrk, mp->handle, mp->context, rv);
 987 }
 988
 989 /* ### WILL BE DEPRECATED POST 20.01 ### */
 990 static void
 991 vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp)
 992 {
 993   vl_api_connect_sock_reply_t *rmp;
 994   vnet_connect_args_t _a, *a = &_a;
 995   application_t *app = 0;
 996   int rv = 0;
 997
 998   if (session_main_is_enabled () == 0)
 999     {
1000       rv = VNET_API_ERROR_FEATURE_DISABLED;
1001       goto done;
1002     }
1003
1004   app = application_lookup (mp->client_index);
1005   if (app)
1006     {
1007       svm_queue_t *client_q;
1008       ip46_address_t *ip46 = (ip46_address_t *) mp->ip;
1009
1010       clib_memset (a, 0, sizeof (*a));
1011       client_q = vl_api_client_index_to_input_queue (mp->client_index);
1012       mp->client_queue_address = pointer_to_uword (client_q);
1013       a->sep.is_ip4 = mp->is_ip4;
1014       a->sep.ip = *ip46;
1015       a->sep.port = mp->port;
1016       a->sep.transport_proto = mp->proto;
1017       a->sep.peer.fib_index = mp->vrf;
1018       a->sep.peer.sw_if_index = ENDPOINT_INVALID_INDEX;
1019       a->sep_ext.parent_handle = mp->parent_handle;
1020       if (mp->hostname_len)
1021         {
1022           vec_validate (a->sep_ext.hostname, mp->hostname_len - 1);
1023           clib_memcpy_fast (a->sep_ext.hostname, mp->hostname,
1024                             mp->hostname_len);
1025         }
1026       a->api_context = mp->context;
1027       a->app_index = app->app_index;
1028       a->wrk_map_index = mp->wrk_index;
1029       if ((rv = vnet_connect (a)))
1030         clib_warning ("connect returned: %U", format_vnet_api_errno, rv);
1031       vec_free (a->sep_ext.hostname);
1032     }
1033   else
1034     {
1035       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1036     }
1037
1038   if (rv == 0)
1039     return;
1040
1041   /* Got some error, relay it */
1042
1043 done:
1044   REPLY_MACRO (VL_API_CONNECT_SOCK_REPLY);
1045
1046   if (app)
1047     {
1048       app_worker_t *app_wrk = application_get_worker (app, mp->wrk_index);
1049       mq_send_session_connected_cb (app_wrk->wrk_index, mp->context, 0, 1);
1050     }
1051 }
1052
1053 static void
1054 vl_api_app_worker_add_del_t_handler (vl_api_app_worker_add_del_t * mp)
1055 {
1056   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
1057   vl_api_app_worker_add_del_reply_t *rmp;
1058   vl_api_registration_t *reg;
1059   application_t *app;
1060   u8 fd_flags = 0;
1061
1062   if (!session_main_is_enabled ())
1063     {
1064       rv = VNET_API_ERROR_FEATURE_DISABLED;
1065       goto done;
1066     }
1067
1068   reg = vl_api_client_index_to_registration (mp->client_index);
1069   if (!reg)
1070     return;
1071
1072   app = application_get_if_valid (clib_net_to_host_u32 (mp->app_index));
1073   if (!app)
1074     {
1075       rv = VNET_API_ERROR_INVALID_VALUE;
1076       goto done;
1077     }
1078
1079   vnet_app_worker_add_del_args_t args = {
1080     .app_index = app->app_index,
1081     .wrk_map_index = clib_net_to_host_u32 (mp->wrk_index),
1082     .api_client_index = mp->client_index,
1083     .is_add = mp->is_add
1084   };
1085   rv = vnet_app_worker_add_del (&args);
1086   if (rv)
1087     {
1088       clib_warning ("app worker add/del returned: %d", rv);
1089       goto done;
1090     }
1091
1092   if (!mp->is_add)
1093     goto done;
1094
1095   /* Send fifo segment fd if needed */
1096   if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD)
1097     {
1098       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
1099       fds[n_fds] = args.segment->fd;
1100       n_fds += 1;
1101     }
1102   if (application_segment_manager_properties (app)->use_mq_eventfd)
1103     {
1104       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
1105       fds[n_fds] = svm_msg_q_get_producer_eventfd (args.evt_q);
1106       n_fds += 1;
1107     }
1108
1109   /* *INDENT-OFF* */
1110 done:
1111   REPLY_MACRO2 (VL_API_APP_WORKER_ADD_DEL_REPLY, ({
1112     rmp->is_add = mp->is_add;
1113     rmp->wrk_index = clib_host_to_net_u32 (args.wrk_map_index);
1114     rmp->segment_handle = clib_host_to_net_u64 (args.segment_handle);
1115     if (!rv && mp->is_add)
1116       {
1117         if (vec_len (args.segment->name))
1118           {
1119             memcpy (rmp->segment_name, args.segment->name,
1120                     vec_len (args.segment->name));
1121             rmp->segment_name_length = vec_len (args.segment->name);
1122           }
1123         rmp->app_event_queue_address = pointer_to_uword (args.evt_q);
1124         rmp->n_fds = n_fds;
1125         rmp->fd_flags = fd_flags;
1126       }
1127   }));
1128   /* *INDENT-ON* */
1129
1130   if (n_fds)
1131     session_send_fds (reg, fds, n_fds);
1132 }
1133
1134 static void
1135 vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp)
1136 {
1137   vl_api_app_namespace_add_del_reply_t *rmp;
1138   u32 appns_index = 0;
1139   u8 *ns_id = 0;
1140   int rv = 0;
1141   if (!session_main_is_enabled ())
1142     {
1143       rv = VNET_API_ERROR_FEATURE_DISABLED;
1144       goto done;
1145     }
1146
1147   if (mp->namespace_id_len > ARRAY_LEN (mp->namespace_id))
1148     {
1149       rv = VNET_API_ERROR_INVALID_VALUE;
1150       goto done;
1151     }
1152
1153   vec_validate (ns_id, mp->namespace_id_len - 1);
1154   clib_memcpy_fast (ns_id, mp->namespace_id, mp->namespace_id_len);
1155   vnet_app_namespace_add_del_args_t args = {
1156     .ns_id = ns_id,
1157     .secret = clib_net_to_host_u64 (mp->secret),
1158     .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index),
1159     .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id),
1160     .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id),
1161     .is_add = 1
1162   };
1163   rv = vnet_app_namespace_add_del (&args);
1164   if (!rv)
1165     {
1166       appns_index = app_namespace_index_from_id (ns_id);
1167       if (appns_index == APP_NAMESPACE_INVALID_INDEX)
1168         {
1169           clib_warning ("app ns lookup failed");
1170           rv = VNET_API_ERROR_UNSPECIFIED;
1171         }
1172     }
1173   vec_free (ns_id);
1174
1175   /* *INDENT-OFF* */
1176 done:
1177   REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({
1178     if (!rv)
1179       rmp->appns_index = clib_host_to_net_u32 (appns_index);
1180   }));
1181   /* *INDENT-ON* */
1182 }
1183
1184 static void
1185 vl_api_session_rule_add_del_t_handler (vl_api_session_rule_add_del_t * mp)
1186 {
1187   vl_api_session_rule_add_del_reply_t *rmp;
1188   session_rule_add_del_args_t args;
1189   session_rule_table_add_del_args_t *table_args = &args.table_args;
1190   u8 fib_proto;
1191   int rv = 0;
1192
1193   clib_memset (&args, 0, sizeof (args));
1194   fib_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
1195
1196   table_args->lcl.fp_len = mp->lcl_plen;
1197   table_args->lcl.fp_proto = fib_proto;
1198   table_args->rmt.fp_len = mp->rmt_plen;
1199   table_args->rmt.fp_proto = fib_proto;
1200   table_args->lcl_port = mp->lcl_port;
1201   table_args->rmt_port = mp->rmt_port;
1202   table_args->action_index = clib_net_to_host_u32 (mp->action_index);
1203   table_args->is_add = mp->is_add;
1204   mp->tag[sizeof (mp->tag) - 1] = 0;
1205   table_args->tag = format (0, "%s", mp->tag);
1206   args.appns_index = clib_net_to_host_u32 (mp->appns_index);
1207   args.scope = mp->scope;
1208   args.transport_proto = mp->transport_proto;
1209
1210   clib_memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr));
1211   clib_memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr));
1212   ip_set (&table_args->lcl.fp_addr, mp->lcl_ip, mp->is_ip4);
1213   ip_set (&table_args->rmt.fp_addr, mp->rmt_ip, mp->is_ip4);
1214   rv = vnet_session_rule_add_del (&args);
1215   if (rv)
1216     clib_warning ("rule add del returned: %d", rv);
1217   vec_free (table_args->tag);
1218   REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY);
1219 }
1220
1221 static void
1222 send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local,
1223                             u8 transport_proto, u32 appns_index, u8 * tag,
1224                             vl_api_registration_t * reg, u32 context)
1225 {
1226   vl_api_session_rules_details_t *rmp = 0;
1227   session_mask_or_match_4_t *match =
1228     (session_mask_or_match_4_t *) & rule->match;
1229   session_mask_or_match_4_t *mask =
1230     (session_mask_or_match_4_t *) & rule->mask;
1231
1232   rmp = vl_msg_api_alloc (sizeof (*rmp));
1233   clib_memset (rmp, 0, sizeof (*rmp));
1234   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1235   rmp->context = context;
1236
1237   rmp->is_ip4 = 1;
1238   clib_memcpy_fast (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1239   clib_memcpy_fast (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1240   rmp->lcl_plen = ip4_mask_to_preflen (&mask->lcl_ip);
1241   rmp->rmt_plen = ip4_mask_to_preflen (&mask->rmt_ip);
1242   rmp->lcl_port = match->lcl_port;
1243   rmp->rmt_port = match->rmt_port;
1244   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
1245   rmp->scope =
1246     is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
1247   rmp->transport_proto = transport_proto;
1248   rmp->appns_index = clib_host_to_net_u32 (appns_index);
1249   if (tag)
1250     {
1251       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
1252       rmp->tag[vec_len (tag)] = 0;
1253     }
1254
1255   vl_api_send_msg (reg, (u8 *) rmp);
1256 }
1257
1258 static void
1259 send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local,
1260                             u8 transport_proto, u32 appns_index, u8 * tag,
1261                             vl_api_registration_t * reg, u32 context)
1262 {
1263   vl_api_session_rules_details_t *rmp = 0;
1264   session_mask_or_match_6_t *match =
1265     (session_mask_or_match_6_t *) & rule->match;
1266   session_mask_or_match_6_t *mask =
1267     (session_mask_or_match_6_t *) & rule->mask;
1268
1269   rmp = vl_msg_api_alloc (sizeof (*rmp));
1270   clib_memset (rmp, 0, sizeof (*rmp));
1271   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1272   rmp->context = context;
1273
1274   rmp->is_ip4 = 0;
1275   clib_memcpy_fast (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1276   clib_memcpy_fast (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1277   rmp->lcl_plen = ip6_mask_to_preflen (&mask->lcl_ip);
1278   rmp->rmt_plen = ip6_mask_to_preflen (&mask->rmt_ip);
1279   rmp->lcl_port = match->lcl_port;
1280   rmp->rmt_port = match->rmt_port;
1281   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
1282   rmp->scope =
1283     is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
1284   rmp->transport_proto = transport_proto;
1285   rmp->appns_index = clib_host_to_net_u32 (appns_index);
1286   if (tag)
1287     {
1288       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
1289       rmp->tag[vec_len (tag)] = 0;
1290     }
1291
1292   vl_api_send_msg (reg, (u8 *) rmp);
1293 }
1294
1295 static void
1296 send_session_rules_table_details (session_rules_table_t * srt, u8 fib_proto,
1297                                   u8 tp, u8 is_local, u32 appns_index,
1298                                   vl_api_registration_t * reg, u32 context)
1299 {
1300   mma_rule_16_t *rule16;
1301   mma_rule_40_t *rule40;
1302   mma_rules_table_16_t *srt16;
1303   mma_rules_table_40_t *srt40;
1304   u32 ri;
1305
1306   if (is_local || fib_proto == FIB_PROTOCOL_IP4)
1307     {
1308       u8 *tag = 0;
1309       /* *INDENT-OFF* */
1310       srt16 = &srt->session_rules_tables_16;
1311       pool_foreach (rule16, srt16->rules, ({
1312         ri = mma_rules_table_rule_index_16 (srt16, rule16);
1313         tag = session_rules_table_rule_tag (srt, ri, 1);
1314         send_session_rule_details4 (rule16, is_local, tp, appns_index, tag,
1315                                     reg, context);
1316       }));
1317       /* *INDENT-ON* */
1318     }
1319   if (is_local || fib_proto == FIB_PROTOCOL_IP6)
1320     {
1321       u8 *tag = 0;
1322       /* *INDENT-OFF* */
1323       srt40 = &srt->session_rules_tables_40;
1324       pool_foreach (rule40, srt40->rules, ({
1325         ri = mma_rules_table_rule_index_40 (srt40, rule40);
1326         tag = session_rules_table_rule_tag (srt, ri, 1);
1327         send_session_rule_details6 (rule40, is_local, tp, appns_index, tag,
1328                                     reg, context);
1329       }));
1330       /* *INDENT-ON* */
1331     }
1332 }
1333
1334 static void
1335 vl_api_session_rules_dump_t_handler (vl_api_one_map_server_dump_t * mp)
1336 {
1337   vl_api_registration_t *reg;
1338   session_table_t *st;
1339   u8 tp;
1340
1341   reg = vl_api_client_index_to_registration (mp->client_index);
1342   if (!reg)
1343     return;
1344
1345   /* *INDENT-OFF* */
1346   session_table_foreach (st, ({
1347     for (tp = 0; tp < TRANSPORT_N_PROTO; tp++)
1348       {
1349         send_session_rules_table_details (&st->session_rules[tp],
1350                                           st->active_fib_proto, tp,
1351                                           st->is_local, st->appns_index, reg,
1352                                           mp->context);
1353       }
1354   }));
1355   /* *INDENT-ON* */
1356 }
1357
1358 static void
1359 vl_api_application_tls_cert_add_t_handler (vl_api_application_tls_cert_add_t *
1360                                            mp)
1361 {
1362   vl_api_app_namespace_add_del_reply_t *rmp;
1363   vnet_app_add_tls_cert_args_t _a, *a = &_a;
1364   clib_error_t *error;
1365   application_t *app;
1366   u32 cert_len;
1367   int rv = 0;
1368   if (!session_main_is_enabled ())
1369     {
1370       rv = VNET_API_ERROR_FEATURE_DISABLED;
1371       goto done;
1372     }
1373   if (!(app = application_lookup (mp->client_index)))
1374     {
1375       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1376       goto done;
1377     }
1378   clib_memset (a, 0, sizeof (*a));
1379   a->app_index = app->app_index;
1380   cert_len = clib_net_to_host_u16 (mp->cert_len);
1381   if (cert_len > 10000)
1382     {
1383       rv = VNET_API_ERROR_INVALID_VALUE;
1384       goto done;
1385     }
1386   vec_validate (a->cert, cert_len);
1387   clib_memcpy_fast (a->cert, mp->cert, cert_len);
1388   if ((error = vnet_app_add_tls_cert (a)))
1389     {
1390       rv = clib_error_get_code (error);
1391       clib_error_report (error);
1392     }
1393   vec_free (a->cert);
1394 done:
1395   REPLY_MACRO (VL_API_APPLICATION_TLS_CERT_ADD_REPLY);
1396 }
1397
1398 static void
1399 vl_api_application_tls_key_add_t_handler (vl_api_application_tls_key_add_t *
1400                                           mp)
1401 {
1402   vl_api_app_namespace_add_del_reply_t *rmp;
1403   vnet_app_add_tls_key_args_t _a, *a = &_a;
1404   clib_error_t *error;
1405   application_t *app;
1406   u32 key_len;
1407   int rv = 0;
1408   if (!session_main_is_enabled ())
1409     {
1410       rv = VNET_API_ERROR_FEATURE_DISABLED;
1411       goto done;
1412     }
1413   if (!(app = application_lookup (mp->client_index)))
1414     {
1415       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1416       goto done;
1417     }
1418   clib_memset (a, 0, sizeof (*a));
1419   a->app_index = app->app_index;
1420   key_len = clib_net_to_host_u16 (mp->key_len);
1421   if (key_len > 10000)
1422     {
1423       rv = VNET_API_ERROR_INVALID_VALUE;
1424       goto done;
1425     }
1426   vec_validate (a->key, key_len);
1427   clib_memcpy_fast (a->key, mp->key, key_len);
1428   if ((error = vnet_app_add_tls_key (a)))
1429     {
1430       rv = clib_error_get_code (error);
1431       clib_error_report (error);
1432     }
1433   vec_free (a->key);
1434 done:
1435   REPLY_MACRO (VL_API_APPLICATION_TLS_KEY_ADD_REPLY);
1436 }
1437
1438 static clib_error_t *
1439 application_reaper_cb (u32 client_index)
1440 {
1441   application_t *app = application_lookup (client_index);
1442   vnet_app_detach_args_t _a, *a = &_a;
1443   if (app)
1444     {
1445       a->app_index = app->app_index;
1446       a->api_client_index = client_index;
1447       vnet_application_detach (a);
1448     }
1449   return 0;
1450 }
1451
1452 VL_MSG_API_REAPER_FUNCTION (application_reaper_cb);
1453
1454 #define vl_msg_name_crc_list
1455 #include <vnet/vnet_all_api_h.h>
1456 #undef vl_msg_name_crc_list
1457
1458 static void
1459 setup_message_id_table (api_main_t * am)
1460 {
1461 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1462   foreach_vl_msg_name_crc_session;
1463 #undef _
1464 }
1465
1466 /*
1467  * session_api_hookup
1468  * Add uri's API message handlers to the table.
1469  * vlib has already mapped shared memory and
1470  * added the client registration handlers.
1471  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
1472  */
1473 static clib_error_t *
1474 session_api_hookup (vlib_main_t * vm)
1475 {
1476   api_main_t *am = &api_main;
1477
1478 #define _(N,n)                                                  \
1479     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1480                            vl_api_##n##_t_handler,              \
1481                            vl_noop_handler,                     \
1482                            vl_api_##n##_t_endian,               \
1483                            vl_api_##n##_t_print,                \
1484                            sizeof(vl_api_##n##_t), 1);
1485   foreach_session_api_msg;
1486 #undef _
1487
1488   /*
1489    * Messages which bounce off the data-plane to
1490    * an API client. Simply tells the message handling infra not
1491    * to free the message.
1492    *
1493    * Bounced message handlers MUST NOT block the data plane
1494    */
1495   am->message_bounce[VL_API_CONNECT_URI] = 1;
1496   am->message_bounce[VL_API_CONNECT_SOCK] = 1;
1497
1498   /*
1499    * Set up the (msg_name, crc, message-id) table
1500    */
1501   setup_message_id_table (am);
1502
1503   return 0;
1504 }
1505
1506 VLIB_API_INIT_FUNCTION (session_api_hookup);
1507
1508 /*
1509  * fd.io coding-style-patch-verification: ON
1510  *
1511  * Local Variables:
1512  * eval: (c-set-style "gnu")
1513  * End:
1514  */