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