src/vcl/vppcom.c

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