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