src/vcl/vppcom.c

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