src/vcl/vppcom.c

   1 /*
   2  * Copyright (c) 2017-2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this
   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 <stdio.h>
  17 #include <stdlib.h>
  18 #include <vcl/vppcom.h>
  19 #include <vcl/vcl_debug.h>
  20 #include <vcl/vcl_private.h>
  21 #include <svm/fifo_segment.h>
  22
  23 __thread uword __vcl_worker_index = ~0;
  24
  25 static inline int
  26 vcl_mq_dequeue_batch (vcl_worker_t * wrk, svm_msg_q_t * mq, u32 n_max_msg)
  27 {
  28   u32 n_msgs = 0, sz, len;
  29
  30   while ((sz = svm_msg_q_size (mq)))
  31     {
  32       len = vec_len (wrk->mq_msg_vector);
  33       vec_validate (wrk->mq_msg_vector, len + sz - 1);
  34       svm_msg_q_sub_raw_batch (mq, wrk->mq_msg_vector + len, sz);
  35       n_msgs += sz;
  36     }
  37   return n_msgs;
  38 }
  39
  40 const char *
  41 vppcom_session_state_str (vcl_session_state_t state)
  42 {
  43   char *st;
  44
  45   switch (state)
  46     {
  47     case VCL_STATE_CLOSED:
  48       st = "STATE_CLOSED";
  49       break;
  50     case VCL_STATE_LISTEN:
  51       st = "STATE_LISTEN";
  52       break;
  53     case VCL_STATE_READY:
  54       st = "STATE_READY";
  55       break;
  56     case VCL_STATE_VPP_CLOSING:
  57       st = "STATE_VPP_CLOSING";
  58       break;
  59     case VCL_STATE_DISCONNECT:
  60       st = "STATE_DISCONNECT";
  61       break;
  62     case VCL_STATE_DETACHED:
  63       st = "STATE_DETACHED";
  64       break;
  65     case VCL_STATE_UPDATED:
  66       st = "STATE_UPDATED";
  67       break;
  68     case VCL_STATE_LISTEN_NO_MQ:
  69       st = "STATE_LISTEN_NO_MQ";
  70       break;
  71     default:
  72       st = "UNKNOWN_STATE";
  73       break;
  74     }
  75
  76   return st;
  77 }
  78
  79 u8 *
  80 format_ip4_address (u8 * s, va_list * args)
  81 {
  82   u8 *a = va_arg (*args, u8 *);
  83   return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
  84 }
  85
  86 u8 *
  87 format_ip6_address (u8 * s, va_list * args)
  88 {
  89   ip6_address_t *a = va_arg (*args, ip6_address_t *);
  90   u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
  91
  92   i_max_n_zero = ARRAY_LEN (a->as_u16);
  93   max_n_zeros = 0;
  94   i_first_zero = i_max_n_zero;
  95   n_zeros = 0;
  96   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
  97     {
  98       u32 is_zero = a->as_u16[i] == 0;
  99       if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
 100         {
 101           i_first_zero = i;
 102           n_zeros = 0;
 103         }
 104       n_zeros += is_zero;
 105       if ((!is_zero && n_zeros > max_n_zeros)
 106           || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
 107         {
 108           i_max_n_zero = i_first_zero;
 109           max_n_zeros = n_zeros;
 110           i_first_zero = ARRAY_LEN (a->as_u16);
 111           n_zeros = 0;
 112         }
 113     }
 114
 115   last_double_colon = 0;
 116   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 117     {
 118       if (i == i_max_n_zero && max_n_zeros > 1)
 119         {
 120           s = format (s, "::");
 121           i += max_n_zeros - 1;
 122           last_double_colon = 1;
 123         }
 124       else
 125         {
 126           s = format (s, "%s%x",
 127                       (last_double_colon || i == 0) ? "" : ":",
 128                       clib_net_to_host_u16 (a->as_u16[i]));
 129           last_double_colon = 0;
 130         }
 131     }
 132
 133   return s;
 134 }
 135
 136 /* Format an IP46 address. */
 137 u8 *
 138 format_ip46_address (u8 * s, va_list * args)
 139 {
 140   ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
 141   ip46_type_t type = va_arg (*args, ip46_type_t);
 142   int is_ip4 = 1;
 143
 144   switch (type)
 145     {
 146     case IP46_TYPE_ANY:
 147       is_ip4 = ip46_address_is_ip4 (ip46);
 148       break;
 149     case IP46_TYPE_IP4:
 150       is_ip4 = 1;
 151       break;
 152     case IP46_TYPE_IP6:
 153       is_ip4 = 0;
 154       break;
 155     }
 156
 157   return is_ip4 ?
 158     format (s, "%U", format_ip4_address, &ip46->ip4) :
 159     format (s, "%U", format_ip6_address, &ip46->ip6);
 160 }
 161
 162 /*
 163  * VPPCOM Utility Functions
 164  */
 165
 166 static void
 167 vcl_msg_add_ext_config (vcl_session_t *s, uword *offset)
 168 {
 169   svm_fifo_chunk_t *c;
 170
 171   c = vcl_segment_alloc_chunk (vcl_vpp_worker_segment_handle (0),
 172                                0 /* one slice only */, s->ext_config->len,
 173                                offset);
 174   if (c)
 175     clib_memcpy_fast (c->data, s->ext_config, s->ext_config->len);
 176 }
 177
 178 static void
 179 vcl_send_session_listen (vcl_worker_t * wrk, vcl_session_t * s)
 180 {
 181   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 182   session_listen_msg_t *mp;
 183   svm_msg_q_t *mq;
 184
 185   mq = vcl_worker_ctrl_mq (wrk);
 186   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_LISTEN);
 187   mp = (session_listen_msg_t *) app_evt->evt->data;
 188   memset (mp, 0, sizeof (*mp));
 189   mp->client_index = wrk->api_client_handle;
 190   mp->context = s->session_index;
 191   mp->wrk_index = wrk->vpp_wrk_index;
 192   mp->is_ip4 = s->transport.is_ip4;
 193   clib_memcpy_fast (&mp->ip, &s->transport.lcl_ip, sizeof (mp->ip));
 194   mp->port = s->transport.lcl_port;
 195   mp->proto = s->session_type;
 196   mp->vrf = s->vrf;
 197   if (s->flags & VCL_SESSION_F_CONNECTED)
 198     mp->flags = TRANSPORT_CFG_F_CONNECTED;
 199   if (s->ext_config)
 200     vcl_msg_add_ext_config (s, &mp->ext_config);
 201   app_send_ctrl_evt_to_vpp (mq, app_evt);
 202   if (s->ext_config)
 203     {
 204       clib_mem_free (s->ext_config);
 205       s->ext_config = 0;
 206     }
 207 }
 208
 209 static void
 210 vcl_send_session_connect (vcl_worker_t * wrk, vcl_session_t * s)
 211 {
 212   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 213   session_connect_msg_t *mp;
 214   svm_msg_q_t *mq;
 215
 216   mq = vcl_worker_ctrl_mq (wrk);
 217   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_CONNECT);
 218   mp = (session_connect_msg_t *) app_evt->evt->data;
 219   memset (mp, 0, sizeof (*mp));
 220   mp->client_index = wrk->api_client_handle;
 221   mp->context = s->session_index;
 222   mp->wrk_index = wrk->vpp_wrk_index;
 223   mp->is_ip4 = s->transport.is_ip4;
 224   mp->parent_handle = s->parent_handle;
 225   clib_memcpy_fast (&mp->ip, &s->transport.rmt_ip, sizeof (mp->ip));
 226   clib_memcpy_fast (&mp->lcl_ip, &s->transport.lcl_ip, sizeof (mp->lcl_ip));
 227   mp->port = s->transport.rmt_port;
 228   mp->lcl_port = s->transport.lcl_port;
 229   mp->proto = s->session_type;
 230   mp->vrf = s->vrf;
 231   if (s->flags & VCL_SESSION_F_CONNECTED)
 232     mp->flags |= TRANSPORT_CFG_F_CONNECTED;
 233   if (s->ext_config)
 234     vcl_msg_add_ext_config (s, &mp->ext_config);
 235   app_send_ctrl_evt_to_vpp (mq, app_evt);
 236
 237   if (s->ext_config)
 238     {
 239       clib_mem_free (s->ext_config);
 240       s->ext_config = 0;
 241     }
 242 }
 243
 244 void
 245 vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s)
 246 {
 247   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 248   session_unlisten_msg_t *mp;
 249   svm_msg_q_t *mq;
 250
 251   mq = vcl_worker_ctrl_mq (wrk);
 252   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_UNLISTEN);
 253   mp = (session_unlisten_msg_t *) app_evt->evt->data;
 254   memset (mp, 0, sizeof (*mp));
 255   mp->client_index = wrk->api_client_handle;
 256   mp->wrk_index = wrk->vpp_wrk_index;
 257   mp->handle = s->vpp_handle;
 258   mp->context = wrk->wrk_index;
 259   app_send_ctrl_evt_to_vpp (mq, app_evt);
 260 }
 261
 262 static void
 263 vcl_send_session_shutdown (vcl_worker_t *wrk, vcl_session_t *s)
 264 {
 265   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 266   session_shutdown_msg_t *mp;
 267   svm_msg_q_t *mq;
 268
 269   /* Send to thread that owns the session */
 270   mq = s->vpp_evt_q;
 271   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_SHUTDOWN);
 272   mp = (session_shutdown_msg_t *) app_evt->evt->data;
 273   memset (mp, 0, sizeof (*mp));
 274   mp->client_index = wrk->api_client_handle;
 275   mp->handle = s->vpp_handle;
 276   app_send_ctrl_evt_to_vpp (mq, app_evt);
 277 }
 278
 279 static void
 280 vcl_send_session_disconnect (vcl_worker_t * wrk, vcl_session_t * s)
 281 {
 282   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 283   session_disconnect_msg_t *mp;
 284   svm_msg_q_t *mq;
 285
 286   /* Send to thread that owns the session */
 287   mq = s->vpp_evt_q;
 288   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_DISCONNECT);
 289   mp = (session_disconnect_msg_t *) app_evt->evt->data;
 290   memset (mp, 0, sizeof (*mp));
 291   mp->client_index = wrk->api_client_handle;
 292   mp->handle = s->vpp_handle;
 293   app_send_ctrl_evt_to_vpp (mq, app_evt);
 294 }
 295
 296 static void
 297 vcl_send_app_detach (vcl_worker_t * wrk)
 298 {
 299   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 300   session_app_detach_msg_t *mp;
 301   svm_msg_q_t *mq;
 302
 303   mq = vcl_worker_ctrl_mq (wrk);
 304   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_APP_DETACH);
 305   mp = (session_app_detach_msg_t *) app_evt->evt->data;
 306   memset (mp, 0, sizeof (*mp));
 307   mp->client_index = wrk->api_client_handle;
 308   app_send_ctrl_evt_to_vpp (mq, app_evt);
 309 }
 310
 311 static void
 312 vcl_send_session_accepted_reply (svm_msg_q_t * mq, u32 context,
 313                                  session_handle_t handle, int retval)
 314 {
 315   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 316   session_accepted_reply_msg_t *rmp;
 317   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_ACCEPTED_REPLY);
 318   rmp = (session_accepted_reply_msg_t *) app_evt->evt->data;
 319   rmp->handle = handle;
 320   rmp->context = context;
 321   rmp->retval = retval;
 322   app_send_ctrl_evt_to_vpp (mq, app_evt);
 323 }
 324
 325 static void
 326 vcl_send_session_disconnected_reply (vcl_worker_t * wrk, vcl_session_t * s,
 327                                      int retval)
 328 {
 329   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 330   session_disconnected_reply_msg_t *rmp;
 331   app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
 332                              SESSION_CTRL_EVT_DISCONNECTED_REPLY);
 333   rmp = (session_disconnected_reply_msg_t *) app_evt->evt->data;
 334   rmp->handle = s->vpp_handle;
 335   rmp->context = wrk->api_client_handle;
 336   rmp->retval = retval;
 337   app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
 338 }
 339
 340 static void
 341 vcl_send_session_reset_reply (vcl_worker_t * wrk, vcl_session_t * s,
 342                               int retval)
 343 {
 344   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 345   session_reset_reply_msg_t *rmp;
 346   app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
 347                              SESSION_CTRL_EVT_RESET_REPLY);
 348   rmp = (session_reset_reply_msg_t *) app_evt->evt->data;
 349   rmp->handle = s->vpp_handle;
 350   rmp->context = wrk->api_client_handle;
 351   rmp->retval = retval;
 352   app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
 353 }
 354
 355 void
 356 vcl_send_session_worker_update (vcl_worker_t * wrk, vcl_session_t * s,
 357                                 u32 wrk_index)
 358 {
 359   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 360   session_worker_update_msg_t *mp;
 361
 362   app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
 363                              SESSION_CTRL_EVT_WORKER_UPDATE);
 364   mp = (session_worker_update_msg_t *) app_evt->evt->data;
 365   mp->client_index = wrk->api_client_handle;
 366   mp->handle = s->vpp_handle;
 367   mp->req_wrk_index = wrk->vpp_wrk_index;
 368   mp->wrk_index = wrk_index;
 369   app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
 370 }
 371
 372 int
 373 vcl_send_worker_rpc (u32 dst_wrk_index, void *data, u32 data_len)
 374 {
 375   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 376   session_app_wrk_rpc_msg_t *mp;
 377   vcl_worker_t *dst_wrk, *wrk;
 378   svm_msg_q_t *mq;
 379   int ret = -1;
 380
 381   if (data_len > sizeof (mp->data))
 382     goto done;
 383
 384   clib_spinlock_lock (&vcm->workers_lock);
 385
 386   dst_wrk = vcl_worker_get_if_valid (dst_wrk_index);
 387   if (!dst_wrk)
 388     goto done;
 389
 390   wrk = vcl_worker_get_current ();
 391   mq = vcl_worker_ctrl_mq (wrk);
 392   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_APP_WRK_RPC);
 393   mp = (session_app_wrk_rpc_msg_t *) app_evt->evt->data;
 394   mp->client_index = wrk->api_client_handle;
 395   mp->wrk_index = dst_wrk->vpp_wrk_index;
 396   clib_memcpy (mp->data, data, data_len);
 397   app_send_ctrl_evt_to_vpp (mq, app_evt);
 398   ret = 0;
 399
 400 done:
 401   clib_spinlock_unlock (&vcm->workers_lock);
 402   return ret;
 403 }
 404
 405 int
 406 vcl_session_transport_attr (vcl_worker_t *wrk, vcl_session_t *s, u8 is_get,
 407                             transport_endpt_attr_t *attr)
 408 {
 409   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 410   session_transport_attr_msg_t *mp;
 411   svm_msg_q_t *mq;
 412   f64 timeout;
 413
 414   ASSERT (!wrk->session_attr_op);
 415   wrk->session_attr_op = 1;
 416   wrk->session_attr_op_rv = -1;
 417
 418   mq = s->vpp_evt_q;
 419   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_TRANSPORT_ATTR);
 420   mp = (session_transport_attr_msg_t *) app_evt->evt->data;
 421   memset (mp, 0, sizeof (*mp));
 422   mp->client_index = wrk->api_client_handle;
 423   mp->handle = s->vpp_handle;
 424   mp->is_get = is_get;
 425   mp->attr = *attr;
 426   app_send_ctrl_evt_to_vpp (mq, app_evt);
 427
 428   timeout = clib_time_now (&wrk->clib_time) + 1;
 429
 430   while (wrk->session_attr_op && clib_time_now (&wrk->clib_time) < timeout)
 431     vcl_flush_mq_events ();
 432
 433   if (!wrk->session_attr_op_rv && is_get)
 434     *attr = wrk->session_attr_rv;
 435
 436   wrk->session_attr_op = 0;
 437
 438   return wrk->session_attr_op_rv;
 439 }
 440
 441 static u32
 442 vcl_session_accepted_handler (vcl_worker_t * wrk, session_accepted_msg_t * mp,
 443                               u32 ls_index)
 444 {
 445   vcl_session_t *session, *listen_session;
 446   svm_msg_q_t *evt_q;
 447
 448   session = vcl_session_alloc (wrk);
 449
 450   listen_session = vcl_session_get (wrk, ls_index);
 451   if (listen_session->vpp_handle != mp->listener_handle)
 452     {
 453       VDBG (0, "ERROR: listener handle %lu does not match session %u",
 454             mp->listener_handle, ls_index);
 455       goto error;
 456     }
 457
 458   if (vcl_segment_attach_session (mp->segment_handle, mp->server_rx_fifo,
 459                                   mp->server_tx_fifo,
 460                                   mp->vpp_event_queue_address, 0, session))
 461     {
 462       VDBG (0, "failed to attach fifos for %u", session->session_index);
 463       goto error;
 464     }
 465
 466   session->vpp_handle = mp->handle;
 467   session->session_state = VCL_STATE_READY;
 468   session->transport.rmt_port = mp->rmt.port;
 469   session->transport.is_ip4 = mp->rmt.is_ip4;
 470   clib_memcpy_fast (&session->transport.rmt_ip, &mp->rmt.ip,
 471                     sizeof (ip46_address_t));
 472
 473   vcl_session_table_add_vpp_handle (wrk, mp->handle, session->session_index);
 474   session->transport.lcl_port = mp->lcl.port;
 475   session->transport.lcl_ip = mp->lcl.ip;
 476   session->session_type = listen_session->session_type;
 477   session->is_dgram = vcl_proto_is_dgram (session->session_type);
 478   session->listener_index = listen_session->session_index;
 479   listen_session->n_accepted_sessions++;
 480
 481   VDBG (1, "session %u [0x%llx]: client accept request from %s address %U"
 482         " port %d queue %p!", session->session_index, mp->handle,
 483         mp->rmt.is_ip4 ? "IPv4" : "IPv6", format_ip46_address, &mp->rmt.ip,
 484         mp->rmt.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
 485         clib_net_to_host_u16 (mp->rmt.port), session->vpp_evt_q);
 486   vcl_evt (VCL_EVT_ACCEPT, session, listen_session, session_index);
 487
 488   vcl_send_session_accepted_reply (session->vpp_evt_q, mp->context,
 489                                    session->vpp_handle, 0);
 490
 491   return session->session_index;
 492
 493 error:
 494   vcl_segment_attach_mq (vcl_vpp_worker_segment_handle (0),
 495                          mp->vpp_event_queue_address, mp->mq_index, &evt_q);
 496   vcl_send_session_accepted_reply (evt_q, mp->context, mp->handle,
 497                                    VNET_API_ERROR_INVALID_ARGUMENT);
 498   vcl_session_free (wrk, session);
 499   return VCL_INVALID_SESSION_INDEX;
 500 }
 501
 502 static u32
 503 vcl_session_connected_handler (vcl_worker_t * wrk,
 504                                session_connected_msg_t * mp)
 505 {
 506   vcl_session_t *session = 0;
 507   u32 session_index;
 508
 509   session_index = mp->context;
 510   session = vcl_session_get (wrk, session_index);
 511   if (!session)
 512     {
 513       VDBG (0, "ERROR: vpp handle 0x%llx has no session index (%u)!",
 514             mp->handle, session_index);
 515       return VCL_INVALID_SESSION_INDEX;
 516     }
 517   if (mp->retval)
 518     {
 519       VDBG (0, "ERROR: session index %u: connect failed! %U",
 520             session_index, format_session_error, mp->retval);
 521       session->session_state = VCL_STATE_DETACHED;
 522       session->vpp_handle = mp->handle;
 523       return session_index;
 524     }
 525
 526   session->vpp_handle = mp->handle;
 527
 528   if (vcl_segment_attach_session (mp->segment_handle, mp->server_rx_fifo,
 529                                   mp->server_tx_fifo,
 530                                   mp->vpp_event_queue_address, 0, session))
 531     {
 532       VDBG (0, "failed to attach fifos for %u", session->session_index);
 533       session->session_state = VCL_STATE_DETACHED;
 534       vcl_send_session_disconnect (wrk, session);
 535       return session_index;
 536     }
 537
 538   if (mp->ct_rx_fifo)
 539     {
 540       if (vcl_segment_attach_session (mp->ct_segment_handle, mp->ct_rx_fifo,
 541                                       mp->ct_tx_fifo, (uword) ~0, 1, session))
 542         {
 543           VDBG (0, "failed to attach ct fifos for %u", session->session_index);
 544           session->session_state = VCL_STATE_DETACHED;
 545           vcl_send_session_disconnect (wrk, session);
 546           return session_index;
 547         }
 548     }
 549
 550   session->transport.is_ip4 = mp->lcl.is_ip4;
 551   clib_memcpy_fast (&session->transport.lcl_ip, &mp->lcl.ip,
 552                     sizeof (session->transport.lcl_ip));
 553   session->transport.lcl_port = mp->lcl.port;
 554
 555   /* Application closed session before connect reply */
 556   if (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK)
 557       && session->session_state == VCL_STATE_CLOSED)
 558     vcl_send_session_disconnect (wrk, session);
 559   else
 560     session->session_state = VCL_STATE_READY;
 561
 562   /* Add it to lookup table */
 563   vcl_session_table_add_vpp_handle (wrk, mp->handle, session_index);
 564
 565   VDBG (1, "session %u [0x%llx] connected! rx_fifo %p, refcnt %d, tx_fifo %p,"
 566         " refcnt %d", session_index, mp->handle, session->rx_fifo,
 567         session->rx_fifo->refcnt, session->tx_fifo, session->tx_fifo->refcnt);
 568
 569   return session_index;
 570 }
 571
 572 static int
 573 vcl_flag_accepted_session (vcl_session_t * session, u64 handle, u32 flags)
 574 {
 575   vcl_session_msg_t *accepted_msg;
 576   int i;
 577
 578   for (i = 0; i < vec_len (session->accept_evts_fifo); i++)
 579     {
 580       accepted_msg = &session->accept_evts_fifo[i];
 581       if (accepted_msg->accepted_msg.handle == handle)
 582         {
 583           accepted_msg->flags |= flags;
 584           return 1;
 585         }
 586     }
 587   return 0;
 588 }
 589
 590 static u32
 591 vcl_session_reset_handler (vcl_worker_t * wrk,
 592                            session_reset_msg_t * reset_msg)
 593 {
 594   vcl_session_t *session;
 595   u32 sid;
 596
 597   sid = vcl_session_index_from_vpp_handle (wrk, reset_msg->handle);
 598   session = vcl_session_get (wrk, sid);
 599   if (!session)
 600     {
 601       VDBG (0, "request to reset unknown handle 0x%llx", reset_msg->handle);
 602       return VCL_INVALID_SESSION_INDEX;
 603     }
 604
 605   /* Caught a reset before actually accepting the session */
 606   if (session->session_state == VCL_STATE_LISTEN)
 607     {
 608
 609       if (!vcl_flag_accepted_session (session, reset_msg->handle,
 610                                       VCL_ACCEPTED_F_RESET))
 611         VDBG (0, "session was not accepted!");
 612       return VCL_INVALID_SESSION_INDEX;
 613     }
 614
 615   if (session->session_state != VCL_STATE_CLOSED)
 616     session->session_state = VCL_STATE_DISCONNECT;
 617   VDBG (0, "reset session %u [0x%llx]", sid, reset_msg->handle);
 618   return sid;
 619 }
 620
 621 static u32
 622 vcl_session_bound_handler (vcl_worker_t * wrk, session_bound_msg_t * mp)
 623 {
 624   vcl_session_t *session;
 625   u32 sid = mp->context;
 626
 627   session = vcl_session_get (wrk, sid);
 628   if (mp->retval)
 629     {
 630       VERR ("session %u [0x%llx]: bind failed: %U", sid, mp->handle,
 631             format_session_error, mp->retval);
 632       if (session)
 633         {
 634           session->session_state = VCL_STATE_DETACHED;
 635           session->vpp_handle = mp->handle;
 636           return sid;
 637         }
 638       else
 639         {
 640           VDBG (0, "ERROR: session %u [0x%llx]: Invalid session index!",
 641                 sid, mp->handle);
 642           return VCL_INVALID_SESSION_INDEX;
 643         }
 644     }
 645
 646   session->vpp_handle = mp->handle;
 647   session->transport.is_ip4 = mp->lcl_is_ip4;
 648   clib_memcpy_fast (&session->transport.lcl_ip, mp->lcl_ip,
 649                     sizeof (ip46_address_t));
 650   session->transport.lcl_port = mp->lcl_port;
 651   vcl_session_table_add_listener (wrk, mp->handle, sid);
 652   session->session_state = VCL_STATE_LISTEN;
 653
 654   if (vcl_session_is_cl (session))
 655     {
 656       if (vcl_segment_attach_session (mp->segment_handle, mp->rx_fifo,
 657                                       mp->tx_fifo, mp->vpp_evt_q, 0, session))
 658         {
 659           VDBG (0, "failed to attach fifos for %u", session->session_index);
 660           session->session_state = VCL_STATE_DETACHED;
 661           return VCL_INVALID_SESSION_INDEX;
 662         }
 663     }
 664
 665   VDBG (0, "session %u [0x%llx]: listen succeeded!", sid, mp->handle);
 666   return sid;
 667 }
 668
 669 static void
 670 vcl_session_unlisten_reply_handler (vcl_worker_t * wrk, void *data)
 671 {
 672   session_unlisten_reply_msg_t *mp = (session_unlisten_reply_msg_t *) data;
 673   vcl_session_t *s;
 674
 675   s = vcl_session_get_w_vpp_handle (wrk, mp->handle);
 676   if (!s)
 677     {
 678       VDBG (0, "Unlisten reply with wrong handle %llx", mp->handle);
 679       return;
 680     }
 681   if (s->session_state != VCL_STATE_DISCONNECT)
 682     {
 683       /* Connected udp listener */
 684       if (s->session_type == VPPCOM_PROTO_UDP
 685           && s->session_state == VCL_STATE_CLOSED)
 686         return;
 687
 688       VDBG (0, "Unlisten session in wrong state %llx", mp->handle);
 689       return;
 690     }
 691
 692   if (mp->retval)
 693     VDBG (0, "ERROR: session %u [0xllx]: unlisten failed: %U",
 694           s->session_index, mp->handle, format_session_error, mp->retval);
 695
 696   if (mp->context != wrk->wrk_index)
 697     VDBG (0, "wrong context");
 698
 699   vcl_session_table_del_vpp_handle (wrk, mp->handle);
 700   vcl_session_free (wrk, s);
 701 }
 702
 703 static void
 704 vcl_session_migrated_handler (vcl_worker_t * wrk, void *data)
 705 {
 706   session_migrated_msg_t *mp = (session_migrated_msg_t *) data;
 707   vcl_session_t *s;
 708   u32 fs_index;
 709
 710   s = vcl_session_get_w_vpp_handle (wrk, mp->handle);
 711   if (!s)
 712     {
 713       VDBG (0, "Migrated notification with wrong handle %llx", mp->handle);
 714       return;
 715     }
 716
 717   /* Only validate if a value is provided */
 718   if (mp->segment_handle != SESSION_INVALID_HANDLE)
 719     {
 720       fs_index = vcl_segment_table_lookup (mp->segment_handle);
 721       if (fs_index == VCL_INVALID_SEGMENT_INDEX)
 722         {
 723           VDBG (0, "segment %lx for session %u is not mounted!",
 724                 mp->segment_handle, s->session_index);
 725           s->session_state = VCL_STATE_DETACHED;
 726           return;
 727         }
 728     }
 729
 730   s->vpp_handle = mp->new_handle;
 731
 732   vcl_segment_attach_mq (vcl_vpp_worker_segment_handle (0), mp->vpp_evt_q,
 733                          mp->vpp_thread_index, &s->vpp_evt_q);
 734
 735   vcl_session_table_del_vpp_handle (wrk, mp->handle);
 736   vcl_session_table_add_vpp_handle (wrk, mp->new_handle, s->session_index);
 737
 738   /* Generate new tx event if we have outstanding data */
 739   if (svm_fifo_has_event (s->tx_fifo))
 740     app_send_io_evt_to_vpp (s->vpp_evt_q,
 741                             s->tx_fifo->shr->master_session_index,
 742                             SESSION_IO_EVT_TX, SVM_Q_WAIT);
 743
 744   VDBG (0, "Migrated 0x%lx to thread %u 0x%lx", mp->handle,
 745         mp->vpp_thread_index, mp->new_handle);
 746 }
 747
 748 static vcl_session_t *
 749 vcl_session_accepted (vcl_worker_t * wrk, session_accepted_msg_t * msg)
 750 {
 751   vcl_session_msg_t *vcl_msg;
 752   vcl_session_t *session;
 753
 754   session = vcl_session_get_w_vpp_handle (wrk, msg->handle);
 755   if (PREDICT_FALSE (session != 0))
 756     VWRN ("session overlap handle %lu state %u!", msg->handle,
 757           session->session_state);
 758
 759   session = vcl_session_table_lookup_listener (wrk, msg->listener_handle);
 760   if (!session)
 761     {
 762       VERR ("couldn't find listen session: listener handle %llx",
 763             msg->listener_handle);
 764       return 0;
 765     }
 766
 767   clib_fifo_add2 (session->accept_evts_fifo, vcl_msg);
 768   vcl_msg->flags = 0;
 769   vcl_msg->accepted_msg = *msg;
 770   /* Session handle points to listener until fully accepted by app */
 771   vcl_session_table_add_vpp_handle (wrk, msg->handle, session->session_index);
 772
 773   return session;
 774 }
 775
 776 static vcl_session_t *
 777 vcl_session_disconnected_handler (vcl_worker_t * wrk,
 778                                   session_disconnected_msg_t * msg)
 779 {
 780   vcl_session_t *session;
 781
 782   session = vcl_session_get_w_vpp_handle (wrk, msg->handle);
 783   if (!session)
 784     {
 785       VDBG (0, "request to disconnect unknown handle 0x%llx", msg->handle);
 786       return 0;
 787     }
 788
 789   /* Late disconnect notification on a session that has been closed */
 790   if (session->session_state == VCL_STATE_CLOSED)
 791     return 0;
 792
 793   /* Caught a disconnect before actually accepting the session */
 794   if (session->session_state == VCL_STATE_LISTEN)
 795     {
 796       if (!vcl_flag_accepted_session (session, msg->handle,
 797                                       VCL_ACCEPTED_F_CLOSED))
 798         VDBG (0, "session was not accepted!");
 799       return 0;
 800     }
 801
 802   /* If not already reset change state */
 803   if (session->session_state != VCL_STATE_DISCONNECT)
 804     session->session_state = VCL_STATE_VPP_CLOSING;
 805
 806   return session;
 807 }
 808
 809 int
 810 vppcom_session_shutdown (uint32_t session_handle, int how)
 811 {
 812   vcl_worker_t *wrk = vcl_worker_get_current ();
 813   vcl_session_t *session;
 814   vcl_session_state_t state;
 815   u64 vpp_handle;
 816
 817   session = vcl_session_get_w_handle (wrk, session_handle);
 818   if (PREDICT_FALSE (!session))
 819     return VPPCOM_EBADFD;
 820
 821   vpp_handle = session->vpp_handle;
 822   state = session->session_state;
 823
 824   VDBG (1, "session %u [0x%llx] state 0x%x (%s)", session->session_index,
 825         vpp_handle, state, vppcom_session_state_str (state));
 826
 827   if (PREDICT_FALSE (state == VCL_STATE_LISTEN))
 828     {
 829       VDBG (0, "ERROR: Cannot shutdown a listen socket!");
 830       return VPPCOM_EBADFD;
 831     }
 832
 833   if (how == SHUT_RD || how == SHUT_RDWR)
 834     {
 835       session->flags |= VCL_SESSION_F_RD_SHUTDOWN;
 836       if (how == SHUT_RD)
 837         return VPPCOM_OK;
 838     }
 839   session->flags |= VCL_SESSION_F_WR_SHUTDOWN;
 840
 841   if (PREDICT_TRUE (state == VCL_STATE_READY))
 842     {
 843       VDBG (1, "session %u [0x%llx]: sending shutdown...",
 844             session->session_index, vpp_handle);
 845
 846       vcl_send_session_shutdown (wrk, session);
 847     }
 848
 849   return VPPCOM_OK;
 850 }
 851
 852 static int
 853 vppcom_session_disconnect (u32 session_handle)
 854 {
 855   vcl_worker_t *wrk = vcl_worker_get_current ();
 856   vcl_session_t *session, *listen_session;
 857   vcl_session_state_t state;
 858   u64 vpp_handle;
 859
 860   session = vcl_session_get_w_handle (wrk, session_handle);
 861   if (!session)
 862     return VPPCOM_EBADFD;
 863
 864   vpp_handle = session->vpp_handle;
 865   state = session->session_state;
 866
 867   VDBG (1, "session %u [0x%llx] state 0x%x (%s)", session->session_index,
 868         vpp_handle, state, vppcom_session_state_str (state));
 869
 870   if (PREDICT_FALSE (state == VCL_STATE_LISTEN))
 871     {
 872       VDBG (0, "ERROR: Cannot disconnect a listen socket!");
 873       return VPPCOM_EBADFD;
 874     }
 875
 876   if (state == VCL_STATE_VPP_CLOSING)
 877     {
 878       vcl_send_session_disconnected_reply (wrk, session, 0);
 879       VDBG (1, "session %u [0x%llx]: sending disconnect REPLY...",
 880             session->session_index, vpp_handle);
 881     }
 882   else
 883     {
 884       /* Session doesn't have an event queue yet. Probably a non-blocking
 885        * connect. Wait for the reply */
 886       if (PREDICT_FALSE (!session->vpp_evt_q))
 887         return VPPCOM_OK;
 888
 889       VDBG (1, "session %u [0x%llx]: sending disconnect...",
 890             session->session_index, vpp_handle);
 891       vcl_send_session_disconnect (wrk, session);
 892     }
 893
 894   if (session->listener_index != VCL_INVALID_SESSION_INDEX)
 895     {
 896       listen_session = vcl_session_get (wrk, session->listener_index);
 897       listen_session->n_accepted_sessions--;
 898     }
 899
 900   return VPPCOM_OK;
 901 }
 902
 903 static void
 904 vcl_session_cleanup_handler (vcl_worker_t * wrk, void *data)
 905 {
 906   session_cleanup_msg_t *msg;
 907   vcl_session_t *session;
 908
 909   msg = (session_cleanup_msg_t *) data;
 910   session = vcl_session_get_w_vpp_handle (wrk, msg->handle);
 911   if (!session)
 912     {
 913       VDBG (0, "disconnect confirmed for unknown handle 0x%llx", msg->handle);
 914       return;
 915     }
 916
 917   if (msg->type == SESSION_CLEANUP_TRANSPORT)
 918     {
 919       /* Transport was cleaned up before we confirmed close. Probably the
 920        * app is still waiting for some data that cannot be delivered.
 921        * Confirm close to make sure everything is cleaned up.
 922        * Move to undetermined state to ensure that the session is not
 923        * removed before both vpp and the app cleanup.
 924        * - If the app closes first, the session is moved to CLOSED state
 925        *   and the session cleanup notification from vpp removes the
 926        *   session.
 927        * - If vpp cleans up the session first, the session is moved to
 928        *   DETACHED state lower and subsequently the close from the app
 929        *   frees the session
 930        */
 931       if (session->session_state == VCL_STATE_VPP_CLOSING)
 932         {
 933           vppcom_session_disconnect (vcl_session_handle (session));
 934           session->session_state = VCL_STATE_UPDATED;
 935         }
 936       else if (session->session_state == VCL_STATE_DISCONNECT)
 937         {
 938           vcl_send_session_reset_reply (wrk, session, 0);
 939           session->session_state = VCL_STATE_UPDATED;
 940         }
 941       return;
 942     }
 943
 944   vcl_session_table_del_vpp_handle (wrk, msg->handle);
 945   /* Should not happen. App did not close the connection so don't free it. */
 946   if (session->session_state != VCL_STATE_CLOSED)
 947     {
 948       VDBG (0, "app did not close session %d", session->session_index);
 949       session->session_state = VCL_STATE_DETACHED;
 950       session->vpp_handle = VCL_INVALID_SESSION_HANDLE;
 951       return;
 952     }
 953   vcl_session_free (wrk, session);
 954 }
 955
 956 static void
 957 vcl_session_req_worker_update_handler (vcl_worker_t * wrk, void *data)
 958 {
 959   session_req_worker_update_msg_t *msg;
 960   vcl_session_t *s;
 961
 962   msg = (session_req_worker_update_msg_t *) data;
 963   s = vcl_session_get_w_vpp_handle (wrk, msg->session_handle);
 964   if (!s)
 965     return;
 966
 967   vec_add1 (wrk->pending_session_wrk_updates, s->session_index);
 968 }
 969
 970 static void
 971 vcl_session_worker_update_reply_handler (vcl_worker_t * wrk, void *data)
 972 {
 973   session_worker_update_reply_msg_t *msg;
 974   vcl_session_t *s;
 975
 976   msg = (session_worker_update_reply_msg_t *) data;
 977   s = vcl_session_get_w_vpp_handle (wrk, msg->handle);
 978   if (!s)
 979     {
 980       VDBG (0, "unknown handle 0x%llx", msg->handle);
 981       return;
 982     }
 983
 984   if (s->rx_fifo)
 985     {
 986       if (vcl_segment_attach_session (msg->segment_handle, msg->rx_fifo,
 987                                       msg->tx_fifo, (uword) ~0, 0, s))
 988         {
 989           VDBG (0, "failed to attach fifos for %u", s->session_index);
 990           return;
 991         }
 992     }
 993   s->session_state = VCL_STATE_UPDATED;
 994
 995   VDBG (0, "session %u[0x%llx] moved to worker %u", s->session_index,
 996         s->vpp_handle, wrk->wrk_index);
 997 }
 998
 999 static int
