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