src/vcl/vppcom.c

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