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