1000 vcl_api_recv_fd (vcl_worker_t * wrk, int *fds, int n_fds)
1001 {
1002
1003   if (vcm->cfg.vpp_app_socket_api)
1004     return vcl_sapi_recv_fds (wrk, fds, n_fds);
1005
1006   return vcl_bapi_recv_fds (wrk, fds, n_fds);
1007 }
1008
1009 static void
1010 vcl_session_app_add_segment_handler (vcl_worker_t * wrk, void *data)
1011 {
1012   ssvm_segment_type_t seg_type = SSVM_SEGMENT_SHM;
1013   session_app_add_segment_msg_t *msg;
1014   u64 segment_handle;
1015   int fd = -1;
1016
1017   msg = (session_app_add_segment_msg_t *) data;
1018
1019   if (msg->fd_flags)
1020     {
1021       vcl_api_recv_fd (wrk, &fd, 1);
1022       seg_type = SSVM_SEGMENT_MEMFD;
1023     }
1024
1025   segment_handle = msg->segment_handle;
1026   if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
1027     {
1028       clib_warning ("invalid segment handle");
1029       return;
1030     }
1031
1032   if (vcl_segment_attach (segment_handle, (char *) msg->segment_name,
1033                           seg_type, fd))
1034     {
1035       VDBG (0, "vcl_segment_attach ('%s') failed", msg->segment_name);
1036       return;
1037     }
1038
1039   VDBG (1, "mapped new segment '%s' size %d", msg->segment_name,
1040         msg->segment_size);
1041 }
1042
1043 static void
1044 vcl_session_app_del_segment_handler (vcl_worker_t * wrk, void *data)
1045 {
1046   session_app_del_segment_msg_t *msg = (session_app_del_segment_msg_t *) data;
1047   vcl_segment_detach (msg->segment_handle);
1048   VDBG (1, "Unmapped segment: %d", msg->segment_handle);
1049 }
1050
1051 static void
1052 vcl_worker_rpc_handler (vcl_worker_t * wrk, void *data)
1053 {
1054   if (!vcm->wrk_rpc_fn)
1055     return;
1056
1057   (vcm->wrk_rpc_fn) (((session_app_wrk_rpc_msg_t *) data)->data);
1058 }
1059
1060 static void
1061 vcl_session_transport_attr_reply_handler (vcl_worker_t *wrk, void *data)
1062 {
1063   session_transport_attr_reply_msg_t *mp;
1064
1065   if (!wrk->session_attr_op)
1066     return;
1067
1068   mp = (session_transport_attr_reply_msg_t *) data;
1069
1070   wrk->session_attr_op_rv = mp->retval;
1071   wrk->session_attr_op = 0;
1072   wrk->session_attr_rv = mp->attr;
1073 }
1074
1075 static int
1076 vcl_handle_mq_event (vcl_worker_t * wrk, session_event_t * e)
1077 {
1078   session_disconnected_msg_t *disconnected_msg;
1079   session_connected_msg_t *connected_msg;
1080   session_reset_msg_t *reset_msg;
1081   session_event_t *ecpy;
1082   vcl_session_t *s;
1083   u32 sid;
1084
1085   switch (e->event_type)
1086     {
1087     case SESSION_IO_EVT_RX:
1088     case SESSION_IO_EVT_TX:
1089       s = vcl_session_get (wrk, e->session_index);
1090       if (!s || !vcl_session_is_open (s))
1091         break;
1092       vec_add1 (wrk->unhandled_evts_vector, *e);
1093       break;
1094     case SESSION_CTRL_EVT_BOUND:
1095       /* We can only wait for only one listen so not postponed */
1096       vcl_session_bound_handler (wrk, (session_bound_msg_t *) e->data);
1097       break;
1098     case SESSION_CTRL_EVT_ACCEPTED:
1099       s = vcl_session_accepted (wrk, (session_accepted_msg_t *) e->data);
1100       if (vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
1101         {
1102           vec_add2 (wrk->unhandled_evts_vector, ecpy, 1);
1103           *ecpy = *e;
1104           ecpy->postponed = 1;
1105           ecpy->session_index = s->session_index;
1106         }
1107       break;
1108     case SESSION_CTRL_EVT_CONNECTED:
1109       connected_msg = (session_connected_msg_t *) e->data;
1110       sid = vcl_session_connected_handler (wrk, connected_msg);
1111       if (!(s = vcl_session_get (wrk, sid)))
1112         break;
1113       if (vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
1114         {
1115           vec_add2 (wrk->unhandled_evts_vector, ecpy, 1);
1116           *ecpy = *e;
1117           ecpy->postponed = 1;
1118           ecpy->session_index = s->session_index;
1119         }
1120       break;
1121     case SESSION_CTRL_EVT_DISCONNECTED:
1122       disconnected_msg = (session_disconnected_msg_t *) e->data;
1123       if (!(s = vcl_session_get_w_vpp_handle (wrk, disconnected_msg->handle)))
1124         break;
1125       if (vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
1126         {
1127           vec_add1 (wrk->unhandled_evts_vector, *e);
1128           break;
1129         }
1130       if (!(s = vcl_session_disconnected_handler (wrk, disconnected_msg)))
1131         break;
1132       VDBG (0, "disconnected session %u [0x%llx]", s->session_index,
1133             s->vpp_handle);
1134       break;
1135     case SESSION_CTRL_EVT_RESET:
1136       reset_msg = (session_reset_msg_t *) e->data;
1137       if (!(s = vcl_session_get_w_vpp_handle (wrk, reset_msg->handle)))
1138         break;
1139       if (vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
1140         {
1141           vec_add1 (wrk->unhandled_evts_vector, *e);
1142           break;
1143         }
1144       vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
1145       break;
1146     case SESSION_CTRL_EVT_UNLISTEN_REPLY:
1147       vcl_session_unlisten_reply_handler (wrk, e->data);
1148       break;
1149     case SESSION_CTRL_EVT_MIGRATED:
1150       vcl_session_migrated_handler (wrk, e->data);
1151       break;
1152     case SESSION_CTRL_EVT_CLEANUP:
1153       vcl_session_cleanup_handler (wrk, e->data);
1154       break;
1155     case SESSION_CTRL_EVT_REQ_WORKER_UPDATE:
1156       vcl_session_req_worker_update_handler (wrk, e->data);
1157       break;
1158     case SESSION_CTRL_EVT_WORKER_UPDATE_REPLY:
1159       vcl_session_worker_update_reply_handler (wrk, e->data);
1160       break;
1161     case SESSION_CTRL_EVT_APP_ADD_SEGMENT:
1162       vcl_session_app_add_segment_handler (wrk, e->data);
1163       break;
1164     case SESSION_CTRL_EVT_APP_DEL_SEGMENT:
1165       vcl_session_app_del_segment_handler (wrk, e->data);
1166       break;
1167     case SESSION_CTRL_EVT_APP_WRK_RPC:
1168       vcl_worker_rpc_handler (wrk, e->data);
1169       break;
1170     case SESSION_CTRL_EVT_TRANSPORT_ATTR_REPLY:
1171       vcl_session_transport_attr_reply_handler (wrk, e->data);
1172       break;
1173     default:
1174       clib_warning ("unhandled %u", e->event_type);
1175     }
1176   return VPPCOM_OK;
1177 }
1178
1179 static int
1180 vppcom_wait_for_session_state_change (u32 session_index,
1181                                       vcl_session_state_t state,
1182                                       f64 wait_for_time)
1183 {
1184   vcl_worker_t *wrk = vcl_worker_get_current ();
1185   f64 timeout = clib_time_now (&wrk->clib_time) + wait_for_time;
1186   vcl_session_t *volatile session;
1187   svm_msg_q_msg_t msg;
1188   session_event_t *e;
1189
1190   do
1191     {
1192       session = vcl_session_get (wrk, session_index);
1193       if (PREDICT_FALSE (!session))
1194         {
1195           return VPPCOM_EBADFD;
1196         }
1197       if (session->session_state == state)
1198         {
1199           return VPPCOM_OK;
1200         }
1201       if (session->session_state == VCL_STATE_DETACHED)
1202         {
1203           return VPPCOM_ECONNREFUSED;
1204         }
1205
1206       if (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_NOWAIT, 0))
1207         {
1208           usleep (100);
1209           continue;
1210         }
1211       e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
1212       vcl_handle_mq_event (wrk, e);
1213       svm_msg_q_free_msg (wrk->app_event_queue, &msg);
1214     }
1215   while (clib_time_now (&wrk->clib_time) < timeout);
1216
1217   VDBG (0, "timeout waiting for state 0x%x (%s)", state,
1218         vppcom_session_state_str (state));
1219   vcl_evt (VCL_EVT_SESSION_TIMEOUT, session, session_state);
1220
1221   return VPPCOM_ETIMEDOUT;
1222 }
1223
1224 static void
1225 vcl_handle_pending_wrk_updates (vcl_worker_t * wrk)
1226 {
1227   vcl_session_state_t state;
1228   vcl_session_t *s;
1229   u32 *sip;
1230
1231   if (PREDICT_TRUE (vec_len (wrk->pending_session_wrk_updates) == 0))
1232     return;
1233
1234   vec_foreach (sip, wrk->pending_session_wrk_updates)
1235   {
1236     s = vcl_session_get (wrk, *sip);
1237     vcl_send_session_worker_update (wrk, s, wrk->wrk_index);
1238     state = s->session_state;
1239     vppcom_wait_for_session_state_change (s->session_index, VCL_STATE_UPDATED,
1240                                           5);
1241     s->session_state = state;
1242   }
1243   vec_reset_length (wrk->pending_session_wrk_updates);
1244 }
1245
1246 void
1247 vcl_worker_flush_mq_events (vcl_worker_t *wrk)
1248 {
1249   svm_msg_q_msg_t *msg;
1250   session_event_t *e;
1251   svm_msg_q_t *mq;
1252   int i;
1253
1254   mq = wrk->app_event_queue;
1255   vcl_mq_dequeue_batch (wrk, mq, ~0);
1256
1257   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
1258     {
1259       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
1260       e = svm_msg_q_msg_data (mq, msg);
1261       vcl_handle_mq_event (wrk, e);
1262       svm_msg_q_free_msg (mq, msg);
1263     }
1264   vec_reset_length (wrk->mq_msg_vector);
1265   vcl_handle_pending_wrk_updates (wrk);
1266 }
1267
1268 void
1269 vcl_flush_mq_events (void)
1270 {
1271   vcl_worker_flush_mq_events (vcl_worker_get_current ());
1272 }
1273
1274 static int
1275 vppcom_session_unbind (u32 session_handle)
1276 {
1277   vcl_worker_t *wrk = vcl_worker_get_current ();
1278   session_accepted_msg_t *accepted_msg;
1279   vcl_session_t *session = 0;
1280   vcl_session_msg_t *evt;
1281
1282   session = vcl_session_get_w_handle (wrk, session_handle);
1283   if (!session)
1284     return VPPCOM_EBADFD;
1285
1286   /* Flush pending accept events, if any */
1287   while (clib_fifo_elts (session->accept_evts_fifo))
1288     {
1289       clib_fifo_sub2 (session->accept_evts_fifo, evt);
1290       accepted_msg = &evt->accepted_msg;
1291       vcl_session_table_del_vpp_handle (wrk, accepted_msg->handle);
1292       vcl_send_session_accepted_reply (session->vpp_evt_q,
1293                                        accepted_msg->context,
1294                                        accepted_msg->handle, -1);
1295     }
1296   clib_fifo_free (session->accept_evts_fifo);
1297
1298   vcl_send_session_unlisten (wrk, session);
1299
1300   VDBG (1, "session %u [0x%llx]: sending unbind!", session->session_index,
1301         session->vpp_handle);
1302   vcl_evt (VCL_EVT_UNBIND, session);
1303
1304   session->vpp_handle = ~0;
1305   session->session_state = VCL_STATE_DISCONNECT;
1306
1307   return VPPCOM_OK;
1308 }
1309
1310 /**
1311  * Handle app exit
1312  *
1313  * Notify vpp of the disconnect and mark the worker as free. If we're the
1314  * last worker, do a full cleanup otherwise, since we're probably a forked
1315  * child, avoid syscalls as much as possible. We might've lost privileges.
1316  */
1317 void
1318 vppcom_app_exit (void)
1319 {
1320   if (!pool_elts (vcm->workers))
1321     return;
1322   vcl_worker_cleanup (vcl_worker_get_current (), 1 /* notify vpp */ );
1323   vcl_set_worker_index (~0);
1324   vcl_elog_stop (vcm);
1325 }
1326
1327 static int
1328 vcl_api_attach (void)
1329 {
1330   if (vcm->cfg.vpp_app_socket_api)
1331     return vcl_sapi_attach ();
1332
1333   return vcl_bapi_attach ();
1334 }
1335
1336 static void
1337 vcl_api_detach (vcl_worker_t * wrk)
1338 {
1339   vcl_send_app_detach (wrk);
1340
1341   if (vcm->cfg.vpp_app_socket_api)
1342     return vcl_sapi_detach (wrk);
1343
1344   return vcl_bapi_disconnect_from_vpp ();
1345 }
1346
1347 /*
1348  * VPPCOM Public API functions
1349  */
1350 int
1351 vppcom_app_create (const char *app_name)
1352 {
1353   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
1354   int rv;
1355
1356   if (vcm->is_init)
1357     {
1358       VDBG (1, "already initialized");
1359       return VPPCOM_EEXIST;
1360     }
1361
1362   vcm->is_init = 1;
1363   vppcom_cfg (&vcm->cfg);
1364   vcl_cfg = &vcm->cfg;
1365
1366   vcm->main_cpu = pthread_self ();
1367   vcm->main_pid = getpid ();
1368   vcm->app_name = format (0, "%s", app_name);
1369   fifo_segment_main_init (&vcm->segment_main, vcl_cfg->segment_baseva,
1370                           20 /* timeout in secs */ );
1371   pool_alloc (vcm->workers, vcl_cfg->max_workers);
1372   clib_spinlock_init (&vcm->workers_lock);
1373   clib_rwlock_init (&vcm->segment_table_lock);
1374   atexit (vppcom_app_exit);
1375   vcl_elog_init (vcm);
1376
1377   /* Allocate default worker */
1378   vcl_worker_alloc_and_init ();
1379
1380   if ((rv = vcl_api_attach ()))
1381     return rv;
1382
1383   VDBG (0, "app_name '%s', my_client_index %d (0x%x)", app_name,
1384         vcm->workers[0].api_client_handle, vcm->workers[0].api_client_handle);
1385
1386   return VPPCOM_OK;
1387 }
1388
1389 void
1390 vppcom_app_destroy (void)
1391 {
1392   vcl_worker_t *wrk, *current_wrk;
1393   void *heap;
1394
1395   if (!pool_elts (vcm->workers))
1396     return;
1397
1398   vcl_evt (VCL_EVT_DETACH, vcm);
1399
1400   current_wrk = vcl_worker_get_current ();
1401
1402   /* *INDENT-OFF* */
1403   pool_foreach (wrk, vcm->workers)  {
1404     if (current_wrk != wrk)
1405       vcl_worker_cleanup (wrk, 0 /* notify vpp */ );
1406   }
1407   /* *INDENT-ON* */
1408
1409   vcl_api_detach (current_wrk);
1410   vcl_worker_cleanup (current_wrk, 0 /* notify vpp */ );
1411
1412   vcl_elog_stop (vcm);
1413
1414   /*
1415    * Free the heap and fix vcm
1416    */
1417   heap = clib_mem_get_heap ();
1418   munmap (clib_mem_get_heap_base (heap), clib_mem_get_heap_size (heap));
1419
1420   vcm = &_vppcom_main;
1421   vcm->is_init = 0;
1422 }
1423
1424 int
1425 vppcom_session_create (u8 proto, u8 is_nonblocking)
1426 {
1427   vcl_worker_t *wrk = vcl_worker_get_current ();
1428   vcl_session_t *session;
1429
1430   session = vcl_session_alloc (wrk);
1431
1432   session->session_type = proto;
1433   session->session_state = VCL_STATE_CLOSED;
1434   session->vpp_handle = ~0;
1435   session->is_dgram = vcl_proto_is_dgram (proto);
1436
1437   if (is_nonblocking)
1438     vcl_session_set_attr (session, VCL_SESS_ATTR_NONBLOCK);
1439
1440   vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
1441            is_nonblocking, session_index);
1442
1443   VDBG (0, "created session %u", session->session_index);
1444
1445   return vcl_session_handle (session);
1446 }
1447
1448 static void
1449 vcl_epoll_lt_add (vcl_worker_t *wrk, vcl_session_t *s)
1450 {
1451   vcl_session_t *cur, *prev;
1452
1453   if (wrk->ep_lt_current == VCL_INVALID_SESSION_INDEX)
1454     {
1455       wrk->ep_lt_current = s->session_index;
1456       s->vep.lt_next = s->session_index;
1457       s->vep.lt_prev = s->session_index;
1458       return;
1459     }
1460
1461   cur = vcl_session_get (wrk, wrk->ep_lt_current);
1462   prev = vcl_session_get (wrk, cur->vep.lt_prev);
1463
1464   prev->vep.lt_next = s->session_index;
1465   s->vep.lt_prev = prev->session_index;
1466
1467   s->vep.lt_next = cur->session_index;
1468   cur->vep.lt_prev = s->session_index;
1469 }
1470
1471 static void
1472 vcl_epoll_lt_del (vcl_worker_t *wrk, vcl_session_t *s)
1473 {
1474   vcl_session_t *prev, *next;
1475
1476   if (s->vep.lt_next == s->session_index)
1477     {
1478       wrk->ep_lt_current = VCL_INVALID_SESSION_INDEX;
1479       s->vep.lt_next = VCL_INVALID_SESSION_INDEX;
1480       return;
1481     }
1482
1483   prev = vcl_session_get (wrk, s->vep.lt_prev);
1484   next = vcl_session_get (wrk, s->vep.lt_next);
1485
1486   prev->vep.lt_next = next->session_index;
1487   next->vep.lt_prev = prev->session_index;
1488
1489   if (s->session_index == wrk->ep_lt_current)
1490     wrk->ep_lt_current = s->vep.lt_next;
1491
1492   s->vep.lt_next = VCL_INVALID_SESSION_INDEX;
1493 }
1494
1495 int
1496 vcl_session_cleanup (vcl_worker_t * wrk, vcl_session_t * s,
1497                      vcl_session_handle_t sh, u8 do_disconnect)
1498 {
1499   int rv = VPPCOM_OK;
1500
1501   VDBG (1, "session %u [0x%llx] closing", s->session_index, s->vpp_handle);
1502
1503   if (s->flags & VCL_SESSION_F_IS_VEP)
1504     {
1505       u32 next_sh = s->vep.next_sh;
1506       while (next_sh != ~0)
1507         {
1508           rv = vppcom_epoll_ctl (sh, EPOLL_CTL_DEL, next_sh, 0);
1509           if (PREDICT_FALSE (rv < 0))
1510             VDBG (0, "vpp handle 0x%llx, sh %u: EPOLL_CTL_DEL vep_idx %u"
1511                   " failed! rv %d (%s)", s->vpp_handle, next_sh,
1512                   s->vep.vep_sh, rv, vppcom_retval_str (rv));
1513           next_sh = s->vep.next_sh;
1514         }
1515       goto free_session;
1516     }
1517
1518   if (s->flags & VCL_SESSION_F_IS_VEP_SESSION)
1519     {
1520       rv = vppcom_epoll_ctl (s->vep.vep_sh, EPOLL_CTL_DEL, sh, 0);
1521       if (rv < 0)
1522         VDBG (0, "session %u [0x%llx]: EPOLL_CTL_DEL vep_idx %u "
1523               "failed! rv %d (%s)", s->session_index, s->vpp_handle,
1524               s->vep.vep_sh, rv, vppcom_retval_str (rv));
1525     }
1526
1527   if (!do_disconnect)
1528     {
1529       VDBG (1, "session %u [0x%llx] disconnect skipped",
1530             s->session_index, s->vpp_handle);
1531       goto cleanup;
1532     }
1533
1534   if (s->session_state == VCL_STATE_LISTEN)
1535     {
1536       rv = vppcom_session_unbind (sh);
1537       if (PREDICT_FALSE (rv < 0))
1538         VDBG (0, "session %u [0x%llx]: listener unbind failed! "
1539               "rv %d (%s)", s->session_index, s->vpp_handle, rv,
1540               vppcom_retval_str (rv));
1541       return rv;
1542     }
1543   else if (vcl_session_is_ready (s)
1544            || (vcl_session_is_connectable_listener (wrk, s)))
1545     {
1546       rv = vppcom_session_disconnect (sh);
1547       if (PREDICT_FALSE (rv < 0))
1548         VDBG (0, "ERROR: session %u [0x%llx]: disconnect failed!"
1549               " rv %d (%s)", s->session_index, s->vpp_handle,
1550               rv, vppcom_retval_str (rv));
1551     }
1552   else if (s->session_state == VCL_STATE_DISCONNECT)
1553     {
1554       vcl_send_session_reset_reply (wrk, s, 0);
1555     }
1556   else if (s->session_state == VCL_STATE_DETACHED)
1557     {
1558       /* Should not happen. VPP cleaned up before app confirmed close */
1559       VDBG (0, "vpp freed session %d before close", s->session_index);
1560       goto free_session;
1561     }
1562
1563   s->session_state = VCL_STATE_CLOSED;
1564
1565   /* Session is removed only after vpp confirms the disconnect */
1566   return rv;
1567
1568 cleanup:
1569   vcl_session_table_del_vpp_handle (wrk, s->vpp_handle);
1570 free_session:
1571   vcl_session_free (wrk, s);
1572   vcl_evt (VCL_EVT_CLOSE, s, rv);
1573
1574   return rv;
1575 }
1576
1577 int
1578 vppcom_session_close (uint32_t session_handle)
1579 {
1580   vcl_worker_t *wrk = vcl_worker_get_current ();
1581   vcl_session_t *session;
1582
1583   session = vcl_session_get_w_handle (wrk, session_handle);
1584   if (!session)
1585     return VPPCOM_EBADFD;
1586   return vcl_session_cleanup (wrk, session, session_handle,
1587                               1 /* do_disconnect */ );
1588 }
1589
1590 int
1591 vppcom_session_bind (uint32_t session_handle, vppcom_endpt_t * ep)
1592 {
1593   vcl_worker_t *wrk = vcl_worker_get_current ();
1594   vcl_session_t *session = 0;
1595
1596   if (!ep || !ep->ip)
1597     return VPPCOM_EINVAL;
1598
1599   session = vcl_session_get_w_handle (wrk, session_handle);
1600   if (!session)
1601     return VPPCOM_EBADFD;
1602
1603   if (session->flags & VCL_SESSION_F_IS_VEP)
1604     {
1605       VDBG (0, "ERROR: cannot bind to epoll session %u!",
1606             session->session_index);
1607       return VPPCOM_EBADFD;
1608     }
1609
1610   session->transport.is_ip4 = ep->is_ip4;
1611   if (ep->is_ip4)
1612     clib_memcpy_fast (&session->transport.lcl_ip.ip4, ep->ip,
1613                       sizeof (ip4_address_t));
1614   else
1615     clib_memcpy_fast (&session->transport.lcl_ip.ip6, ep->ip,
1616                       sizeof (ip6_address_t));
1617   session->transport.lcl_port = ep->port;
1618
1619   VDBG (0, "session %u handle %u: binding to local %s address %U port %u, "
1620         "proto %s", session->session_index, session_handle,
1621         session->transport.is_ip4 ? "IPv4" : "IPv6",
1622         format_ip46_address, &session->transport.lcl_ip,
1623         session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1624         clib_net_to_host_u16 (session->transport.lcl_port),
1625         vppcom_proto_str (session->session_type));
1626   vcl_evt (VCL_EVT_BIND, session);
1627
1628   if (session->session_type == VPPCOM_PROTO_UDP)
1629     vppcom_session_listen (session_handle, 10);
1630
1631   return VPPCOM_OK;
1632 }
1633
1634 int
1635 vppcom_session_listen (uint32_t listen_sh, uint32_t q_len)
1636 {
1637   vcl_worker_t *wrk = vcl_worker_get_current ();
1638   vcl_session_t *listen_session = 0;
1639   u64 listen_vpp_handle;
1640   int rv;
1641
1642   listen_session = vcl_session_get_w_handle (wrk, listen_sh);
1643   if (!listen_session || (listen_session->flags & VCL_SESSION_F_IS_VEP))
1644     return VPPCOM_EBADFD;
1645
1646   if (q_len == 0 || q_len == ~0)
1647     q_len = vcm->cfg.listen_queue_size;
1648
1649   listen_vpp_handle = listen_session->vpp_handle;
1650   if (listen_session->session_state == VCL_STATE_LISTEN)
1651     {
1652       VDBG (0, "session %u [0x%llx]: already in listen state!",
1653             listen_sh, listen_vpp_handle);
1654       return VPPCOM_OK;
1655     }
1656
1657   VDBG (0, "session %u: sending vpp listen request...", listen_sh);
1658
1659   /*
1660    * Send listen request to vpp and wait for reply
1661    */
1662   vcl_send_session_listen (wrk, listen_session);
1663   rv = vppcom_wait_for_session_state_change (listen_session->session_index,
1664                                              VCL_STATE_LISTEN,
1665                                              vcm->cfg.session_timeout);
1666
1667   if (PREDICT_FALSE (rv))
1668     {
1669       listen_session = vcl_session_get_w_handle (wrk, listen_sh);
1670       VDBG (0, "session %u [0x%llx]: listen failed! returning %d (%s)",
1671             listen_sh, listen_session->vpp_handle, rv,
1672             vppcom_retval_str (rv));
1673       return rv;
1674     }
1675
1676   return VPPCOM_OK;
1677 }
1678
1679 static int
1680 validate_args_session_accept_ (vcl_worker_t * wrk, vcl_session_t * ls)
1681 {
1682   if (ls->flags & VCL_SESSION_F_IS_VEP)
1683     {
1684       VDBG (0, "ERROR: cannot accept on epoll session %u!",
1685             ls->session_index);
1686       return VPPCOM_EBADFD;
1687     }
1688
1689   if ((ls->session_state != VCL_STATE_LISTEN)
1690       && (!vcl_session_is_connectable_listener (wrk, ls)))
1691     {
1692       VDBG (0, "ERROR: session [0x%llx]: not in listen state! state 0x%x"
1693             " (%s)", ls->vpp_handle, ls->session_state,
1694             vppcom_session_state_str (ls->session_state));
1695       return VPPCOM_EBADFD;
1696     }
1697   return VPPCOM_OK;
1698 }
1699
1700 int
1701 vppcom_unformat_proto (uint8_t * proto, char *proto_str)
1702 {
1703   if (!strcmp (proto_str, "TCP"))
1704     *proto = VPPCOM_PROTO_TCP;
1705   else if (!strcmp (proto_str, "tcp"))
1706     *proto = VPPCOM_PROTO_TCP;
1707   else if (!strcmp (proto_str, "UDP"))
1708     *proto = VPPCOM_PROTO_UDP;
1709   else if (!strcmp (proto_str, "udp"))
1710     *proto = VPPCOM_PROTO_UDP;
1711   else if (!strcmp (proto_str, "TLS"))
1712     *proto = VPPCOM_PROTO_TLS;
1713   else if (!strcmp (proto_str, "tls"))
1714     *proto = VPPCOM_PROTO_TLS;
1715   else if (!strcmp (proto_str, "QUIC"))
1716     *proto = VPPCOM_PROTO_QUIC;
1717   else if (!strcmp (proto_str, "quic"))
1718     *proto = VPPCOM_PROTO_QUIC;
1719   else if (!strcmp (proto_str, "DTLS"))
1720     *proto = VPPCOM_PROTO_DTLS;
1721   else if (!strcmp (proto_str, "dtls"))
1722     *proto = VPPCOM_PROTO_DTLS;
1723   else if (!strcmp (proto_str, "SRTP"))
1724     *proto = VPPCOM_PROTO_SRTP;
1725   else if (!strcmp (proto_str, "srtp"))
1726     *proto = VPPCOM_PROTO_SRTP;
1727   else
1728     return 1;
1729   return 0;
1730 }
1731
1732 int
1733 vppcom_session_accept (uint32_t listen_session_handle, vppcom_endpt_t * ep,
1734                        uint32_t flags)
1735 {
1736   u32 client_session_index = ~0, listen_session_index, accept_flags = 0;
1737   vcl_worker_t *wrk = vcl_worker_get_current ();
1738   session_accepted_msg_t accepted_msg;
1739   vcl_session_t *listen_session = 0;
1740   vcl_session_t *client_session = 0;
1741   vcl_session_msg_t *evt;
1742   u8 is_nonblocking;
1743   int rv;
1744
1745 again:
1746
1747   listen_session = vcl_session_get_w_handle (wrk, listen_session_handle);
1748   if (!listen_session)
1749     return VPPCOM_EBADFD;
1750
1751   listen_session_index = listen_session->session_index;
1752   if ((rv = validate_args_session_accept_ (wrk, listen_session)))
1753     return rv;
1754
1755   if (clib_fifo_elts (listen_session->accept_evts_fifo))
1756     {
1757       clib_fifo_sub2 (listen_session->accept_evts_fifo, evt);
1758       accept_flags = evt->flags;
1759       accepted_msg = evt->accepted_msg;
1760       goto handle;
1761     }
1762
1763   is_nonblocking = vcl_session_has_attr (listen_session,
1764                                          VCL_SESS_ATTR_NONBLOCK);
1765   while (1)
1766     {
1767       if (svm_msg_q_is_empty (wrk->app_event_queue) && is_nonblocking)
1768         return VPPCOM_EAGAIN;
1769
1770       svm_msg_q_wait (wrk->app_event_queue, SVM_MQ_WAIT_EMPTY);
1771       vcl_worker_flush_mq_events (wrk);
1772       goto again;
1773     }
1774
1775 handle:
1776
1777   client_session_index = vcl_session_accepted_handler (wrk, &accepted_msg,
1778                                                        listen_session_index);
1779   if (client_session_index == VCL_INVALID_SESSION_INDEX)
1780     return VPPCOM_ECONNABORTED;
1781
1782   listen_session = vcl_session_get (wrk, listen_session_index);
1783   client_session = vcl_session_get (wrk, client_session_index);
1784
1785   if (flags & O_NONBLOCK)
1786     vcl_session_set_attr (client_session, VCL_SESS_ATTR_NONBLOCK);
1787
1788   VDBG (1, "listener %u [0x%llx]: Got a connect request! session %u [0x%llx],"
1789         " flags %d, is_nonblocking %u", listen_session->session_index,
1790         listen_session->vpp_handle, client_session_index,
1791         client_session->vpp_handle, flags,
1792         vcl_session_has_attr (client_session, VCL_SESS_ATTR_NONBLOCK));
1793
1794   if (ep)
1795     {
1796       ep->is_ip4 = client_session->transport.is_ip4;
1797       ep->port = client_session->transport.rmt_port;
1798       if (client_session->transport.is_ip4)
1799         clib_memcpy_fast (ep->ip, &client_session->transport.rmt_ip.ip4,
1800                           sizeof (ip4_address_t));
1801       else
1802         clib_memcpy_fast (ep->ip, &client_session->transport.rmt_ip.ip6,
1803                           sizeof (ip6_address_t));
1804     }
1805
1806   VDBG (0, "listener %u [0x%llx] accepted %u [0x%llx] peer: %U:%u "
1807         "local: %U:%u", listen_session_handle, listen_session->vpp_handle,
1808         client_session_index, client_session->vpp_handle,
1809         format_ip46_address, &client_session->transport.rmt_ip,
1810         client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1811         clib_net_to_host_u16 (client_session->transport.rmt_port),
1812         format_ip46_address, &client_session->transport.lcl_ip,
1813         client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1814         clib_net_to_host_u16 (client_session->transport.lcl_port));
1815   vcl_evt (VCL_EVT_ACCEPT, client_session, listen_session,
1816            client_session_index);
1817
1818   /*
1819    * Session might have been closed already
1820    */
1821   if (accept_flags)
1822     {
1823       if (accept_flags & VCL_ACCEPTED_F_CLOSED)
1824         client_session->session_state = VCL_STATE_VPP_CLOSING;
1825       else if (accept_flags & VCL_ACCEPTED_F_RESET)
1826         client_session->session_state = VCL_STATE_DISCONNECT;
1827     }
1828   return vcl_session_handle (client_session);
1829 }
1830
1831 int
1832 vppcom_session_connect (uint32_t session_handle, vppcom_endpt_t * server_ep)
1833 {
1834   vcl_worker_t *wrk = vcl_worker_get_current ();
1835   vcl_session_t *session = 0;
1836   u32 session_index;
1837   int rv;
1838
1839   session = vcl_session_get_w_handle (wrk, session_handle);
1840   if (!session)
1841     return VPPCOM_EBADFD;
1842   session_index = session->session_index;
1843
1844   if (PREDICT_FALSE (session->flags & VCL_SESSION_F_IS_VEP))
1845     {
1846       VDBG (0, "ERROR: cannot connect epoll session %u!",
1847             session->session_index);
1848       return VPPCOM_EBADFD;
1849     }
1850
1851   if (PREDICT_FALSE (vcl_session_is_ready (session)))
1852     {
1853       VDBG (0, "session handle %u [0x%llx]: session already "
1854             "connected to %s %U port %d proto %s, state 0x%x (%s)",
1855             session_handle, session->vpp_handle,
1856             session->transport.is_ip4 ? "IPv4" : "IPv6", format_ip46_address,
1857             &session->transport.rmt_ip, session->transport.is_ip4 ?
1858             IP46_TYPE_IP4 : IP46_TYPE_IP6,
1859             clib_net_to_host_u16 (session->transport.rmt_port),
1860             vppcom_proto_str (session->session_type), session->session_state,
1861             vppcom_session_state_str (session->session_state));
1862       return VPPCOM_OK;
1863     }
1864
1865   /* Attempt to connect a connectionless listener */
1866   if (PREDICT_FALSE (session->session_state == VCL_STATE_LISTEN))
1867     {
1868       if (session->session_type != VPPCOM_PROTO_UDP)
1869         return VPPCOM_EINVAL;
1870       vcl_send_session_unlisten (wrk, session);
1871       session->session_state = VCL_STATE_CLOSED;
1872     }
1873
1874   session->transport.is_ip4 = server_ep->is_ip4;
1875   vcl_ip_copy_from_ep (&session->transport.rmt_ip, server_ep);
1876   session->transport.rmt_port = server_ep->port;
1877   session->parent_handle = VCL_INVALID_SESSION_HANDLE;
1878   session->flags |= VCL_SESSION_F_CONNECTED;
1879
1880   VDBG (0, "session handle %u (%s): connecting to peer %s %U "
1881         "port %d proto %s", session_handle,
1882         vppcom_session_state_str (session->session_state),
1883         session->transport.is_ip4 ? "IPv4" : "IPv6",
1884         format_ip46_address,
1885         &session->transport.rmt_ip, session->transport.is_ip4 ?
1886         IP46_TYPE_IP4 : IP46_TYPE_IP6,
1887         clib_net_to_host_u16 (session->transport.rmt_port),
1888         vppcom_proto_str (session->session_type));
1889
1890   vcl_send_session_connect (wrk, session);
1891
1892   if (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK))
1893     {
1894       /* State set to STATE_UPDATED to ensure the session is not assumed
1895        * to be ready and to also allow the app to close it prior to vpp's
1896        * connected reply. */
1897       session->session_state = VCL_STATE_UPDATED;
1898       return VPPCOM_EINPROGRESS;
1899     }
1900
1901   /*
1902    * Wait for reply from vpp if blocking
1903    */
1904   rv = vppcom_wait_for_session_state_change (session_index, VCL_STATE_READY,
1905                                              vcm->cfg.session_timeout);
1906
1907   session = vcl_session_get (wrk, session_index);
1908   VDBG (0, "session %u [0x%llx]: connect %s!", session->session_index,
1909         session->vpp_handle, rv ? "failed" : "succeeded");
1910
1911   return rv;
1912 }
1913
1914 int
1915 vppcom_session_stream_connect (uint32_t session_handle,
1916                                uint32_t parent_session_handle)
1917 {
1918   vcl_worker_t *wrk = vcl_worker_get_current ();
1919   vcl_session_t *session, *parent_session;
1920   u32 session_index, parent_session_index;
1921   int rv;
1922
1923   session = vcl_session_get_w_handle (wrk, session_handle);
1924   if (!session)
1925     return VPPCOM_EBADFD;
1926   parent_session = vcl_session_get_w_handle (wrk, parent_session_handle);
1927   if (!parent_session)
1928     return VPPCOM_EBADFD;
1929
1930   session_index = session->session_index;
1931   parent_session_index = parent_session->session_index;
1932   if (PREDICT_FALSE (session->flags & VCL_SESSION_F_IS_VEP))
1933     {
1934       VDBG (0, "ERROR: cannot connect epoll session %u!",
1935             session->session_index);
1936       return VPPCOM_EBADFD;
1937     }
1938
1939   if (PREDICT_FALSE (vcl_session_is_ready (session)))
1940     {
1941       VDBG (0, "session handle %u [0x%llx]: session already "
1942             "connected to session %u [0x%llx] proto %s, state 0x%x (%s)",
1943             session_handle, session->vpp_handle,
1944             parent_session_handle, parent_session->vpp_handle,
1945             vppcom_proto_str (session->session_type), session->session_state,
1946             vppcom_session_state_str (session->session_state));
1947       return VPPCOM_OK;
1948     }
1949
1950   /* Connect to quic session specifics */
1951   session->transport.is_ip4 = parent_session->transport.is_ip4;
1952   session->transport.rmt_ip.ip4.as_u32 = (uint32_t) 1;
1953   session->transport.rmt_port = 0;
1954   session->parent_handle = parent_session->vpp_handle;
1955
1956   VDBG (0, "session handle %u: connecting to session %u [0x%llx]",
1957         session_handle, parent_session_handle, parent_session->vpp_handle);
1958
1959   /*
1960    * Send connect request and wait for reply from vpp
1961    */
1962   vcl_send_session_connect (wrk, session);
1963   rv = vppcom_wait_for_session_state_change (session_index, VCL_STATE_READY,
1964                                              vcm->cfg.session_timeout);
1965
1966   session->listener_index = parent_session_index;
1967   parent_session = vcl_session_get_w_handle (wrk, parent_session_handle);
1968   if (parent_session)
1969     parent_session->n_accepted_sessions++;
1970
1971   session = vcl_session_get (wrk, session_index);
1972   VDBG (0, "session %u [0x%llx]: connect %s!", session->session_index,
1973         session->vpp_handle, rv ? "failed" : "succeeded");
1974
1975   return rv;
1976 }
1977
1978 static inline int
1979 vppcom_session_read_internal (uint32_t session_handle, void *buf, int n,
1980                               u8 peek)
1981 {
1982   vcl_worker_t *wrk = vcl_worker_get_current ();
1983   int rv, n_read = 0, is_nonblocking;
1984   vcl_session_t *s = 0;
1985   svm_fifo_t *rx_fifo;
1986   session_event_t *e;
1987   svm_msg_q_t *mq;
1988   u8 is_ct;
1989
1990   if (PREDICT_FALSE (!buf))
1991     return VPPCOM_EINVAL;
1992
1993   s = vcl_session_get_w_handle (wrk, session_handle);
1994   if (PREDICT_FALSE (!s || (s->flags & VCL_SESSION_F_IS_VEP)))
1995     return VPPCOM_EBADFD;
1996
1997   if (PREDICT_FALSE (!vcl_session_is_open (s)))
1998     {
1999       VDBG (0, "session %u[0x%llx] is not open! state 0x%x (%s)",
2000             s->session_index, s->vpp_handle, s->session_state,
2001             vppcom_session_state_str (s->session_state));
2002       return vcl_session_closed_error (s);
2003     }
2004
2005   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_RD_SHUTDOWN))
2006     {
2007       /* Vpp would ack the incoming data and enqueue it for reading.
2008        * So even if SHUT_RD is set, we can still read() the data if
2009        * the session is ready.
2010        */
2011       if (!vcl_session_read_ready (s))
2012         {
2013           return 0;
2014         }
2015     }
2016
2017   is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
2018   is_ct = vcl_session_is_ct (s);
2019   mq = wrk->app_event_queue;
2020   rx_fifo = is_ct ? s->ct_rx_fifo : s->rx_fifo;
2021   s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2022
2023   if (svm_fifo_is_empty_cons (rx_fifo))
2024     {
2025       if (is_nonblocking)
2026         {
2027           if (vcl_session_is_closing (s))
2028             return vcl_session_closing_error (s);
2029           if (is_ct)
2030             svm_fifo_unset_event (s->rx_fifo);
2031           svm_fifo_unset_event (rx_fifo);
2032           return VPPCOM_EWOULDBLOCK;
2033         }
2034       while (svm_fifo_is_empty_cons (rx_fifo))
2035         {
2036           if (vcl_session_is_closing (s))
2037             return vcl_session_closing_error (s);
2038
2039           if (is_ct)
2040             svm_fifo_unset_event (s->rx_fifo);
2041           svm_fifo_unset_event (rx_fifo);
2042
2043           svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2044           vcl_worker_flush_mq_events (wrk);
2045         }
2046     }
2047
2048 read_again:
2049
2050   if (s->is_dgram)
2051     rv = app_recv_dgram_raw (rx_fifo, buf, n, &s->transport, 0, peek);
2052   else
2053     rv = app_recv_stream_raw (rx_fifo, buf, n, 0, peek);
2054
2055   ASSERT (rv >= 0);
2056
2057   if (peek)
2058     return rv;
2059
2060   n_read += rv;
2061
2062   if (svm_fifo_is_empty_cons (rx_fifo))
2063     {
2064       if (is_ct)
2065         svm_fifo_unset_event (s->rx_fifo);
2066       svm_fifo_unset_event (rx_fifo);
2067       if (!svm_fifo_is_empty_cons (rx_fifo)
2068           && svm_fifo_set_event (rx_fifo) && is_nonblocking)
2069         {
2070           vec_add2 (wrk->unhandled_evts_vector, e, 1);
2071           e->event_type = SESSION_IO_EVT_RX;
2072           e->session_index = s->session_index;
2073         }
2074     }
2075   else if (PREDICT_FALSE (rv < n && !s->is_dgram))
2076     {
2077       /* More data enqueued while reading. Try to drain it
2078        * or fill the buffer. Avoid doing that for dgrams */
2079       buf += rv;
2080       n -= rv;
2081       goto read_again;
2082     }
2083
2084   if (PREDICT_FALSE (svm_fifo_needs_deq_ntf (rx_fifo, n_read)))
2085     {
2086       svm_fifo_clear_deq_ntf (rx_fifo);
2087       app_send_io_evt_to_vpp (s->vpp_evt_q,
2088                               s->rx_fifo->shr->master_session_index,
2089                               SESSION_IO_EVT_RX, SVM_Q_WAIT);
2090     }
2091
2092   VDBG (2, "session %u[0x%llx]: read %d bytes from (%p)", s->session_index,
2093         s->vpp_handle, n_read, rx_fifo);
2094
2095   return n_read;
2096 }
2097
2098 int
2099 vppcom_session_read (uint32_t session_handle, void *buf, size_t n)
2100 {
2101   return (vppcom_session_read_internal (session_handle, buf, n, 0));
2102 }
2103
2104 static int
2105 vppcom_session_peek (uint32_t session_handle, void *buf, int n)
2106 {
2107   return (vppcom_session_read_internal (session_handle, buf, n, 1));
2108 }
2109
2110 int
2111 vppcom_session_read_segments (uint32_t session_handle,
2112                               vppcom_data_segment_t * ds, uint32_t n_segments,
2113                               uint32_t max_bytes)
2114 {
2115   vcl_worker_t *wrk = vcl_worker_get_current ();
2116   int n_read = 0, is_nonblocking;
2117   vcl_session_t *s = 0;
2118   svm_fifo_t *rx_fifo;
2119   svm_msg_q_t *mq;
2120   u8 is_ct;
2121
2122   s = vcl_session_get_w_handle (wrk, session_handle);
2123   if (PREDICT_FALSE (!s || (s->flags & VCL_SESSION_F_IS_VEP)))
2124     return VPPCOM_EBADFD;
2125
2126   if (PREDICT_FALSE (!vcl_session_is_open (s)))
2127     return vcl_session_closed_error (s);
2128
2129   is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
2130   is_ct = vcl_session_is_ct (s);
2131   mq = wrk->app_event_queue;
2132   rx_fifo = is_ct ? s->ct_rx_fifo : s->rx_fifo;
2133   s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2134
2135   if (svm_fifo_is_empty_cons (rx_fifo))
2136     {
2137       if (is_nonblocking)
2138         {
2139           if (is_ct)
2140             svm_fifo_unset_event (s->rx_fifo);
2141           svm_fifo_unset_event (rx_fifo);
2142           return VPPCOM_EWOULDBLOCK;
2143         }
2144       while (svm_fifo_is_empty_cons (rx_fifo))
2145         {
2146           if (vcl_session_is_closing (s))
2147             return vcl_session_closing_error (s);
2148
2149           if (is_ct)
2150             svm_fifo_unset_event (s->rx_fifo);
2151           svm_fifo_unset_event (rx_fifo);
2152
2153           svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2154           vcl_worker_flush_mq_events (wrk);
2155         }
2156     }
2157
2158   n_read = svm_fifo_segments (rx_fifo, s->rx_bytes_pending,
2159                               (svm_fifo_seg_t *) ds, n_segments, max_bytes);
2160   if (n_read < 0)
2161     return VPPCOM_EAGAIN;
2162
2163   if (svm_fifo_max_dequeue_cons (rx_fifo) == n_read)
2164     {
2165       if (is_ct)
2166         svm_fifo_unset_event (s->rx_fifo);
2167       svm_fifo_unset_event (rx_fifo);
2168       if (svm_fifo_max_dequeue_cons (rx_fifo) != n_read
2169           && svm_fifo_set_event (rx_fifo)
2170           && vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
2171         {
2172           session_event_t *e;
2173           vec_add2 (wrk->unhandled_evts_vector, e, 1);
2174           e->event_type = SESSION_IO_EVT_RX;
2175           e->session_index = s->session_index;
2176         }
2177     }
2178
2179   s->rx_bytes_pending += n_read;
2180   return n_read;
2181 }
2182
2183 void
2184 vppcom_session_free_segments (uint32_t session_handle, uint32_t n_bytes)
2185 {
2186   vcl_worker_t *wrk = vcl_worker_get_current ();
2187   vcl_session_t *s;
2188   u8 is_ct;
2189
2190   s = vcl_session_get_w_handle (wrk, session_handle);
2191   if (PREDICT_FALSE (!s || (s->flags & VCL_SESSION_F_IS_VEP)))
2192     return;
2193
2194   is_ct = vcl_session_is_ct (s);
2195   svm_fifo_dequeue_drop (is_ct ? s->ct_rx_fifo : s->rx_fifo, n_bytes);
2196
2197   ASSERT (s->rx_bytes_pending < n_bytes);
2198   s->rx_bytes_pending -= n_bytes;
2199 }
2200
2201 always_inline u8
2202 vcl_fifo_is_writeable (svm_fifo_t * f, u32 len, u8 is_dgram)
2203 {
2204   u32 max_enq = svm_fifo_max_enqueue_prod (f);
2205   if (is_dgram)
2206     return max_enq >= (sizeof (session_dgram_hdr_t) + len);
2207   else
2208     return max_enq > 0;
2209 }
2210
2211 always_inline int
2212 vppcom_session_write_inline (vcl_worker_t * wrk, vcl_session_t * s, void *buf,
2213                              size_t n, u8 is_flush, u8 is_dgram)
2214 {
2215   int n_write, is_nonblocking;
2216   session_evt_type_t et;
2217   svm_fifo_t *tx_fifo;
2218   svm_msg_q_t *mq;
2219   u8 is_ct;
2220
2221   /* Accept zero length writes but just return */
2222   if (PREDICT_FALSE (!n))
2223     return VPPCOM_OK;
2224
2225   if (PREDICT_FALSE (!buf))
2226     return VPPCOM_EFAULT;
2227
2228   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_IS_VEP))
2229     {
2230       VDBG (0, "ERROR: session %u [0x%llx]: cannot write to an epoll"
2231             " session!", s->session_index, s->vpp_handle);
2232       return VPPCOM_EBADFD;
2233     }
2234
2235   if (PREDICT_FALSE (!vcl_session_is_open (s)))
2236     {
2237       VDBG (1, "session %u [0x%llx]: is not open! state 0x%x (%s)",
2238             s->session_index, s->vpp_handle, s->session_state,
2239             vppcom_session_state_str (s->session_state));
2240       return vcl_session_closed_error (s);;
2241     }
2242
2243   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_WR_SHUTDOWN))
2244     {
2245       VDBG (1, "session %u [0x%llx]: is shutdown! state 0x%x (%s)",
2246             s->session_index, s->vpp_handle, s->session_state,
2247             vppcom_session_state_str (s->session_state));
2248       return VPPCOM_EPIPE;
2249     }
2250
2251   is_ct = vcl_session_is_ct (s);
2252   tx_fifo = is_ct ? s->ct_tx_fifo : s->tx_fifo;
2253   is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
2254
2255   mq = wrk->app_event_queue;
2256   if (!vcl_fifo_is_writeable (tx_fifo, n, is_dgram))
2257     {
2258       if (is_nonblocking)
2259         {
2260           return VPPCOM_EWOULDBLOCK;
2261         }
2262       while (!vcl_fifo_is_writeable (tx_fifo, n, is_dgram))
2263         {
2264           svm_fifo_add_want_deq_ntf (tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
2265           if (vcl_session_is_closing (s))
2266             return vcl_session_closing_error (s);
2267
2268           svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2269           vcl_worker_flush_mq_events (wrk);
2270         }
2271     }
2272
2273   et = SESSION_IO_EVT_TX;
2274   if (is_flush && !is_ct)
2275     et = SESSION_IO_EVT_TX_FLUSH;
2276
2277   if (is_dgram)
2278     n_write = app_send_dgram_raw (tx_fifo, &s->transport,
2279                                   s->vpp_evt_q, buf, n, et,
2280                                   0 /* do_evt */ , SVM_Q_WAIT);
2281   else
2282     n_write = app_send_stream_raw (tx_fifo, s->vpp_evt_q, buf, n, et,
2283                                    0 /* do_evt */ , SVM_Q_WAIT);
2284
2285   if (svm_fifo_set_event (s->tx_fifo))
2286     app_send_io_evt_to_vpp (
2287       s->vpp_evt_q, s->tx_fifo->shr->master_session_index, et, SVM_Q_WAIT);
2288
2289   /* The underlying fifo segment can run out of memory */
2290   if (PREDICT_FALSE (n_write < 0))
2291     return VPPCOM_EAGAIN;
2292
2293   VDBG (2, "session %u [0x%llx]: wrote %d bytes", s->session_index,
2294         s->vpp_handle, n_write);
2295
2296   return n_write;
2297 }
2298
2299 int
2300 vppcom_session_write (uint32_t session_handle, void *buf, size_t n)
2301 {
2302   vcl_worker_t *wrk = vcl_worker_get_current ();
2303   vcl_session_t *s;
2304
2305   s = vcl_session_get_w_handle (wrk, session_handle);
2306   if (PREDICT_FALSE (!s))
2307     return VPPCOM_EBADFD;
2308
2309   return vppcom_session_write_inline (wrk, s, buf, n,
2310                                       0 /* is_flush */ , s->is_dgram ? 1 : 0);
2311 }
2312
2313 int
2314 vppcom_session_write_msg (uint32_t session_handle, void *buf, size_t n)
2315 {
2316   vcl_worker_t *wrk = vcl_worker_get_current ();
2317   vcl_session_t *s;
2318
2319   s = vcl_session_get_w_handle (wrk, session_handle);
2320   if (PREDICT_FALSE (!s))
2321     return VPPCOM_EBADFD;
2322
2323   return vppcom_session_write_inline (wrk, s, buf, n,
2324                                       1 /* is_flush */ , s->is_dgram ? 1 : 0);
2325 }
2326
2327 #define vcl_fifo_rx_evt_valid_or_break(_s)                              \
2328 if (PREDICT_FALSE (!_s->rx_fifo))                                       \
2329   break;                                                                \
2330 if (PREDICT_FALSE (svm_fifo_is_empty (_s->rx_fifo)))                    \
2331   {                                                                     \
2332     if (!vcl_session_is_ct (_s))                                        \
2333       {                                                                 \
2334         svm_fifo_unset_event (_s->rx_fifo);                             \
2335         if (svm_fifo_is_empty (_s->rx_fifo))                            \
2336           break;                                                        \
2337       }                                                                 \
2338     else if (svm_fifo_is_empty (_s->ct_rx_fifo))                        \
2339       {                                                                 \
2340         svm_fifo_unset_event (_s->rx_fifo); /* rx evts on actual fifo*/ \
2341         if (svm_fifo_is_empty (_s->ct_rx_fifo))                         \
2342           break;                                                        \
2343       }                                                                 \
2344   }                                                                     \
2345
2346 static void
2347 vcl_select_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
2348                             unsigned long n_bits, unsigned long *read_map,
2349                             unsigned long *write_map,
2350                             unsigned long *except_map, u32 * bits_set)
2351 {
2352   session_disconnected_msg_t *disconnected_msg;
2353   session_connected_msg_t *connected_msg;
2354   vcl_session_t *s;
2355   u32 sid;
2356
2357   switch (e->event_type)
2358     {
2359     case SESSION_IO_EVT_RX:
2360       sid = e->session_index;
2361       s = vcl_session_get (wrk, sid);
2362       if (!s || !vcl_session_is_open (s))
2363         break;
2364       vcl_fifo_rx_evt_valid_or_break (s);
2365       if (sid < n_bits && read_map)
2366         {
2367           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2368           *bits_set += 1;
2369         }
2370       break;
2371     case SESSION_IO_EVT_TX:
2372       sid = e->session_index;
2373       s = vcl_session_get (wrk, sid);
2374       if (!s || !vcl_session_is_open (s))
2375         break;
2376       if (sid < n_bits && write_map)
2377         {
2378           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2379           *bits_set += 1;
2380         }
2381       break;
2382     case SESSION_CTRL_EVT_ACCEPTED:
2383       if (!e->postponed)
2384         s = vcl_session_accepted (wrk, (session_accepted_msg_t *) e->data);
2385       else
2386         s = vcl_session_get (wrk, e->session_index);
2387       if (!s)
2388         break;
2389       sid = s->session_index;
2390       if (sid < n_bits && read_map)
2391         {
2392           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2393           *bits_set += 1;
2394         }
2395       break;
2396     case SESSION_CTRL_EVT_CONNECTED:
2397       if (!e->postponed)
2398         {
2399           connected_msg = (session_connected_msg_t *) e->data;
2400           sid = vcl_session_connected_handler (wrk, connected_msg);
2401         }
2402       else
2403         sid = e->session_index;
2404       if (sid == VCL_INVALID_SESSION_INDEX)
2405         break;
2406       if (sid < n_bits && write_map)
2407         {
2408           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2409           *bits_set += 1;
2410         }
2411       break;
2412     case SESSION_CTRL_EVT_DISCONNECTED:
2413       disconnected_msg = (session_disconnected_msg_t *) e->data;
2414       s = vcl_session_disconnected_handler (wrk, disconnected_msg);
2415       if (!s)
2416         break;
2417       sid = s->session_index;
2418       if (sid < n_bits && except_map)
2419         {
2420           clib_bitmap_set_no_check ((uword *) except_map, sid, 1);
2421           *bits_set += 1;
2422         }
2423       break;
2424     case SESSION_CTRL_EVT_RESET:
2425       sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
2426       if (sid < n_bits && except_map)
2427         {
2428           clib_bitmap_set_no_check ((uword *) except_map, sid, 1);
2429           *bits_set += 1;
2430         }
2431       break;
2432     case SESSION_CTRL_EVT_UNLISTEN_REPLY:
2433       vcl_session_unlisten_reply_handler (wrk, e->data);
2434       break;
2435     case SESSION_CTRL_EVT_MIGRATED:
2436       vcl_session_migrated_handler (wrk, e->data);
2437       break;
2438     case SESSION_CTRL_EVT_CLEANUP:
2439       vcl_session_cleanup_handler (wrk, e->data);
2440       break;
2441     case SESSION_CTRL_EVT_WORKER_UPDATE_REPLY:
2442       vcl_session_worker_update_reply_handler (wrk, e->data);
2443       break;
2444     case SESSION_CTRL_EVT_REQ_WORKER_UPDATE:
2445       vcl_session_req_worker_update_handler (wrk, e->data);
2446       break;
2447     case SESSION_CTRL_EVT_APP_ADD_SEGMENT:
2448       vcl_session_app_add_segment_handler (wrk, e->data);
2449       break;
2450     case SESSION_CTRL_EVT_APP_DEL_SEGMENT:
2451       vcl_session_app_del_segment_handler (wrk, e->data);
2452       break;
2453     case SESSION_CTRL_EVT_APP_WRK_RPC:
2454       vcl_worker_rpc_handler (wrk, e->data);
2455       break;
2456     default:
2457       clib_warning ("unhandled: %u", e->event_type);
2458       break;
2459     }
2460 }
2461
2462 static int
2463 vcl_select_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
2464                       unsigned long n_bits, unsigned long *read_map,
2465                       unsigned long *write_map, unsigned long *except_map,
2466                       double time_to_wait, u32 * bits_set)
2467 {
2468   svm_msg_q_msg_t *msg;
2469   session_event_t *e;
2470   u32 i;
2471
2472   if (svm_msg_q_is_empty (mq))
2473     {
2474       if (*bits_set)
2475         return 0;
2476
2477       if (!time_to_wait)
2478         return 0;
2479       else if (time_to_wait < 0)
2480         svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2481       else
2482         {
2483           if (svm_msg_q_timedwait (mq, time_to_wait))
2484             return 0;
2485         }
2486     }
2487   vcl_mq_dequeue_batch (wrk, mq, ~0);
2488
2489   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
2490     {
2491       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
2492       e = svm_msg_q_msg_data (mq, msg);
2493       vcl_select_handle_mq_event (wrk, e, n_bits, read_map, write_map,
2494                                   except_map, bits_set);
2495       svm_msg_q_free_msg (mq, msg);
2496     }
2497   vec_reset_length (wrk->mq_msg_vector);
2498   vcl_handle_pending_wrk_updates (wrk);
2499   return *bits_set;
2500 }
2501
2502 static int
2503 vppcom_select_condvar (vcl_worker_t * wrk, int n_bits,
2504                        vcl_si_set * read_map, vcl_si_set * write_map,
2505                        vcl_si_set * except_map, double time_to_wait,
2506                        u32 * bits_set)
2507 {
2508   double wait = 0, start = 0;
2509
2510   if (!*bits_set)
2511     {
2512       wait = time_to_wait;
2513       start = clib_time_now (&wrk->clib_time);
2514     }
2515
2516   do
2517     {
2518       vcl_select_handle_mq (wrk, wrk->app_event_queue, n_bits, read_map,
2519                             write_map, except_map, wait, bits_set);
2520       if (*bits_set)
2521         return *bits_set;
2522       if (wait == -1)
2523         continue;
2524
2525       wait = wait - (clib_time_now (&wrk->clib_time) - start);
2526     }
2527   while (wait > 0);
2528
2529   return 0;
2530 }
2531
2532 static int
2533 vppcom_select_eventfd (vcl_worker_t * wrk, int n_bits,
2534                        vcl_si_set * read_map, vcl_si_set * write_map,
2535                        vcl_si_set * except_map, double time_to_wait,
2536                        u32 * bits_set)
2537 {
2538   vcl_mq_evt_conn_t *mqc;
2539   int __clib_unused n_read;
2540   int n_mq_evts, i;
2541   u64 buf;
2542
2543   vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
2544   n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
2545                           vec_len (wrk->mq_events), time_to_wait);
2546   for (i = 0; i < n_mq_evts; i++)
2547     {
2548       mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
2549       n_read = read (mqc->mq_fd, &buf, sizeof (buf));
2550       vcl_select_handle_mq (wrk, mqc->mq, n_bits, read_map, write_map,
2551                             except_map, 0, bits_set);
2552     }
2553
2554   return (n_mq_evts > 0 ? (int) *bits_set : 0);
2555 }
2556
2557 int
2558 vppcom_select (int n_bits, vcl_si_set * read_map, vcl_si_set * write_map,
2559                vcl_si_set * except_map, double time_to_wait)
2560 {
2561   u32 sid, minbits = clib_max (n_bits, BITS (uword)), bits_set = 0;
2562   vcl_worker_t *wrk = vcl_worker_get_current ();
2563   vcl_session_t *s = 0;
2564   int i;
2565
2566   if (n_bits && read_map)
2567     {
2568       clib_bitmap_validate (wrk->rd_bitmap, minbits);
2569       clib_memcpy_fast (wrk->rd_bitmap, read_map,
2570                         vec_len (wrk->rd_bitmap) * sizeof (vcl_si_set));
2571       memset (read_map, 0, vec_len (wrk->rd_bitmap) * sizeof (vcl_si_set));
2572     }
2573   if (n_bits && write_map)
2574     {
2575       clib_bitmap_validate (wrk->wr_bitmap, minbits);
2576       clib_memcpy_fast (wrk->wr_bitmap, write_map,
2577                         vec_len (wrk->wr_bitmap) * sizeof (vcl_si_set));
2578       memset (write_map, 0, vec_len (wrk->wr_bitmap) * sizeof (vcl_si_set));
2579     }
2580   if (n_bits && except_map)
2581     {
2582       clib_bitmap_validate (wrk->ex_bitmap, minbits);
2583       clib_memcpy_fast (wrk->ex_bitmap, except_map,
2584                         vec_len (wrk->ex_bitmap) * sizeof (vcl_si_set));
2585       memset (except_map, 0, vec_len (wrk->ex_bitmap) * sizeof (vcl_si_set));
2586     }
2587
2588   if (!n_bits)
2589     return 0;
2590
2591   if (!write_map)
2592     goto check_rd;
2593
2594   clib_bitmap_foreach (sid, wrk->wr_bitmap)
2595     {
2596       if (!(s = vcl_session_get (wrk, sid)))
2597         {
2598           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2599           bits_set++;
2600           continue;
2601         }
2602
2603       if (vcl_session_write_ready (s))
2604         {
2605           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2606           bits_set++;
2607         }
2608       else
2609         {
2610           svm_fifo_t *txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2611           svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF);
2612         }
2613     }
2614
2615 check_rd:
2616   if (!read_map)
2617     goto check_mq;
2618
2619   clib_bitmap_foreach (sid, wrk->rd_bitmap)
2620     {
2621       if (!(s = vcl_session_get (wrk, sid)))
2622         {
2623           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2624           bits_set++;
2625           continue;
2626         }
2627
2628       if (vcl_session_read_ready (s))
2629         {
2630           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2631           bits_set++;
2632         }
2633     }
2634
2635 check_mq:
2636
2637   for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
2638     {
2639       vcl_select_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i], n_bits,
2640                                   read_map, write_map, except_map, &bits_set);
2641     }
2642   vec_reset_length (wrk->unhandled_evts_vector);
2643
2644   if (vcm->cfg.use_mq_eventfd)
2645     vppcom_select_eventfd (wrk, n_bits, read_map, write_map, except_map,
2646                            time_to_wait, &bits_set);
2647   else
2648     vppcom_select_condvar (wrk, n_bits, read_map, write_map, except_map,
2649                            time_to_wait, &bits_set);
2650
2651   return (bits_set);
2652 }
2653
2654 static inline void
2655 vep_verify_epoll_chain (vcl_worker_t * wrk, u32 vep_handle)
2656 {
2657   vppcom_epoll_t *vep;
2658   u32 sh = vep_handle;
2659   vcl_session_t *s;
2660
2661   if (VPPCOM_DEBUG <= 2)
2662     return;
2663
2664   s = vcl_session_get_w_handle (wrk, vep_handle);
2665   if (PREDICT_FALSE (!s))
2666     {
2667       VDBG (0, "ERROR: Invalid vep_sh (%u)!", vep_handle);
2668       goto done;
2669     }
2670   if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP)))
2671     {
2672       VDBG (0, "ERROR: vep_sh (%u) is not a vep!", vep_handle);
2673       goto done;
2674     }
2675   vep = &s->vep;
2676   VDBG (0, "vep_sh (%u): Dumping epoll chain\n"
2677         "{\n"
2678         "   is_vep         = %u\n"
2679         "   is_vep_session = %u\n"
2680         "   next_sh        = 0x%x (%u)\n"
2681         "}\n", vep_handle, s->flags & VCL_SESSION_F_IS_VEP,
2682         s->flags & VCL_SESSION_F_IS_VEP_SESSION, vep->next_sh, vep->next_sh);
2683
2684   for (sh = vep->next_sh; sh != ~0; sh = vep->next_sh)
2685     {
2686       s = vcl_session_get_w_handle (wrk, sh);
2687       if (PREDICT_FALSE (!s))
2688         {
2689           VDBG (0, "ERROR: Invalid sh (%u)!", sh);
2690           goto done;
2691         }
2692       if (PREDICT_FALSE (s->flags & VCL_SESSION_F_IS_VEP))
2693         {
2694           VDBG (0, "ERROR: sh (%u) is a vep!", vep_handle);
2695         }
2696       else if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP_SESSION)))
2697         {
2698           VDBG (0, "ERROR: sh (%u) is not a vep session handle!", sh);
2699           goto done;
2700         }
2701       vep = &s->vep;
2702       if (PREDICT_FALSE (vep->vep_sh != vep_handle))
2703         VDBG (0, "ERROR: session (%u) vep_sh (%u) != vep_sh (%u)!",
2704               sh, s->vep.vep_sh, vep_handle);
2705       if (s->flags & VCL_SESSION_F_IS_VEP_SESSION)
2706         {
2707           VDBG (0, "vep_sh[%u]: sh 0x%x (%u)\n"
2708                 "{\n"
2709                 "   next_sh        = 0x%x (%u)\n"
2710                 "   prev_sh        = 0x%x (%u)\n"
2711                 "   vep_sh         = 0x%x (%u)\n"
2712                 "   ev.events      = 0x%x\n"
2713                 "   ev.data.u64    = 0x%llx\n"
2714                 "   et_mask        = 0x%x\n"
2715                 "}\n",
2716                 vep_handle, sh, sh, vep->next_sh, vep->next_sh, vep->prev_sh,
2717                 vep->prev_sh, vep->vep_sh, vep->vep_sh, vep->ev.events,
2718                 vep->ev.data.u64, vep->et_mask);
2719         }
2720     }
2721
2722 done:
2723   VDBG (0, "vep_sh (%u): Dump complete!\n", vep_handle);
2724 }
2725
2726 int
2727 vppcom_epoll_create (void)
2728 {
2729   vcl_worker_t *wrk = vcl_worker_get_current ();
2730   vcl_session_t *vep_session;
2731
2732   vep_session = vcl_session_alloc (wrk);
2733
2734   vep_session->flags |= VCL_SESSION_F_IS_VEP;
2735   vep_session->vep.vep_sh = ~0;
2736   vep_session->vep.next_sh = ~0;
2737   vep_session->vep.prev_sh = ~0;
2738   vep_session->vpp_handle = ~0;
2739
2740   vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, vep_session->session_index);
2741   VDBG (0, "Created vep_idx %u", vep_session->session_index);
2742
2743   return vcl_session_handle (vep_session);
2744 }
2745
2746 int
2747 vppcom_epoll_ctl (uint32_t vep_handle, int op, uint32_t session_handle,
2748                   struct epoll_event *event)
2749 {
2750   vcl_worker_t *wrk = vcl_worker_get_current ();
2751   int rv = VPPCOM_OK, add_evt = 0;
2752   vcl_session_t *vep_session;
2753   vcl_session_t *s;
2754   svm_fifo_t *txf;
2755
2756   if (vep_handle == session_handle)
2757     {
2758       VDBG (0, "vep_sh == session handle (%u)!", vep_handle);
2759       return VPPCOM_EINVAL;
2760     }
2761
2762   vep_session = vcl_session_get_w_handle (wrk, vep_handle);
2763   if (PREDICT_FALSE (!vep_session))
2764     {
2765       VDBG (0, "Invalid vep_sh (%u)!", vep_handle);
2766       return VPPCOM_EBADFD;
2767     }
2768   if (PREDICT_FALSE (!(vep_session->flags & VCL_SESSION_F_IS_VEP)))
2769     {
2770       VDBG (0, "vep_sh (%u) is not a vep!", vep_handle);
2771       return VPPCOM_EINVAL;
2772     }
2773
2774   ASSERT (vep_session->vep.vep_sh == ~0);
2775   ASSERT (vep_session->vep.prev_sh == ~0);
2776
2777   s = vcl_session_get_w_handle (wrk, session_handle);
2778   if (PREDICT_FALSE (!s))
2779     {
2780       VDBG (0, "Invalid session_handle (%u)!", session_handle);
2781       return VPPCOM_EBADFD;
2782     }
2783   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_IS_VEP))
2784     {
2785       VDBG (0, "session_handle (%u) is a vep!", vep_handle);
2786       return VPPCOM_EINVAL;
2787     }
2788
2789   switch (op)
2790     {
2791     case EPOLL_CTL_ADD:
2792       if (PREDICT_FALSE (!event))
2793         {
2794           VDBG (0, "EPOLL_CTL_ADD: NULL pointer to epoll_event structure!");
2795           return VPPCOM_EINVAL;
2796         }
2797       if (s->flags & VCL_SESSION_F_IS_VEP_SESSION)
2798         {
2799           VDBG (0, "EPOLL_CTL_ADD: %u already epolled!", s->session_index);
2800           rv = VPPCOM_EEXIST;
2801           goto done;
2802         }
2803       if (vep_session->vep.next_sh != ~0)
2804         {
2805           vcl_session_t *next_session;
2806           next_session = vcl_session_get_w_handle (wrk,
2807                                                    vep_session->vep.next_sh);
2808           if (PREDICT_FALSE (!next_session))
2809             {
2810               VDBG (0, "EPOLL_CTL_ADD: Invalid vep.next_sh (%u) on "
2811                     "vep_idx (%u)!", vep_session->vep.next_sh, vep_handle);
2812               return VPPCOM_EBADFD;
2813             }
2814           ASSERT (next_session->vep.prev_sh == vep_handle);
2815           next_session->vep.prev_sh = session_handle;
2816         }
2817       s->vep.next_sh = vep_session->vep.next_sh;
2818       s->vep.prev_sh = vep_handle;
2819       s->vep.vep_sh = vep_handle;
2820       s->vep.et_mask = VEP_DEFAULT_ET_MASK;
2821       s->vep.lt_next = VCL_INVALID_SESSION_INDEX;
2822       s->vep.ev = *event;
2823       s->flags &= ~VCL_SESSION_F_IS_VEP;
2824       s->flags |= VCL_SESSION_F_IS_VEP_SESSION;
2825       vep_session->vep.next_sh = session_handle;
2826
2827       txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2828       if (txf && (event->events & EPOLLOUT))
2829         svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2830
2831       /* Generate EPOLLOUT if tx fifo not full */
2832       if ((event->events & EPOLLOUT) && (vcl_session_write_ready (s) > 0))
2833         {
2834           session_event_t e = { 0 };
2835           e.event_type = SESSION_IO_EVT_TX;
2836           e.session_index = s->session_index;
2837           vec_add1 (wrk->unhandled_evts_vector, e);
2838           add_evt = 1;
2839         }
2840       /* Generate EPOLLIN if rx fifo has data */
2841       if ((event->events & EPOLLIN) && (vcl_session_read_ready (s) > 0))
2842         {
2843           session_event_t e = { 0 };
2844           e.event_type = SESSION_IO_EVT_RX;
2845           e.session_index = s->session_index;
2846           vec_add1 (wrk->unhandled_evts_vector, e);
2847           s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2848           add_evt = 1;
2849         }
2850       if (!add_evt && vcl_session_is_closing (s))
2851         {
2852           session_event_t e = { 0 };
2853           if (s->session_state == VCL_STATE_VPP_CLOSING)
2854             e.event_type = SESSION_CTRL_EVT_DISCONNECTED;
2855           else
2856             e.event_type = SESSION_CTRL_EVT_RESET;
2857           e.session_index = s->session_index;
2858           e.postponed = 1;
2859           vec_add1 (wrk->unhandled_evts_vector, e);
2860         }
2861       VDBG (1, "EPOLL_CTL_ADD: vep_sh %u, sh %u, events 0x%x, data 0x%llx!",
2862             vep_handle, session_handle, event->events, event->data.u64);
2863       vcl_evt (VCL_EVT_EPOLL_CTLADD, s, event->events, event->data.u64);
2864       break;
2865
2866     case EPOLL_CTL_MOD:
2867       if (PREDICT_FALSE (!event))
2868         {
2869           VDBG (0, "EPOLL_CTL_MOD: NULL pointer to epoll_event structure!");
2870           rv = VPPCOM_EINVAL;
2871           goto done;
2872         }
2873       else if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP_SESSION)))
2874         {
2875           VDBG (0, "sh %u EPOLL_CTL_MOD: not a vep session!", session_handle);
2876           rv = VPPCOM_ENOENT;
2877           goto done;
2878         }
2879       else if (PREDICT_FALSE (s->vep.vep_sh != vep_handle))
2880         {
2881           VDBG (0, "EPOLL_CTL_MOD: sh %u vep_sh (%u) != vep_sh (%u)!",
2882                 session_handle, s->vep.vep_sh, vep_handle);
2883           rv = VPPCOM_EINVAL;
2884           goto done;
2885         }
2886
2887       /* Generate EPOLLOUT if session write ready nd event was not on */
2888       if ((event->events & EPOLLOUT) && !(s->vep.ev.events & EPOLLOUT) &&
2889           (vcl_session_write_ready (s) > 0))
2890         {
2891           session_event_t e = { 0 };
2892           e.event_type = SESSION_IO_EVT_TX;
2893           e.session_index = s->session_index;
2894           vec_add1 (wrk->unhandled_evts_vector, e);
2895         }
2896       /* Generate EPOLLIN if session read ready and event was not on */
2897       if ((event->events & EPOLLIN) && !(s->vep.ev.events & EPOLLIN) &&
2898           (vcl_session_read_ready (s) > 0))
2899         {
2900           session_event_t e = { 0 };
2901           e.event_type = SESSION_IO_EVT_RX;
2902           e.session_index = s->session_index;
2903           vec_add1 (wrk->unhandled_evts_vector, e);
2904           s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2905         }
2906       s->vep.et_mask = VEP_DEFAULT_ET_MASK;
2907       s->vep.ev = *event;
2908       txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2909       if (txf)
2910         {
2911           if (event->events & EPOLLOUT)
2912             svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2913           else
2914             svm_fifo_del_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2915         }
2916       VDBG (1, "EPOLL_CTL_MOD: vep_sh %u, sh %u, events 0x%x, data 0x%llx!",
2917             vep_handle, session_handle, event->events, event->data.u64);
2918       break;
2919
2920     case EPOLL_CTL_DEL:
2921       if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP_SESSION)))
2922         {
2923           VDBG (0, "EPOLL_CTL_DEL: %u not a vep session!", session_handle);
2924           rv = VPPCOM_ENOENT;
2925           goto done;
2926         }
2927       else if (PREDICT_FALSE (s->vep.vep_sh != vep_handle))
2928         {
2929           VDBG (0, "EPOLL_CTL_DEL: sh %u vep_sh (%u) != vep_sh (%u)!",
2930                 session_handle, s->vep.vep_sh, vep_handle);
2931           rv = VPPCOM_EINVAL;
2932           goto done;
2933         }
2934
2935       if (s->vep.prev_sh == vep_handle)
2936         vep_session->vep.next_sh = s->vep.next_sh;
2937       else
2938         {
2939           vcl_session_t *prev_session;
2940           prev_session = vcl_session_get_w_handle (wrk, s->vep.prev_sh);
2941           if (PREDICT_FALSE (!prev_session))
2942             {
2943               VDBG (0, "EPOLL_CTL_DEL: Invalid prev_sh (%u) on sh (%u)!",
2944                     s->vep.prev_sh, session_handle);
2945               return VPPCOM_EBADFD;
2946             }
2947           ASSERT (prev_session->vep.next_sh == session_handle);
2948           prev_session->vep.next_sh = s->vep.next_sh;
2949         }
2950       if (s->vep.next_sh != ~0)
2951         {
2952           vcl_session_t *next_session;
2953           next_session = vcl_session_get_w_handle (wrk, s->vep.next_sh);
2954           if (PREDICT_FALSE (!next_session))
2955             {
2956               VDBG (0, "EPOLL_CTL_DEL: Invalid next_sh (%u) on sh (%u)!",
2957                     s->vep.next_sh, session_handle);
2958               return VPPCOM_EBADFD;
2959             }
2960           ASSERT (next_session->vep.prev_sh == session_handle);
2961           next_session->vep.prev_sh = s->vep.prev_sh;
2962         }
2963
2964       if (s->vep.lt_next != VCL_INVALID_SESSION_INDEX)
2965         vcl_epoll_lt_del (wrk, s);
2966
2967       memset (&s->vep, 0, sizeof (s->vep));
2968       s->vep.next_sh = ~0;
2969       s->vep.prev_sh = ~0;
2970       s->vep.vep_sh = ~0;
2971       s->vep.lt_next = VCL_INVALID_SESSION_INDEX;
2972       s->flags &= ~VCL_SESSION_F_IS_VEP_SESSION;
2973
2974       if (vcl_session_is_open (s))
2975         {
2976           txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2977           if (txf)
2978             svm_fifo_del_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2979         }
2980
2981       VDBG (1, "EPOLL_CTL_DEL: vep_idx %u, sh %u!", vep_handle,
2982             session_handle);
2983       vcl_evt (VCL_EVT_EPOLL_CTLDEL, s, vep_sh);
2984       break;
2985
2986     default:
2987       VDBG (0, "Invalid operation (%d)!", op);
2988       rv = VPPCOM_EINVAL;
2989     }
2990
2991   vep_verify_epoll_chain (wrk, vep_handle);
2992
2993 done:
2994   return rv;
2995 }
2996
2997 static inline void
2998 vcl_epoll_wait_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
2999                                 struct epoll_event *events, u32 * num_ev)
3000 {
3001   session_disconnected_msg_t *disconnected_msg;
3002   session_connected_msg_t *connected_msg;
3003   u32 sid = ~0, session_events;
3004   u64 session_evt_data = ~0;
3005   vcl_session_t *s;
3006   u8 add_event = 0;
3007
3008   switch (e->event_type)
3009     {
3010     case SESSION_IO_EVT_RX:
3011       sid = e->session_index;
3012       s = vcl_session_get (wrk, sid);
3013       if (vcl_session_is_closed (s))
3014         break;
3015       vcl_fifo_rx_evt_valid_or_break (s);
3016       session_events = s->vep.ev.events;
3017       if (!(EPOLLIN & s->vep.ev.events)
3018           || (s->flags & VCL_SESSION_F_HAS_RX_EVT))
3019         break;
3020       add_event = 1;
3021       events[*num_ev].events = EPOLLIN;
3022       session_evt_data = s->vep.ev.data.u64;
3023       s->flags |= VCL_SESSION_F_HAS_RX_EVT;
3024       break;
3025     case SESSION_IO_EVT_TX:
3026       sid = e->session_index;
3027       s = vcl_session_get (wrk, sid);
3028       if (vcl_session_is_closed (s))
3029         break;
3030       session_events = s->vep.ev.events;
3031       if (!(EPOLLOUT & session_events))
3032         break;
3033       add_event = 1;
3034       events[*num_ev].events = EPOLLOUT;
3035       session_evt_data = s->vep.ev.data.u64;
3036       svm_fifo_reset_has_deq_ntf (vcl_session_is_ct (s) ?
3037                                   s->ct_tx_fifo : s->tx_fifo);
3038       break;
3039     case SESSION_CTRL_EVT_ACCEPTED:
3040       if (!e->postponed)
3041         s = vcl_session_accepted (wrk, (session_accepted_msg_t *) e->data);
3042       else
3043         s = vcl_session_get (wrk, e->session_index);
3044       if (!s)
3045         break;
3046       session_events = s->vep.ev.events;
3047       sid = s->session_index;
3048       if (!(EPOLLIN & session_events))
3049         break;
3050       add_event = 1;
3051       events[*num_ev].events = EPOLLIN;
3052       session_evt_data = s->vep.ev.data.u64;
3053       break;
3054     case SESSION_CTRL_EVT_CONNECTED:
3055       if (!e->postponed)
3056         {
3057           connected_msg = (session_connected_msg_t *) e->data;
3058           sid = vcl_session_connected_handler (wrk, connected_msg);
3059         }
3060       else
3061         sid = e->session_index;
3062       s = vcl_session_get (wrk, sid);
3063       if (vcl_session_is_closed (s))
3064         break;
3065       session_events = s->vep.ev.events;
3066       /* Generate EPOLLOUT because there's no connected event */
3067       if (!(EPOLLOUT & session_events))
3068         break;
3069       add_event = 1;
3070       events[*num_ev].events = EPOLLOUT;
3071       session_evt_data = s->vep.ev.data.u64;
3072       if (s->session_state == VCL_STATE_DETACHED)
3073         events[*num_ev].events |= EPOLLHUP;
3074       break;
3075     case SESSION_CTRL_EVT_DISCONNECTED:
3076       if (!e->postponed)
3077         {
3078           disconnected_msg = (session_disconnected_msg_t *) e->data;
3079           s = vcl_session_disconnected_handler (wrk, disconnected_msg);
3080         }
3081       else
3082         {
3083           s = vcl_session_get (wrk, e->session_index);
3084         }
3085       if (vcl_session_is_closed (s) ||
3086           !(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
3087         break;
3088       sid = s->session_index;
3089       session_events = s->vep.ev.events;
3090       add_event = 1;
3091       events[*num_ev].events = EPOLLHUP | EPOLLRDHUP;
3092       session_evt_data = s->vep.ev.data.u64;
3093       break;
3094     case SESSION_CTRL_EVT_RESET:
3095       if (!e->postponed)
3096         sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
3097       else
3098         sid = e->session_index;
3099       s = vcl_session_get (wrk, sid);
3100       if (vcl_session_is_closed (s) ||
3101           !(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
3102         break;
3103       session_events = s->vep.ev.events;
3104       add_event = 1;
3105       events[*num_ev].events = EPOLLHUP | EPOLLRDHUP;
3106       session_evt_data = s->vep.ev.data.u64;
3107       break;
3108     case SESSION_CTRL_EVT_UNLISTEN_REPLY:
3109       vcl_session_unlisten_reply_handler (wrk, e->data);
3110       break;
3111     case SESSION_CTRL_EVT_MIGRATED:
3112       vcl_session_migrated_handler (wrk, e->data);
3113       break;
3114     case SESSION_CTRL_EVT_CLEANUP:
3115       vcl_session_cleanup_handler (wrk, e->data);
3116       break;
3117     case SESSION_CTRL_EVT_REQ_WORKER_UPDATE:
3118       vcl_session_req_worker_update_handler (wrk, e->data);
3119       break;
3120     case SESSION_CTRL_EVT_WORKER_UPDATE_REPLY:
3121       vcl_session_worker_update_reply_handler (wrk, e->data);
3122       break;
3123     case SESSION_CTRL_EVT_APP_ADD_SEGMENT:
3124       vcl_session_app_add_segment_handler (wrk, e->data);
3125       break;
3126     case SESSION_CTRL_EVT_APP_DEL_SEGMENT:
3127       vcl_session_app_del_segment_handler (wrk, e->data);
3128       break;
3129     case SESSION_CTRL_EVT_APP_WRK_RPC:
3130       vcl_worker_rpc_handler (wrk, e->data);
3131       break;
3132     default:
3133       VDBG (0, "unhandled: %u", e->event_type);
3134       break;
3135     }
3136
3137   if (add_event)
3138     {
3139       events[*num_ev].data.u64 = session_evt_data;
3140       if (EPOLLONESHOT & session_events)
3141         {
3142           s = vcl_session_get (wrk, sid);
3143           s->vep.ev.events = 0;
3144         }
3145       else if (!(EPOLLET & session_events))
3146         {
3147           s = vcl_session_get (wrk, sid);
3148           if (s->vep.lt_next == VCL_INVALID_SESSION_INDEX)
3149             vcl_epoll_lt_add (wrk, s);
3150         }
3151       *num_ev += 1;
3152     }
3153 }
3154
3155 static int
3156 vcl_epoll_wait_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
3157                           struct epoll_event *events, u32 maxevents,
3158                           double wait_for_time, u32 * num_ev)
3159 {
3160   svm_msg_q_msg_t *msg;
3161   session_event_t *e;
3162   int i;
3163
3164   if (vec_len (wrk->mq_msg_vector) && svm_msg_q_is_empty (mq))
3165     goto handle_dequeued;
3166
3167   if (svm_msg_q_is_empty (mq))
3168     {
3169       if (!wait_for_time)
3170         return 0;
3171       else if (wait_for_time < 0)
3172         svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
3173       else
3174         {
3175           if (svm_msg_q_timedwait (mq, wait_for_time / 1e3))
3176             return 0;
3177         }
3178     }
3179   ASSERT (maxevents > *num_ev);
3180   vcl_mq_dequeue_batch (wrk, mq, ~0);
3181
3182 handle_dequeued:
3183   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
3184     {
3185       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
3186       e = svm_msg_q_msg_data (mq, msg);
3187       if (*num_ev < maxevents)
3188         vcl_epoll_wait_handle_mq_event (wrk, e, events, num_ev);
3189       else
3190         vcl_handle_mq_event (wrk, e);
3191       svm_msg_q_free_msg (mq, msg);
3192     }
3193   vec_reset_length (wrk->mq_msg_vector);
3194   vcl_handle_pending_wrk_updates (wrk);
3195   return *num_ev;
3196 }
3197
3198 static int
3199 vppcom_epoll_wait_condvar (vcl_worker_t *wrk, struct epoll_event *events,
3200                            int maxevents, u32 n_evts, double timeout_ms)
3201 {
3202   double end = -1;
3203
3204   if (!n_evts)
3205     {
3206       if (timeout_ms > 0)
3207         end = clib_time_now (&wrk->clib_time) + (timeout_ms / 1e3);
3208     }
3209
3210   do
3211     {
3212       vcl_epoll_wait_handle_mq (wrk, wrk->app_event_queue, events, maxevents,
3213                                 timeout_ms, &n_evts);
3214       if (n_evts || !timeout_ms)
3215         return n_evts;
3216     }
3217   while (end == -1 || clib_time_now (&wrk->clib_time) < end);
3218
3219   return 0;
3220 }
3221
3222 static int
3223 vppcom_epoll_wait_eventfd (vcl_worker_t *wrk, struct epoll_event *events,
3224                            int maxevents, u32 n_evts, double timeout_ms)
3225 {
3226   int __clib_unused n_read;
3227   vcl_mq_evt_conn_t *mqc;
3228   int n_mq_evts, i;
3229   double end = -1;
3230   u64 buf;
3231
3232   vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
3233   if (!n_evts)
3234     {
3235       if (timeout_ms > 0)
3236         end = clib_time_now (&wrk->clib_time) + (timeout_ms / 1e3);
3237     }
3238
3239   do
3240     {
3241       n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
3242                               vec_len (wrk->mq_events), timeout_ms);
3243       if (n_mq_evts < 0)
3244         {
3245           VDBG (0, "epoll_wait error %u", errno);
3246           return n_evts;
3247         }
3248
3249       for (i = 0; i < n_mq_evts; i++)
3250         {
3251           mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
3252           n_read = read (mqc->mq_fd, &buf, sizeof (buf));
3253           vcl_epoll_wait_handle_mq (wrk, mqc->mq, events, maxevents, 0,
3254                                     &n_evts);
3255         }
3256
3257       if (n_evts || !timeout_ms)
3258         return n_evts;
3259     }
3260   while (end == -1 || clib_time_now (&wrk->clib_time) < end);
3261
3262   return 0;
3263 }
3264
3265 static void
3266 vcl_epoll_wait_handle_lt (vcl_worker_t *wrk, struct epoll_event *events,
3267                           int maxevents, u32 *n_evts)
3268 {
3269   u32 add_event, next;
3270   vcl_session_t *s;
3271   u64 evt_data;
3272   int rv;
3273
3274   ASSERT (wrk->ep_lt_current != VCL_INVALID_SESSION_INDEX);
3275   if (*n_evts >= maxevents)
3276     return;
3277
3278   next = wrk->ep_lt_current;
3279   do
3280     {
3281       s = vcl_session_get (wrk, next);
3282       next = s->vep.lt_next;
3283
3284       if ((s->vep.ev.events & EPOLLIN) && (rv = vcl_session_read_ready (s)))
3285         {
3286           add_event = 1;
3287           events[*n_evts].events |= rv > 0 ? EPOLLIN : EPOLLHUP | EPOLLRDHUP;
3288           evt_data = s->vep.ev.data.u64;
3289         }
3290       if ((s->vep.ev.events & EPOLLOUT) && (rv = vcl_session_write_ready (s)))
3291         {
3292           add_event = 1;
3293           events[*n_evts].events |= rv > 0 ? EPOLLOUT : EPOLLHUP | EPOLLRDHUP;
3294           evt_data = s->vep.ev.data.u64;
3295         }
3296       if (!add_event && s->session_state > VCL_STATE_READY)
3297         {
3298           add_event = 1;
3299           events[*n_evts].events |= EPOLLHUP | EPOLLRDHUP;
3300           evt_data = s->vep.ev.data.u64;
3301         }
3302       if (add_event)
3303         {
3304           events[*n_evts].data.u64 = evt_data;
3305           *n_evts += 1;
3306           add_event = 0;
3307           if (EPOLLONESHOT & s->vep.ev.events)
3308             s->vep.ev.events = 0;
3309           if (*n_evts == maxevents)
3310             {
3311               wrk->ep_lt_current = next;
3312               break;
3313             }
3314         }
3315       else
3316         {
3317           vcl_epoll_lt_del (wrk, s);
3318           if (wrk->ep_lt_current == VCL_INVALID_SESSION_INDEX)
3319             break;
3320         }
3321     }
3322   while (next != wrk->ep_lt_current);
3323 }
3324
3325 int
3326 vppcom_epoll_wait (uint32_t vep_handle, struct epoll_event *events,
3327                    int maxevents, double wait_for_time)
3328 {
3329   vcl_worker_t *wrk = vcl_worker_get_current ();
3330   vcl_session_t *vep_session;
3331   u32 n_evts = 0;
3332   int i;
3333
3334   if (PREDICT_FALSE (maxevents <= 0))
3335     {
3336       VDBG (0, "ERROR: Invalid maxevents (%d)!", maxevents);
3337       return VPPCOM_EINVAL;
3338     }
3339
3340   vep_session = vcl_session_get_w_handle (wrk, vep_handle);
3341   if (!vep_session)
3342     return VPPCOM_EBADFD;
3343
3344   if (PREDICT_FALSE (!(vep_session->flags & VCL_SESSION_F_IS_VEP)))
3345     {
3346       VDBG (0, "ERROR: vep_idx (%u) is not a vep!", vep_handle);
3347       return VPPCOM_EINVAL;
3348     }
3349
3350   if (vec_len (wrk->unhandled_evts_vector))
3351     {
3352       for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
3353         {
3354           vcl_epoll_wait_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i],
3355                                           events, &n_evts);
3356           if (n_evts == maxevents)
3357             {
3358               vec_delete (wrk->unhandled_evts_vector, i + 1, 0);
3359               return n_evts;
3360             }
3361         }
3362       vec_reset_length (wrk->unhandled_evts_vector);
3363     }
3364   /* Request to only drain unhandled */
3365   if ((int) wait_for_time == -2)
3366     return n_evts;
3367
3368
3369   if (vcm->cfg.use_mq_eventfd)
3370     n_evts = vppcom_epoll_wait_eventfd (wrk, events, maxevents, n_evts,
3371                                         wait_for_time);
3372   else
3373     n_evts = vppcom_epoll_wait_condvar (wrk, events, maxevents, n_evts,
3374                                         wait_for_time);
3375
3376   if (PREDICT_FALSE (wrk->ep_lt_current != VCL_INVALID_SESSION_INDEX))
3377     vcl_epoll_wait_handle_lt (wrk, events, maxevents, &n_evts);
3378
3379   return n_evts;
3380 }
3381
3382 int
3383 vppcom_session_attr (uint32_t session_handle, uint32_t op,
3384                      void *buffer, uint32_t * buflen)
3385 {
3386   vcl_worker_t *wrk = vcl_worker_get_current ();
3387   u32 *flags = buffer;
3388   vppcom_endpt_t *ep = buffer;
3389   transport_endpt_attr_t tea;
3390   vcl_session_t *session;
3391   int rv = VPPCOM_OK;
3392
3393   session = vcl_session_get_w_handle (wrk, session_handle);
3394   if (!session)
3395     return VPPCOM_EBADFD;
3396
3397   switch (op)
3398     {
3399     case VPPCOM_ATTR_GET_NREAD:
3400       rv = vcl_session_read_ready (session);
3401       VDBG (2, "VPPCOM_ATTR_GET_NREAD: sh %u, nread = %d", session_handle,
3402             rv);
3403       break;
3404
3405     case VPPCOM_ATTR_GET_NWRITE:
3406       rv = vcl_session_write_ready (session);
3407       VDBG (2, "VPPCOM_ATTR_GET_NWRITE: sh %u, nwrite = %d", session_handle,
3408             rv);
3409       break;
3410
3411     case VPPCOM_ATTR_GET_FLAGS:
3412       if (PREDICT_TRUE (buffer && buflen && (*buflen >= sizeof (*flags))))
3413         {
3414           *flags =
3415             O_RDWR |
3416             (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK) ?
3417              O_NONBLOCK : 0);
3418           *buflen = sizeof (*flags);
3419           VDBG (2, "VPPCOM_ATTR_GET_FLAGS: sh %u, flags = 0x%08x, "
3420                 "is_nonblocking = %u", session_handle, *flags,
3421                 vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK));
3422         }
3423       else
3424         rv = VPPCOM_EINVAL;
3425       break;
3426
3427     case VPPCOM_ATTR_SET_FLAGS:
3428       if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
3429         {
3430           if (*flags & O_NONBLOCK)
3431             vcl_session_set_attr (session, VCL_SESS_ATTR_NONBLOCK);
3432           else
3433             vcl_session_clear_attr (session, VCL_SESS_ATTR_NONBLOCK);
3434
3435           VDBG (2, "VPPCOM_ATTR_SET_FLAGS: sh %u, flags = 0x%08x,"
3436                 " is_nonblocking = %u", session_handle, *flags,
3437                 vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK));
3438         }
3439       else
3440         rv = VPPCOM_EINVAL;
3441       break;
3442
3443     case VPPCOM_ATTR_GET_PEER_ADDR:
3444       if (PREDICT_TRUE (buffer && buflen &&
3445                         (*buflen >= sizeof (*ep)) && ep->ip))
3446         {
3447           ep->is_ip4 = session->transport.is_ip4;
3448           ep->port = session->transport.rmt_port;
3449           if (session->transport.is_ip4)
3450             clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip4,
3451                               sizeof (ip4_address_t));
3452           else
3453             clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip6,
3454                               sizeof (ip6_address_t));
3455           *buflen = sizeof (*ep);
3456           VDBG (1, "VPPCOM_ATTR_GET_PEER_ADDR: sh %u, is_ip4 = %u, "
3457                 "addr = %U, port %u", session_handle, ep->is_ip4,
3458                 format_ip46_address, &session->transport.rmt_ip,
3459                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
3460                 clib_net_to_host_u16 (ep->port));
3461         }
3462       else
3463         rv = VPPCOM_EINVAL;
3464       break;
3465
3466     case VPPCOM_ATTR_GET_LCL_ADDR:
3467       if (PREDICT_TRUE (buffer && buflen &&
3468                         (*buflen >= sizeof (*ep)) && ep->ip))
3469         {
3470           ep->is_ip4 = session->transport.is_ip4;
3471           ep->port = session->transport.lcl_port;
3472           if (session->transport.is_ip4)
3473             clib_memcpy_fast (ep->ip, &session->transport.lcl_ip.ip4,
3474                               sizeof (ip4_address_t));
3475           else
3476             clib_memcpy_fast (ep->ip, &session->transport.lcl_ip.ip6,
3477                               sizeof (ip6_address_t));
3478           *buflen = sizeof (*ep);
3479           VDBG (1, "VPPCOM_ATTR_GET_LCL_ADDR: sh %u, is_ip4 = %u, addr = %U"
3480                 " port %d", session_handle, ep->is_ip4, format_ip46_address,
3481                 &session->transport.lcl_ip,
3482                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
3483                 clib_net_to_host_u16 (ep->port));
3484         }
3485       else
3486         rv = VPPCOM_EINVAL;
3487       break;
3488
3489     case VPPCOM_ATTR_SET_LCL_ADDR:
3490       if (PREDICT_TRUE (buffer && buflen &&
3491                         (*buflen >= sizeof (*ep)) && ep->ip))
3492         {
3493           session->transport.is_ip4 = ep->is_ip4;
3494           session->transport.lcl_port = ep->port;
3495           vcl_ip_copy_from_ep (&session->transport.lcl_ip, ep);
3496           *buflen = sizeof (*ep);
3497           VDBG (1, "VPPCOM_ATTR_SET_LCL_ADDR: sh %u, is_ip4 = %u, addr = %U"
3498                 " port %d", session_handle, ep->is_ip4, format_ip46_address,
3499                 &session->transport.lcl_ip,
3500                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
3501                 clib_net_to_host_u16 (ep->port));
3502         }
3503       else
3504         rv = VPPCOM_EINVAL;
3505       break;
3506
3507     case VPPCOM_ATTR_GET_LIBC_EPFD:
3508       rv = session->libc_epfd;
3509       VDBG (2, "VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d", rv);
3510       break;
3511
3512     case VPPCOM_ATTR_SET_LIBC_EPFD:
3513       if (PREDICT_TRUE (buffer && buflen &&
3514                         (*buflen == sizeof (session->libc_epfd))))
3515         {
3516           session->libc_epfd = *(int *) buffer;
3517           *buflen = sizeof (session->libc_epfd);
3518
3519           VDBG (2, "VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, buflen %d",
3520                 session->libc_epfd, *buflen);
3521         }
3522       else
3523         rv = VPPCOM_EINVAL;
3524       break;
3525
3526     case VPPCOM_ATTR_GET_PROTOCOL:
3527       if (buffer && buflen && (*buflen >= sizeof (int)))
3528         {
3529           *(int *) buffer = session->session_type;
3530           *buflen = sizeof (int);
3531
3532           VDBG (2, "VPPCOM_ATTR_GET_PROTOCOL: %d (%s), buflen %d",
3533                 *(int *) buffer, *(int *) buffer ? "UDP" : "TCP", *buflen);
3534         }
3535       else
3536         rv = VPPCOM_EINVAL;
3537       break;
3538
3539     case VPPCOM_ATTR_GET_LISTEN:
3540       if (buffer && buflen && (*buflen >= sizeof (int)))
3541         {
3542           *(int *) buffer = vcl_session_has_attr (session,
3543                                                   VCL_SESS_ATTR_LISTEN);
3544           *buflen = sizeof (int);
3545
3546           VDBG (2, "VPPCOM_ATTR_GET_LISTEN: %d, buflen %d", *(int *) buffer,
3547                 *buflen);
3548         }
3549       else
3550         rv = VPPCOM_EINVAL;
3551       break;
3552
3553     case VPPCOM_ATTR_GET_ERROR:
3554       if (buffer && buflen && (*buflen >= sizeof (int)))
3555         {
3556           *(int *) buffer = 0;
3557           *buflen = sizeof (int);
3558
3559           VDBG (2, "VPPCOM_ATTR_GET_ERROR: %d, buflen %d, #VPP-TBD#",
3560                 *(int *) buffer, *buflen);
3561         }
3562       else
3563         rv = VPPCOM_EINVAL;
3564       break;
3565
3566     case VPPCOM_ATTR_GET_TX_FIFO_LEN:
3567       if (buffer && buflen && (*buflen >= sizeof (u32)))
3568         {
3569
3570           /* VPP-TBD */
3571           *(size_t *) buffer = (session->sndbuf_size ? session->sndbuf_size :
3572                                 session->tx_fifo ?
3573                                 svm_fifo_size (session->tx_fifo) :
3574                                 vcm->cfg.tx_fifo_size);
3575           *buflen = sizeof (u32);
3576
3577           VDBG (2, "VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), buflen %d,"
3578                 " #VPP-TBD#", *(size_t *) buffer, *(size_t *) buffer,
3579                 *buflen);
3580         }
3581       else
3582         rv = VPPCOM_EINVAL;
3583       break;
3584
3585     case VPPCOM_ATTR_SET_TX_FIFO_LEN:
3586       if (buffer && buflen && (*buflen == sizeof (u32)))
3587         {
3588           /* VPP-TBD */
3589           session->sndbuf_size = *(u32 *) buffer;
3590           VDBG (2, "VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), buflen %d,"
3591                 " #VPP-TBD#", session->sndbuf_size, session->sndbuf_size,
3592                 *buflen);
3593         }
3594       else
3595         rv = VPPCOM_EINVAL;
3596       break;
3597
3598     case VPPCOM_ATTR_GET_RX_FIFO_LEN:
3599       if (buffer && buflen && (*buflen >= sizeof (u32)))
3600         {
3601
3602           /* VPP-TBD */
3603           *(size_t *) buffer = (session->rcvbuf_size ? session->rcvbuf_size :
3604                                 session->rx_fifo ?
3605                                 svm_fifo_size (session->rx_fifo) :
3606                                 vcm->cfg.rx_fifo_size);
3607           *buflen = sizeof (u32);
3608
3609           VDBG (2, "VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), buflen %d, "
3610                 "#VPP-TBD#", *(size_t *) buffer, *(size_t *) buffer, *buflen);
3611         }
3612       else
3613         rv = VPPCOM_EINVAL;
3614       break;
3615
3616     case VPPCOM_ATTR_SET_RX_FIFO_LEN:
3617       if (buffer && buflen && (*buflen == sizeof (u32)))
3618         {
3619           /* VPP-TBD */
3620           session->rcvbuf_size = *(u32 *) buffer;
3621           VDBG (2, "VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), buflen %d,"
3622                 " #VPP-TBD#", session->sndbuf_size, session->sndbuf_size,
3623                 *buflen);
3624         }
3625       else
3626         rv = VPPCOM_EINVAL;
3627       break;
3628
3629     case VPPCOM_ATTR_GET_REUSEADDR:
3630       if (buffer && buflen && (*buflen >= sizeof (int)))
3631         {
3632           /* VPP-TBD */
3633           *(int *) buffer = vcl_session_has_attr (session,
3634                                                   VCL_SESS_ATTR_REUSEADDR);
3635           *buflen = sizeof (int);
3636
3637           VDBG (2, "VPPCOM_ATTR_GET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
3638                 *(int *) buffer, *buflen);
3639         }
3640       else
3641         rv = VPPCOM_EINVAL;
3642       break;
3643
3644     case VPPCOM_ATTR_SET_REUSEADDR:
3645       if (buffer && buflen && (*buflen == sizeof (int)) &&
3646           !vcl_session_has_attr (session, VCL_SESS_ATTR_LISTEN))
3647         {
3648           /* VPP-TBD */
3649           if (*(int *) buffer)
3650             vcl_session_set_attr (session, VCL_SESS_ATTR_REUSEADDR);
3651           else
3652             vcl_session_clear_attr (session, VCL_SESS_ATTR_REUSEADDR);
3653
3654           VDBG (2, "VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
3655                 vcl_session_has_attr (session, VCL_SESS_ATTR_REUSEADDR),
3656                 *buflen);
3657         }
3658       else
3659         rv = VPPCOM_EINVAL;
3660       break;
3661
3662     case VPPCOM_ATTR_GET_REUSEPORT:
3663       if (buffer && buflen && (*buflen >= sizeof (int)))
3664         {
3665           /* VPP-TBD */
3666           *(int *) buffer = vcl_session_has_attr (session,
3667                                                   VCL_SESS_ATTR_REUSEPORT);
3668           *buflen = sizeof (int);
3669
3670           VDBG (2, "VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
3671                 *(int *) buffer, *buflen);
3672         }
3673       else
3674         rv = VPPCOM_EINVAL;
3675       break;
3676
3677     case VPPCOM_ATTR_SET_REUSEPORT:
3678       if (buffer && buflen && (*buflen == sizeof (int)) &&
3679           !vcl_session_has_attr (session, VCL_SESS_ATTR_LISTEN))
3680         {
3681           /* VPP-TBD */
3682           if (*(int *) buffer)
3683             vcl_session_set_attr (session, VCL_SESS_ATTR_REUSEPORT);
3684           else
3685             vcl_session_clear_attr (session, VCL_SESS_ATTR_REUSEPORT);
3686
3687           VDBG (2, "VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
3688                 vcl_session_has_attr (session, VCL_SESS_ATTR_REUSEPORT),
3689                 *buflen);
3690         }
3691       else
3692         rv = VPPCOM_EINVAL;
3693       break;
3694
3695     case VPPCOM_ATTR_GET_BROADCAST:
3696       if (buffer && buflen && (*buflen >= sizeof (int)))
3697         {
3698           /* VPP-TBD */
3699           *(int *) buffer = vcl_session_has_attr (session,
3700                                                   VCL_SESS_ATTR_BROADCAST);
3701           *buflen = sizeof (int);
3702
3703           VDBG (2, "VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d, #VPP-TBD#",
3704                 *(int *) buffer, *buflen);
3705         }
3706       else
3707         rv = VPPCOM_EINVAL;
3708       break;
3709
3710     case VPPCOM_ATTR_SET_BROADCAST:
3711       if (buffer && buflen && (*buflen == sizeof (int)))
3712         {
3713           /* VPP-TBD */
3714           if (*(int *) buffer)
3715             vcl_session_set_attr (session, VCL_SESS_ATTR_BROADCAST);
3716           else
3717             vcl_session_clear_attr (session, VCL_SESS_ATTR_BROADCAST);
3718
3719           VDBG (2, "VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, #VPP-TBD#",
3720                 vcl_session_has_attr (session, VCL_SESS_ATTR_BROADCAST),
3721                 *buflen);
3722         }
3723       else
3724         rv = VPPCOM_EINVAL;
3725       break;
3726
3727     case VPPCOM_ATTR_GET_V6ONLY:
3728       if (buffer && buflen && (*buflen >= sizeof (int)))
3729         {
3730           /* VPP-TBD */
3731           *(int *) buffer = vcl_session_has_attr (session,
3732                                                   VCL_SESS_ATTR_V6ONLY);
3733           *buflen = sizeof (int);
3734
3735           VDBG (2, "VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, #VPP-TBD#",
3736                 *(int *) buffer, *buflen);
3737         }
3738       else
3739         rv = VPPCOM_EINVAL;
3740       break;
3741
3742     case VPPCOM_ATTR_SET_V6ONLY:
3743       if (buffer && buflen && (*buflen == sizeof (int)))
3744         {
3745           /* VPP-TBD */
3746           if (*(int *) buffer)
3747             vcl_session_set_attr (session, VCL_SESS_ATTR_V6ONLY);
3748           else
3749             vcl_session_clear_attr (session, VCL_SESS_ATTR_V6ONLY);
3750
3751           VDBG (2, "VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, #VPP-TBD#",
3752                 vcl_session_has_attr (session, VCL_SESS_ATTR_V6ONLY),
3753                 *buflen);
3754         }
3755       else
3756         rv = VPPCOM_EINVAL;
3757       break;
3758
3759     case VPPCOM_ATTR_GET_KEEPALIVE:
3760       if (buffer && buflen && (*buflen >= sizeof (int)))
3761         {
3762           /* VPP-TBD */
3763           *(int *) buffer = vcl_session_has_attr (session,
3764                                                   VCL_SESS_ATTR_KEEPALIVE);
3765           *buflen = sizeof (int);
3766
3767           VDBG (2, "VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
3768                 *(int *) buffer, *buflen);
3769         }
3770       else
3771         rv = VPPCOM_EINVAL;
3772       break;
3773
3774     case VPPCOM_ATTR_SET_KEEPALIVE:
3775       if (buffer && buflen && (*buflen == sizeof (int)))
3776         {
3777           /* VPP-TBD */
3778           if (*(int *) buffer)
3779             vcl_session_set_attr (session, VCL_SESS_ATTR_KEEPALIVE);
3780           else
3781             vcl_session_clear_attr (session, VCL_SESS_ATTR_KEEPALIVE);
3782
3783           VDBG (2, "VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
3784                 vcl_session_has_attr (session, VCL_SESS_ATTR_KEEPALIVE),
3785                 *buflen);
3786         }
3787       else
3788         rv = VPPCOM_EINVAL;
3789       break;
3790
3791     case VPPCOM_ATTR_GET_TCP_NODELAY:
3792       if (buffer && buflen && (*buflen >= sizeof (int)))
3793         {
3794           /* VPP-TBD */
3795           *(int *) buffer = vcl_session_has_attr (session,
3796                                                   VCL_SESS_ATTR_TCP_NODELAY);
3797           *buflen = sizeof (int);
3798
3799           VDBG (2, "VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
3800                 *(int *) buffer, *buflen);
3801         }
3802       else
3803         rv = VPPCOM_EINVAL;
3804       break;
3805
3806     case VPPCOM_ATTR_SET_TCP_NODELAY:
3807       if (buffer && buflen && (*buflen == sizeof (int)))
3808         {
3809           /* VPP-TBD */
3810           if (*(int *) buffer)
3811             vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_NODELAY);
3812           else
3813             vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_NODELAY);
3814
3815           VDBG (2, "VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
3816                 vcl_session_has_attr (session, VCL_SESS_ATTR_TCP_NODELAY),
3817                 *buflen);
3818         }
3819       else
3820         rv = VPPCOM_EINVAL;
3821       break;
3822
3823     case VPPCOM_ATTR_GET_TCP_KEEPIDLE:
3824       if (buffer && buflen && (*buflen >= sizeof (int)))
3825         {
3826           /* VPP-TBD */
3827           *(int *) buffer = vcl_session_has_attr (session,
3828                                                   VCL_SESS_ATTR_TCP_KEEPIDLE);
3829           *buflen = sizeof (int);
3830
3831           VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
3832                 *(int *) buffer, *buflen);
3833         }
3834       else
3835         rv = VPPCOM_EINVAL;
3836       break;
3837
3838     case VPPCOM_ATTR_SET_TCP_KEEPIDLE:
3839       if (buffer && buflen && (*buflen == sizeof (int)))
3840         {
3841           /* VPP-TBD */
3842           if (*(int *) buffer)
3843             vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_KEEPIDLE);
3844           else
3845             vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_KEEPIDLE);
3846
3847           VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
3848                 vcl_session_has_attr (session,
3849                                       VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
3850         }
3851       else
3852         rv = VPPCOM_EINVAL;
3853       break;
3854
3855     case VPPCOM_ATTR_GET_TCP_KEEPINTVL:
3856       if (buffer && buflen && (*buflen >= sizeof (int)))
3857         {
3858           /* VPP-TBD */
3859           *(int *) buffer = vcl_session_has_attr (session,
3860                                                   VCL_SESS_ATTR_TCP_KEEPINTVL);
3861           *buflen = sizeof (int);
3862
3863           VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
3864                 *(int *) buffer, *buflen);
3865         }
3866       else
3867         rv = VPPCOM_EINVAL;
3868       break;
3869
3870     case VPPCOM_ATTR_SET_TCP_KEEPINTVL:
3871       if (buffer && buflen && (*buflen == sizeof (int)))
3872         {
3873           /* VPP-TBD */
3874           if (*(int *) buffer)
3875             vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_KEEPINTVL);
3876           else
3877             vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_KEEPINTVL);
3878
3879           VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
3880                 vcl_session_has_attr (session,
3881                                       VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
3882         }
3883       else
3884         rv = VPPCOM_EINVAL;
3885       break;
3886
3887     case VPPCOM_ATTR_GET_TCP_USER_MSS:
3888       if (!(buffer && buflen && (*buflen >= sizeof (u32))))
3889         {
3890           rv = VPPCOM_EINVAL;
3891           break;
3892         }
3893
3894       tea.type = TRANSPORT_ENDPT_ATTR_MSS;
3895       tea.mss = *(u32 *) buffer;
3896       if (vcl_session_transport_attr (wrk, session, 1 /* is_get */, &tea))
3897         rv = VPPCOM_ENOPROTOOPT;
3898
3899       if (!rv)
3900         {
3901           *(u32 *) buffer = tea.mss;
3902           *buflen = sizeof (int);
3903         }
3904
3905       VDBG (2, "VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d", *(int *) buffer,
3906             *buflen);
3907       break;
3908
3909     case VPPCOM_ATTR_SET_TCP_USER_MSS:
3910       if (!(buffer && buflen && (*buflen == sizeof (u32))))
3911         {
3912           rv = VPPCOM_EINVAL;
3913           break;
3914         }
3915
3916       tea.type = TRANSPORT_ENDPT_ATTR_MSS;
3917       tea.mss = *(u32 *) buffer;
3918       if (vcl_session_transport_attr (wrk, session, 0 /* is_get */, &tea))
3919         rv = VPPCOM_ENOPROTOOPT;
3920
3921       VDBG (2, "VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d", tea.mss,
3922             *buflen);
3923       break;
3924
3925     case VPPCOM_ATTR_SET_CONNECTED:
3926       session->flags |= VCL_SESSION_F_CONNECTED;
3927       break;
3928
3929     case VPPCOM_ATTR_SET_CKPAIR:
3930       if (!(buffer && buflen && (*buflen == sizeof (int))) ||
3931           !vcl_session_has_crypto (session))
3932         {
3933           rv = VPPCOM_EINVAL;
3934           break;
3935         }
3936       if (!session->ext_config)
3937         {
3938           vcl_session_alloc_ext_cfg (session, TRANSPORT_ENDPT_EXT_CFG_CRYPTO,
3939                                      sizeof (transport_endpt_ext_cfg_t));
3940         }
3941       else if (session->ext_config->type != TRANSPORT_ENDPT_EXT_CFG_CRYPTO)
3942         {
3943           rv = VPPCOM_EINVAL;
3944           break;
3945         }
3946
3947       session->ext_config->crypto.ckpair_index = *(uint32_t *) buffer;
3948       break;
3949
3950     case VPPCOM_ATTR_SET_VRF:
3951       if (!(buffer && buflen && (*buflen == sizeof (u32))))
3952         {
3953           rv = VPPCOM_EINVAL;
3954           break;
3955         }
3956       session->vrf = *(u32 *) buffer;
3957       break;
3958
3959     case VPPCOM_ATTR_GET_VRF:
3960       if (!(buffer && buflen && (*buflen >= sizeof (u32))))
3961         {
3962           rv = VPPCOM_EINVAL;
3963           break;
3964         }
3965       *(u32 *) buffer = session->vrf;
3966       *buflen = sizeof (u32);
3967       break;
3968
3969     case VPPCOM_ATTR_GET_DOMAIN:
3970       if (!(buffer && buflen && (*buflen >= sizeof (int))))
3971         {
3972           rv = VPPCOM_EINVAL;
3973           break;
3974         }
3975
3976       if (session->transport.is_ip4)
3977         *(int *) buffer = AF_INET;
3978       else
3979         *(int *) buffer = AF_INET6;
3980       *buflen = sizeof (int);
3981
3982       VDBG (2, "VPPCOM_ATTR_GET_DOMAIN: %d, buflen %u", *(int *) buffer,
3983             *buflen);
3984       break;
3985
3986     case VPPCOM_ATTR_SET_ENDPT_EXT_CFG:
3987       if (!(buffer && buflen && (*buflen > 0)))
3988         {
3989           rv = VPPCOM_EINVAL;
3990           break;
3991         }
3992       if (session->ext_config)
3993         {
3994           rv = VPPCOM_EINVAL;
3995           break;
3996         }
3997       vcl_session_alloc_ext_cfg (session, TRANSPORT_ENDPT_EXT_CFG_NONE,
3998                                  *buflen + sizeof (u32));
3999       clib_memcpy (session->ext_config->data, buffer, *buflen);
4000       session->ext_config->len = *buflen;
4001       break;
4002
4003     default:
4004       rv = VPPCOM_EINVAL;
4005       break;
4006     }
4007
4008   return rv;
4009 }
4010
4011 int
4012 vppcom_session_recvfrom (uint32_t session_handle, void *buffer,
4013                          uint32_t buflen, int flags, vppcom_endpt_t * ep)
4014 {
4015   vcl_worker_t *wrk = vcl_worker_get_current ();
4016   vcl_session_t *session;
4017   int rv = VPPCOM_OK;
4018
4019   if (flags == 0)
4020     rv = vppcom_session_read (session_handle, buffer, buflen);
4021   else if (flags & MSG_PEEK)
4022     rv = vppcom_session_peek (session_handle, buffer, buflen);
4023   else
4024     {
4025       VDBG (0, "Unsupport flags for recvfrom %d", flags);
4026       return VPPCOM_EAFNOSUPPORT;
4027     }
4028
4029   if (ep && rv > 0)
4030     {
4031       session = vcl_session_get_w_handle (wrk, session_handle);
4032       if (session->transport.is_ip4)
4033         clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip4,
4034                           sizeof (ip4_address_t));
4035       else
4036         clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip6,
4037                           sizeof (ip6_address_t));
4038       ep->is_ip4 = session->transport.is_ip4;
4039       ep->port = session->transport.rmt_port;
4040     }
4041
4042   return rv;
4043 }
4044
4045 int
4046 vppcom_session_sendto (uint32_t session_handle, void *buffer,
4047                        uint32_t buflen, int flags, vppcom_endpt_t * ep)
4048 {
4049   vcl_worker_t *wrk = vcl_worker_get_current ();
4050   vcl_session_t *s;
4051
4052   s = vcl_session_get_w_handle (wrk, session_handle);
4053   if (PREDICT_FALSE (!s))
4054     return VPPCOM_EBADFD;
4055
4056   if (ep)
4057     {
4058       if (!vcl_session_is_cl (s))
4059         return VPPCOM_EINVAL;
4060
4061       /* Session not connected/bound in vpp. Create it by 'connecting' it */
4062       if (PREDICT_FALSE (s->session_state == VCL_STATE_CLOSED))
4063         {
4064           u32 session_index = s->session_index;
4065           f64 timeout = vcm->cfg.session_timeout;
4066           int rv;
4067
4068           vcl_send_session_connect (wrk, s);
4069           rv = vppcom_wait_for_session_state_change (session_index,
4070                                                      VCL_STATE_READY,
4071                                                      timeout);
4072           if (rv < 0)
4073             return rv;
4074           s = vcl_session_get (wrk, session_index);
4075         }
4076
4077       s->transport.is_ip4 = ep->is_ip4;
4078       s->transport.rmt_port = ep->port;
4079       vcl_ip_copy_from_ep (&s->transport.rmt_ip, ep);
4080     }
4081
4082   if (flags)
4083     {
4084       // TBD check the flags and do the right thing
4085       VDBG (2, "handling flags 0x%u (%d) not implemented yet.", flags, flags);
4086     }
4087
4088   return (vppcom_session_write_inline (wrk, s, buffer, buflen, 1,
4089                                        s->is_dgram ? 1 : 0));
4090 }
4091
4092 int
4093 vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
4094 {
4095   vcl_worker_t *wrk = vcl_worker_get_current ();
4096   f64 timeout = clib_time_now (&wrk->clib_time) + wait_for_time;
4097   u32 i, keep_trying = 1;
4098   svm_msg_q_msg_t msg;
4099   session_event_t *e;
4100   int rv, num_ev = 0;
4101
4102   VDBG (3, "vp %p, nsids %u, wait_for_time %f", vp, n_sids, wait_for_time);
4103
4104   if (!vp)
4105     return VPPCOM_EFAULT;
4106
4107   do
4108     {
4109       vcl_session_t *session;
4110
4111       /* Dequeue all events and drop all unhandled io events */
4112       while (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_NOWAIT, 0) == 0)
4113         {
4114           e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
4115           vcl_handle_mq_event (wrk, e);
4116           svm_msg_q_free_msg (wrk->app_event_queue, &msg);
4117         }
4118       vec_reset_length (wrk->unhandled_evts_vector);
4119
4120       for (i = 0; i < n_sids; i++)
4121         {
4122           session = vcl_session_get (wrk, vp[i].sh);
4123           if (!session)
4124             {
4125               vp[i].revents = POLLHUP;
4126               num_ev++;
4127               continue;
4128             }
4129
4130           vp[i].revents = 0;
4131
4132           if (POLLIN & vp[i].events)
4133             {
4134               rv = vcl_session_read_ready (session);
4135               if (rv > 0)
4136                 {
4137                   vp[i].revents |= POLLIN;
4138                   num_ev++;
4139                 }
4140               else if (rv < 0)
4141                 {
4142                   switch (rv)
4143                     {
4144                     case VPPCOM_ECONNRESET:
4145                       vp[i].revents = POLLHUP;
4146                       break;
4147
4148                     default:
4149                       vp[i].revents = POLLERR;
4150                       break;
4151                     }
4152                   num_ev++;
4153                 }
4154             }
4155
4156           if (POLLOUT & vp[i].events)
4157             {
4158               rv = vcl_session_write_ready (session);
4159               if (rv > 0)
4160                 {
4161                   vp[i].revents |= POLLOUT;
4162                   num_ev++;
4163                 }
4164               else if (rv < 0)
4165                 {
4166                   switch (rv)
4167                     {
4168                     case VPPCOM_ECONNRESET:
4169                       vp[i].revents = POLLHUP;
4170                       break;
4171
4172                     default:
4173                       vp[i].revents = POLLERR;
4174                       break;
4175                     }
4176                   num_ev++;
4177                 }
4178             }
4179
4180           if (0)                // Note "done:" label used by VCL_SESSION_LOCK_AND_GET()
4181             {
4182               vp[i].revents = POLLNVAL;
4183               num_ev++;
4184             }
4185         }
4186       if (wait_for_time != -1)
4187         keep_trying = (clib_time_now (&wrk->clib_time) <= timeout) ? 1 : 0;
4188     }
4189   while ((num_ev == 0) && keep_trying);
4190
4191   return num_ev;
4192 }
4193
4194 int
4195 vppcom_mq_epoll_fd (void)
4196 {
4197   vcl_worker_t *wrk = vcl_worker_get_current ();
4198   return wrk->mqs_epfd;
4199 }
4200
4201 int
4202 vppcom_session_index (vcl_session_handle_t session_handle)
4203 {
4204   return session_handle & 0xFFFFFF;
4205 }
4206
4207 int
4208 vppcom_session_worker (vcl_session_handle_t session_handle)
4209 {
4210   return session_handle >> 24;
4211 }
4212
4213 int
4214 vppcom_worker_register (void)
4215 {
4216   if (!vcl_worker_alloc_and_init ())
4217     return VPPCOM_EEXIST;
4218
4219   if (vcl_worker_register_with_vpp ())
4220     return VPPCOM_EEXIST;
4221
4222   return VPPCOM_OK;
4223 }
4224
4225 void
4226 vppcom_worker_unregister (void)
4227 {
4228   vcl_worker_cleanup (vcl_worker_get_current (), 1 /* notify vpp */ );
4229   vcl_set_worker_index (~0);
4230 }
4231
4232 void
4233 vppcom_worker_index_set (int index)
4234 {
4235   vcl_set_worker_index (index);
4236 }
4237
4238 int
4239 vppcom_worker_index (void)
4240 {
4241   return vcl_get_worker_index ();
4242 }
4243
4244 int
4245 vppcom_worker_mqs_epfd (void)
4246 {
4247   vcl_worker_t *wrk = vcl_worker_get_current ();
4248   if (!vcm->cfg.use_mq_eventfd)
4249     return -1;
4250   return wrk->mqs_epfd;
4251 }
4252
4253 int
4254 vppcom_session_is_connectable_listener (uint32_t session_handle)
4255 {
4256   vcl_session_t *session;
4257   vcl_worker_t *wrk = vcl_worker_get_current ();
4258   session = vcl_session_get_w_handle (wrk, session_handle);
4259   if (!session)
4260     return VPPCOM_EBADFD;
4261   return vcl_session_is_connectable_listener (wrk, session);
4262 }
4263
4264 int
4265 vppcom_session_listener (uint32_t session_handle)
4266 {
4267   vcl_worker_t *wrk = vcl_worker_get_current ();
4268   vcl_session_t *listen_session, *session;
4269   session = vcl_session_get_w_handle (wrk, session_handle);
4270   if (!session)
4271     return VPPCOM_EBADFD;
4272   if (session->listener_index == VCL_INVALID_SESSION_INDEX)
4273     return VPPCOM_EBADFD;
4274   listen_session = vcl_session_get_w_handle (wrk, session->listener_index);
4275   if (!listen_session)
4276     return VPPCOM_EBADFD;
4277   return vcl_session_handle (listen_session);
4278 }
4279
4280 int
4281 vppcom_session_n_accepted (uint32_t session_handle)
4282 {
4283   vcl_worker_t *wrk = vcl_worker_get_current ();
4284   vcl_session_t *session = vcl_session_get_w_handle (wrk, session_handle);
4285   if (!session)
4286     return VPPCOM_EBADFD;
4287   return session->n_accepted_sessions;
4288 }
4289
4290 const char *
4291 vppcom_proto_str (vppcom_proto_t proto)
4292 {
4293   char const *proto_str;
4294
4295   switch (proto)
4296     {
4297     case VPPCOM_PROTO_TCP:
4298       proto_str = "TCP";
4299       break;
4300     case VPPCOM_PROTO_UDP:
4301       proto_str = "UDP";
4302       break;
4303     case VPPCOM_PROTO_TLS:
4304       proto_str = "TLS";
4305       break;
4306     case VPPCOM_PROTO_QUIC:
4307       proto_str = "QUIC";
4308       break;
4309     case VPPCOM_PROTO_DTLS:
4310       proto_str = "DTLS";
4311       break;
4312     case VPPCOM_PROTO_SRTP:
4313       proto_str = "SRTP";
4314       break;
4315     default:
4316       proto_str = "UNKNOWN";
4317       break;
4318     }
4319   return proto_str;
4320 }
4321
4322 const char *
4323 vppcom_retval_str (int retval)
4324 {
4325   char const *st;
4326
4327   switch (retval)
4328     {
4329     case VPPCOM_OK:
4330       st = "VPPCOM_OK";
4331       break;
4332
4333     case VPPCOM_EAGAIN:
4334       st = "VPPCOM_EAGAIN";
4335       break;
4336
4337     case VPPCOM_EFAULT:
4338       st = "VPPCOM_EFAULT";
4339       break;
4340
4341     case VPPCOM_ENOMEM:
4342       st = "VPPCOM_ENOMEM";
4343       break;
4344
4345     case VPPCOM_EINVAL:
4346       st = "VPPCOM_EINVAL";
4347       break;
4348
4349     case VPPCOM_EBADFD:
4350       st = "VPPCOM_EBADFD";
4351       break;
4352
4353     case VPPCOM_EAFNOSUPPORT:
4354       st = "VPPCOM_EAFNOSUPPORT";
4355       break;
4356
4357     case VPPCOM_ECONNABORTED:
4358       st = "VPPCOM_ECONNABORTED";
4359       break;
4360
4361     case VPPCOM_ECONNRESET:
4362       st = "VPPCOM_ECONNRESET";
4363       break;
4364
4365     case VPPCOM_ENOTCONN:
4366       st = "VPPCOM_ENOTCONN";
4367       break;
4368
4369     case VPPCOM_ECONNREFUSED:
4370       st = "VPPCOM_ECONNREFUSED";
4371       break;
4372
4373     case VPPCOM_ETIMEDOUT:
4374       st = "VPPCOM_ETIMEDOUT";
4375       break;
4376
4377     default:
4378       st = "UNKNOWN_STATE";
4379       break;
4380     }
4381
4382   return st;
4383 }
4384
4385 int
4386 vppcom_add_cert_key_pair (vppcom_cert_key_pair_t *ckpair)
4387 {
4388   if (vcm->cfg.vpp_app_socket_api)
4389     {
4390       clib_warning ("not supported");
4391       return VPPCOM_EINVAL;
4392     }
4393   return vcl_bapi_add_cert_key_pair (ckpair);
4394 }
4395
4396 int
4397 vppcom_del_cert_key_pair (uint32_t ckpair_index)
4398 {
4399   if (vcm->cfg.vpp_app_socket_api)
4400     {
4401       clib_warning ("not supported");
4402       return VPPCOM_EINVAL;
4403     }
4404   return vcl_bapi_del_cert_key_pair (ckpair_index);
4405 }
4406
4407 /*
4408  * fd.io coding-style-patch-verification: ON
4409  *
4410  * Local Variables:
4411  * eval: (c-set-style "gnu")
4412  * End:
4413  */