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           (s->vep.lt_next != VCL_INVALID_SESSION_INDEX))
3022         break;
3023       add_event = 1;
3024       events[*num_ev].events = EPOLLIN;
3025       session_evt_data = s->vep.ev.data.u64;
3026       s->flags |= VCL_SESSION_F_HAS_RX_EVT;
3027       break;
3028     case SESSION_IO_EVT_TX:
3029       sid = e->session_index;
3030       s = vcl_session_get (wrk, sid);
3031       if (vcl_session_is_closed (s))
3032         break;
3033       session_events = s->vep.ev.events;
3034       if (!(EPOLLOUT & session_events))
3035         break;
3036       add_event = 1;
3037       events[*num_ev].events = EPOLLOUT;
3038       session_evt_data = s->vep.ev.data.u64;
3039       svm_fifo_reset_has_deq_ntf (vcl_session_is_ct (s) ?
3040                                   s->ct_tx_fifo : s->tx_fifo);
3041       break;
3042     case SESSION_CTRL_EVT_ACCEPTED:
3043       if (!e->postponed)
3044         s = vcl_session_accepted (wrk, (session_accepted_msg_t *) e->data);
3045       else
3046         s = vcl_session_get (wrk, e->session_index);
3047       if (!s)
3048         break;
3049       session_events = s->vep.ev.events;
3050       sid = s->session_index;
3051       if (!(EPOLLIN & session_events) ||
3052           (s->vep.lt_next != VCL_INVALID_SESSION_INDEX))
3053         break;
3054       add_event = 1;
3055       events[*num_ev].events = EPOLLIN;
3056       session_evt_data = s->vep.ev.data.u64;
3057       break;
3058     case SESSION_CTRL_EVT_CONNECTED:
3059       if (!e->postponed)
3060         {
3061           connected_msg = (session_connected_msg_t *) e->data;
3062           sid = vcl_session_connected_handler (wrk, connected_msg);
3063         }
3064       else
3065         sid = e->session_index;
3066       s = vcl_session_get (wrk, sid);
3067       if (vcl_session_is_closed (s))
3068         break;
3069       session_events = s->vep.ev.events;
3070       /* Generate EPOLLOUT because there's no connected event */
3071       if (!(EPOLLOUT & session_events))
3072         break;
3073       add_event = 1;
3074       events[*num_ev].events = EPOLLOUT;
3075       session_evt_data = s->vep.ev.data.u64;
3076       if (s->session_state == VCL_STATE_DETACHED)
3077         events[*num_ev].events |= EPOLLHUP;
3078       break;
3079     case SESSION_CTRL_EVT_DISCONNECTED:
3080       if (!e->postponed)
3081         {
3082           disconnected_msg = (session_disconnected_msg_t *) e->data;
3083           s = vcl_session_disconnected_handler (wrk, disconnected_msg);
3084         }
3085       else
3086         {
3087           s = vcl_session_get (wrk, e->session_index);
3088         }
3089       if (vcl_session_is_closed (s) ||
3090           !(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
3091         break;
3092       sid = s->session_index;
3093       session_events = s->vep.ev.events;
3094       add_event = 1;
3095       events[*num_ev].events = EPOLLHUP | EPOLLRDHUP;
3096       session_evt_data = s->vep.ev.data.u64;
3097       break;
3098     case SESSION_CTRL_EVT_RESET:
3099       if (!e->postponed)
3100         sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
3101       else
3102         sid = e->session_index;
3103       s = vcl_session_get (wrk, sid);
3104       if (vcl_session_is_closed (s) ||
3105           !(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
3106         break;
3107       session_events = s->vep.ev.events;
3108       add_event = 1;
3109       events[*num_ev].events = EPOLLHUP | EPOLLRDHUP;
3110       session_evt_data = s->vep.ev.data.u64;
3111       break;
3112     case SESSION_CTRL_EVT_UNLISTEN_REPLY:
3113       vcl_session_unlisten_reply_handler (wrk, e->data);
3114       break;
3115     case SESSION_CTRL_EVT_MIGRATED:
3116       vcl_session_migrated_handler (wrk, e->data);
3117       break;
3118     case SESSION_CTRL_EVT_CLEANUP:
3119       vcl_session_cleanup_handler (wrk, e->data);
3120       break;
3121     case SESSION_CTRL_EVT_REQ_WORKER_UPDATE:
3122       vcl_session_req_worker_update_handler (wrk, e->data);
3123       break;
3124     case SESSION_CTRL_EVT_WORKER_UPDATE_REPLY:
3125       vcl_session_worker_update_reply_handler (wrk, e->data);
3126       break;
3127     case SESSION_CTRL_EVT_APP_ADD_SEGMENT:
3128       vcl_session_app_add_segment_handler (wrk, e->data);
3129       break;
3130     case SESSION_CTRL_EVT_APP_DEL_SEGMENT:
3131       vcl_session_app_del_segment_handler (wrk, e->data);
3132       break;
3133     case SESSION_CTRL_EVT_APP_WRK_RPC:
3134       vcl_worker_rpc_handler (wrk, e->data);
3135       break;
3136     default:
3137       VDBG (0, "unhandled: %u", e->event_type);
3138       break;
3139     }
3140
3141   if (add_event)
3142     {
3143       events[*num_ev].data.u64 = session_evt_data;
3144       if (EPOLLONESHOT & session_events)
3145         {
3146           s = vcl_session_get (wrk, sid);
3147           s->vep.ev.events = 0;
3148         }
3149       else if (!(EPOLLET & session_events))
3150         {
3151           s = vcl_session_get (wrk, sid);
3152           if (s->vep.lt_next == VCL_INVALID_SESSION_INDEX)
3153             vcl_epoll_lt_add (wrk, s);
3154         }
3155       *num_ev += 1;
3156     }
3157 }
3158
3159 static int
3160 vcl_epoll_wait_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
3161                           struct epoll_event *events, u32 maxevents,
3162                           double wait_for_time, u32 * num_ev)
3163 {
3164   svm_msg_q_msg_t *msg;
3165   session_event_t *e;
3166   int i;
3167
3168   if (vec_len (wrk->mq_msg_vector) && svm_msg_q_is_empty (mq))
3169     goto handle_dequeued;
3170
3171   if (svm_msg_q_is_empty (mq))
3172     {
3173       if (!wait_for_time)
3174         return 0;
3175       else if (wait_for_time < 0)
3176         svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
3177       else
3178         {
3179           if (svm_msg_q_timedwait (mq, wait_for_time / 1e3))
3180             return 0;
3181         }
3182     }
3183   ASSERT (maxevents > *num_ev);
3184   vcl_mq_dequeue_batch (wrk, mq, ~0);
3185
3186 handle_dequeued:
3187   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
3188     {
3189       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
3190       e = svm_msg_q_msg_data (mq, msg);
3191       if (*num_ev < maxevents)
3192         vcl_epoll_wait_handle_mq_event (wrk, e, events, num_ev);
3193       else
3194         vcl_handle_mq_event (wrk, e);
3195       svm_msg_q_free_msg (mq, msg);
3196     }
3197   vec_reset_length (wrk->mq_msg_vector);
3198   vcl_handle_pending_wrk_updates (wrk);
3199   return *num_ev;
3200 }
3201
3202 static int
3203 vppcom_epoll_wait_condvar (vcl_worker_t *wrk, struct epoll_event *events,
3204                            int maxevents, u32 n_evts, double timeout_ms)
3205 {
3206   double end = -1;
3207
3208   if (!n_evts)
3209     {
3210       if (timeout_ms > 0)
3211         end = clib_time_now (&wrk->clib_time) + (timeout_ms / 1e3);
3212     }
3213
3214   do
3215     {
3216       vcl_epoll_wait_handle_mq (wrk, wrk->app_event_queue, events, maxevents,
3217                                 timeout_ms, &n_evts);
3218       if (n_evts || !timeout_ms)
3219         return n_evts;
3220     }
3221   while (end == -1 || clib_time_now (&wrk->clib_time) < end);
3222
3223   return 0;
3224 }
3225
3226 static int
3227 vppcom_epoll_wait_eventfd (vcl_worker_t *wrk, struct epoll_event *events,
3228                            int maxevents, u32 n_evts, double timeout_ms)
3229 {
3230   int __clib_unused n_read;
3231   vcl_mq_evt_conn_t *mqc;
3232   int n_mq_evts, i;
3233   double end = -1;
3234   u64 buf;
3235
3236   vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
3237   if (!n_evts)
3238     {
3239       if (timeout_ms > 0)
3240         end = clib_time_now (&wrk->clib_time) + (timeout_ms / 1e3);
3241     }
3242
3243   do
3244     {
3245       n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
3246                               vec_len (wrk->mq_events), timeout_ms);
3247       if (n_mq_evts < 0)
3248         {
3249           VDBG (0, "epoll_wait error %u", errno);
3250           return n_evts;
3251         }
3252
3253       for (i = 0; i < n_mq_evts; i++)
3254         {
3255           mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
3256           n_read = read (mqc->mq_fd, &buf, sizeof (buf));
3257           vcl_epoll_wait_handle_mq (wrk, mqc->mq, events, maxevents, 0,
3258                                     &n_evts);
3259         }
3260
3261       if (n_evts || !timeout_ms)
3262         return n_evts;
3263     }
3264   while (end == -1 || clib_time_now (&wrk->clib_time) < end);
3265
3266   return 0;
3267 }
3268
3269 static void
3270 vcl_epoll_wait_handle_lt (vcl_worker_t *wrk, struct epoll_event *events,
3271                           int maxevents, u32 *n_evts)
3272 {
3273   u32 add_event = 0, next;
3274   vcl_session_t *s;
3275   u64 evt_data;
3276   int rv;
3277
3278   ASSERT (wrk->ep_lt_current != VCL_INVALID_SESSION_INDEX);
3279   if (*n_evts >= maxevents)
3280     return;
3281
3282   next = wrk->ep_lt_current;
3283   do
3284     {
3285       s = vcl_session_get (wrk, next);
3286       next = s->vep.lt_next;
3287
3288       if ((s->vep.ev.events & EPOLLIN) && (rv = vcl_session_read_ready (s)))
3289         {
3290           add_event = 1;
3291           events[*n_evts].events |= rv > 0 ? EPOLLIN : EPOLLHUP | EPOLLRDHUP;
3292           evt_data = s->vep.ev.data.u64;
3293         }
3294       if ((s->vep.ev.events & EPOLLOUT) && (rv = vcl_session_write_ready (s)))
3295         {
3296           add_event = 1;
3297           events[*n_evts].events |= rv > 0 ? EPOLLOUT : EPOLLHUP | EPOLLRDHUP;
3298           evt_data = s->vep.ev.data.u64;
3299         }
3300       if (!add_event && s->session_state > VCL_STATE_READY)
3301         {
3302           add_event = 1;
3303           events[*n_evts].events |= EPOLLHUP | EPOLLRDHUP;
3304           evt_data = s->vep.ev.data.u64;
3305         }
3306       if (add_event)
3307         {
3308           events[*n_evts].data.u64 = evt_data;
3309           *n_evts += 1;
3310           add_event = 0;
3311           if (EPOLLONESHOT & s->vep.ev.events)
3312             s->vep.ev.events = 0;
3313           if (*n_evts == maxevents)
3314             {
3315               wrk->ep_lt_current = next;
3316               break;
3317             }
3318         }
3319       else
3320         {
3321           vcl_epoll_lt_del (wrk, s);
3322           if (wrk->ep_lt_current == VCL_INVALID_SESSION_INDEX)
3323             break;
3324         }
3325     }
3326   while (next != wrk->ep_lt_current);
3327 }
3328
3329 int
3330 vppcom_epoll_wait (uint32_t vep_handle, struct epoll_event *events,
3331                    int maxevents, double wait_for_time)
3332 {
3333   vcl_worker_t *wrk = vcl_worker_get_current ();
3334   vcl_session_t *vep_session;
3335   u32 n_evts = 0;
3336   int i;
3337
3338   if (PREDICT_FALSE (maxevents <= 0))
3339     {
3340       VDBG (0, "ERROR: Invalid maxevents (%d)!", maxevents);
3341       return VPPCOM_EINVAL;
3342     }
3343
3344   vep_session = vcl_session_get_w_handle (wrk, vep_handle);
3345   if (!vep_session)
3346     return VPPCOM_EBADFD;
3347
3348   if (PREDICT_FALSE (!(vep_session->flags & VCL_SESSION_F_IS_VEP)))
3349     {
3350       VDBG (0, "ERROR: vep_idx (%u) is not a vep!", vep_handle);
3351       return VPPCOM_EINVAL;
3352     }
3353
3354   if (vec_len (wrk->unhandled_evts_vector))
3355     {
3356       for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
3357         {
3358           vcl_epoll_wait_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i],
3359                                           events, &n_evts);
3360           if (n_evts == maxevents)
3361             {
3362               vec_delete (wrk->unhandled_evts_vector, i + 1, 0);
3363               return n_evts;
3364             }
3365         }
3366       vec_reset_length (wrk->unhandled_evts_vector);
3367     }
3368
3369   if (PREDICT_FALSE (wrk->ep_lt_current != VCL_INVALID_SESSION_INDEX))
3370     vcl_epoll_wait_handle_lt (wrk, events, maxevents, &n_evts);
3371
3372   /* Request to only drain unhandled */
3373   if ((int) wait_for_time == -2)
3374     return n_evts;
3375
3376
3377   if (vcm->cfg.use_mq_eventfd)
3378     n_evts = vppcom_epoll_wait_eventfd (wrk, events, maxevents, n_evts,
3379                                         wait_for_time);
3380   else
3381     n_evts = vppcom_epoll_wait_condvar (wrk, events, maxevents, n_evts,
3382                                         wait_for_time);
3383
3384   return n_evts;
3385 }
3386
3387 int
3388 vppcom_session_attr (uint32_t session_handle, uint32_t op,
3389                      void *buffer, uint32_t * buflen)
3390 {
3391   vcl_worker_t *wrk = vcl_worker_get_current ();
3392   u32 *flags = buffer;
3393   vppcom_endpt_t *ep = buffer;
3394   transport_endpt_attr_t tea;
3395   vcl_session_t *session;
3396   int rv = VPPCOM_OK;
3397
3398   session = vcl_session_get_w_handle (wrk, session_handle);
3399   if (!session)
3400     return VPPCOM_EBADFD;
3401
3402   switch (op)
3403     {
3404     case VPPCOM_ATTR_GET_NREAD:
3405       rv = vcl_session_read_ready (session);
3406       VDBG (2, "VPPCOM_ATTR_GET_NREAD: sh %u, nread = %d", session_handle,
3407             rv);
3408       break;
3409
3410     case VPPCOM_ATTR_GET_NWRITE:
3411       rv = vcl_session_write_ready (session);
3412       VDBG (2, "VPPCOM_ATTR_GET_NWRITE: sh %u, nwrite = %d", session_handle,
3413             rv);
3414       break;
3415
3416     case VPPCOM_ATTR_GET_FLAGS:
3417       if (PREDICT_TRUE (buffer && buflen && (*buflen >= sizeof (*flags))))
3418         {
3419           *flags =
3420             O_RDWR |
3421             (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK) ?
3422              O_NONBLOCK : 0);
3423           *buflen = sizeof (*flags);
3424           VDBG (2, "VPPCOM_ATTR_GET_FLAGS: sh %u, flags = 0x%08x, "
3425                 "is_nonblocking = %u", session_handle, *flags,
3426                 vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK));
3427         }
3428       else
3429         rv = VPPCOM_EINVAL;
3430       break;
3431
3432     case VPPCOM_ATTR_SET_FLAGS:
3433       if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
3434         {
3435           if (*flags & O_NONBLOCK)
3436             vcl_session_set_attr (session, VCL_SESS_ATTR_NONBLOCK);
3437           else
3438             vcl_session_clear_attr (session, VCL_SESS_ATTR_NONBLOCK);
3439
3440           VDBG (2, "VPPCOM_ATTR_SET_FLAGS: sh %u, flags = 0x%08x,"
3441                 " is_nonblocking = %u", session_handle, *flags,
3442                 vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK));
3443         }
3444       else
3445         rv = VPPCOM_EINVAL;
3446       break;
3447
3448     case VPPCOM_ATTR_GET_PEER_ADDR:
3449       if (PREDICT_TRUE (buffer && buflen &&
3450                         (*buflen >= sizeof (*ep)) && ep->ip))
3451         {
3452           ep->is_ip4 = session->transport.is_ip4;
3453           ep->port = session->transport.rmt_port;
3454           if (session->transport.is_ip4)
3455             clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip4,
3456                               sizeof (ip4_address_t));
3457           else
3458             clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip6,
3459                               sizeof (ip6_address_t));
3460           *buflen = sizeof (*ep);
3461           VDBG (1, "VPPCOM_ATTR_GET_PEER_ADDR: sh %u, is_ip4 = %u, "
3462                 "addr = %U, port %u", session_handle, ep->is_ip4,
3463                 format_ip46_address, &session->transport.rmt_ip,
3464                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
3465                 clib_net_to_host_u16 (ep->port));
3466         }
3467       else
3468         rv = VPPCOM_EINVAL;
3469       break;
3470
3471     case VPPCOM_ATTR_GET_LCL_ADDR:
3472       if (PREDICT_TRUE (buffer && buflen &&
3473                         (*buflen >= sizeof (*ep)) && ep->ip))
3474         {
3475           ep->is_ip4 = session->transport.is_ip4;
3476           ep->port = session->transport.lcl_port;
3477           if (session->transport.is_ip4)
3478             clib_memcpy_fast (ep->ip, &session->transport.lcl_ip.ip4,
3479                               sizeof (ip4_address_t));
3480           else
3481             clib_memcpy_fast (ep->ip, &session->transport.lcl_ip.ip6,
3482                               sizeof (ip6_address_t));
3483           *buflen = sizeof (*ep);
3484           VDBG (1, "VPPCOM_ATTR_GET_LCL_ADDR: sh %u, is_ip4 = %u, addr = %U"
3485                 " port %d", session_handle, ep->is_ip4, format_ip46_address,
3486                 &session->transport.lcl_ip,
3487                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
3488                 clib_net_to_host_u16 (ep->port));
3489         }
3490       else
3491         rv = VPPCOM_EINVAL;
3492       break;
3493
3494     case VPPCOM_ATTR_SET_LCL_ADDR:
3495       if (PREDICT_TRUE (buffer && buflen &&
3496                         (*buflen >= sizeof (*ep)) && ep->ip))
3497         {
3498           session->transport.is_ip4 = ep->is_ip4;
3499           session->transport.lcl_port = ep->port;
3500           vcl_ip_copy_from_ep (&session->transport.lcl_ip, ep);
3501           *buflen = sizeof (*ep);
3502           VDBG (1, "VPPCOM_ATTR_SET_LCL_ADDR: sh %u, is_ip4 = %u, addr = %U"
3503                 " port %d", session_handle, ep->is_ip4, format_ip46_address,
3504                 &session->transport.lcl_ip,
3505                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
3506                 clib_net_to_host_u16 (ep->port));
3507         }
3508       else
3509         rv = VPPCOM_EINVAL;
3510       break;
3511
3512     case VPPCOM_ATTR_GET_LIBC_EPFD:
3513       rv = session->libc_epfd;
3514       VDBG (2, "VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d", rv);
3515       break;
3516
3517     case VPPCOM_ATTR_SET_LIBC_EPFD:
3518       if (PREDICT_TRUE (buffer && buflen &&
3519                         (*buflen == sizeof (session->libc_epfd))))
3520         {
3521           session->libc_epfd = *(int *) buffer;
3522           *buflen = sizeof (session->libc_epfd);
3523
3524           VDBG (2, "VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, buflen %d",
3525                 session->libc_epfd, *buflen);
3526         }
3527       else
3528         rv = VPPCOM_EINVAL;
3529       break;
3530
3531     case VPPCOM_ATTR_GET_PROTOCOL:
3532       if (buffer && buflen && (*buflen >= sizeof (int)))
3533         {
3534           *(int *) buffer = session->session_type;
3535           *buflen = sizeof (int);
3536
3537           VDBG (2, "VPPCOM_ATTR_GET_PROTOCOL: %d (%s), buflen %d",
3538                 *(int *) buffer, *(int *) buffer ? "UDP" : "TCP", *buflen);
3539         }
3540       else
3541         rv = VPPCOM_EINVAL;
3542       break;
3543
3544     case VPPCOM_ATTR_GET_LISTEN:
3545       if (buffer && buflen && (*buflen >= sizeof (int)))
3546         {
3547           *(int *) buffer = vcl_session_has_attr (session,
3548                                                   VCL_SESS_ATTR_LISTEN);
3549           *buflen = sizeof (int);
3550
3551           VDBG (2, "VPPCOM_ATTR_GET_LISTEN: %d, buflen %d", *(int *) buffer,
3552                 *buflen);
3553         }
3554       else
3555         rv = VPPCOM_EINVAL;
3556       break;
3557
3558     case VPPCOM_ATTR_GET_ERROR:
3559       if (buffer && buflen && (*buflen >= sizeof (int)))
3560         {
3561           *(int *) buffer = 0;
3562           *buflen = sizeof (int);
3563
3564           VDBG (2, "VPPCOM_ATTR_GET_ERROR: %d, buflen %d, #VPP-TBD#",
3565                 *(int *) buffer, *buflen);
3566         }
3567       else
3568         rv = VPPCOM_EINVAL;
3569       break;
3570
3571     case VPPCOM_ATTR_GET_TX_FIFO_LEN:
3572       if (buffer && buflen && (*buflen >= sizeof (u32)))
3573         {
3574
3575           /* VPP-TBD */
3576           *(size_t *) buffer = (session->sndbuf_size ? session->sndbuf_size :
3577                                 session->tx_fifo ?
3578                                 svm_fifo_size (session->tx_fifo) :
3579                                 vcm->cfg.tx_fifo_size);
3580           *buflen = sizeof (u32);
3581
3582           VDBG (2, "VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), buflen %d,"
3583                 " #VPP-TBD#", *(size_t *) buffer, *(size_t *) buffer,
3584                 *buflen);
3585         }
3586       else
3587         rv = VPPCOM_EINVAL;
3588       break;
3589
3590     case VPPCOM_ATTR_SET_TX_FIFO_LEN:
3591       if (buffer && buflen && (*buflen == sizeof (u32)))
3592         {
3593           /* VPP-TBD */
3594           session->sndbuf_size = *(u32 *) buffer;
3595           VDBG (2, "VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), buflen %d,"
3596                 " #VPP-TBD#", session->sndbuf_size, session->sndbuf_size,
3597                 *buflen);
3598         }
3599       else
3600         rv = VPPCOM_EINVAL;
3601       break;
3602
3603     case VPPCOM_ATTR_GET_RX_FIFO_LEN:
3604       if (buffer && buflen && (*buflen >= sizeof (u32)))
3605         {
3606
3607           /* VPP-TBD */
3608           *(size_t *) buffer = (session->rcvbuf_size ? session->rcvbuf_size :
3609                                 session->rx_fifo ?
3610                                 svm_fifo_size (session->rx_fifo) :
3611                                 vcm->cfg.rx_fifo_size);
3612           *buflen = sizeof (u32);
3613
3614           VDBG (2, "VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), buflen %d, "
3615                 "#VPP-TBD#", *(size_t *) buffer, *(size_t *) buffer, *buflen);
3616         }
3617       else
3618         rv = VPPCOM_EINVAL;
3619       break;
3620
3621     case VPPCOM_ATTR_SET_RX_FIFO_LEN:
3622       if (buffer && buflen && (*buflen == sizeof (u32)))
3623         {
3624           /* VPP-TBD */
3625           session->rcvbuf_size = *(u32 *) buffer;
3626           VDBG (2, "VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), buflen %d,"
3627                 " #VPP-TBD#", session->sndbuf_size, session->sndbuf_size,
3628                 *buflen);
3629         }
3630       else
3631         rv = VPPCOM_EINVAL;
3632       break;
3633
3634     case VPPCOM_ATTR_GET_REUSEADDR:
3635       if (buffer && buflen && (*buflen >= sizeof (int)))
3636         {
3637           /* VPP-TBD */
3638           *(int *) buffer = vcl_session_has_attr (session,
3639                                                   VCL_SESS_ATTR_REUSEADDR);
3640           *buflen = sizeof (int);
3641
3642           VDBG (2, "VPPCOM_ATTR_GET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
3643                 *(int *) buffer, *buflen);
3644         }
3645       else
3646         rv = VPPCOM_EINVAL;
3647       break;
3648
3649     case VPPCOM_ATTR_SET_REUSEADDR:
3650       if (buffer && buflen && (*buflen == sizeof (int)) &&
3651           !vcl_session_has_attr (session, VCL_SESS_ATTR_LISTEN))
3652         {
3653           /* VPP-TBD */
3654           if (*(int *) buffer)
3655             vcl_session_set_attr (session, VCL_SESS_ATTR_REUSEADDR);
3656           else
3657             vcl_session_clear_attr (session, VCL_SESS_ATTR_REUSEADDR);
3658
3659           VDBG (2, "VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
3660                 vcl_session_has_attr (session, VCL_SESS_ATTR_REUSEADDR),
3661                 *buflen);
3662         }
3663       else
3664         rv = VPPCOM_EINVAL;
3665       break;
3666
3667     case VPPCOM_ATTR_GET_REUSEPORT:
3668       if (buffer && buflen && (*buflen >= sizeof (int)))
3669         {
3670           /* VPP-TBD */
3671           *(int *) buffer = vcl_session_has_attr (session,
3672                                                   VCL_SESS_ATTR_REUSEPORT);
3673           *buflen = sizeof (int);
3674
3675           VDBG (2, "VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
3676                 *(int *) buffer, *buflen);
3677         }
3678       else
3679         rv = VPPCOM_EINVAL;
3680       break;
3681
3682     case VPPCOM_ATTR_SET_REUSEPORT:
3683       if (buffer && buflen && (*buflen == sizeof (int)) &&
3684           !vcl_session_has_attr (session, VCL_SESS_ATTR_LISTEN))
3685         {
3686           /* VPP-TBD */
3687           if (*(int *) buffer)
3688             vcl_session_set_attr (session, VCL_SESS_ATTR_REUSEPORT);
3689           else
3690             vcl_session_clear_attr (session, VCL_SESS_ATTR_REUSEPORT);
3691
3692           VDBG (2, "VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
3693                 vcl_session_has_attr (session, VCL_SESS_ATTR_REUSEPORT),
3694                 *buflen);
3695         }
3696       else
3697         rv = VPPCOM_EINVAL;
3698       break;
3699
3700     case VPPCOM_ATTR_GET_BROADCAST:
3701       if (buffer && buflen && (*buflen >= sizeof (int)))
3702         {
3703           /* VPP-TBD */
3704           *(int *) buffer = vcl_session_has_attr (session,
3705                                                   VCL_SESS_ATTR_BROADCAST);
3706           *buflen = sizeof (int);
3707
3708           VDBG (2, "VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d, #VPP-TBD#",
3709                 *(int *) buffer, *buflen);
3710         }
3711       else
3712         rv = VPPCOM_EINVAL;
3713       break;
3714
3715     case VPPCOM_ATTR_SET_BROADCAST:
3716       if (buffer && buflen && (*buflen == sizeof (int)))
3717         {
3718           /* VPP-TBD */
3719           if (*(int *) buffer)
3720             vcl_session_set_attr (session, VCL_SESS_ATTR_BROADCAST);
3721           else
3722             vcl_session_clear_attr (session, VCL_SESS_ATTR_BROADCAST);
3723
3724           VDBG (2, "VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, #VPP-TBD#",
3725                 vcl_session_has_attr (session, VCL_SESS_ATTR_BROADCAST),
3726                 *buflen);
3727         }
3728       else
3729         rv = VPPCOM_EINVAL;
3730       break;
3731
3732     case VPPCOM_ATTR_GET_V6ONLY:
3733       if (buffer && buflen && (*buflen >= sizeof (int)))
3734         {
3735           /* VPP-TBD */
3736           *(int *) buffer = vcl_session_has_attr (session,
3737                                                   VCL_SESS_ATTR_V6ONLY);
3738           *buflen = sizeof (int);
3739
3740           VDBG (2, "VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, #VPP-TBD#",
3741                 *(int *) buffer, *buflen);
3742         }
3743       else
3744         rv = VPPCOM_EINVAL;
3745       break;
3746
3747     case VPPCOM_ATTR_SET_V6ONLY:
3748       if (buffer && buflen && (*buflen == sizeof (int)))
3749         {
3750           /* VPP-TBD */
3751           if (*(int *) buffer)
3752             vcl_session_set_attr (session, VCL_SESS_ATTR_V6ONLY);
3753           else
3754             vcl_session_clear_attr (session, VCL_SESS_ATTR_V6ONLY);
3755
3756           VDBG (2, "VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, #VPP-TBD#",
3757                 vcl_session_has_attr (session, VCL_SESS_ATTR_V6ONLY),
3758                 *buflen);
3759         }
3760       else
3761         rv = VPPCOM_EINVAL;
3762       break;
3763
3764     case VPPCOM_ATTR_GET_KEEPALIVE:
3765       if (buffer && buflen && (*buflen >= sizeof (int)))
3766         {
3767           /* VPP-TBD */
3768           *(int *) buffer = vcl_session_has_attr (session,
3769                                                   VCL_SESS_ATTR_KEEPALIVE);
3770           *buflen = sizeof (int);
3771
3772           VDBG (2, "VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
3773                 *(int *) buffer, *buflen);
3774         }
3775       else
3776         rv = VPPCOM_EINVAL;
3777       break;
3778
3779     case VPPCOM_ATTR_SET_KEEPALIVE:
3780       if (buffer && buflen && (*buflen == sizeof (int)))
3781         {
3782           /* VPP-TBD */
3783           if (*(int *) buffer)
3784             vcl_session_set_attr (session, VCL_SESS_ATTR_KEEPALIVE);
3785           else
3786             vcl_session_clear_attr (session, VCL_SESS_ATTR_KEEPALIVE);
3787
3788           VDBG (2, "VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
3789                 vcl_session_has_attr (session, VCL_SESS_ATTR_KEEPALIVE),
3790                 *buflen);
3791         }
3792       else
3793         rv = VPPCOM_EINVAL;
3794       break;
3795
3796     case VPPCOM_ATTR_GET_TCP_NODELAY:
3797       if (buffer && buflen && (*buflen >= sizeof (int)))
3798         {
3799           /* VPP-TBD */
3800           *(int *) buffer = vcl_session_has_attr (session,
3801                                                   VCL_SESS_ATTR_TCP_NODELAY);
3802           *buflen = sizeof (int);
3803
3804           VDBG (2, "VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
3805                 *(int *) buffer, *buflen);
3806         }
3807       else
3808         rv = VPPCOM_EINVAL;
3809       break;
3810
3811     case VPPCOM_ATTR_SET_TCP_NODELAY:
3812       if (buffer && buflen && (*buflen == sizeof (int)))
3813         {
3814           /* VPP-TBD */
3815           if (*(int *) buffer)
3816             vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_NODELAY);
3817           else
3818             vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_NODELAY);
3819
3820           VDBG (2, "VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
3821                 vcl_session_has_attr (session, VCL_SESS_ATTR_TCP_NODELAY),
3822                 *buflen);
3823         }
3824       else
3825         rv = VPPCOM_EINVAL;
3826       break;
3827
3828     case VPPCOM_ATTR_GET_TCP_KEEPIDLE:
3829       if (buffer && buflen && (*buflen >= sizeof (int)))
3830         {
3831           /* VPP-TBD */
3832           *(int *) buffer = vcl_session_has_attr (session,
3833                                                   VCL_SESS_ATTR_TCP_KEEPIDLE);
3834           *buflen = sizeof (int);
3835
3836           VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
3837                 *(int *) buffer, *buflen);
3838         }
3839       else
3840         rv = VPPCOM_EINVAL;
3841       break;
3842
3843     case VPPCOM_ATTR_SET_TCP_KEEPIDLE:
3844       if (buffer && buflen && (*buflen == sizeof (int)))
3845         {
3846           /* VPP-TBD */
3847           if (*(int *) buffer)
3848             vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_KEEPIDLE);
3849           else
3850             vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_KEEPIDLE);
3851
3852           VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
3853                 vcl_session_has_attr (session,
3854                                       VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
3855         }
3856       else
3857         rv = VPPCOM_EINVAL;
3858       break;
3859
3860     case VPPCOM_ATTR_GET_TCP_KEEPINTVL:
3861       if (buffer && buflen && (*buflen >= sizeof (int)))
3862         {
3863           /* VPP-TBD */
3864           *(int *) buffer = vcl_session_has_attr (session,
3865                                                   VCL_SESS_ATTR_TCP_KEEPINTVL);
3866           *buflen = sizeof (int);
3867
3868           VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
3869                 *(int *) buffer, *buflen);
3870         }
3871       else
3872         rv = VPPCOM_EINVAL;
3873       break;
3874
3875     case VPPCOM_ATTR_SET_TCP_KEEPINTVL:
3876       if (buffer && buflen && (*buflen == sizeof (int)))
3877         {
3878           /* VPP-TBD */
3879           if (*(int *) buffer)
3880             vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_KEEPINTVL);
3881           else
3882             vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_KEEPINTVL);
3883
3884           VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
3885                 vcl_session_has_attr (session,
3886                                       VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
3887         }
3888       else
3889         rv = VPPCOM_EINVAL;
3890       break;
3891
3892     case VPPCOM_ATTR_GET_TCP_USER_MSS:
3893       if (!(buffer && buflen && (*buflen >= sizeof (u32))))
3894         {
3895           rv = VPPCOM_EINVAL;
3896           break;
3897         }
3898
3899       tea.type = TRANSPORT_ENDPT_ATTR_MSS;
3900       tea.mss = *(u32 *) buffer;
3901       if (vcl_session_transport_attr (wrk, session, 1 /* is_get */, &tea))
3902         rv = VPPCOM_ENOPROTOOPT;
3903
3904       if (!rv)
3905         {
3906           *(u32 *) buffer = tea.mss;
3907           *buflen = sizeof (int);
3908         }
3909
3910       VDBG (2, "VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d", *(int *) buffer,
3911             *buflen);
3912       break;
3913
3914     case VPPCOM_ATTR_SET_TCP_USER_MSS:
3915       if (!(buffer && buflen && (*buflen == sizeof (u32))))
3916         {
3917           rv = VPPCOM_EINVAL;
3918           break;
3919         }
3920
3921       tea.type = TRANSPORT_ENDPT_ATTR_MSS;
3922       tea.mss = *(u32 *) buffer;
3923       if (vcl_session_transport_attr (wrk, session, 0 /* is_get */, &tea))
3924         rv = VPPCOM_ENOPROTOOPT;
3925
3926       VDBG (2, "VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d", tea.mss,
3927             *buflen);
3928       break;
3929
3930     case VPPCOM_ATTR_SET_CONNECTED:
3931       session->flags |= VCL_SESSION_F_CONNECTED;
3932       break;
3933
3934     case VPPCOM_ATTR_SET_CKPAIR:
3935       if (!(buffer && buflen && (*buflen == sizeof (int))) ||
3936           !vcl_session_has_crypto (session))
3937         {
3938           rv = VPPCOM_EINVAL;
3939           break;
3940         }
3941       if (!session->ext_config)
3942         {
3943           vcl_session_alloc_ext_cfg (session, TRANSPORT_ENDPT_EXT_CFG_CRYPTO,
3944                                      sizeof (transport_endpt_ext_cfg_t));
3945         }
3946       else if (session->ext_config->type != TRANSPORT_ENDPT_EXT_CFG_CRYPTO)
3947         {
3948           rv = VPPCOM_EINVAL;
3949           break;
3950         }
3951
3952       session->ext_config->crypto.ckpair_index = *(uint32_t *) buffer;
3953       break;
3954
3955     case VPPCOM_ATTR_SET_VRF:
3956       if (!(buffer && buflen && (*buflen == sizeof (u32))))
3957         {
3958           rv = VPPCOM_EINVAL;
3959           break;
3960         }
3961       session->vrf = *(u32 *) buffer;
3962       break;
3963
3964     case VPPCOM_ATTR_GET_VRF:
3965       if (!(buffer && buflen && (*buflen >= sizeof (u32))))
3966         {
3967           rv = VPPCOM_EINVAL;
3968           break;
3969         }
3970       *(u32 *) buffer = session->vrf;
3971       *buflen = sizeof (u32);
3972       break;
3973
3974     case VPPCOM_ATTR_GET_DOMAIN:
3975       if (!(buffer && buflen && (*buflen >= sizeof (int))))
3976         {
3977           rv = VPPCOM_EINVAL;
3978           break;
3979         }
3980
3981       if (session->transport.is_ip4)
3982         *(int *) buffer = AF_INET;
3983       else
3984         *(int *) buffer = AF_INET6;
3985       *buflen = sizeof (int);
3986
3987       VDBG (2, "VPPCOM_ATTR_GET_DOMAIN: %d, buflen %u", *(int *) buffer,
3988             *buflen);
3989       break;
3990
3991     case VPPCOM_ATTR_SET_ENDPT_EXT_CFG:
3992       if (!(buffer && buflen && (*buflen > 0)))
3993         {
3994           rv = VPPCOM_EINVAL;
3995           break;
3996         }
3997       if (session->ext_config)
3998         {
3999           rv = VPPCOM_EINVAL;
4000           break;
4001         }
4002       vcl_session_alloc_ext_cfg (session, TRANSPORT_ENDPT_EXT_CFG_NONE,
4003                                  *buflen + sizeof (u32));
4004       clib_memcpy (session->ext_config->data, buffer, *buflen);
4005       session->ext_config->len = *buflen;
4006       break;
4007
4008     default:
4009       rv = VPPCOM_EINVAL;
4010       break;
4011     }
4012
4013   return rv;
4014 }
4015
4016 int
4017 vppcom_session_recvfrom (uint32_t session_handle, void *buffer,
4018                          uint32_t buflen, int flags, vppcom_endpt_t * ep)
4019 {
4020   vcl_worker_t *wrk = vcl_worker_get_current ();
4021   vcl_session_t *session;
4022   int rv = VPPCOM_OK;
4023
4024   if (flags == 0)
4025     rv = vppcom_session_read (session_handle, buffer, buflen);
4026   else if (flags & MSG_PEEK)
4027     rv = vppcom_session_peek (session_handle, buffer, buflen);
4028   else
4029     {
4030       VDBG (0, "Unsupport flags for recvfrom %d", flags);
4031       return VPPCOM_EAFNOSUPPORT;
4032     }
4033
4034   if (ep && rv > 0)
4035     {
4036       session = vcl_session_get_w_handle (wrk, session_handle);
4037       if (session->transport.is_ip4)
4038         clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip4,
4039                           sizeof (ip4_address_t));
4040       else
4041         clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip6,
4042                           sizeof (ip6_address_t));
4043       ep->is_ip4 = session->transport.is_ip4;
4044       ep->port = session->transport.rmt_port;
4045     }
4046
4047   return rv;
4048 }
4049
4050 int
4051 vppcom_session_sendto (uint32_t session_handle, void *buffer,
4052                        uint32_t buflen, int flags, vppcom_endpt_t * ep)
4053 {
4054   vcl_worker_t *wrk = vcl_worker_get_current ();
4055   vcl_session_t *s;
4056
4057   s = vcl_session_get_w_handle (wrk, session_handle);
4058   if (PREDICT_FALSE (!s))
4059     return VPPCOM_EBADFD;
4060
4061   if (ep)
4062     {
4063       if (!vcl_session_is_cl (s))
4064         return VPPCOM_EINVAL;
4065
4066       s->transport.is_ip4 = ep->is_ip4;
4067       s->transport.rmt_port = ep->port;
4068       vcl_ip_copy_from_ep (&s->transport.rmt_ip, ep);
4069
4070       /* Session not connected/bound in vpp. Create it by 'connecting' it */
4071       if (PREDICT_FALSE (s->session_state == VCL_STATE_CLOSED))
4072         {
4073           u32 session_index = s->session_index;
4074           f64 timeout = vcm->cfg.session_timeout;
4075           int rv;
4076
4077           vcl_send_session_connect (wrk, s);
4078           rv = vppcom_wait_for_session_state_change (session_index,
4079                                                      VCL_STATE_READY,
4080                                                      timeout);
4081           if (rv < 0)
4082             return rv;
4083           s = vcl_session_get (wrk, session_index);
4084         }
4085     }
4086
4087   if (flags)
4088     {
4089       // TBD check the flags and do the right thing
4090       VDBG (2, "handling flags 0x%u (%d) not implemented yet.", flags, flags);
4091     }
4092
4093   return (vppcom_session_write_inline (wrk, s, buffer, buflen, 1,
4094                                        s->is_dgram ? 1 : 0));
4095 }
4096
4097 int
4098 vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
4099 {
4100   vcl_worker_t *wrk = vcl_worker_get_current ();
4101   f64 timeout = clib_time_now (&wrk->clib_time) + wait_for_time;
4102   u32 i, keep_trying = 1;
4103   svm_msg_q_msg_t msg;
4104   session_event_t *e;
4105   int rv, num_ev = 0;
4106
4107   VDBG (3, "vp %p, nsids %u, wait_for_time %f", vp, n_sids, wait_for_time);
4108
4109   if (!vp)
4110     return VPPCOM_EFAULT;
4111
4112   do
4113     {
4114       vcl_session_t *session;
4115
4116       /* Dequeue all events and drop all unhandled io events */
4117       while (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_NOWAIT, 0) == 0)
4118         {
4119           e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
4120           vcl_handle_mq_event (wrk, e);
4121           svm_msg_q_free_msg (wrk->app_event_queue, &msg);
4122         }
4123       vec_reset_length (wrk->unhandled_evts_vector);
4124
4125       for (i = 0; i < n_sids; i++)
4126         {
4127           session = vcl_session_get (wrk, vp[i].sh);
4128           if (!session)
4129             {
4130               vp[i].revents = POLLHUP;
4131               num_ev++;
4132               continue;
4133             }
4134
4135           vp[i].revents = 0;
4136
4137           if (POLLIN & vp[i].events)
4138             {
4139               rv = vcl_session_read_ready (session);
4140               if (rv > 0)
4141                 {
4142                   vp[i].revents |= POLLIN;
4143                   num_ev++;
4144                 }
4145               else if (rv < 0)
4146                 {
4147                   switch (rv)
4148                     {
4149                     case VPPCOM_ECONNRESET:
4150                       vp[i].revents = POLLHUP;
4151                       break;
4152
4153                     default:
4154                       vp[i].revents = POLLERR;
4155                       break;
4156                     }
4157                   num_ev++;
4158                 }
4159             }
4160
4161           if (POLLOUT & vp[i].events)
4162             {
4163               rv = vcl_session_write_ready (session);
4164               if (rv > 0)
4165                 {
4166                   vp[i].revents |= POLLOUT;
4167                   num_ev++;
4168                 }
4169               else if (rv < 0)
4170                 {
4171                   switch (rv)
4172                     {
4173                     case VPPCOM_ECONNRESET:
4174                       vp[i].revents = POLLHUP;
4175                       break;
4176
4177                     default:
4178                       vp[i].revents = POLLERR;
4179                       break;
4180                     }
4181                   num_ev++;
4182                 }
4183             }
4184
4185           if (0)                // Note "done:" label used by VCL_SESSION_LOCK_AND_GET()
4186             {
4187               vp[i].revents = POLLNVAL;
4188               num_ev++;
4189             }
4190         }
4191       if (wait_for_time != -1)
4192         keep_trying = (clib_time_now (&wrk->clib_time) <= timeout) ? 1 : 0;
4193     }
4194   while ((num_ev == 0) && keep_trying);
4195
4196   return num_ev;
4197 }
4198
4199 int
4200 vppcom_mq_epoll_fd (void)
4201 {
4202   vcl_worker_t *wrk = vcl_worker_get_current ();
4203   return wrk->mqs_epfd;
4204 }
4205
4206 int
4207 vppcom_session_index (vcl_session_handle_t session_handle)
4208 {
4209   return session_handle & 0xFFFFFF;
4210 }
4211
4212 int
4213 vppcom_session_worker (vcl_session_handle_t session_handle)
4214 {
4215   return session_handle >> 24;
4216 }
4217
4218 int
4219 vppcom_worker_register (void)
4220 {
4221   if (!vcl_worker_alloc_and_init ())
4222     return VPPCOM_EEXIST;
4223
4224   if (vcl_worker_register_with_vpp ())
4225     return VPPCOM_EEXIST;
4226
4227   return VPPCOM_OK;
4228 }
4229
4230 void
4231 vppcom_worker_unregister (void)
4232 {
4233   vcl_worker_cleanup (vcl_worker_get_current (), 1 /* notify vpp */ );
4234   vcl_set_worker_index (~0);
4235 }
4236
4237 void
4238 vppcom_worker_index_set (int index)
4239 {
4240   vcl_set_worker_index (index);
4241 }
4242
4243 int
4244 vppcom_worker_index (void)
4245 {
4246   return vcl_get_worker_index ();
4247 }
4248
4249 int
4250 vppcom_worker_mqs_epfd (void)
4251 {
4252   vcl_worker_t *wrk = vcl_worker_get_current ();
4253   if (!vcm->cfg.use_mq_eventfd)
4254     return -1;
4255   return wrk->mqs_epfd;
4256 }
4257
4258 int
4259 vppcom_session_is_connectable_listener (uint32_t session_handle)
4260 {
4261   vcl_session_t *session;
4262   vcl_worker_t *wrk = vcl_worker_get_current ();
4263   session = vcl_session_get_w_handle (wrk, session_handle);
4264   if (!session)
4265     return VPPCOM_EBADFD;
4266   return vcl_session_is_connectable_listener (wrk, session);
4267 }
4268
4269 int
4270 vppcom_session_listener (uint32_t session_handle)
4271 {
4272   vcl_worker_t *wrk = vcl_worker_get_current ();
4273   vcl_session_t *listen_session, *session;
4274   session = vcl_session_get_w_handle (wrk, session_handle);
4275   if (!session)
4276     return VPPCOM_EBADFD;
4277   if (session->listener_index == VCL_INVALID_SESSION_INDEX)
4278     return VPPCOM_EBADFD;
4279   listen_session = vcl_session_get_w_handle (wrk, session->listener_index);
4280   if (!listen_session)
4281     return VPPCOM_EBADFD;
4282   return vcl_session_handle (listen_session);
4283 }
4284
4285 int
4286 vppcom_session_n_accepted (uint32_t session_handle)
4287 {
4288   vcl_worker_t *wrk = vcl_worker_get_current ();
4289   vcl_session_t *session = vcl_session_get_w_handle (wrk, session_handle);
4290   if (!session)
4291     return VPPCOM_EBADFD;
4292   return session->n_accepted_sessions;
4293 }
4294
4295 const char *
4296 vppcom_proto_str (vppcom_proto_t proto)
4297 {
4298   char const *proto_str;
4299
4300   switch (proto)
4301     {
4302     case VPPCOM_PROTO_TCP:
4303       proto_str = "TCP";
4304       break;
4305     case VPPCOM_PROTO_UDP:
4306       proto_str = "UDP";
4307       break;
4308     case VPPCOM_PROTO_TLS:
4309       proto_str = "TLS";
4310       break;
4311     case VPPCOM_PROTO_QUIC:
4312       proto_str = "QUIC";
4313       break;
4314     case VPPCOM_PROTO_DTLS:
4315       proto_str = "DTLS";
4316       break;
4317     case VPPCOM_PROTO_SRTP:
4318       proto_str = "SRTP";
4319       break;
4320     default:
4321       proto_str = "UNKNOWN";
4322       break;
4323     }
4324   return proto_str;
4325 }
4326
4327 const char *
4328 vppcom_retval_str (int retval)
4329 {
4330   char const *st;
4331
4332   switch (retval)
4333     {
4334     case VPPCOM_OK:
4335       st = "VPPCOM_OK";
4336       break;
4337
4338     case VPPCOM_EAGAIN:
4339       st = "VPPCOM_EAGAIN";
4340       break;
4341
4342     case VPPCOM_EFAULT:
4343       st = "VPPCOM_EFAULT";
4344       break;
4345
4346     case VPPCOM_ENOMEM:
4347       st = "VPPCOM_ENOMEM";
4348       break;
4349
4350     case VPPCOM_EINVAL:
4351       st = "VPPCOM_EINVAL";
4352       break;
4353
4354     case VPPCOM_EBADFD:
4355       st = "VPPCOM_EBADFD";
4356       break;
4357
4358     case VPPCOM_EAFNOSUPPORT:
4359       st = "VPPCOM_EAFNOSUPPORT";
4360       break;
4361
4362     case VPPCOM_ECONNABORTED:
4363       st = "VPPCOM_ECONNABORTED";
4364       break;
4365
4366     case VPPCOM_ECONNRESET:
4367       st = "VPPCOM_ECONNRESET";
4368       break;
4369
4370     case VPPCOM_ENOTCONN:
4371       st = "VPPCOM_ENOTCONN";
4372       break;
4373
4374     case VPPCOM_ECONNREFUSED:
4375       st = "VPPCOM_ECONNREFUSED";
4376       break;
4377
4378     case VPPCOM_ETIMEDOUT:
4379       st = "VPPCOM_ETIMEDOUT";
4380       break;
4381
4382     default:
4383       st = "UNKNOWN_STATE";
4384       break;
4385     }
4386
4387   return st;
4388 }
4389
4390 int
4391 vppcom_add_cert_key_pair (vppcom_cert_key_pair_t *ckpair)
4392 {
4393   if (vcm->cfg.vpp_app_socket_api)
4394     return vcl_sapi_add_cert_key_pair (ckpair);
4395   else
4396     return vcl_bapi_add_cert_key_pair (ckpair);
4397 }
4398
4399 int
4400 vppcom_del_cert_key_pair (uint32_t ckpair_index)
4401 {
4402   if (vcm->cfg.vpp_app_socket_api)
4403     return vcl_sapi_del_cert_key_pair (ckpair_index);
4404   else
4405     return vcl_bapi_del_cert_key_pair (ckpair_index);
4406 }
4407
4408 /*
4409  * fd.io coding-style-patch-verification: ON
4410  *
4411  * Local Variables:
4412  * eval: (c-set-style "gnu")
4413  * End:
4414  */