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, vcl_cfg->segment_baseva,
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   if (q_len == 0 || q_len == ~0)
1649     q_len = vcm->cfg.listen_queue_size;
1650
1651   listen_vpp_handle = listen_session->vpp_handle;
1652   if (listen_session->session_state == VCL_STATE_LISTEN)
1653     {
1654       VDBG (0, "session %u [0x%llx]: already in listen state!",
1655             listen_sh, listen_vpp_handle);
1656       return VPPCOM_OK;
1657     }
1658
1659   VDBG (0, "session %u: sending vpp listen request...", listen_sh);
1660
1661   /*
1662    * Send listen request to vpp and wait for reply
1663    */
1664   vcl_send_session_listen (wrk, listen_session);
1665   rv = vppcom_wait_for_session_state_change (listen_session->session_index,
1666                                              VCL_STATE_LISTEN,
1667                                              vcm->cfg.session_timeout);
1668
1669   if (PREDICT_FALSE (rv))
1670     {
1671       listen_session = vcl_session_get_w_handle (wrk, listen_sh);
1672       VDBG (0, "session %u [0x%llx]: listen failed! returning %d (%s)",
1673             listen_sh, listen_session->vpp_handle, rv,
1674             vppcom_retval_str (rv));
1675       return rv;
1676     }
1677
1678   return VPPCOM_OK;
1679 }
1680
1681 static int
1682 validate_args_session_accept_ (vcl_worker_t * wrk, vcl_session_t * ls)
1683 {
1684   if (ls->flags & VCL_SESSION_F_IS_VEP)
1685     {
1686       VDBG (0, "ERROR: cannot accept on epoll session %u!",
1687             ls->session_index);
1688       return VPPCOM_EBADFD;
1689     }
1690
1691   if ((ls->session_state != VCL_STATE_LISTEN)
1692       && (!vcl_session_is_connectable_listener (wrk, ls)))
1693     {
1694       VDBG (0, "ERROR: session [0x%llx]: not in listen state! state 0x%x"
1695             " (%s)", ls->vpp_handle, ls->session_state,
1696             vppcom_session_state_str (ls->session_state));
1697       return VPPCOM_EBADFD;
1698     }
1699   return VPPCOM_OK;
1700 }
1701
1702 int
1703 vppcom_unformat_proto (uint8_t * proto, char *proto_str)
1704 {
1705   if (!strcmp (proto_str, "TCP"))
1706     *proto = VPPCOM_PROTO_TCP;
1707   else if (!strcmp (proto_str, "tcp"))
1708     *proto = VPPCOM_PROTO_TCP;
1709   else if (!strcmp (proto_str, "UDP"))
1710     *proto = VPPCOM_PROTO_UDP;
1711   else if (!strcmp (proto_str, "udp"))
1712     *proto = VPPCOM_PROTO_UDP;
1713   else if (!strcmp (proto_str, "TLS"))
1714     *proto = VPPCOM_PROTO_TLS;
1715   else if (!strcmp (proto_str, "tls"))
1716     *proto = VPPCOM_PROTO_TLS;
1717   else if (!strcmp (proto_str, "QUIC"))
1718     *proto = VPPCOM_PROTO_QUIC;
1719   else if (!strcmp (proto_str, "quic"))
1720     *proto = VPPCOM_PROTO_QUIC;
1721   else if (!strcmp (proto_str, "DTLS"))
1722     *proto = VPPCOM_PROTO_DTLS;
1723   else if (!strcmp (proto_str, "dtls"))
1724     *proto = VPPCOM_PROTO_DTLS;
1725   else if (!strcmp (proto_str, "SRTP"))
1726     *proto = VPPCOM_PROTO_SRTP;
1727   else if (!strcmp (proto_str, "srtp"))
1728     *proto = VPPCOM_PROTO_SRTP;
1729   else
1730     return 1;
1731   return 0;
1732 }
1733
1734 int
1735 vppcom_session_accept (uint32_t listen_session_handle, vppcom_endpt_t * ep,
1736                        uint32_t flags)
1737 {
1738   u32 client_session_index = ~0, listen_session_index, accept_flags = 0;
1739   vcl_worker_t *wrk = vcl_worker_get_current ();
1740   session_accepted_msg_t accepted_msg;
1741   vcl_session_t *listen_session = 0;
1742   vcl_session_t *client_session = 0;
1743   vcl_session_msg_t *evt;
1744   u8 is_nonblocking;
1745   int rv;
1746
1747 again:
1748
1749   listen_session = vcl_session_get_w_handle (wrk, listen_session_handle);
1750   if (!listen_session)
1751     return VPPCOM_EBADFD;
1752
1753   listen_session_index = listen_session->session_index;
1754   if ((rv = validate_args_session_accept_ (wrk, listen_session)))
1755     return rv;
1756
1757   if (clib_fifo_elts (listen_session->accept_evts_fifo))
1758     {
1759       clib_fifo_sub2 (listen_session->accept_evts_fifo, evt);
1760       accept_flags = evt->flags;
1761       accepted_msg = evt->accepted_msg;
1762       goto handle;
1763     }
1764
1765   is_nonblocking = vcl_session_has_attr (listen_session,
1766                                          VCL_SESS_ATTR_NONBLOCK);
1767   while (1)
1768     {
1769       if (svm_msg_q_is_empty (wrk->app_event_queue) && is_nonblocking)
1770         return VPPCOM_EAGAIN;
1771
1772       svm_msg_q_wait (wrk->app_event_queue, SVM_MQ_WAIT_EMPTY);
1773       vcl_worker_flush_mq_events (wrk);
1774       goto again;
1775     }
1776
1777 handle:
1778
1779   client_session_index = vcl_session_accepted_handler (wrk, &accepted_msg,
1780                                                        listen_session_index);
1781   if (client_session_index == VCL_INVALID_SESSION_INDEX)
1782     return VPPCOM_ECONNABORTED;
1783
1784   listen_session = vcl_session_get (wrk, listen_session_index);
1785   client_session = vcl_session_get (wrk, client_session_index);
1786
1787   if (flags & O_NONBLOCK)
1788     vcl_session_set_attr (client_session, VCL_SESS_ATTR_NONBLOCK);
1789
1790   VDBG (1, "listener %u [0x%llx]: Got a connect request! session %u [0x%llx],"
1791         " flags %d, is_nonblocking %u", listen_session->session_index,
1792         listen_session->vpp_handle, client_session_index,
1793         client_session->vpp_handle, flags,
1794         vcl_session_has_attr (client_session, VCL_SESS_ATTR_NONBLOCK));
1795
1796   if (ep)
1797     {
1798       ep->is_ip4 = client_session->transport.is_ip4;
1799       ep->port = client_session->transport.rmt_port;
1800       if (client_session->transport.is_ip4)
1801         clib_memcpy_fast (ep->ip, &client_session->transport.rmt_ip.ip4,
1802                           sizeof (ip4_address_t));
1803       else
1804         clib_memcpy_fast (ep->ip, &client_session->transport.rmt_ip.ip6,
1805                           sizeof (ip6_address_t));
1806     }
1807
1808   VDBG (0, "listener %u [0x%llx] accepted %u [0x%llx] peer: %U:%u "
1809         "local: %U:%u", listen_session_handle, listen_session->vpp_handle,
1810         client_session_index, client_session->vpp_handle,
1811         format_ip46_address, &client_session->transport.rmt_ip,
1812         client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1813         clib_net_to_host_u16 (client_session->transport.rmt_port),
1814         format_ip46_address, &client_session->transport.lcl_ip,
1815         client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1816         clib_net_to_host_u16 (client_session->transport.lcl_port));
1817   vcl_evt (VCL_EVT_ACCEPT, client_session, listen_session,
1818            client_session_index);
1819
1820   /*
1821    * Session might have been closed already
1822    */
1823   if (accept_flags)
1824     {
1825       if (accept_flags & VCL_ACCEPTED_F_CLOSED)
1826         client_session->session_state = VCL_STATE_VPP_CLOSING;
1827       else if (accept_flags & VCL_ACCEPTED_F_RESET)
1828         client_session->session_state = VCL_STATE_DISCONNECT;
1829     }
1830   return vcl_session_handle (client_session);
1831 }
1832
1833 int
1834 vppcom_session_connect (uint32_t session_handle, vppcom_endpt_t * server_ep)
1835 {
1836   vcl_worker_t *wrk = vcl_worker_get_current ();
1837   vcl_session_t *session = 0;
1838   u32 session_index;
1839   int rv;
1840
1841   session = vcl_session_get_w_handle (wrk, session_handle);
1842   if (!session)
1843     return VPPCOM_EBADFD;
1844   session_index = session->session_index;
1845
1846   if (PREDICT_FALSE (session->flags & VCL_SESSION_F_IS_VEP))
1847     {
1848       VDBG (0, "ERROR: cannot connect epoll session %u!",
1849             session->session_index);
1850       return VPPCOM_EBADFD;
1851     }
1852
1853   if (PREDICT_FALSE (vcl_session_is_ready (session)))
1854     {
1855       VDBG (0, "session handle %u [0x%llx]: session already "
1856             "connected to %s %U port %d proto %s, state 0x%x (%s)",
1857             session_handle, session->vpp_handle,
1858             session->transport.is_ip4 ? "IPv4" : "IPv6", format_ip46_address,
1859             &session->transport.rmt_ip, session->transport.is_ip4 ?
1860             IP46_TYPE_IP4 : IP46_TYPE_IP6,
1861             clib_net_to_host_u16 (session->transport.rmt_port),
1862             vppcom_proto_str (session->session_type), session->session_state,
1863             vppcom_session_state_str (session->session_state));
1864       return VPPCOM_OK;
1865     }
1866
1867   /* Attempt to connect a connectionless listener */
1868   if (PREDICT_FALSE (session->session_state == VCL_STATE_LISTEN))
1869     {
1870       if (session->session_type != VPPCOM_PROTO_UDP)
1871         return VPPCOM_EINVAL;
1872       vcl_send_session_unlisten (wrk, session);
1873       session->session_state = VCL_STATE_CLOSED;
1874     }
1875
1876   session->transport.is_ip4 = server_ep->is_ip4;
1877   vcl_ip_copy_from_ep (&session->transport.rmt_ip, server_ep);
1878   session->transport.rmt_port = server_ep->port;
1879   session->parent_handle = VCL_INVALID_SESSION_HANDLE;
1880   session->flags |= VCL_SESSION_F_CONNECTED;
1881
1882   VDBG (0, "session handle %u (%s): connecting to peer %s %U "
1883         "port %d proto %s", session_handle,
1884         vppcom_session_state_str (session->session_state),
1885         session->transport.is_ip4 ? "IPv4" : "IPv6",
1886         format_ip46_address,
1887         &session->transport.rmt_ip, session->transport.is_ip4 ?
1888         IP46_TYPE_IP4 : IP46_TYPE_IP6,
1889         clib_net_to_host_u16 (session->transport.rmt_port),
1890         vppcom_proto_str (session->session_type));
1891
1892   vcl_send_session_connect (wrk, session);
1893
1894   if (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK))
1895     {
1896       /* State set to STATE_UPDATED to ensure the session is not assumed
1897        * to be ready and to also allow the app to close it prior to vpp's
1898        * connected reply. */
1899       session->session_state = VCL_STATE_UPDATED;
1900       return VPPCOM_EINPROGRESS;
1901     }
1902
1903   /*
1904    * Wait for reply from vpp if blocking
1905    */
1906   rv = vppcom_wait_for_session_state_change (session_index, VCL_STATE_READY,
1907                                              vcm->cfg.session_timeout);
1908
1909   session = vcl_session_get (wrk, session_index);
1910   VDBG (0, "session %u [0x%llx]: connect %s!", session->session_index,
1911         session->vpp_handle, rv ? "failed" : "succeeded");
1912
1913   return rv;
1914 }
1915
1916 int
1917 vppcom_session_stream_connect (uint32_t session_handle,
1918                                uint32_t parent_session_handle)
1919 {
1920   vcl_worker_t *wrk = vcl_worker_get_current ();
1921   vcl_session_t *session, *parent_session;
1922   u32 session_index, parent_session_index;
1923   int rv;
1924
1925   session = vcl_session_get_w_handle (wrk, session_handle);
1926   if (!session)
1927     return VPPCOM_EBADFD;
1928   parent_session = vcl_session_get_w_handle (wrk, parent_session_handle);
1929   if (!parent_session)
1930     return VPPCOM_EBADFD;
1931
1932   session_index = session->session_index;
1933   parent_session_index = parent_session->session_index;
1934   if (PREDICT_FALSE (session->flags & VCL_SESSION_F_IS_VEP))
1935     {
1936       VDBG (0, "ERROR: cannot connect epoll session %u!",
1937             session->session_index);
1938       return VPPCOM_EBADFD;
1939     }
1940
1941   if (PREDICT_FALSE (vcl_session_is_ready (session)))
1942     {
1943       VDBG (0, "session handle %u [0x%llx]: session already "
1944             "connected to session %u [0x%llx] proto %s, state 0x%x (%s)",
1945             session_handle, session->vpp_handle,
1946             parent_session_handle, parent_session->vpp_handle,
1947             vppcom_proto_str (session->session_type), session->session_state,
1948             vppcom_session_state_str (session->session_state));
1949       return VPPCOM_OK;
1950     }
1951
1952   /* Connect to quic session specifics */
1953   session->transport.is_ip4 = parent_session->transport.is_ip4;
1954   session->transport.rmt_ip.ip4.as_u32 = (uint32_t) 1;
1955   session->transport.rmt_port = 0;
1956   session->parent_handle = parent_session->vpp_handle;
1957
1958   VDBG (0, "session handle %u: connecting to session %u [0x%llx]",
1959         session_handle, parent_session_handle, parent_session->vpp_handle);
1960
1961   /*
1962    * Send connect request and wait for reply from vpp
1963    */
1964   vcl_send_session_connect (wrk, session);
1965   rv = vppcom_wait_for_session_state_change (session_index, VCL_STATE_READY,
1966                                              vcm->cfg.session_timeout);
1967
1968   session->listener_index = parent_session_index;
1969   parent_session = vcl_session_get_w_handle (wrk, parent_session_handle);
1970   if (parent_session)
1971     parent_session->n_accepted_sessions++;
1972
1973   session = vcl_session_get (wrk, session_index);
1974   VDBG (0, "session %u [0x%llx]: connect %s!", session->session_index,
1975         session->vpp_handle, rv ? "failed" : "succeeded");
1976
1977   return rv;
1978 }
1979
1980 static inline int
1981 vppcom_session_read_internal (uint32_t session_handle, void *buf, int n,
1982                               u8 peek)
1983 {
1984   vcl_worker_t *wrk = vcl_worker_get_current ();
1985   int rv, n_read = 0, is_nonblocking;
1986   vcl_session_t *s = 0;
1987   svm_fifo_t *rx_fifo;
1988   session_event_t *e;
1989   svm_msg_q_t *mq;
1990   u8 is_ct;
1991
1992   if (PREDICT_FALSE (!buf))
1993     return VPPCOM_EFAULT;
1994
1995   s = vcl_session_get_w_handle (wrk, session_handle);
1996   if (PREDICT_FALSE (!s || (s->flags & VCL_SESSION_F_IS_VEP)))
1997     return VPPCOM_EBADFD;
1998
1999   if (PREDICT_FALSE (!vcl_session_is_open (s)))
2000     {
2001       VDBG (0, "session %u[0x%llx] is not open! state 0x%x (%s)",
2002             s->session_index, s->vpp_handle, s->session_state,
2003             vppcom_session_state_str (s->session_state));
2004       return vcl_session_closed_error (s);
2005     }
2006
2007   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_RD_SHUTDOWN))
2008     {
2009       /* Vpp would ack the incoming data and enqueue it for reading.
2010        * So even if SHUT_RD is set, we can still read() the data if
2011        * the session is ready.
2012        */
2013       if (!vcl_session_read_ready (s))
2014         {
2015           return 0;
2016         }
2017     }
2018
2019   is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
2020   is_ct = vcl_session_is_ct (s);
2021   mq = wrk->app_event_queue;
2022   rx_fifo = is_ct ? s->ct_rx_fifo : s->rx_fifo;
2023   s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2024
2025   if (svm_fifo_is_empty_cons (rx_fifo))
2026     {
2027       if (is_nonblocking)
2028         {
2029           if (vcl_session_is_closing (s))
2030             return vcl_session_closing_error (s);
2031           if (is_ct)
2032             svm_fifo_unset_event (s->rx_fifo);
2033           svm_fifo_unset_event (rx_fifo);
2034           return VPPCOM_EWOULDBLOCK;
2035         }
2036       while (svm_fifo_is_empty_cons (rx_fifo))
2037         {
2038           if (vcl_session_is_closing (s))
2039             return vcl_session_closing_error (s);
2040
2041           if (is_ct)
2042             svm_fifo_unset_event (s->rx_fifo);
2043           svm_fifo_unset_event (rx_fifo);
2044
2045           svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2046           vcl_worker_flush_mq_events (wrk);
2047         }
2048     }
2049
2050 read_again:
2051
2052   if (s->is_dgram)
2053     rv = app_recv_dgram_raw (rx_fifo, buf, n, &s->transport, 0, peek);
2054   else
2055     rv = app_recv_stream_raw (rx_fifo, buf, n, 0, peek);
2056
2057   ASSERT (rv >= 0);
2058
2059   if (peek)
2060     return rv;
2061
2062   n_read += rv;
2063
2064   if (svm_fifo_is_empty_cons (rx_fifo))
2065     {
2066       if (is_ct)
2067         svm_fifo_unset_event (s->rx_fifo);
2068       svm_fifo_unset_event (rx_fifo);
2069       if (!svm_fifo_is_empty_cons (rx_fifo)
2070           && svm_fifo_set_event (rx_fifo) && is_nonblocking)
2071         {
2072           vec_add2 (wrk->unhandled_evts_vector, e, 1);
2073           e->event_type = SESSION_IO_EVT_RX;
2074           e->session_index = s->session_index;
2075         }
2076     }
2077   else if (PREDICT_FALSE (rv < n && !s->is_dgram))
2078     {
2079       /* More data enqueued while reading. Try to drain it
2080        * or fill the buffer. Avoid doing that for dgrams */
2081       buf += rv;
2082       n -= rv;
2083       goto read_again;
2084     }
2085
2086   if (PREDICT_FALSE (svm_fifo_needs_deq_ntf (rx_fifo, n_read)))
2087     {
2088       svm_fifo_clear_deq_ntf (rx_fifo);
2089       app_send_io_evt_to_vpp (s->vpp_evt_q,
2090                               s->rx_fifo->shr->master_session_index,
2091                               SESSION_IO_EVT_RX, SVM_Q_WAIT);
2092     }
2093
2094   VDBG (2, "session %u[0x%llx]: read %d bytes from (%p)", s->session_index,
2095         s->vpp_handle, n_read, rx_fifo);
2096
2097   return n_read;
2098 }
2099
2100 int
2101 vppcom_session_read (uint32_t session_handle, void *buf, size_t n)
2102 {
2103   return (vppcom_session_read_internal (session_handle, buf, n, 0));
2104 }
2105
2106 static int
2107 vppcom_session_peek (uint32_t session_handle, void *buf, int n)
2108 {
2109   return (vppcom_session_read_internal (session_handle, buf, n, 1));
2110 }
2111
2112 int
2113 vppcom_session_read_segments (uint32_t session_handle,
2114                               vppcom_data_segment_t * ds, uint32_t n_segments,
2115                               uint32_t max_bytes)
2116 {
2117   vcl_worker_t *wrk = vcl_worker_get_current ();
2118   int n_read = 0, is_nonblocking;
2119   vcl_session_t *s = 0;
2120   svm_fifo_t *rx_fifo;
2121   svm_msg_q_t *mq;
2122   u8 is_ct;
2123
2124   s = vcl_session_get_w_handle (wrk, session_handle);
2125   if (PREDICT_FALSE (!s || (s->flags & VCL_SESSION_F_IS_VEP)))
2126     return VPPCOM_EBADFD;
2127
2128   if (PREDICT_FALSE (!vcl_session_is_open (s)))
2129     return vcl_session_closed_error (s);
2130
2131   is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
2132   is_ct = vcl_session_is_ct (s);
2133   mq = wrk->app_event_queue;
2134   rx_fifo = is_ct ? s->ct_rx_fifo : s->rx_fifo;
2135   s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2136
2137   if (svm_fifo_is_empty_cons (rx_fifo))
2138     {
2139       if (is_nonblocking)
2140         {
2141           if (is_ct)
2142             svm_fifo_unset_event (s->rx_fifo);
2143           svm_fifo_unset_event (rx_fifo);
2144           return VPPCOM_EWOULDBLOCK;
2145         }
2146       while (svm_fifo_is_empty_cons (rx_fifo))
2147         {
2148           if (vcl_session_is_closing (s))
2149             return vcl_session_closing_error (s);
2150
2151           if (is_ct)
2152             svm_fifo_unset_event (s->rx_fifo);
2153           svm_fifo_unset_event (rx_fifo);
2154
2155           svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2156           vcl_worker_flush_mq_events (wrk);
2157         }
2158     }
2159
2160   n_read = svm_fifo_segments (rx_fifo, s->rx_bytes_pending,
2161                               (svm_fifo_seg_t *) ds, n_segments, max_bytes);
2162   if (n_read < 0)
2163     return VPPCOM_EAGAIN;
2164
2165   if (svm_fifo_max_dequeue_cons (rx_fifo) == n_read)
2166     {
2167       if (is_ct)
2168         svm_fifo_unset_event (s->rx_fifo);
2169       svm_fifo_unset_event (rx_fifo);
2170       if (svm_fifo_max_dequeue_cons (rx_fifo) != n_read
2171           && svm_fifo_set_event (rx_fifo)
2172           && vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
2173         {
2174           session_event_t *e;
2175           vec_add2 (wrk->unhandled_evts_vector, e, 1);
2176           e->event_type = SESSION_IO_EVT_RX;
2177           e->session_index = s->session_index;
2178         }
2179     }
2180
2181   s->rx_bytes_pending += n_read;
2182   return n_read;
2183 }
2184
2185 void
2186 vppcom_session_free_segments (uint32_t session_handle, uint32_t n_bytes)
2187 {
2188   vcl_worker_t *wrk = vcl_worker_get_current ();
2189   vcl_session_t *s;
2190   u8 is_ct;
2191
2192   s = vcl_session_get_w_handle (wrk, session_handle);
2193   if (PREDICT_FALSE (!s || (s->flags & VCL_SESSION_F_IS_VEP)))
2194     return;
2195
2196   is_ct = vcl_session_is_ct (s);
2197   svm_fifo_dequeue_drop (is_ct ? s->ct_rx_fifo : s->rx_fifo, n_bytes);
2198
2199   ASSERT (s->rx_bytes_pending < n_bytes);
2200   s->rx_bytes_pending -= n_bytes;
2201 }
2202
2203 always_inline u8
2204 vcl_fifo_is_writeable (svm_fifo_t * f, u32 len, u8 is_dgram)
2205 {
2206   u32 max_enq = svm_fifo_max_enqueue_prod (f);
2207   if (is_dgram)
2208     return max_enq >= (sizeof (session_dgram_hdr_t) + len);
2209   else
2210     return max_enq > 0;
2211 }
2212
2213 always_inline int
2214 vppcom_session_write_inline (vcl_worker_t * wrk, vcl_session_t * s, void *buf,
2215                              size_t n, u8 is_flush, u8 is_dgram)
2216 {
2217   int n_write, is_nonblocking;
2218   session_evt_type_t et;
2219   svm_fifo_t *tx_fifo;
2220   svm_msg_q_t *mq;
2221   u8 is_ct;
2222
2223   /* Accept zero length writes but just return */
2224   if (PREDICT_FALSE (!n))
2225     return VPPCOM_OK;
2226
2227   if (PREDICT_FALSE (!buf))
2228     return VPPCOM_EFAULT;
2229
2230   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_IS_VEP))
2231     {
2232       VDBG (0, "ERROR: session %u [0x%llx]: cannot write to an epoll"
2233             " session!", s->session_index, s->vpp_handle);
2234       return VPPCOM_EBADFD;
2235     }
2236
2237   if (PREDICT_FALSE (!vcl_session_is_open (s)))
2238     {
2239       VDBG (1, "session %u [0x%llx]: is not open! state 0x%x (%s)",
2240             s->session_index, s->vpp_handle, s->session_state,
2241             vppcom_session_state_str (s->session_state));
2242       return vcl_session_closed_error (s);;
2243     }
2244
2245   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_WR_SHUTDOWN))
2246     {
2247       VDBG (1, "session %u [0x%llx]: is shutdown! state 0x%x (%s)",
2248             s->session_index, s->vpp_handle, s->session_state,
2249             vppcom_session_state_str (s->session_state));
2250       return VPPCOM_EPIPE;
2251     }
2252
2253   is_ct = vcl_session_is_ct (s);
2254   tx_fifo = is_ct ? s->ct_tx_fifo : s->tx_fifo;
2255   is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
2256
2257   mq = wrk->app_event_queue;
2258   if (!vcl_fifo_is_writeable (tx_fifo, n, is_dgram))
2259     {
2260       if (is_nonblocking)
2261         {
2262           return VPPCOM_EWOULDBLOCK;
2263         }
2264       while (!vcl_fifo_is_writeable (tx_fifo, n, is_dgram))
2265         {
2266           svm_fifo_add_want_deq_ntf (tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
2267           if (vcl_session_is_closing (s))
2268             return vcl_session_closing_error (s);
2269
2270           svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2271           vcl_worker_flush_mq_events (wrk);
2272         }
2273     }
2274
2275   et = SESSION_IO_EVT_TX;
2276   if (is_flush && !is_ct)
2277     et = SESSION_IO_EVT_TX_FLUSH;
2278
2279   if (is_dgram)
2280     n_write = app_send_dgram_raw (tx_fifo, &s->transport,
2281                                   s->vpp_evt_q, buf, n, et,
2282                                   0 /* do_evt */ , SVM_Q_WAIT);
2283   else
2284     n_write = app_send_stream_raw (tx_fifo, s->vpp_evt_q, buf, n, et,
2285                                    0 /* do_evt */ , SVM_Q_WAIT);
2286
2287   if (svm_fifo_set_event (s->tx_fifo))
2288     app_send_io_evt_to_vpp (
2289       s->vpp_evt_q, s->tx_fifo->shr->master_session_index, et, SVM_Q_WAIT);
2290
2291   /* The underlying fifo segment can run out of memory */
2292   if (PREDICT_FALSE (n_write < 0))
2293     return VPPCOM_EAGAIN;
2294
2295   VDBG (2, "session %u [0x%llx]: wrote %d bytes", s->session_index,
2296         s->vpp_handle, n_write);
2297
2298   return n_write;
2299 }
2300
2301 int
2302 vppcom_session_write (uint32_t session_handle, void *buf, size_t n)
2303 {
2304   vcl_worker_t *wrk = vcl_worker_get_current ();
2305   vcl_session_t *s;
2306
2307   s = vcl_session_get_w_handle (wrk, session_handle);
2308   if (PREDICT_FALSE (!s))
2309     return VPPCOM_EBADFD;
2310
2311   return vppcom_session_write_inline (wrk, s, buf, n,
2312                                       0 /* is_flush */ , s->is_dgram ? 1 : 0);
2313 }
2314
2315 int
2316 vppcom_session_write_msg (uint32_t session_handle, void *buf, size_t n)
2317 {
2318   vcl_worker_t *wrk = vcl_worker_get_current ();
2319   vcl_session_t *s;
2320
2321   s = vcl_session_get_w_handle (wrk, session_handle);
2322   if (PREDICT_FALSE (!s))
2323     return VPPCOM_EBADFD;
2324
2325   return vppcom_session_write_inline (wrk, s, buf, n,
2326                                       1 /* is_flush */ , s->is_dgram ? 1 : 0);
2327 }
2328
2329 #define vcl_fifo_rx_evt_valid_or_break(_s)                              \
2330 if (PREDICT_FALSE (!_s->rx_fifo))                                       \
2331   break;                                                                \
2332 if (PREDICT_FALSE (svm_fifo_is_empty (_s->rx_fifo)))                    \
2333   {                                                                     \
2334     if (!vcl_session_is_ct (_s))                                        \
2335       {                                                                 \
2336         svm_fifo_unset_event (_s->rx_fifo);                             \
2337         if (svm_fifo_is_empty (_s->rx_fifo))                            \
2338           break;                                                        \
2339       }                                                                 \
2340     else if (svm_fifo_is_empty (_s->ct_rx_fifo))                        \
2341       {                                                                 \
2342         svm_fifo_unset_event (_s->rx_fifo); /* rx evts on actual fifo*/ \
2343         if (svm_fifo_is_empty (_s->ct_rx_fifo))                         \
2344           break;                                                        \
2345       }                                                                 \
2346   }                                                                     \
2347
2348 static void
2349 vcl_select_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
2350                             unsigned long n_bits, unsigned long *read_map,
2351                             unsigned long *write_map,
2352                             unsigned long *except_map, u32 * bits_set)
2353 {
2354   session_disconnected_msg_t *disconnected_msg;
2355   session_connected_msg_t *connected_msg;
2356   vcl_session_t *s;
2357   u32 sid;
2358
2359   switch (e->event_type)
2360     {
2361     case SESSION_IO_EVT_RX:
2362       sid = e->session_index;
2363       s = vcl_session_get (wrk, sid);
2364       if (!s || !vcl_session_is_open (s))
2365         break;
2366       vcl_fifo_rx_evt_valid_or_break (s);
2367       if (sid < n_bits && read_map)
2368         {
2369           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2370           *bits_set += 1;
2371         }
2372       break;
2373     case SESSION_IO_EVT_TX:
2374       sid = e->session_index;
2375       s = vcl_session_get (wrk, sid);
2376       if (!s || !vcl_session_is_open (s))
2377         break;
2378       if (sid < n_bits && write_map)
2379         {
2380           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2381           *bits_set += 1;
2382         }
2383       break;
2384     case SESSION_CTRL_EVT_ACCEPTED:
2385       if (!e->postponed)
2386         s = vcl_session_accepted (wrk, (session_accepted_msg_t *) e->data);
2387       else
2388         s = vcl_session_get (wrk, e->session_index);
2389       if (!s)
2390         break;
2391       sid = s->session_index;
2392       if (sid < n_bits && read_map)
2393         {
2394           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2395           *bits_set += 1;
2396         }
2397       break;
2398     case SESSION_CTRL_EVT_CONNECTED:
2399       if (!e->postponed)
2400         {
2401           connected_msg = (session_connected_msg_t *) e->data;
2402           sid = vcl_session_connected_handler (wrk, connected_msg);
2403         }
2404       else
2405         sid = e->session_index;
2406       if (sid == VCL_INVALID_SESSION_INDEX)
2407         break;
2408       if (sid < n_bits && write_map)
2409         {
2410           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2411           *bits_set += 1;
2412         }
2413       break;
2414     case SESSION_CTRL_EVT_DISCONNECTED:
2415       disconnected_msg = (session_disconnected_msg_t *) e->data;
2416       s = vcl_session_disconnected_handler (wrk, disconnected_msg);
2417       if (!s)
2418         break;
2419       sid = s->session_index;
2420       if (sid < n_bits && except_map)
2421         {
2422           clib_bitmap_set_no_check ((uword *) except_map, sid, 1);
2423           *bits_set += 1;
2424         }
2425       break;
2426     case SESSION_CTRL_EVT_RESET:
2427       sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
2428       if (sid < n_bits && except_map)
2429         {
2430           clib_bitmap_set_no_check ((uword *) except_map, sid, 1);
2431           *bits_set += 1;
2432         }
2433       break;
2434     case SESSION_CTRL_EVT_UNLISTEN_REPLY:
2435       vcl_session_unlisten_reply_handler (wrk, e->data);
2436       break;
2437     case SESSION_CTRL_EVT_MIGRATED:
2438       vcl_session_migrated_handler (wrk, e->data);
2439       break;
2440     case SESSION_CTRL_EVT_CLEANUP:
2441       vcl_session_cleanup_handler (wrk, e->data);
2442       break;
2443     case SESSION_CTRL_EVT_WORKER_UPDATE_REPLY:
2444       vcl_session_worker_update_reply_handler (wrk, e->data);
2445       break;
2446     case SESSION_CTRL_EVT_REQ_WORKER_UPDATE:
2447       vcl_session_req_worker_update_handler (wrk, e->data);
2448       break;
2449     case SESSION_CTRL_EVT_APP_ADD_SEGMENT:
2450       vcl_session_app_add_segment_handler (wrk, e->data);
2451       break;
2452     case SESSION_CTRL_EVT_APP_DEL_SEGMENT:
2453       vcl_session_app_del_segment_handler (wrk, e->data);
2454       break;
2455     case SESSION_CTRL_EVT_APP_WRK_RPC:
2456       vcl_worker_rpc_handler (wrk, e->data);
2457       break;
2458     default:
2459       clib_warning ("unhandled: %u", e->event_type);
2460       break;
2461     }
2462 }
2463
2464 static int
2465 vcl_select_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
2466                       unsigned long n_bits, unsigned long *read_map,
2467                       unsigned long *write_map, unsigned long *except_map,
2468                       double time_to_wait, u32 * bits_set)
2469 {
2470   svm_msg_q_msg_t *msg;
2471   session_event_t *e;
2472   u32 i;
2473
2474   if (svm_msg_q_is_empty (mq))
2475     {
2476       if (*bits_set)
2477         return 0;
2478
2479       if (!time_to_wait)
2480         return 0;
2481       else if (time_to_wait < 0)
2482         svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
2483       else
2484         {
2485           if (svm_msg_q_timedwait (mq, time_to_wait))
2486             return 0;
2487         }
2488     }
2489   vcl_mq_dequeue_batch (wrk, mq, ~0);
2490
2491   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
2492     {
2493       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
2494       e = svm_msg_q_msg_data (mq, msg);
2495       vcl_select_handle_mq_event (wrk, e, n_bits, read_map, write_map,
2496                                   except_map, bits_set);
2497       svm_msg_q_free_msg (mq, msg);
2498     }
2499   vec_reset_length (wrk->mq_msg_vector);
2500   vcl_handle_pending_wrk_updates (wrk);
2501   return *bits_set;
2502 }
2503
2504 static int
2505 vppcom_select_condvar (vcl_worker_t * wrk, int n_bits,
2506                        vcl_si_set * read_map, vcl_si_set * write_map,
2507                        vcl_si_set * except_map, double time_to_wait,
2508                        u32 * bits_set)
2509 {
2510   double wait = 0, start = 0;
2511
2512   if (!*bits_set)
2513     {
2514       wait = time_to_wait;
2515       start = clib_time_now (&wrk->clib_time);
2516     }
2517
2518   do
2519     {
2520       vcl_select_handle_mq (wrk, wrk->app_event_queue, n_bits, read_map,
2521                             write_map, except_map, wait, bits_set);
2522       if (*bits_set)
2523         return *bits_set;
2524       if (wait == -1)
2525         continue;
2526
2527       wait = wait - (clib_time_now (&wrk->clib_time) - start);
2528     }
2529   while (wait > 0);
2530
2531   return 0;
2532 }
2533
2534 static int
2535 vppcom_select_eventfd (vcl_worker_t * wrk, int n_bits,
2536                        vcl_si_set * read_map, vcl_si_set * write_map,
2537                        vcl_si_set * except_map, double time_to_wait,
2538                        u32 * bits_set)
2539 {
2540   vcl_mq_evt_conn_t *mqc;
2541   int __clib_unused n_read;
2542   int n_mq_evts, i;
2543   u64 buf;
2544
2545   vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
2546   n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
2547                           vec_len (wrk->mq_events), time_to_wait);
2548   for (i = 0; i < n_mq_evts; i++)
2549     {
2550       mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
2551       n_read = read (mqc->mq_fd, &buf, sizeof (buf));
2552       vcl_select_handle_mq (wrk, mqc->mq, n_bits, read_map, write_map,
2553                             except_map, 0, bits_set);
2554     }
2555
2556   return (n_mq_evts > 0 ? (int) *bits_set : 0);
2557 }
2558
2559 int
2560 vppcom_select (int n_bits, vcl_si_set * read_map, vcl_si_set * write_map,
2561                vcl_si_set * except_map, double time_to_wait)
2562 {
2563   u32 sid, minbits = clib_max (n_bits, BITS (uword)), bits_set = 0;
2564   vcl_worker_t *wrk = vcl_worker_get_current ();
2565   vcl_session_t *s = 0;
2566   int i;
2567
2568   if (n_bits && read_map)
2569     {
2570       clib_bitmap_validate (wrk->rd_bitmap, minbits);
2571       clib_memcpy_fast (wrk->rd_bitmap, read_map,
2572                         vec_len (wrk->rd_bitmap) * sizeof (vcl_si_set));
2573       memset (read_map, 0, vec_len (wrk->rd_bitmap) * sizeof (vcl_si_set));
2574     }
2575   if (n_bits && write_map)
2576     {
2577       clib_bitmap_validate (wrk->wr_bitmap, minbits);
2578       clib_memcpy_fast (wrk->wr_bitmap, write_map,
2579                         vec_len (wrk->wr_bitmap) * sizeof (vcl_si_set));
2580       memset (write_map, 0, vec_len (wrk->wr_bitmap) * sizeof (vcl_si_set));
2581     }
2582   if (n_bits && except_map)
2583     {
2584       clib_bitmap_validate (wrk->ex_bitmap, minbits);
2585       clib_memcpy_fast (wrk->ex_bitmap, except_map,
2586                         vec_len (wrk->ex_bitmap) * sizeof (vcl_si_set));
2587       memset (except_map, 0, vec_len (wrk->ex_bitmap) * sizeof (vcl_si_set));
2588     }
2589
2590   if (!n_bits)
2591     return 0;
2592
2593   if (!write_map)
2594     goto check_rd;
2595
2596   clib_bitmap_foreach (sid, wrk->wr_bitmap)
2597     {
2598       if (!(s = vcl_session_get (wrk, sid)))
2599         {
2600           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2601           bits_set++;
2602           continue;
2603         }
2604
2605       if (vcl_session_write_ready (s))
2606         {
2607           clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
2608           bits_set++;
2609         }
2610       else
2611         {
2612           svm_fifo_t *txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2613           svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF);
2614         }
2615     }
2616
2617 check_rd:
2618   if (!read_map)
2619     goto check_mq;
2620
2621   clib_bitmap_foreach (sid, wrk->rd_bitmap)
2622     {
2623       if (!(s = vcl_session_get (wrk, sid)))
2624         {
2625           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2626           bits_set++;
2627           continue;
2628         }
2629
2630       if (vcl_session_read_ready (s))
2631         {
2632           clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
2633           bits_set++;
2634         }
2635     }
2636
2637 check_mq:
2638
2639   for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
2640     {
2641       vcl_select_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i], n_bits,
2642                                   read_map, write_map, except_map, &bits_set);
2643     }
2644   vec_reset_length (wrk->unhandled_evts_vector);
2645
2646   if (vcm->cfg.use_mq_eventfd)
2647     vppcom_select_eventfd (wrk, n_bits, read_map, write_map, except_map,
2648                            time_to_wait, &bits_set);
2649   else
2650     vppcom_select_condvar (wrk, n_bits, read_map, write_map, except_map,
2651                            time_to_wait, &bits_set);
2652
2653   return (bits_set);
2654 }
2655
2656 static inline void
2657 vep_verify_epoll_chain (vcl_worker_t * wrk, u32 vep_handle)
2658 {
2659   vppcom_epoll_t *vep;
2660   u32 sh = vep_handle;
2661   vcl_session_t *s;
2662
2663   if (VPPCOM_DEBUG <= 2)
2664     return;
2665
2666   s = vcl_session_get_w_handle (wrk, vep_handle);
2667   if (PREDICT_FALSE (!s))
2668     {
2669       VDBG (0, "ERROR: Invalid vep_sh (%u)!", vep_handle);
2670       goto done;
2671     }
2672   if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP)))
2673     {
2674       VDBG (0, "ERROR: vep_sh (%u) is not a vep!", vep_handle);
2675       goto done;
2676     }
2677   vep = &s->vep;
2678   VDBG (0, "vep_sh (%u): Dumping epoll chain\n"
2679         "{\n"
2680         "   is_vep         = %u\n"
2681         "   is_vep_session = %u\n"
2682         "   next_sh        = 0x%x (%u)\n"
2683         "}\n", vep_handle, s->flags & VCL_SESSION_F_IS_VEP,
2684         s->flags & VCL_SESSION_F_IS_VEP_SESSION, vep->next_sh, vep->next_sh);
2685
2686   for (sh = vep->next_sh; sh != ~0; sh = vep->next_sh)
2687     {
2688       s = vcl_session_get_w_handle (wrk, sh);
2689       if (PREDICT_FALSE (!s))
2690         {
2691           VDBG (0, "ERROR: Invalid sh (%u)!", sh);
2692           goto done;
2693         }
2694       if (PREDICT_FALSE (s->flags & VCL_SESSION_F_IS_VEP))
2695         {
2696           VDBG (0, "ERROR: sh (%u) is a vep!", vep_handle);
2697         }
2698       else if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP_SESSION)))
2699         {
2700           VDBG (0, "ERROR: sh (%u) is not a vep session handle!", sh);
2701           goto done;
2702         }
2703       vep = &s->vep;
2704       if (PREDICT_FALSE (vep->vep_sh != vep_handle))
2705         VDBG (0, "ERROR: session (%u) vep_sh (%u) != vep_sh (%u)!",
2706               sh, s->vep.vep_sh, vep_handle);
2707       if (s->flags & VCL_SESSION_F_IS_VEP_SESSION)
2708         {
2709           VDBG (0, "vep_sh[%u]: sh 0x%x (%u)\n"
2710                 "{\n"
2711                 "   next_sh        = 0x%x (%u)\n"
2712                 "   prev_sh        = 0x%x (%u)\n"
2713                 "   vep_sh         = 0x%x (%u)\n"
2714                 "   ev.events      = 0x%x\n"
2715                 "   ev.data.u64    = 0x%llx\n"
2716                 "   et_mask        = 0x%x\n"
2717                 "}\n",
2718                 vep_handle, sh, sh, vep->next_sh, vep->next_sh, vep->prev_sh,
2719                 vep->prev_sh, vep->vep_sh, vep->vep_sh, vep->ev.events,
2720                 vep->ev.data.u64, vep->et_mask);
2721         }
2722     }
2723
2724 done:
2725   VDBG (0, "vep_sh (%u): Dump complete!\n", vep_handle);
2726 }
2727
2728 int
2729 vppcom_epoll_create (void)
2730 {
2731   vcl_worker_t *wrk = vcl_worker_get_current ();
2732   vcl_session_t *vep_session;
2733
2734   vep_session = vcl_session_alloc (wrk);
2735
2736   vep_session->flags |= VCL_SESSION_F_IS_VEP;
2737   vep_session->vep.vep_sh = ~0;
2738   vep_session->vep.next_sh = ~0;
2739   vep_session->vep.prev_sh = ~0;
2740   vep_session->vpp_handle = ~0;
2741
2742   vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, vep_session->session_index);
2743   VDBG (0, "Created vep_idx %u", vep_session->session_index);
2744
2745   return vcl_session_handle (vep_session);
2746 }
2747
2748 int
2749 vppcom_epoll_ctl (uint32_t vep_handle, int op, uint32_t session_handle,
2750                   struct epoll_event *event)
2751 {
2752   vcl_worker_t *wrk = vcl_worker_get_current ();
2753   int rv = VPPCOM_OK, add_evt = 0;
2754   vcl_session_t *vep_session;
2755   vcl_session_t *s;
2756   svm_fifo_t *txf;
2757
2758   if (vep_handle == session_handle)
2759     {
2760       VDBG (0, "vep_sh == session handle (%u)!", vep_handle);
2761       return VPPCOM_EINVAL;
2762     }
2763
2764   vep_session = vcl_session_get_w_handle (wrk, vep_handle);
2765   if (PREDICT_FALSE (!vep_session))
2766     {
2767       VDBG (0, "Invalid vep_sh (%u)!", vep_handle);
2768       return VPPCOM_EBADFD;
2769     }
2770   if (PREDICT_FALSE (!(vep_session->flags & VCL_SESSION_F_IS_VEP)))
2771     {
2772       VDBG (0, "vep_sh (%u) is not a vep!", vep_handle);
2773       return VPPCOM_EINVAL;
2774     }
2775
2776   ASSERT (vep_session->vep.vep_sh == ~0);
2777   ASSERT (vep_session->vep.prev_sh == ~0);
2778
2779   s = vcl_session_get_w_handle (wrk, session_handle);
2780   if (PREDICT_FALSE (!s))
2781     {
2782       VDBG (0, "Invalid session_handle (%u)!", session_handle);
2783       return VPPCOM_EBADFD;
2784     }
2785   if (PREDICT_FALSE (s->flags & VCL_SESSION_F_IS_VEP))
2786     {
2787       VDBG (0, "session_handle (%u) is a vep!", vep_handle);
2788       return VPPCOM_EINVAL;
2789     }
2790
2791   switch (op)
2792     {
2793     case EPOLL_CTL_ADD:
2794       if (PREDICT_FALSE (!event))
2795         {
2796           VDBG (0, "EPOLL_CTL_ADD: NULL pointer to epoll_event structure!");
2797           return VPPCOM_EINVAL;
2798         }
2799       if (s->flags & VCL_SESSION_F_IS_VEP_SESSION)
2800         {
2801           VDBG (0, "EPOLL_CTL_ADD: %u already epolled!", s->session_index);
2802           rv = VPPCOM_EEXIST;
2803           goto done;
2804         }
2805       if (vep_session->vep.next_sh != ~0)
2806         {
2807           vcl_session_t *next_session;
2808           next_session = vcl_session_get_w_handle (wrk,
2809                                                    vep_session->vep.next_sh);
2810           if (PREDICT_FALSE (!next_session))
2811             {
2812               VDBG (0, "EPOLL_CTL_ADD: Invalid vep.next_sh (%u) on "
2813                     "vep_idx (%u)!", vep_session->vep.next_sh, vep_handle);
2814               return VPPCOM_EBADFD;
2815             }
2816           ASSERT (next_session->vep.prev_sh == vep_handle);
2817           next_session->vep.prev_sh = session_handle;
2818         }
2819       s->vep.next_sh = vep_session->vep.next_sh;
2820       s->vep.prev_sh = vep_handle;
2821       s->vep.vep_sh = vep_handle;
2822       s->vep.et_mask = VEP_DEFAULT_ET_MASK;
2823       s->vep.lt_next = VCL_INVALID_SESSION_INDEX;
2824       s->vep.ev = *event;
2825       s->flags &= ~VCL_SESSION_F_IS_VEP;
2826       s->flags |= VCL_SESSION_F_IS_VEP_SESSION;
2827       vep_session->vep.next_sh = session_handle;
2828
2829       txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2830       if (txf && (event->events & EPOLLOUT))
2831         svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2832
2833       /* Generate EPOLLOUT if tx fifo not full */
2834       if ((event->events & EPOLLOUT) && (vcl_session_write_ready (s) > 0))
2835         {
2836           session_event_t e = { 0 };
2837           e.event_type = SESSION_IO_EVT_TX;
2838           e.session_index = s->session_index;
2839           vec_add1 (wrk->unhandled_evts_vector, e);
2840           add_evt = 1;
2841         }
2842       /* Generate EPOLLIN if rx fifo has data */
2843       if ((event->events & EPOLLIN) && (vcl_session_read_ready (s) > 0))
2844         {
2845           session_event_t e = { 0 };
2846           e.event_type = SESSION_IO_EVT_RX;
2847           e.session_index = s->session_index;
2848           vec_add1 (wrk->unhandled_evts_vector, e);
2849           s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2850           add_evt = 1;
2851         }
2852       if (!add_evt && vcl_session_is_closing (s))
2853         {
2854           session_event_t e = { 0 };
2855           if (s->session_state == VCL_STATE_VPP_CLOSING)
2856             e.event_type = SESSION_CTRL_EVT_DISCONNECTED;
2857           else
2858             e.event_type = SESSION_CTRL_EVT_RESET;
2859           e.session_index = s->session_index;
2860           e.postponed = 1;
2861           vec_add1 (wrk->unhandled_evts_vector, e);
2862         }
2863       VDBG (1, "EPOLL_CTL_ADD: vep_sh %u, sh %u, events 0x%x, data 0x%llx!",
2864             vep_handle, session_handle, event->events, event->data.u64);
2865       vcl_evt (VCL_EVT_EPOLL_CTLADD, s, event->events, event->data.u64);
2866       break;
2867
2868     case EPOLL_CTL_MOD:
2869       if (PREDICT_FALSE (!event))
2870         {
2871           VDBG (0, "EPOLL_CTL_MOD: NULL pointer to epoll_event structure!");
2872           rv = VPPCOM_EINVAL;
2873           goto done;
2874         }
2875       else if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP_SESSION)))
2876         {
2877           VDBG (0, "sh %u EPOLL_CTL_MOD: not a vep session!", session_handle);
2878           rv = VPPCOM_ENOENT;
2879           goto done;
2880         }
2881       else if (PREDICT_FALSE (s->vep.vep_sh != vep_handle))
2882         {
2883           VDBG (0, "EPOLL_CTL_MOD: sh %u vep_sh (%u) != vep_sh (%u)!",
2884                 session_handle, s->vep.vep_sh, vep_handle);
2885           rv = VPPCOM_EINVAL;
2886           goto done;
2887         }
2888
2889       /* Generate EPOLLOUT if session write ready nd event was not on */
2890       if ((event->events & EPOLLOUT) && !(s->vep.ev.events & EPOLLOUT) &&
2891           (vcl_session_write_ready (s) > 0))
2892         {
2893           session_event_t e = { 0 };
2894           e.event_type = SESSION_IO_EVT_TX;
2895           e.session_index = s->session_index;
2896           vec_add1 (wrk->unhandled_evts_vector, e);
2897         }
2898       /* Generate EPOLLIN if session read ready and event was not on */
2899       if ((event->events & EPOLLIN) && !(s->vep.ev.events & EPOLLIN) &&
2900           (vcl_session_read_ready (s) > 0))
2901         {
2902           session_event_t e = { 0 };
2903           e.event_type = SESSION_IO_EVT_RX;
2904           e.session_index = s->session_index;
2905           vec_add1 (wrk->unhandled_evts_vector, e);
2906           s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
2907         }
2908       s->vep.et_mask = VEP_DEFAULT_ET_MASK;
2909       s->vep.ev = *event;
2910       txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2911       if (txf)
2912         {
2913           if (event->events & EPOLLOUT)
2914             svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2915           else
2916             svm_fifo_del_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2917         }
2918       VDBG (1, "EPOLL_CTL_MOD: vep_sh %u, sh %u, events 0x%x, data 0x%llx!",
2919             vep_handle, session_handle, event->events, event->data.u64);
2920       break;
2921
2922     case EPOLL_CTL_DEL:
2923       if (PREDICT_FALSE (!(s->flags & VCL_SESSION_F_IS_VEP_SESSION)))
2924         {
2925           VDBG (0, "EPOLL_CTL_DEL: %u not a vep session!", session_handle);
2926           rv = VPPCOM_ENOENT;
2927           goto done;
2928         }
2929       else if (PREDICT_FALSE (s->vep.vep_sh != vep_handle))
2930         {
2931           VDBG (0, "EPOLL_CTL_DEL: sh %u vep_sh (%u) != vep_sh (%u)!",
2932                 session_handle, s->vep.vep_sh, vep_handle);
2933           rv = VPPCOM_EINVAL;
2934           goto done;
2935         }
2936
2937       if (s->vep.prev_sh == vep_handle)
2938         vep_session->vep.next_sh = s->vep.next_sh;
2939       else
2940         {
2941           vcl_session_t *prev_session;
2942           prev_session = vcl_session_get_w_handle (wrk, s->vep.prev_sh);
2943           if (PREDICT_FALSE (!prev_session))
2944             {
2945               VDBG (0, "EPOLL_CTL_DEL: Invalid prev_sh (%u) on sh (%u)!",
2946                     s->vep.prev_sh, session_handle);
2947               return VPPCOM_EBADFD;
2948             }
2949           ASSERT (prev_session->vep.next_sh == session_handle);
2950           prev_session->vep.next_sh = s->vep.next_sh;
2951         }
2952       if (s->vep.next_sh != ~0)
2953         {
2954           vcl_session_t *next_session;
2955           next_session = vcl_session_get_w_handle (wrk, s->vep.next_sh);
2956           if (PREDICT_FALSE (!next_session))
2957             {
2958               VDBG (0, "EPOLL_CTL_DEL: Invalid next_sh (%u) on sh (%u)!",
2959                     s->vep.next_sh, session_handle);
2960               return VPPCOM_EBADFD;
2961             }
2962           ASSERT (next_session->vep.prev_sh == session_handle);
2963           next_session->vep.prev_sh = s->vep.prev_sh;
2964         }
2965
2966       if (s->vep.lt_next != VCL_INVALID_SESSION_INDEX)
2967         vcl_epoll_lt_del (wrk, s);
2968
2969       memset (&s->vep, 0, sizeof (s->vep));
2970       s->vep.next_sh = ~0;
2971       s->vep.prev_sh = ~0;
2972       s->vep.vep_sh = ~0;
2973       s->vep.lt_next = VCL_INVALID_SESSION_INDEX;
2974       s->flags &= ~VCL_SESSION_F_IS_VEP_SESSION;
2975
2976       if (vcl_session_is_open (s))
2977         {
2978           txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
2979           if (txf)
2980             svm_fifo_del_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
2981         }
2982
2983       VDBG (1, "EPOLL_CTL_DEL: vep_idx %u, sh %u!", vep_handle,
2984             session_handle);
2985       vcl_evt (VCL_EVT_EPOLL_CTLDEL, s, vep_sh);
2986       break;
2987
2988     default:
2989       VDBG (0, "Invalid operation (%d)!", op);
2990       rv = VPPCOM_EINVAL;
2991     }
2992
2993   vep_verify_epoll_chain (wrk, vep_handle);
2994
2995 done:
2996   return rv;
2997 }
2998
2999 static inline void
3000 vcl_epoll_wait_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
3001                                 struct epoll_event *events, u32 * num_ev)
3002 {
3003   session_disconnected_msg_t *disconnected_msg;
3004   session_connected_msg_t *connected_msg;
3005   u32 sid = ~0, session_events;
3006   u64 session_evt_data = ~0;
3007   vcl_session_t *s;
3008   u8 add_event = 0;
3009
3010   switch (e->event_type)
3011     {
3012     case SESSION_IO_EVT_RX:
3013       sid = e->session_index;
3014       s = vcl_session_get (wrk, sid);
3015       if (vcl_session_is_closed (s))
3016         break;
3017       vcl_fifo_rx_evt_valid_or_break (s);
3018       session_events = s->vep.ev.events;
3019       if (!(EPOLLIN & s->vep.ev.events)
3020           || (s->flags & VCL_SESSION_F_HAS_RX_EVT))
3021         break;
3022       add_event = 1;
3023       events[*num_ev].events = EPOLLIN;
3024       session_evt_data = s->vep.ev.data.u64;
3025       s->flags |= VCL_SESSION_F_HAS_RX_EVT;
3026       break;
3027     case SESSION_IO_EVT_TX:
3028       sid = e->session_index;
3029       s = vcl_session_get (wrk, sid);
3030       if (vcl_session_is_closed (s))
3031         break;
3032       session_events = s->vep.ev.events;
3033       if (!(EPOLLOUT & session_events))
3034         break;
3035       add_event = 1;
3036       events[*num_ev].events = EPOLLOUT;
3037       session_evt_data = s->vep.ev.data.u64;
3038       svm_fifo_reset_has_deq_ntf (vcl_session_is_ct (s) ?
3039                                   s->ct_tx_fifo : s->tx_fifo);
3040       break;
3041     case SESSION_CTRL_EVT_ACCEPTED:
3042       if (!e->postponed)
3043         s = vcl_session_accepted (wrk, (session_accepted_msg_t *) e->data);
3044       else
3045         s = vcl_session_get (wrk, e->session_index);
3046       if (!s)
3047         break;
3048       session_events = s->vep.ev.events;
3049       sid = s->session_index;
3050       if (!(EPOLLIN & session_events))
3051         break;
3052       add_event = 1;
3053       events[*num_ev].events = EPOLLIN;
3054       session_evt_data = s->vep.ev.data.u64;
3055       break;
3056     case SESSION_CTRL_EVT_CONNECTED:
3057       if (!e->postponed)
3058         {
3059           connected_msg = (session_connected_msg_t *) e->data;
3060           sid = vcl_session_connected_handler (wrk, connected_msg);
3061         }
3062       else
3063         sid = e->session_index;
3064       s = vcl_session_get (wrk, sid);
3065       if (vcl_session_is_closed (s))
3066         break;
3067       session_events = s->vep.ev.events;
3068       /* Generate EPOLLOUT because there's no connected event */
3069       if (!(EPOLLOUT & session_events))
3070         break;
3071       add_event = 1;
3072       events[*num_ev].events = EPOLLOUT;
3073       session_evt_data = s->vep.ev.data.u64;
3074       if (s->session_state == VCL_STATE_DETACHED)
3075         events[*num_ev].events |= EPOLLHUP;
3076       break;
3077     case SESSION_CTRL_EVT_DISCONNECTED:
3078       if (!e->postponed)
3079         {
3080           disconnected_msg = (session_disconnected_msg_t *) e->data;
3081           s = vcl_session_disconnected_handler (wrk, disconnected_msg);
3082         }
3083       else
3084         {
3085           s = vcl_session_get (wrk, e->session_index);
3086         }
3087       if (vcl_session_is_closed (s) ||
3088           !(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
3089         break;
3090       sid = s->session_index;
3091       session_events = s->vep.ev.events;
3092       add_event = 1;
3093       events[*num_ev].events = EPOLLHUP | EPOLLRDHUP;
3094       session_evt_data = s->vep.ev.data.u64;
3095       break;
3096     case SESSION_CTRL_EVT_RESET:
3097       if (!e->postponed)
3098         sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
3099       else
3100         sid = e->session_index;
3101       s = vcl_session_get (wrk, sid);
3102       if (vcl_session_is_closed (s) ||
3103           !(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
3104         break;
3105       session_events = s->vep.ev.events;
3106       add_event = 1;
3107       events[*num_ev].events = EPOLLHUP | EPOLLRDHUP;
3108       session_evt_data = s->vep.ev.data.u64;
3109       break;
3110     case SESSION_CTRL_EVT_UNLISTEN_REPLY:
3111       vcl_session_unlisten_reply_handler (wrk, e->data);
3112       break;
3113     case SESSION_CTRL_EVT_MIGRATED:
3114       vcl_session_migrated_handler (wrk, e->data);
3115       break;
3116     case SESSION_CTRL_EVT_CLEANUP:
3117       vcl_session_cleanup_handler (wrk, e->data);
3118       break;
3119     case SESSION_CTRL_EVT_REQ_WORKER_UPDATE:
3120       vcl_session_req_worker_update_handler (wrk, e->data);
3121       break;
3122     case SESSION_CTRL_EVT_WORKER_UPDATE_REPLY:
3123       vcl_session_worker_update_reply_handler (wrk, e->data);
3124       break;
3125     case SESSION_CTRL_EVT_APP_ADD_SEGMENT:
3126       vcl_session_app_add_segment_handler (wrk, e->data);
3127       break;
3128     case SESSION_CTRL_EVT_APP_DEL_SEGMENT:
3129       vcl_session_app_del_segment_handler (wrk, e->data);
3130       break;
3131     case SESSION_CTRL_EVT_APP_WRK_RPC:
3132       vcl_worker_rpc_handler (wrk, e->data);
3133       break;
3134     default:
3135       VDBG (0, "unhandled: %u", e->event_type);
3136       break;
3137     }
3138
3139   if (add_event)
3140     {
3141       events[*num_ev].data.u64 = session_evt_data;
3142       if (EPOLLONESHOT & session_events)
3143         {
3144           s = vcl_session_get (wrk, sid);
3145           s->vep.ev.events = 0;
3146         }
3147       else if (!(EPOLLET & session_events))
3148         {
3149           s = vcl_session_get (wrk, sid);
3150           if (s->vep.lt_next == VCL_INVALID_SESSION_INDEX)
3151             vcl_epoll_lt_add (wrk, s);
3152         }
3153       *num_ev += 1;
3154     }
3155 }
3156
3157 static int
3158 vcl_epoll_wait_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
3159                           struct epoll_event *events, u32 maxevents,
3160                           double wait_for_time, u32 * num_ev)
3161 {
3162   svm_msg_q_msg_t *msg;
3163   session_event_t *e;
3164   int i;
3165
3166   if (vec_len (wrk->mq_msg_vector) && svm_msg_q_is_empty (mq))
3167     goto handle_dequeued;
3168
3169   if (svm_msg_q_is_empty (mq))
3170     {
3171       if (!wait_for_time)
3172         return 0;
3173       else if (wait_for_time < 0)
3174         svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
3175       else
3176         {
3177           if (svm_msg_q_timedwait (mq, wait_for_time / 1e3))
3178             return 0;
3179         }
3180     }
3181   ASSERT (maxevents > *num_ev);
3182   vcl_mq_dequeue_batch (wrk, mq, ~0);
3183
3184 handle_dequeued:
3185   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
3186     {
3187       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
3188       e = svm_msg_q_msg_data (mq, msg);
3189       if (*num_ev < maxevents)
3190         vcl_epoll_wait_handle_mq_event (wrk, e, events, num_ev);
3191       else
3192         vcl_handle_mq_event (wrk, e);
3193       svm_msg_q_free_msg (mq, msg);
3194     }
3195   vec_reset_length (wrk->mq_msg_vector);
3196   vcl_handle_pending_wrk_updates (wrk);
3197   return *num_ev;
3198 }
3199
3200 static int
3201 vppcom_epoll_wait_condvar (vcl_worker_t *wrk, struct epoll_event *events,
3202                            int maxevents, u32 n_evts, double timeout_ms)
3203 {
3204   double end = -1;
3205
3206   if (!n_evts)
3207     {
3208       if (timeout_ms > 0)
3209         end = clib_time_now (&wrk->clib_time) + (timeout_ms / 1e3);
3210     }
3211
3212   do
3213     {
3214       vcl_epoll_wait_handle_mq (wrk, wrk->app_event_queue, events, maxevents,
3215                                 timeout_ms, &n_evts);
3216       if (n_evts || !timeout_ms)
3217         return n_evts;
3218     }
3219   while (end == -1 || clib_time_now (&wrk->clib_time) < end);
3220
3221   return 0;
3222 }
3223
3224 static int
3225 vppcom_epoll_wait_eventfd (vcl_worker_t *wrk, struct epoll_event *events,
3226                            int maxevents, u32 n_evts, double timeout_ms)
3227 {
3228   int __clib_unused n_read;
3229   vcl_mq_evt_conn_t *mqc;
3230   int n_mq_evts, i;
3231   double end = -1;
3232   u64 buf;
3233
3234   vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
3235   if (!n_evts)
3236     {
3237       if (timeout_ms > 0)
3238         end = clib_time_now (&wrk->clib_time) + (timeout_ms / 1e3);
3239     }
3240
3241   do
3242     {
3243       n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
3244                               vec_len (wrk->mq_events), timeout_ms);
3245       if (n_mq_evts < 0)
3246         {
3247           VDBG (0, "epoll_wait error %u", errno);
3248           return n_evts;
3249         }
3250
3251       for (i = 0; i < n_mq_evts; i++)
3252         {
3253           mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
3254           n_read = read (mqc->mq_fd, &buf, sizeof (buf));
3255           vcl_epoll_wait_handle_mq (wrk, mqc->mq, events, maxevents, 0,
3256                                     &n_evts);
3257         }
3258
3259       if (n_evts || !timeout_ms)
3260         return n_evts;
3261     }
3262   while (end == -1 || clib_time_now (&wrk->clib_time) < end);
3263
3264   return 0;
3265 }
3266
3267 static void
3268 vcl_epoll_wait_handle_lt (vcl_worker_t *wrk, struct epoll_event *events,
3269                           int maxevents, u32 *n_evts)
3270 {
3271   u32 add_event = 0, next;
3272   vcl_session_t *s;
3273   u64 evt_data;
3274   int rv;
3275
3276   ASSERT (wrk->ep_lt_current != VCL_INVALID_SESSION_INDEX);
3277   if (*n_evts >= maxevents)
3278     return;
3279
3280   next = wrk->ep_lt_current;
3281   do
3282     {
3283       s = vcl_session_get (wrk, next);
3284       next = s->vep.lt_next;
3285
3286       if ((s->vep.ev.events & EPOLLIN) && (rv = vcl_session_read_ready (s)))
3287         {
3288           add_event = 1;
3289           events[*n_evts].events |= rv > 0 ? EPOLLIN : EPOLLHUP | EPOLLRDHUP;
3290           evt_data = s->vep.ev.data.u64;
3291         }
3292       if ((s->vep.ev.events & EPOLLOUT) && (rv = vcl_session_write_ready (s)))
3293         {
3294           add_event = 1;
3295           events[*n_evts].events |= rv > 0 ? EPOLLOUT : EPOLLHUP | EPOLLRDHUP;
3296           evt_data = s->vep.ev.data.u64;
3297         }
3298       if (!add_event && s->session_state > VCL_STATE_READY)
3299         {
3300           add_event = 1;
3301           events[*n_evts].events |= EPOLLHUP | EPOLLRDHUP;
3302           evt_data = s->vep.ev.data.u64;
3303         }
3304       if (add_event)
3305         {
3306           events[*n_evts].data.u64 = evt_data;
3307           *n_evts += 1;
3308           add_event = 0;
3309           if (EPOLLONESHOT & s->vep.ev.events)
3310             s->vep.ev.events = 0;
3311           if (*n_evts == maxevents)
3312             {
3313               wrk->ep_lt_current = next;
3314               break;
3315             }
3316         }
3317       else
3318         {
3319           vcl_epoll_lt_del (wrk, s);
3320           if (wrk->ep_lt_current == VCL_INVALID_SESSION_INDEX)
3321             break;
3322         }
3323     }
3324   while (next != wrk->ep_lt_current);
3325 }
3326
3327 int
3328 vppcom_epoll_wait (uint32_t vep_handle, struct epoll_event *events,
3329                    int maxevents, double wait_for_time)
3330 {
3331   vcl_worker_t *wrk = vcl_worker_get_current ();
3332   vcl_session_t *vep_session;
3333   u32 n_evts = 0;
3334   int i;
3335
3336   if (PREDICT_FALSE (maxevents <= 0))
3337     {
3338       VDBG (0, "ERROR: Invalid maxevents (%d)!", maxevents);
3339       return VPPCOM_EINVAL;
3340     }
3341
3342   vep_session = vcl_session_get_w_handle (wrk, vep_handle);
3343   if (!vep_session)
3344     return VPPCOM_EBADFD;
3345
3346   if (PREDICT_FALSE (!(vep_session->flags & VCL_SESSION_F_IS_VEP)))
3347     {
3348       VDBG (0, "ERROR: vep_idx (%u) is not a vep!", vep_handle);
3349       return VPPCOM_EINVAL;
3350     }
3351
3352   if (vec_len (wrk->unhandled_evts_vector))
3353     {
3354       for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
3355         {
3356           vcl_epoll_wait_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i],
3357                                           events, &n_evts);
3358           if (n_evts == maxevents)
3359             {
3360               vec_delete (wrk->unhandled_evts_vector, i + 1, 0);
3361               return n_evts;
3362             }
3363         }
3364       vec_reset_length (wrk->unhandled_evts_vector);
3365     }
3366   /* Request to only drain unhandled */
3367   if ((int) wait_for_time == -2)
3368     return n_evts;
3369
3370
3371   if (vcm->cfg.use_mq_eventfd)
3372     n_evts = vppcom_epoll_wait_eventfd (wrk, events, maxevents, n_evts,
3373                                         wait_for_time);
3374   else
3375     n_evts = vppcom_epoll_wait_condvar (wrk, events, maxevents, n_evts,
3376                                         wait_for_time);
3377
3378   if (PREDICT_FALSE (wrk->ep_lt_current != VCL_INVALID_SESSION_INDEX))
3379     vcl_epoll_wait_handle_lt (wrk, events, maxevents, &n_evts);
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       /* Session not connected/bound in vpp. Create it by 'connecting' it */
4064       if (PREDICT_FALSE (s->session_state == VCL_STATE_CLOSED))
4065         {
4066           u32 session_index = s->session_index;
4067           f64 timeout = vcm->cfg.session_timeout;
4068           int rv;
4069
4070           vcl_send_session_connect (wrk, s);
4071           rv = vppcom_wait_for_session_state_change (session_index,
4072                                                      VCL_STATE_READY,
4073                                                      timeout);
4074           if (rv < 0)
4075             return rv;
4076           s = vcl_session_get (wrk, session_index);
4077         }
4078
4079       s->transport.is_ip4 = ep->is_ip4;
4080       s->transport.rmt_port = ep->port;
4081       vcl_ip_copy_from_ep (&s->transport.rmt_ip, ep);
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     {
4392       clib_warning ("not supported");
4393       return VPPCOM_EINVAL;
4394     }
4395   return vcl_bapi_add_cert_key_pair (ckpair);
4396 }
4397
4398 int
4399 vppcom_del_cert_key_pair (uint32_t ckpair_index)
4400 {
4401   if (vcm->cfg.vpp_app_socket_api)
4402     {
4403       clib_warning ("not supported");
4404       return VPPCOM_EINVAL;
4405     }
4406   return vcl_bapi_del_cert_key_pair (ckpair_index);
4407 }
4408
4409 /*
4410  * fd.io coding-style-patch-verification: ON
4411  *
4412  * Local Variables:
4413  * eval: (c-set-style "gnu")
4414  * End:
4415  */