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