src/vnet/session/session_api.c

   1 /*
   2  * Copyright (c) 2015-2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/vnet.h>
  17 #include <vlibmemory/api.h>
  18 #include <vnet/session/application.h>
  19 #include <vnet/session/application_interface.h>
  20 #include <vnet/session/application_local.h>
  21 #include <vnet/session/session_rules_table.h>
  22 #include <vnet/session/session_table.h>
  23 #include <vnet/session/session.h>
  24
  25 #include <vnet/ip/ip_types_api.h>
  26
  27 #include <vnet/vnet_msg_enum.h>
  28
  29 #define vl_typedefs             /* define message structures */
  30 #include <vnet/vnet_all_api_h.h>
  31 #undef vl_typedefs
  32
  33 #define vl_endianfun            /* define message structures */
  34 #include <vnet/vnet_all_api_h.h>
  35 #undef vl_endianfun
  36
  37 /* instantiate all the print functions we know about */
  38 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  39 #define vl_printfun
  40 #include <vnet/vnet_all_api_h.h>
  41 #undef vl_printfun
  42
  43 #include <vlibapi/api_helper_macros.h>
  44
  45 #define foreach_session_api_msg                                         \
  46 _(APP_ATTACH, app_attach)                                               \
  47 _(APPLICATION_DETACH, application_detach)                               \
  48 _(SESSION_ENABLE_DISABLE, session_enable_disable)                       \
  49 _(APP_NAMESPACE_ADD_DEL, app_namespace_add_del)                         \
  50 _(SESSION_RULE_ADD_DEL, session_rule_add_del)                           \
  51 _(SESSION_RULES_DUMP, session_rules_dump)                               \
  52 _(APP_ADD_CERT_KEY_PAIR, app_add_cert_key_pair)                         \
  53 _(APP_DEL_CERT_KEY_PAIR, app_del_cert_key_pair)                         \
  54 _(APP_WORKER_ADD_DEL, app_worker_add_del)                               \
  55
  56 static transport_proto_t
  57 api_session_transport_proto_decode (const vl_api_transport_proto_t * api_tp)
  58 {
  59   switch (*api_tp)
  60     {
  61     case TRANSPORT_PROTO_API_TCP:
  62       return TRANSPORT_PROTO_TCP;
  63     case TRANSPORT_PROTO_API_UDP:
  64       return TRANSPORT_PROTO_UDP;
  65     case TRANSPORT_PROTO_API_TLS:
  66       return TRANSPORT_PROTO_TLS;
  67     case TRANSPORT_PROTO_API_QUIC:
  68       return TRANSPORT_PROTO_QUIC;
  69     default:
  70       return TRANSPORT_PROTO_NONE;
  71     }
  72 }
  73
  74 static vl_api_transport_proto_t
  75 api_session_transport_proto_encode (const transport_proto_t tp)
  76 {
  77   switch (tp)
  78     {
  79     case TRANSPORT_PROTO_TCP:
  80       return TRANSPORT_PROTO_API_TCP;
  81     case TRANSPORT_PROTO_UDP:
  82       return TRANSPORT_PROTO_API_UDP;
  83     case TRANSPORT_PROTO_TLS:
  84       return TRANSPORT_PROTO_API_TLS;
  85     case TRANSPORT_PROTO_QUIC:
  86       return TRANSPORT_PROTO_API_QUIC;
  87     default:
  88       return TRANSPORT_PROTO_API_NONE;
  89     }
  90 }
  91
  92 static int
  93 session_send_fds (vl_api_registration_t * reg, int fds[], int n_fds)
  94 {
  95   clib_error_t *error;
  96   if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
  97     return SESSION_E_BAPI_NO_FD;
  98   error = vl_api_send_fd_msg (reg, fds, n_fds);
  99   if (error)
 100     {
 101       clib_error_report (error);
 102       return SESSION_E_BAPI_SEND_FD;
 103     }
 104   return 0;
 105 }
 106
 107 static int
 108 mq_try_lock_and_alloc_msg (svm_msg_q_t * app_mq, svm_msg_q_msg_t * msg)
 109 {
 110   int rv;
 111   u8 try = 0;
 112   while (try < 100)
 113     {
 114       rv = svm_msg_q_lock_and_alloc_msg_w_ring (app_mq,
 115                                                 SESSION_MQ_CTRL_EVT_RING,
 116                                                 SVM_Q_NOWAIT, msg);
 117       if (!rv)
 118         return 0;
 119       try++;
 120       usleep (1);
 121     }
 122   clib_warning ("failed to alloc msg");
 123   return -1;
 124 }
 125
 126 static int
 127 mq_send_session_accepted_cb (session_t * s)
 128 {
 129   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 130   svm_msg_q_msg_t _msg, *msg = &_msg;
 131   session_accepted_msg_t m = { 0 };
 132   svm_msg_q_t *app_mq;
 133   fifo_segment_t *eq_seg;
 134   session_t *listener;
 135   session_event_t *evt;
 136   application_t *app;
 137
 138   app = application_get (app_wrk->app_index);
 139
 140   m.context = app->app_index;
 141   m.server_rx_fifo = fifo_segment_fifo_offset (s->rx_fifo);
 142   m.server_tx_fifo = fifo_segment_fifo_offset (s->tx_fifo);
 143   m.segment_handle = session_segment_handle (s);
 144   m.flags = s->flags;
 145
 146   eq_seg = session_main_get_evt_q_segment ();
 147
 148   if (session_has_transport (s))
 149     {
 150       listener = listen_session_get_from_handle (s->listener_handle);
 151       m.listener_handle = app_listen_session_handle (listener);
 152       if (application_is_proxy (app))
 153         {
 154           listener =
 155             app_worker_first_listener (app_wrk, session_get_fib_proto (s),
 156                                        session_get_transport_proto (s));
 157           if (listener)
 158             m.listener_handle = listen_session_get_handle (listener);
 159         }
 160       m.vpp_event_queue_address =
 161         fifo_segment_msg_q_offset (eq_seg, s->thread_index);
 162       m.mq_index = s->thread_index;
 163       m.handle = session_handle (s);
 164
 165       session_get_endpoint (s, &m.rmt, 0 /* is_lcl */);
 166     }
 167   else
 168     {
 169       ct_connection_t *ct;
 170
 171       ct = (ct_connection_t *) session_get_transport (s);
 172       listener = listen_session_get_from_handle (s->listener_handle);
 173       m.listener_handle = app_listen_session_handle (listener);
 174       m.rmt.is_ip4 = session_type_is_ip4 (listener->session_type);
 175       m.rmt.port = ct->c_rmt_port;
 176       m.handle = session_handle (s);
 177       m.vpp_event_queue_address =
 178         fifo_segment_msg_q_offset (eq_seg, s->thread_index);
 179       m.mq_index = s->thread_index;
 180     }
 181
 182   app_mq = app_wrk->event_queue;
 183   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 184     return SESSION_E_MQ_MSG_ALLOC;
 185
 186   evt = svm_msg_q_msg_data (app_mq, msg);
 187   clib_memset (evt, 0, sizeof (*evt));
 188   evt->event_type = SESSION_CTRL_EVT_ACCEPTED;
 189   clib_memcpy_fast (evt->data, &m, sizeof (m));
 190   svm_msg_q_add_and_unlock (app_mq, msg);
 191
 192   return 0;
 193 }
 194
 195 static inline void
 196 mq_send_session_close_evt (app_worker_t * app_wrk, session_handle_t sh,
 197                            session_evt_type_t evt_type)
 198 {
 199   svm_msg_q_msg_t _msg, *msg = &_msg;
 200   session_disconnected_msg_t *mp;
 201   svm_msg_q_t *app_mq;
 202   session_event_t *evt;
 203
 204   app_mq = app_wrk->event_queue;
 205   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 206     return;
 207   evt = svm_msg_q_msg_data (app_mq, msg);
 208   clib_memset (evt, 0, sizeof (*evt));
 209   evt->event_type = evt_type;
 210   mp = (session_disconnected_msg_t *) evt->data;
 211   mp->handle = sh;
 212   mp->context = app_wrk->api_client_index;
 213   svm_msg_q_add_and_unlock (app_mq, msg);
 214 }
 215
 216 static inline void
 217 mq_notify_close_subscribers (u32 app_index, session_handle_t sh,
 218                              svm_fifo_t * f, session_evt_type_t evt_type)
 219 {
 220   app_worker_t *app_wrk;
 221   application_t *app;
 222   int i;
 223
 224   app = application_get (app_index);
 225   if (!app)
 226     return;
 227
 228   for (i = 0; i < f->shr->n_subscribers; i++)
 229     {
 230       if (!(app_wrk = application_get_worker (app, f->shr->subscribers[i])))
 231         continue;
 232       mq_send_session_close_evt (app_wrk, sh, SESSION_CTRL_EVT_DISCONNECTED);
 233     }
 234 }
 235
 236 static void
 237 mq_send_session_disconnected_cb (session_t * s)
 238 {
 239   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 240   session_handle_t sh = session_handle (s);
 241
 242   mq_send_session_close_evt (app_wrk, session_handle (s),
 243                              SESSION_CTRL_EVT_DISCONNECTED);
 244
 245   if (svm_fifo_n_subscribers (s->rx_fifo))
 246     mq_notify_close_subscribers (app_wrk->app_index, sh, s->rx_fifo,
 247                                  SESSION_CTRL_EVT_DISCONNECTED);
 248 }
 249
 250 static void
 251 mq_send_session_reset_cb (session_t * s)
 252 {
 253   app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
 254   session_handle_t sh = session_handle (s);
 255
 256   mq_send_session_close_evt (app_wrk, sh, SESSION_CTRL_EVT_RESET);
 257
 258   if (svm_fifo_n_subscribers (s->rx_fifo))
 259     mq_notify_close_subscribers (app_wrk->app_index, sh, s->rx_fifo,
 260                                  SESSION_CTRL_EVT_RESET);
 261 }
 262
 263 int
 264 mq_send_session_connected_cb (u32 app_wrk_index, u32 api_context,
 265                               session_t * s, session_error_t err)
 266 {
 267   svm_msg_q_msg_t _msg, *msg = &_msg;
 268   session_connected_msg_t m = { 0 };
 269   svm_msg_q_t *app_mq;
 270   transport_connection_t *tc;
 271   fifo_segment_t *eq_seg;
 272   app_worker_t *app_wrk;
 273   session_event_t *evt;
 274
 275   m.context = api_context;
 276   m.retval = err;
 277
 278   if (err)
 279     goto snd_msg;
 280
 281   eq_seg = session_main_get_evt_q_segment ();
 282
 283   if (session_has_transport (s))
 284     {
 285       tc = session_get_transport (s);
 286       if (!tc)
 287         {
 288           clib_warning ("failed to retrieve transport!");
 289           m.retval = SESSION_E_REFUSED;
 290           goto snd_msg;
 291         }
 292
 293       m.handle = session_handle (s);
 294       m.vpp_event_queue_address =
 295         fifo_segment_msg_q_offset (eq_seg, s->thread_index);
 296
 297       session_get_endpoint (s, &m.lcl, 1 /* is_lcl */);
 298
 299       m.server_rx_fifo = fifo_segment_fifo_offset (s->rx_fifo);
 300       m.server_tx_fifo = fifo_segment_fifo_offset (s->tx_fifo);
 301       m.segment_handle = session_segment_handle (s);
 302     }
 303   else
 304     {
 305       ct_connection_t *cct;
 306       session_t *ss;
 307
 308       cct = (ct_connection_t *) session_get_transport (s);
 309       m.handle = session_handle (s);
 310       m.lcl.port = cct->c_lcl_port;
 311       m.lcl.is_ip4 = cct->c_is_ip4;
 312       m.vpp_event_queue_address =
 313         fifo_segment_msg_q_offset (eq_seg, s->thread_index);
 314       m.server_rx_fifo = fifo_segment_fifo_offset (s->rx_fifo);
 315       m.server_tx_fifo = fifo_segment_fifo_offset (s->tx_fifo);
 316       m.segment_handle = session_segment_handle (s);
 317       ss = ct_session_get_peer (s);
 318       m.ct_rx_fifo = fifo_segment_fifo_offset (ss->tx_fifo);
 319       m.ct_tx_fifo = fifo_segment_fifo_offset (ss->rx_fifo);
 320       m.ct_segment_handle = session_segment_handle (ss);
 321     }
 322
 323 snd_msg:
 324
 325   app_wrk = app_worker_get (app_wrk_index);
 326   app_mq = app_wrk->event_queue;
 327
 328   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 329     return SESSION_E_MQ_MSG_ALLOC;
 330
 331   evt = svm_msg_q_msg_data (app_mq, msg);
 332   clib_memset (evt, 0, sizeof (*evt));
 333   evt->event_type = SESSION_CTRL_EVT_CONNECTED;
 334   clib_memcpy_fast (evt->data, &m, sizeof (m));
 335
 336   svm_msg_q_add_and_unlock (app_mq, msg);
 337   return 0;
 338 }
 339
 340 int
 341 mq_send_session_bound_cb (u32 app_wrk_index, u32 api_context,
 342                           session_handle_t handle, int rv)
 343 {
 344   svm_msg_q_msg_t _msg, *msg = &_msg;
 345   session_bound_msg_t m = { 0 };
 346   svm_msg_q_t *app_mq;
 347   transport_endpoint_t tep;
 348   fifo_segment_t *eq_seg;
 349   app_worker_t *app_wrk;
 350   session_event_t *evt;
 351   app_listener_t *al;
 352   session_t *ls = 0;
 353
 354   m.context = api_context;
 355   m.retval = rv;
 356
 357   if (rv)
 358     goto snd_msg;
 359
 360   m.handle = handle;
 361   al = app_listener_get_w_handle (handle);
 362   if (al->session_index != SESSION_INVALID_INDEX)
 363     ls = app_listener_get_session (al);
 364   else
 365     ls = app_listener_get_local_session (al);
 366
 367   session_get_endpoint (ls, &tep, 1 /* is_lcl */);
 368   m.lcl_port = tep.port;
 369   m.lcl_is_ip4 = tep.is_ip4;
 370   clib_memcpy_fast (m.lcl_ip, &tep.ip, sizeof (tep.ip));
 371
 372   eq_seg = session_main_get_evt_q_segment ();
 373   m.vpp_evt_q = fifo_segment_msg_q_offset (eq_seg, ls->thread_index);
 374
 375   if (session_transport_service_type (ls) == TRANSPORT_SERVICE_CL &&
 376       ls->rx_fifo)
 377     {
 378       m.rx_fifo = fifo_segment_fifo_offset (ls->rx_fifo);
 379       m.tx_fifo = fifo_segment_fifo_offset (ls->tx_fifo);
 380       m.segment_handle = session_segment_handle (ls);
 381     }
 382
 383 snd_msg:
 384
 385   app_wrk = app_worker_get (app_wrk_index);
 386   app_mq = app_wrk->event_queue;
 387
 388   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 389     return SESSION_E_MQ_MSG_ALLOC;
 390
 391   evt = svm_msg_q_msg_data (app_mq, msg);
 392   clib_memset (evt, 0, sizeof (*evt));
 393   evt->event_type = SESSION_CTRL_EVT_BOUND;
 394   clib_memcpy_fast (evt->data, &m, sizeof (m));
 395
 396   svm_msg_q_add_and_unlock (app_mq, msg);
 397   return 0;
 398 }
 399
 400 void
 401 mq_send_unlisten_reply (app_worker_t * app_wrk, session_handle_t sh,
 402                         u32 context, int rv)
 403 {
 404   svm_msg_q_msg_t _msg, *msg = &_msg;
 405   session_unlisten_reply_msg_t *ump;
 406   svm_msg_q_t *app_mq;
 407   session_event_t *evt;
 408
 409   app_mq = app_wrk->event_queue;
 410   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 411     return;
 412
 413   evt = svm_msg_q_msg_data (app_mq, msg);
 414   clib_memset (evt, 0, sizeof (*evt));
 415   evt->event_type = SESSION_CTRL_EVT_UNLISTEN_REPLY;
 416   ump = (session_unlisten_reply_msg_t *) evt->data;
 417   ump->context = context;
 418   ump->handle = sh;
 419   ump->retval = rv;
 420   svm_msg_q_add_and_unlock (app_mq, msg);
 421 }
 422
 423 static void
 424 mq_send_session_migrate_cb (session_t * s, session_handle_t new_sh)
 425 {
 426   svm_msg_q_msg_t _msg, *msg = &_msg;
 427   session_migrated_msg_t m = { 0 };
 428   fifo_segment_t *eq_seg;
 429   app_worker_t *app_wrk;
 430   session_event_t *evt;
 431   svm_msg_q_t *app_mq;
 432   u32 thread_index;
 433
 434   thread_index = session_thread_from_handle (new_sh);
 435   eq_seg = session_main_get_evt_q_segment ();
 436
 437   m.handle = session_handle (s);
 438   m.new_handle = new_sh;
 439   m.vpp_thread_index = thread_index;
 440   m.vpp_evt_q = fifo_segment_msg_q_offset (eq_seg, thread_index);
 441   m.segment_handle = SESSION_INVALID_HANDLE;
 442
 443   app_wrk = app_worker_get (s->app_wrk_index);
 444   app_mq = app_wrk->event_queue;
 445   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 446     return;
 447
 448   evt = svm_msg_q_msg_data (app_mq, msg);
 449   clib_memset (evt, 0, sizeof (*evt));
 450   evt->event_type = SESSION_CTRL_EVT_MIGRATED;
 451   clib_memcpy_fast (evt->data, &m, sizeof (m));
 452
 453   svm_msg_q_add_and_unlock (app_mq, msg);
 454 }
 455
 456 static int
 457 mq_send_add_segment_cb (u32 app_wrk_index, u64 segment_handle)
 458 {
 459   int fds[SESSION_N_FD_TYPE], n_fds = 0;
 460   svm_msg_q_msg_t _msg, *msg = &_msg;
 461   session_app_add_segment_msg_t *mp;
 462   vl_api_registration_t *reg;
 463   app_worker_t *app_wrk;
 464   session_event_t *evt;
 465   svm_msg_q_t *app_mq;
 466   fifo_segment_t *fs;
 467   ssvm_private_t *sp;
 468   u8 fd_flags = 0;
 469
 470   app_wrk = app_worker_get (app_wrk_index);
 471
 472   reg = vl_mem_api_client_index_to_registration (app_wrk->api_client_index);
 473   if (!reg)
 474     {
 475       clib_warning ("no api registration for client: %u",
 476                     app_wrk->api_client_index);
 477       return -1;
 478     }
 479
 480   fs = segment_manager_get_segment_w_handle (segment_handle);
 481   sp = &fs->ssvm;
 482   if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD)
 483     {
 484       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 485         {
 486           clib_warning ("can't send memfd fd");
 487           return -1;
 488         }
 489
 490       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 491       fds[n_fds] = sp->fd;
 492       n_fds += 1;
 493     }
 494
 495   app_mq = app_wrk->event_queue;
 496   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 497     return -1;
 498
 499   if (n_fds)
 500     session_send_fds (reg, fds, n_fds);
 501
 502   evt = svm_msg_q_msg_data (app_mq, msg);
 503   clib_memset (evt, 0, sizeof (*evt));
 504   evt->event_type = SESSION_CTRL_EVT_APP_ADD_SEGMENT;
 505   mp = (session_app_add_segment_msg_t *) evt->data;
 506   clib_memset (mp, 0, sizeof (*mp));
 507   mp->segment_size = sp->ssvm_size;
 508   mp->fd_flags = fd_flags;
 509   mp->segment_handle = segment_handle;
 510   strncpy ((char *) mp->segment_name, (char *) sp->name,
 511            sizeof (mp->segment_name) - 1);
 512
 513   svm_msg_q_add_and_unlock (app_mq, msg);
 514
 515   return 0;
 516 }
 517
 518 static int
 519 mq_send_del_segment_cb (u32 app_wrk_index, u64 segment_handle)
 520 {
 521   svm_msg_q_msg_t _msg, *msg = &_msg;
 522   session_app_del_segment_msg_t *mp;
 523   vl_api_registration_t *reg;
 524   app_worker_t *app_wrk;
 525   session_event_t *evt;
 526   svm_msg_q_t *app_mq;
 527
 528   app_wrk = app_worker_get (app_wrk_index);
 529   reg = vl_mem_api_client_index_to_registration (app_wrk->api_client_index);
 530   if (!reg)
 531     {
 532       clib_warning ("no registration: %u", app_wrk->api_client_index);
 533       return -1;
 534     }
 535
 536   app_mq = app_wrk->event_queue;
 537   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 538     return -1;
 539
 540   evt = svm_msg_q_msg_data (app_mq, msg);
 541   clib_memset (evt, 0, sizeof (*evt));
 542   evt->event_type = SESSION_CTRL_EVT_APP_DEL_SEGMENT;
 543   mp = (session_app_del_segment_msg_t *) evt->data;
 544   clib_memset (mp, 0, sizeof (*mp));
 545   mp->segment_handle = segment_handle;
 546   svm_msg_q_add_and_unlock (app_mq, msg);
 547
 548   return 0;
 549 }
 550
 551 static void
 552 mq_send_session_cleanup_cb (session_t * s, session_cleanup_ntf_t ntf)
 553 {
 554   svm_msg_q_msg_t _msg, *msg = &_msg;
 555   session_cleanup_msg_t *mp;
 556   svm_msg_q_t *app_mq;
 557   session_event_t *evt;
 558   app_worker_t *app_wrk;
 559
 560   /* Propagate transport cleanup notifications only if app didn't close */
 561   if (ntf == SESSION_CLEANUP_TRANSPORT
 562       && s->session_state != SESSION_STATE_TRANSPORT_DELETED)
 563     return;
 564
 565   app_wrk = app_worker_get_if_valid (s->app_wrk_index);
 566   if (!app_wrk)
 567     return;
 568
 569   app_mq = app_wrk->event_queue;
 570   if (mq_try_lock_and_alloc_msg (app_mq, msg))
 571     return;
 572
 573   evt = svm_msg_q_msg_data (app_mq, msg);
 574   clib_memset (evt, 0, sizeof (*evt));
 575   evt->event_type = SESSION_CTRL_EVT_CLEANUP;
 576   mp = (session_cleanup_msg_t *) evt->data;
 577   mp->handle = session_handle (s);
 578   mp->type = ntf;
 579   svm_msg_q_add_and_unlock (app_mq, msg);
 580 }
 581
 582 static session_cb_vft_t session_mq_cb_vft = {
 583   .session_accept_callback = mq_send_session_accepted_cb,
 584   .session_disconnect_callback = mq_send_session_disconnected_cb,
 585   .session_connected_callback = mq_send_session_connected_cb,
 586   .session_reset_callback = mq_send_session_reset_cb,
 587   .session_migrate_callback = mq_send_session_migrate_cb,
 588   .session_cleanup_callback = mq_send_session_cleanup_cb,
 589   .add_segment_callback = mq_send_add_segment_cb,
 590   .del_segment_callback = mq_send_del_segment_cb,
 591 };
 592
 593 static void
 594 vl_api_session_enable_disable_t_handler (vl_api_session_enable_disable_t * mp)
 595 {
 596   vl_api_session_enable_disable_reply_t *rmp;
 597   vlib_main_t *vm = vlib_get_main ();
 598   int rv = 0;
 599
 600   vnet_session_enable_disable (vm, mp->is_enable);
 601   REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY);
 602 }
 603
 604 static void
 605 vl_api_app_attach_t_handler (vl_api_app_attach_t * mp)
 606 {
 607   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
 608   vl_api_app_attach_reply_t *rmp;
 609   fifo_segment_t *segp, *evt_q_segment = 0;
 610   vnet_app_attach_args_t _a, *a = &_a;
 611   u8 fd_flags = 0, ctrl_thread;
 612   vl_api_registration_t *reg;
 613
 614   reg = vl_api_client_index_to_registration (mp->client_index);
 615   if (!reg)
 616     return;
 617
 618   if (!session_main_is_enabled () || appns_sapi_enabled ())
 619     {
 620       rv = VNET_API_ERROR_FEATURE_DISABLED;
 621       goto done;
 622     }
 623   /* Only support binary api with socket transport */
 624   if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 625     {
 626       rv = VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 627       goto done;
 628     }
 629
 630   STATIC_ASSERT (sizeof (u64) * APP_OPTIONS_N_OPTIONS <=
 631                  sizeof (mp->options),
 632                  "Out of options, fix api message definition");
 633
 634   clib_memset (a, 0, sizeof (*a));
 635   a->api_client_index = mp->client_index;
 636   a->options = mp->options;
 637   a->session_cb_vft = &session_mq_cb_vft;
 638   a->namespace_id = vl_api_from_api_to_new_vec (mp, &mp->namespace_id);
 639
 640   if ((rv = vnet_application_attach (a)))
 641     {
 642       clib_warning ("attach returned: %d", rv);
 643       vec_free (a->namespace_id);
 644       goto done;
 645     }
 646   vec_free (a->namespace_id);
 647
 648   /* Send event queues segment */
 649   if ((evt_q_segment = session_main_get_evt_q_segment ()))
 650     {
 651       fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
 652       fds[n_fds] = evt_q_segment->ssvm.fd;
 653       n_fds += 1;
 654     }
 655   /* Send fifo segment fd if needed */
 656   if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
 657     {
 658       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 659       fds[n_fds] = a->segment->fd;
 660       n_fds += 1;
 661     }
 662   if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 663     {
 664       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
 665       fds[n_fds] = svm_msg_q_get_eventfd (a->app_evt_q);
 666       n_fds += 1;
 667     }
 668
 669 done:
 670   /* *INDENT-OFF* */
 671   REPLY_MACRO2 (VL_API_APP_ATTACH_REPLY, ({
 672     if (!rv)
 673       {
 674         ctrl_thread = vlib_num_workers () ? 1 : 0;
 675         segp = (fifo_segment_t *) a->segment;
 676         rmp->app_index = clib_host_to_net_u32 (a->app_index);
 677         rmp->app_mq = fifo_segment_msg_q_offset (segp, 0);
 678         rmp->vpp_ctrl_mq =
 679           fifo_segment_msg_q_offset (evt_q_segment, ctrl_thread);
 680         rmp->vpp_ctrl_mq_thread = ctrl_thread;
 681         rmp->n_fds = n_fds;
 682         rmp->fd_flags = fd_flags;
 683         if (vec_len (segp->ssvm.name))
 684           {
 685             vl_api_vec_to_api_string (segp->ssvm.name, &rmp->segment_name);
 686           }
 687         rmp->segment_size = segp->ssvm.ssvm_size;
 688         rmp->segment_handle = clib_host_to_net_u64 (a->segment_handle);
 689       }
 690   }));
 691   /* *INDENT-ON* */
 692
 693   if (n_fds)
 694     session_send_fds (reg, fds, n_fds);
 695 }
 696
 697 static void
 698 vl_api_app_worker_add_del_t_handler (vl_api_app_worker_add_del_t * mp)
 699 {
 700   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
 701   vl_api_app_worker_add_del_reply_t *rmp;
 702   vl_api_registration_t *reg;
 703   application_t *app;
 704   u8 fd_flags = 0;
 705
 706   if (!session_main_is_enabled () || appns_sapi_enabled ())
 707     {
 708       rv = VNET_API_ERROR_FEATURE_DISABLED;
 709       goto done;
 710     }
 711
 712   reg = vl_api_client_index_to_registration (mp->client_index);
 713   if (!reg)
 714     return;
 715
 716   app = application_get_if_valid (clib_net_to_host_u32 (mp->app_index));
 717   if (!app)
 718     {
 719       rv = VNET_API_ERROR_INVALID_VALUE;
 720       goto done;
 721     }
 722
 723   vnet_app_worker_add_del_args_t args = {
 724     .app_index = app->app_index,
 725     .wrk_map_index = clib_net_to_host_u32 (mp->wrk_index),
 726     .api_client_index = mp->client_index,
 727     .is_add = mp->is_add
 728   };
 729   rv = vnet_app_worker_add_del (&args);
 730   if (rv)
 731     {
 732       clib_warning ("app worker add/del returned: %d", rv);
 733       goto done;
 734     }
 735
 736   if (!mp->is_add)
 737     goto done;
 738
 739   /* Send fifo segment fd if needed */
 740   if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD)
 741     {
 742       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
 743       fds[n_fds] = args.segment->fd;
 744       n_fds += 1;
 745     }
 746   if (application_segment_manager_properties (app)->use_mq_eventfd)
 747     {
 748       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
 749       fds[n_fds] = svm_msg_q_get_eventfd (args.evt_q);
 750       n_fds += 1;
 751     }
 752
 753   /* *INDENT-OFF* */
 754 done:
 755   REPLY_MACRO2 (VL_API_APP_WORKER_ADD_DEL_REPLY, ({
 756     rmp->is_add = mp->is_add;
 757     rmp->wrk_index = clib_host_to_net_u32 (args.wrk_map_index);
 758     rmp->segment_handle = clib_host_to_net_u64 (args.segment_handle);
 759     if (!rv && mp->is_add)
 760       {
 761         rmp->app_event_queue_address =
 762           fifo_segment_msg_q_offset ((fifo_segment_t *) args.segment, 0);
 763         rmp->n_fds = n_fds;
 764         rmp->fd_flags = fd_flags;
 765         if (vec_len (args.segment->name))
 766           {
 767             vl_api_vec_to_api_string (args.segment->name, &rmp->segment_name);
 768           }
 769       }
 770   }));
 771   /* *INDENT-ON* */
 772
 773   if (n_fds)
 774     session_send_fds (reg, fds, n_fds);
 775 }
 776
 777 static void
 778 vl_api_application_detach_t_handler (vl_api_application_detach_t * mp)
 779 {
 780   vl_api_application_detach_reply_t *rmp;
 781   int rv = VNET_API_ERROR_INVALID_VALUE_2;
 782   vnet_app_detach_args_t _a, *a = &_a;
 783   application_t *app;
 784
 785   if (!session_main_is_enabled () || appns_sapi_enabled ())
 786     {
 787       rv = VNET_API_ERROR_FEATURE_DISABLED;
 788       goto done;
 789     }
 790
 791   app = application_lookup (mp->client_index);
 792   if (app)
 793     {
 794       a->app_index = app->app_index;
 795       a->api_client_index = mp->client_index;
 796       rv = vnet_application_detach (a);
 797     }
 798
 799 done:
 800   REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY);
 801 }
 802
 803 static void
 804 vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp)
 805 {
 806   vl_api_app_namespace_add_del_reply_t *rmp;
 807   u32 appns_index = 0;
 808   u8 *ns_id = 0;
 809   int rv = 0;
 810   if (session_main_is_enabled () == 0)
 811     {
 812       rv = VNET_API_ERROR_FEATURE_DISABLED;
 813       goto done;
 814     }
 815
 816   ns_id = vl_api_from_api_to_new_vec (mp, &mp->namespace_id);
 817
 818   vnet_app_namespace_add_del_args_t args = {
 819     .ns_id = ns_id,
 820     .secret = clib_net_to_host_u64 (mp->secret),
 821     .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index),
 822     .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id),
 823     .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id),
 824     .is_add = 1
 825   };
 826   rv = vnet_app_namespace_add_del (&args);
 827   if (!rv)
 828     {
 829       appns_index = app_namespace_index_from_id (ns_id);
 830       if (appns_index == APP_NAMESPACE_INVALID_INDEX)
 831         {
 832           clib_warning ("app ns lookup failed");
 833           rv = VNET_API_ERROR_UNSPECIFIED;
 834         }
 835     }
 836   vec_free (ns_id);
 837
 838   /* *INDENT-OFF* */
 839 done:
 840   REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({
 841     if (!rv)
 842       rmp->appns_index = clib_host_to_net_u32 (appns_index);
 843   }));
 844   /* *INDENT-ON* */
 845 }
 846
 847 static void
 848 vl_api_session_rule_add_del_t_handler (vl_api_session_rule_add_del_t * mp)
 849 {
 850   vl_api_session_rule_add_del_reply_t *rmp;
 851   session_rule_add_del_args_t args;
 852   session_rule_table_add_del_args_t *table_args = &args.table_args;
 853   int rv = 0;
 854
 855   clib_memset (&args, 0, sizeof (args));
 856
 857   ip_prefix_decode (&mp->lcl, &table_args->lcl);
 858   ip_prefix_decode (&mp->rmt, &table_args->rmt);
 859
 860   table_args->lcl_port = mp->lcl_port;
 861   table_args->rmt_port = mp->rmt_port;
 862   table_args->action_index = clib_net_to_host_u32 (mp->action_index);
 863   table_args->is_add = mp->is_add;
 864   mp->tag[sizeof (mp->tag) - 1] = 0;
 865   table_args->tag = format (0, "%s", mp->tag);
 866   args.appns_index = clib_net_to_host_u32 (mp->appns_index);
 867   args.scope = mp->scope;
 868   args.transport_proto =
 869     api_session_transport_proto_decode (&mp->transport_proto) ==
 870     TRANSPORT_PROTO_UDP ? 1 : 0;
 871
 872   rv = vnet_session_rule_add_del (&args);
 873   if (rv)
 874     clib_warning ("rule add del returned: %d", rv);
 875   vec_free (table_args->tag);
 876   REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY);
 877 }
 878
 879 static void
 880 send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local,
 881                             u8 transport_proto, u32 appns_index, u8 * tag,
 882                             vl_api_registration_t * reg, u32 context)
 883 {
 884   vl_api_session_rules_details_t *rmp = 0;
 885   session_mask_or_match_4_t *match =
 886     (session_mask_or_match_4_t *) & rule->match;
 887   session_mask_or_match_4_t *mask =
 888     (session_mask_or_match_4_t *) & rule->mask;
 889   fib_prefix_t lcl, rmt;
 890
 891   rmp = vl_msg_api_alloc (sizeof (*rmp));
 892   clib_memset (rmp, 0, sizeof (*rmp));
 893   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
 894   rmp->context = context;
 895
 896   clib_memset (&lcl, 0, sizeof (lcl));
 897   clib_memset (&rmt, 0, sizeof (rmt));
 898   ip_set (&lcl.fp_addr, &match->lcl_ip, 1);
 899   ip_set (&rmt.fp_addr, &match->rmt_ip, 1);
 900   lcl.fp_len = ip4_mask_to_preflen (&mask->lcl_ip);
 901   rmt.fp_len = ip4_mask_to_preflen (&mask->rmt_ip);
 902
 903   ip_prefix_encode (&lcl, &rmp->lcl);
 904   ip_prefix_encode (&rmt, &rmp->rmt);
 905   rmp->lcl_port = match->lcl_port;
 906   rmp->rmt_port = match->rmt_port;
 907   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
 908   rmp->scope =
 909     is_local ? SESSION_RULE_SCOPE_API_LOCAL : SESSION_RULE_SCOPE_API_GLOBAL;
 910   rmp->transport_proto = api_session_transport_proto_encode (transport_proto);
 911   rmp->appns_index = clib_host_to_net_u32 (appns_index);
 912   if (tag)
 913     {
 914       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
 915       rmp->tag[vec_len (tag)] = 0;
 916     }
 917
 918   vl_api_send_msg (reg, (u8 *) rmp);
 919 }
 920
 921 static void
 922 send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local,
 923                             u8 transport_proto, u32 appns_index, u8 * tag,
 924                             vl_api_registration_t * reg, u32 context)
 925 {
 926   vl_api_session_rules_details_t *rmp = 0;
 927   session_mask_or_match_6_t *match =
 928     (session_mask_or_match_6_t *) & rule->match;
 929   session_mask_or_match_6_t *mask =
 930     (session_mask_or_match_6_t *) & rule->mask;
 931   fib_prefix_t lcl, rmt;
 932
 933   rmp = vl_msg_api_alloc (sizeof (*rmp));
 934   clib_memset (rmp, 0, sizeof (*rmp));
 935   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
 936   rmp->context = context;
 937
 938   clib_memset (&lcl, 0, sizeof (lcl));
 939   clib_memset (&rmt, 0, sizeof (rmt));
 940   ip_set (&lcl.fp_addr, &match->lcl_ip, 0);
 941   ip_set (&rmt.fp_addr, &match->rmt_ip, 0);
 942   lcl.fp_len = ip6_mask_to_preflen (&mask->lcl_ip);
 943   rmt.fp_len = ip6_mask_to_preflen (&mask->rmt_ip);
 944
 945   ip_prefix_encode (&lcl, &rmp->lcl);
 946   ip_prefix_encode (&rmt, &rmp->rmt);
 947   rmp->lcl_port = match->lcl_port;
 948   rmp->rmt_port = match->rmt_port;
 949   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
 950   rmp->scope =
 951     is_local ? SESSION_RULE_SCOPE_API_LOCAL : SESSION_RULE_SCOPE_API_GLOBAL;
 952   rmp->transport_proto = api_session_transport_proto_encode (transport_proto);
 953   rmp->appns_index = clib_host_to_net_u32 (appns_index);
 954   if (tag)
 955     {
 956       clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
 957       rmp->tag[vec_len (tag)] = 0;
 958     }
 959
 960   vl_api_send_msg (reg, (u8 *) rmp);
 961 }
 962
 963 static void
 964 send_session_rules_table_details (session_rules_table_t * srt, u8 fib_proto,
 965                                   u8 tp, u8 is_local, u32 appns_index,
 966                                   vl_api_registration_t * reg, u32 context)
 967 {
 968   mma_rule_16_t *rule16;
 969   mma_rule_40_t *rule40;
 970   mma_rules_table_16_t *srt16;
 971   mma_rules_table_40_t *srt40;
 972   u32 ri;
 973
 974   if (is_local || fib_proto == FIB_PROTOCOL_IP4)
 975     {
 976       u8 *tag = 0;
 977       /* *INDENT-OFF* */
 978       srt16 = &srt->session_rules_tables_16;
 979       pool_foreach (rule16, srt16->rules)  {
 980         ri = mma_rules_table_rule_index_16 (srt16, rule16);
 981         tag = session_rules_table_rule_tag (srt, ri, 1);
 982         send_session_rule_details4 (rule16, is_local, tp, appns_index, tag,
 983                                     reg, context);
 984       }
 985       /* *INDENT-ON* */
 986     }
 987   if (is_local || fib_proto == FIB_PROTOCOL_IP6)
 988     {
 989       u8 *tag = 0;
 990       /* *INDENT-OFF* */
 991       srt40 = &srt->session_rules_tables_40;
 992       pool_foreach (rule40, srt40->rules)  {
 993         ri = mma_rules_table_rule_index_40 (srt40, rule40);
 994         tag = session_rules_table_rule_tag (srt, ri, 1);
 995         send_session_rule_details6 (rule40, is_local, tp, appns_index, tag,
 996                                     reg, context);
 997       }
 998       /* *INDENT-ON* */
 999     }
1000 }
1001
1002 static void
1003 vl_api_session_rules_dump_t_handler (vl_api_session_rules_dump_t * mp)
1004 {
1005   vl_api_registration_t *reg;
1006   session_table_t *st;
1007   u8 tp;
1008
1009   reg = vl_api_client_index_to_registration (mp->client_index);
1010   if (!reg)
1011     return;
1012
1013   /* *INDENT-OFF* */
1014   session_table_foreach (st, ({
1015     for (tp = 0; tp < TRANSPORT_N_PROTOS; tp++)
1016       {
1017         send_session_rules_table_details (&st->session_rules[tp],
1018                                           st->active_fib_proto, tp,
1019                                           st->is_local, st->appns_index, reg,
1020                                           mp->context);
1021       }
1022   }));
1023   /* *INDENT-ON* */
1024 }
1025
1026 static void
1027 vl_api_app_add_cert_key_pair_t_handler (vl_api_app_add_cert_key_pair_t * mp)
1028 {
1029   vl_api_app_add_cert_key_pair_reply_t *rmp;
1030   vnet_app_add_cert_key_pair_args_t _a, *a = &_a;
1031   u32 certkey_len, key_len, cert_len;
1032   int rv = 0;
1033   if (session_main_is_enabled () == 0)
1034     {
1035       rv = VNET_API_ERROR_FEATURE_DISABLED;
1036       goto done;
1037     }
1038
1039   cert_len = clib_net_to_host_u16 (mp->cert_len);
1040   if (cert_len > 10000)
1041     {
1042       rv = VNET_API_ERROR_INVALID_VALUE;
1043       goto done;
1044     }
1045
1046   certkey_len = clib_net_to_host_u16 (mp->certkey_len);
1047   if (certkey_len < cert_len)
1048     {
1049       rv = VNET_API_ERROR_INVALID_VALUE;
1050       goto done;
1051     }
1052
1053   key_len = certkey_len - cert_len;
1054   if (key_len > 10000)
1055     {
1056       rv = VNET_API_ERROR_INVALID_VALUE;
1057       goto done;
1058     }
1059
1060   clib_memset (a, 0, sizeof (*a));
1061   a->cert = mp->certkey;
1062   a->key = mp->certkey + cert_len;
1063   a->cert_len = cert_len;
1064   a->key_len = key_len;
1065   rv = vnet_app_add_cert_key_pair (a);
1066
1067 done:
1068   /* *INDENT-OFF* */
1069   REPLY_MACRO2 (VL_API_APP_ADD_CERT_KEY_PAIR_REPLY, ({
1070     if (!rv)
1071       rmp->index = clib_host_to_net_u32 (a->index);
1072   }));
1073   /* *INDENT-ON* */
1074 }
1075
1076 static void
1077 vl_api_app_del_cert_key_pair_t_handler (vl_api_app_del_cert_key_pair_t * mp)
1078 {
1079   vl_api_app_del_cert_key_pair_reply_t *rmp;
1080   u32 ckpair_index;
1081   int rv = 0;
1082   if (session_main_is_enabled () == 0)
1083     {
1084       rv = VNET_API_ERROR_FEATURE_DISABLED;
1085       goto done;
1086     }
1087   ckpair_index = clib_net_to_host_u32 (mp->index);
1088   rv = vnet_app_del_cert_key_pair (ckpair_index);
1089
1090 done:
1091   REPLY_MACRO (VL_API_APP_DEL_CERT_KEY_PAIR_REPLY);
1092 }
1093
1094 static clib_error_t *
1095 application_reaper_cb (u32 client_index)
1096 {
1097   application_t *app = application_lookup (client_index);
1098   vnet_app_detach_args_t _a, *a = &_a;
1099   if (app)
1100     {
1101       a->app_index = app->app_index;
1102       a->api_client_index = client_index;
1103       vnet_application_detach (a);
1104     }
1105   return 0;
1106 }
1107
1108 VL_MSG_API_REAPER_FUNCTION (application_reaper_cb);
1109
1110 #define vl_msg_name_crc_list
1111 #include <vnet/vnet_all_api_h.h>
1112 #undef vl_msg_name_crc_list
1113
1114 static void
1115 setup_message_id_table (api_main_t * am)
1116 {
1117 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1118   foreach_vl_msg_name_crc_session;
1119 #undef _
1120 }
1121
1122 /*
1123  * session_api_hookup
1124  * Add uri's API message handlers to the table.
1125  * vlib has already mapped shared memory and
1126  * added the client registration handlers.
1127  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
1128  */
1129 static clib_error_t *
1130 session_api_hookup (vlib_main_t * vm)
1131 {
1132   api_main_t *am = vlibapi_get_main ();
1133
1134 #define _(N,n)                                                  \
1135     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1136                            vl_api_##n##_t_handler,              \
1137                            vl_noop_handler,                     \
1138                            vl_api_##n##_t_endian,               \
1139                            vl_api_##n##_t_print,                \
1140                            sizeof(vl_api_##n##_t), 1);
1141   foreach_session_api_msg;
1142 #undef _
1143
1144   /*
1145    * Set up the (msg_name, crc, message-id) table
1146    */
1147   setup_message_id_table (am);
1148
1149   return 0;
1150 }
1151
1152 VLIB_API_INIT_FUNCTION (session_api_hookup);
1153
1154 /*
1155  * Socket api functions
1156  */
1157
1158 static void
1159 sapi_send_fds (app_worker_t * app_wrk, int *fds, int n_fds)
1160 {
1161   app_sapi_msg_t smsg = { 0 };
1162   app_namespace_t *app_ns;
1163   application_t *app;
1164   clib_socket_t *cs;
1165   u32 cs_index;
1166
1167   app = application_get (app_wrk->app_index);
1168   app_ns = app_namespace_get (app->ns_index);
1169   cs_index = appns_sapi_handle_sock_index (app_wrk->api_client_index);
1170   cs = appns_sapi_get_socket (app_ns, cs_index);
1171   if (PREDICT_FALSE (!cs))
1172     return;
1173
1174   /* There's no payload for the message only the type */
1175   smsg.type = APP_SAPI_MSG_TYPE_SEND_FDS;
1176   clib_socket_sendmsg (cs, &smsg, sizeof (smsg), fds, n_fds);
1177 }
1178
1179 static int
1180 mq_send_add_segment_sapi_cb (u32 app_wrk_index, u64 segment_handle)
1181 {
1182   int fds[SESSION_N_FD_TYPE], n_fds = 0;
1183   svm_msg_q_msg_t _msg, *msg = &_msg;
1184   session_app_add_segment_msg_t *mp;
1185   app_worker_t *app_wrk;
1186   session_event_t *evt;
1187   svm_msg_q_t *app_mq;
1188   fifo_segment_t *fs;
1189   ssvm_private_t *sp;
1190   u8 fd_flags = 0;
1191
1192   app_wrk = app_worker_get (app_wrk_index);
1193
1194   fs = segment_manager_get_segment_w_handle (segment_handle);
1195   sp = &fs->ssvm;
1196   ASSERT (ssvm_type (sp) == SSVM_SEGMENT_MEMFD);
1197
1198   fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
1199   fds[n_fds] = sp->fd;
1200   n_fds += 1;
1201
1202   app_mq = app_wrk->event_queue;
1203   if (mq_try_lock_and_alloc_msg (app_mq, msg))
1204     return -1;
1205
1206   /*
1207    * Send the fd over api socket
1208    */
1209   sapi_send_fds (app_wrk, fds, n_fds);
1210
1211   /*
1212    * Send the actual message over mq
1213    */
1214   evt = svm_msg_q_msg_data (app_mq, msg);
1215   clib_memset (evt, 0, sizeof (*evt));
1216   evt->event_type = SESSION_CTRL_EVT_APP_ADD_SEGMENT;
1217   mp = (session_app_add_segment_msg_t *) evt->data;
1218   clib_memset (mp, 0, sizeof (*mp));
1219   mp->segment_size = sp->ssvm_size;
1220   mp->fd_flags = fd_flags;
1221   mp->segment_handle = segment_handle;
1222   strncpy ((char *) mp->segment_name, (char *) sp->name,
1223            sizeof (mp->segment_name) - 1);
1224
1225   svm_msg_q_add_and_unlock (app_mq, msg);
1226
1227   return 0;
1228 }
1229
1230 static int
1231 mq_send_del_segment_sapi_cb (u32 app_wrk_index, u64 segment_handle)
1232 {
1233   svm_msg_q_msg_t _msg, *msg = &_msg;
1234   session_app_del_segment_msg_t *mp;
1235   app_worker_t *app_wrk;
1236   session_event_t *evt;
1237   svm_msg_q_t *app_mq;
1238
1239   app_wrk = app_worker_get (app_wrk_index);
1240
1241   app_mq = app_wrk->event_queue;
1242   if (mq_try_lock_and_alloc_msg (app_mq, msg))
1243     return -1;
1244
1245   evt = svm_msg_q_msg_data (app_mq, msg);
1246   clib_memset (evt, 0, sizeof (*evt));
1247   evt->event_type = SESSION_CTRL_EVT_APP_DEL_SEGMENT;
1248   mp = (session_app_del_segment_msg_t *) evt->data;
1249   clib_memset (mp, 0, sizeof (*mp));
1250   mp->segment_handle = segment_handle;
1251   svm_msg_q_add_and_unlock (app_mq, msg);
1252
1253   return 0;
1254 }
1255
1256 static session_cb_vft_t session_mq_sapi_cb_vft = {
1257   .session_accept_callback = mq_send_session_accepted_cb,
1258   .session_disconnect_callback = mq_send_session_disconnected_cb,
1259   .session_connected_callback = mq_send_session_connected_cb,
1260   .session_reset_callback = mq_send_session_reset_cb,
1261   .session_migrate_callback = mq_send_session_migrate_cb,
1262   .session_cleanup_callback = mq_send_session_cleanup_cb,
1263   .add_segment_callback = mq_send_add_segment_sapi_cb,
1264   .del_segment_callback = mq_send_del_segment_sapi_cb,
1265 };
1266
1267 static void
1268 session_api_attach_handler (app_namespace_t * app_ns, clib_socket_t * cs,
1269                             app_sapi_attach_msg_t * mp)
1270 {
1271   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
1272   vnet_app_attach_args_t _a, *a = &_a;
1273   app_sapi_attach_reply_msg_t *rmp;
1274   fifo_segment_t *evt_q_segment;
1275   u8 fd_flags = 0, ctrl_thread;
1276   app_ns_api_handle_t *handle;
1277   app_sapi_msg_t msg = { 0 };
1278   app_worker_t *app_wrk;
1279   application_t *app;
1280
1281   /* Make sure name is null terminated */
1282   mp->name[63] = 0;
1283
1284   clib_memset (a, 0, sizeof (*a));
1285   a->api_client_index = appns_sapi_socket_handle (app_ns, cs);
1286   a->name = format (0, "%s", (char *) mp->name);
1287   a->options = mp->options;
1288   a->session_cb_vft = &session_mq_sapi_cb_vft;
1289   a->use_sock_api = 1;
1290   a->options[APP_OPTIONS_NAMESPACE] = app_namespace_index (app_ns);
1291
1292   if ((rv = vnet_application_attach (a)))
1293     {
1294       clib_warning ("attach returned: %d", rv);
1295       goto done;
1296     }
1297
1298   /* Send event queues segment */
1299   if ((evt_q_segment = session_main_get_evt_q_segment ()))
1300     {
1301       fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
1302       fds[n_fds] = evt_q_segment->ssvm.fd;
1303       n_fds += 1;
1304     }
1305   /* Send fifo segment fd if needed */
1306   if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
1307     {
1308       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
1309       fds[n_fds] = a->segment->fd;
1310       n_fds += 1;
1311     }
1312   if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
1313     {
1314       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
1315       fds[n_fds] = svm_msg_q_get_eventfd (a->app_evt_q);
1316       n_fds += 1;
1317     }
1318
1319 done:
1320
1321   msg.type = APP_SAPI_MSG_TYPE_ATTACH_REPLY;
1322   rmp = &msg.attach_reply;
1323   rmp->retval = rv;
1324   if (!rv)
1325     {
1326       ctrl_thread = vlib_num_workers ()? 1 : 0;
1327       rmp->app_index = a->app_index;
1328       rmp->app_mq =
1329         fifo_segment_msg_q_offset ((fifo_segment_t *) a->segment, 0);
1330       rmp->vpp_ctrl_mq =
1331         fifo_segment_msg_q_offset (evt_q_segment, ctrl_thread);
1332       rmp->vpp_ctrl_mq_thread = ctrl_thread;
1333       rmp->n_fds = n_fds;
1334       rmp->fd_flags = fd_flags;
1335       /* No segment name and size since we only support memfds
1336        * in this configuration */
1337       rmp->segment_handle = a->segment_handle;
1338       rmp->api_client_handle = a->api_client_index;
1339
1340       /* Update app index for socket */
1341       handle = (app_ns_api_handle_t *) & cs->private_data;
1342       app = application_get (a->app_index);
1343       app_wrk = application_get_worker (app, 0);
1344       handle->aah_app_wrk_index = app_wrk->wrk_index;
1345     }
1346
1347   clib_socket_sendmsg (cs, &msg, sizeof (msg), fds, n_fds);
1348   vec_free (a->name);
1349 }
1350
1351 static void
1352 sapi_socket_close_w_handle (u32 api_handle)
1353 {
1354   app_namespace_t *app_ns = app_namespace_get (api_handle >> 16);
1355   u16 sock_index = api_handle & 0xffff;
1356   app_ns_api_handle_t *handle;
1357   clib_socket_t *cs;
1358   clib_file_t *cf;
1359
1360   cs = appns_sapi_get_socket (app_ns, sock_index);
1361   if (!cs)
1362     return;
1363
1364   handle = (app_ns_api_handle_t *) & cs->private_data;
1365   cf = clib_file_get (&file_main, handle->aah_file_index);
1366   clib_file_del (&file_main, cf);
1367
1368   clib_socket_close (cs);
1369   appns_sapi_free_socket (app_ns, cs);
1370 }
1371
1372 static void
1373 sapi_add_del_worker_handler (app_namespace_t * app_ns,
1374                              clib_socket_t * cs,
1375                              app_sapi_worker_add_del_msg_t * mp)
1376 {
1377   int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
1378   app_sapi_worker_add_del_reply_msg_t *rmp;
1379   app_ns_api_handle_t *handle;
1380   app_sapi_msg_t msg = { 0 };
1381   app_worker_t *app_wrk;
1382   u32 sapi_handle = -1;
1383   application_t *app;
1384   u8 fd_flags = 0;
1385
1386   app = application_get_if_valid (mp->app_index);
1387   if (!app)
1388     {
1389       rv = VNET_API_ERROR_INVALID_VALUE;
1390       goto done;
1391     }
1392
1393   sapi_handle = appns_sapi_socket_handle (app_ns, cs);
1394
1395   vnet_app_worker_add_del_args_t args = {
1396     .app_index = app->app_index,
1397     .wrk_map_index = mp->wrk_index,
1398     .api_client_index = sapi_handle,
1399     .is_add = mp->is_add
1400   };
1401   rv = vnet_app_worker_add_del (&args);
1402   if (rv)
1403     {
1404       clib_warning ("app worker add/del returned: %d", rv);
1405       goto done;
1406     }
1407
1408   if (!mp->is_add)
1409     {
1410       sapi_socket_close_w_handle (sapi_handle);
1411       goto done;
1412     }
1413
1414   /* Send fifo segment fd if needed */
1415   if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD)
1416     {
1417       fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
1418       fds[n_fds] = args.segment->fd;
1419       n_fds += 1;
1420     }
1421   if (application_segment_manager_properties (app)->use_mq_eventfd)
1422     {
1423       fd_flags |= SESSION_FD_F_MQ_EVENTFD;
1424       fds[n_fds] = svm_msg_q_get_eventfd (args.evt_q);
1425       n_fds += 1;
1426     }
1427
1428 done:
1429
1430   msg.type = APP_SAPI_MSG_TYPE_ADD_DEL_WORKER_REPLY;
1431   rmp = &msg.worker_add_del_reply;
1432   rmp->retval = rv;
1433   rmp->is_add = mp->is_add;
1434   rmp->api_client_handle = sapi_handle;
1435   rmp->wrk_index = args.wrk_map_index;
1436   rmp->segment_handle = args.segment_handle;
1437   if (!rv && mp->is_add)
1438     {
1439       /* No segment name and size. This supports only memfds */
1440       rmp->app_event_queue_address =
1441         fifo_segment_msg_q_offset ((fifo_segment_t *) args.segment, 0);
1442       rmp->n_fds = n_fds;
1443       rmp->fd_flags = fd_flags;
1444
1445       /* Update app index for socket */
1446       handle = (app_ns_api_handle_t *) & cs->private_data;
1447       app_wrk = application_get_worker (app, args.wrk_map_index);
1448       handle->aah_app_wrk_index = app_wrk->wrk_index;
1449     }
1450
1451   clib_socket_sendmsg (cs, &msg, sizeof (msg), fds, n_fds);
1452 }
1453
1454 static void
1455 sapi_socket_detach (app_namespace_t * app_ns, clib_socket_t * cs)
1456 {
1457   app_ns_api_handle_t *handle;
1458   app_worker_t *app_wrk;
1459   u32 api_client_handle;
1460
1461   api_client_handle = appns_sapi_socket_handle (app_ns, cs);
1462   sapi_socket_close_w_handle (api_client_handle);
1463
1464   /* Cleanup everything because app worker closed socket or crashed */
1465   handle = (app_ns_api_handle_t *) & cs->private_data;
1466   app_wrk = app_worker_get (handle->aah_app_wrk_index);
1467
1468   vnet_app_worker_add_del_args_t args = {
1469     .app_index = app_wrk->app_index,
1470     .wrk_map_index = app_wrk->wrk_map_index,
1471     .api_client_index = api_client_handle,
1472     .is_add = 0
1473   };
1474   /* Send rpc to main thread for worker barrier */
1475   vlib_rpc_call_main_thread (vnet_app_worker_add_del, (u8 *) & args,
1476                              sizeof (args));
1477 }
1478
1479 static clib_error_t *
1480 sapi_sock_read_ready (clib_file_t * cf)
1481 {
1482   app_ns_api_handle_t *handle = (app_ns_api_handle_t *) & cf->private_data;
1483   vlib_main_t *vm = vlib_get_main ();
1484   app_sapi_msg_t msg = { 0 };
1485   app_namespace_t *app_ns;
1486   clib_error_t *err = 0;
1487   clib_socket_t *cs;
1488
1489   app_ns = app_namespace_get (handle->aah_app_ns_index);
1490   cs = appns_sapi_get_socket (app_ns, handle->aah_sock_index);
1491   if (!cs)
1492     goto error;
1493
1494   err = clib_socket_recvmsg (cs, &msg, sizeof (msg), 0, 0);
1495   if (err)
1496     {
1497       clib_error_free (err);
1498       sapi_socket_detach (app_ns, cs);
1499       goto error;
1500     }
1501
1502   handle = (app_ns_api_handle_t *) & cs->private_data;
1503
1504   vlib_worker_thread_barrier_sync (vm);
1505
1506   switch (msg.type)
1507     {
1508     case APP_SAPI_MSG_TYPE_ATTACH:
1509       session_api_attach_handler (app_ns, cs, &msg.attach);
1510       break;
1511     case APP_SAPI_MSG_TYPE_ADD_DEL_WORKER:
1512       sapi_add_del_worker_handler (app_ns, cs, &msg.worker_add_del);
1513       break;
1514     default:
1515       clib_warning ("app wrk %u unknown message type: %u",
1516                     handle->aah_app_wrk_index, msg.type);
1517       break;
1518     }
1519
1520   vlib_worker_thread_barrier_release (vm);
1521
1522 error:
1523   return 0;
1524 }
1525
1526 static clib_error_t *
1527 sapi_sock_write_ready (clib_file_t * cf)
1528 {
1529   app_ns_api_handle_t *handle = (app_ns_api_handle_t *) & cf->private_data;
1530   clib_warning ("called for app ns %u", handle->aah_app_ns_index);
1531   return 0;
1532 }
1533
1534 static clib_error_t *
1535 sapi_sock_error (clib_file_t * cf)
1536 {
1537   app_ns_api_handle_t *handle = (app_ns_api_handle_t *) & cf->private_data;
1538   app_namespace_t *app_ns;
1539   clib_socket_t *cs;
1540
1541   app_ns = app_namespace_get (handle->aah_app_ns_index);
1542   cs = appns_sapi_get_socket (app_ns, handle->aah_sock_index);
1543   if (!cs)
1544     return 0;
1545
1546   sapi_socket_detach (app_ns, cs);
1547   return 0;
1548 }
1549
1550 static clib_error_t *
1551 sapi_sock_accept_ready (clib_file_t * scf)
1552 {
1553   app_ns_api_handle_t handle = *(app_ns_api_handle_t *) & scf->private_data;
1554   app_namespace_t *app_ns;
1555   clib_file_t cf = { 0 };
1556   clib_error_t *err = 0;
1557   clib_socket_t *ccs, *scs;
1558
1559   /* Listener files point to namespace */
1560   app_ns = app_namespace_get (handle.aah_app_ns_index);
1561
1562   /*
1563    * Initialize client socket
1564    */
1565   ccs = appns_sapi_alloc_socket (app_ns);
1566
1567   /* Grab server socket after client is initialized  */
1568   scs = appns_sapi_get_socket (app_ns, handle.aah_sock_index);
1569   if (!scs)
1570     goto error;
1571
1572   err = clib_socket_accept (scs, ccs);
1573   if (err)
1574     {
1575       clib_error_report (err);
1576       goto error;
1577     }
1578
1579   cf.read_function = sapi_sock_read_ready;
1580   cf.write_function = sapi_sock_write_ready;
1581   cf.error_function = sapi_sock_error;
1582   cf.file_descriptor = ccs->fd;
1583   /* File points to app namespace and socket */
1584   handle.aah_sock_index = appns_sapi_socket_index (app_ns, ccs);
1585   cf.private_data = handle.as_u64;
1586   cf.description = format (0, "app sock conn fd: %d", ccs->fd);
1587
1588   /* Poll until we get an attach message. Socket points to file and
1589    * application that owns the socket */
1590   handle.aah_app_wrk_index = APP_INVALID_INDEX;
1591   handle.aah_file_index = clib_file_add (&file_main, &cf);
1592   ccs->private_data = handle.as_u64;
1593
1594   return err;
1595
1596 error:
1597   appns_sapi_free_socket (app_ns, ccs);
1598   return err;
1599 }
1600
1601 int
1602 appns_sapi_add_ns_socket (app_namespace_t * app_ns)
1603 {
1604   char *subdir = "/app_ns_sockets/";
1605   app_ns_api_handle_t *handle;
1606   clib_file_t cf = { 0 };
1607   struct stat file_stat;
1608   clib_error_t *err;
1609   clib_socket_t *cs;
1610   u8 *dir = 0;
1611   int rv = 0;
1612
1613   vec_add (dir, vlib_unix_get_runtime_dir (),
1614            strlen (vlib_unix_get_runtime_dir ()));
1615   vec_add (dir, (u8 *) subdir, strlen (subdir));
1616
1617   err = vlib_unix_recursive_mkdir ((char *) dir);
1618   if (err)
1619     {
1620       clib_error_report (err);
1621       rv = -1;
1622       goto error;
1623     }
1624
1625   app_ns->sock_name = format (0, "%v%v%c", dir, app_ns->ns_id, 0);
1626
1627   /*
1628    * Create and initialize socket to listen on
1629    */
1630   cs = appns_sapi_alloc_socket (app_ns);
1631   cs->config = (char *) app_ns->sock_name;
1632   cs->flags = CLIB_SOCKET_F_IS_SERVER |
1633     CLIB_SOCKET_F_ALLOW_GROUP_WRITE |
1634     CLIB_SOCKET_F_SEQPACKET | CLIB_SOCKET_F_PASSCRED;
1635
1636   if ((err = clib_socket_init (cs)))
1637     {
1638       clib_error_report (err);
1639       rv = -1;
1640       goto error;
1641     }
1642
1643   if (stat ((char *) app_ns->sock_name, &file_stat) == -1)
1644     {
1645       rv = -1;
1646       goto error;
1647     }
1648
1649   /*
1650    * Start polling it
1651    */
1652   cf.read_function = sapi_sock_accept_ready;
1653   cf.file_descriptor = cs->fd;
1654   /* File points to namespace */
1655   handle = (app_ns_api_handle_t *) & cf.private_data;
1656   handle->aah_app_ns_index = app_namespace_index (app_ns);
1657   handle->aah_sock_index = appns_sapi_socket_index (app_ns, cs);
1658   cf.description = format (0, "app sock listener: %s", app_ns->sock_name);
1659
1660   /* Socket points to clib file index */
1661   handle = (app_ns_api_handle_t *) & cs->private_data;
1662   handle->aah_file_index = clib_file_add (&file_main, &cf);
1663   handle->aah_app_wrk_index = APP_INVALID_INDEX;
1664
1665 error:
1666   vec_free (dir);
1667   return rv;
1668 }
1669
1670 /*
1671  * fd.io coding-style-patch-verification: ON
1672  *
1673  * Local Variables:
1674  * eval: (c-set-style "gnu")
1675  * End:
1676  */