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