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