src/vcl/vppcom.c

   1 /*
   2  * Copyright (c) 2017 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <svm/svm_fifo_segment.h>
  19 #include <vcl/vppcom.h>
  20 #include <vcl/vcl_event.h>
  21 #include <vcl/vcl_debug.h>
  22 #include <vcl/vcl_private.h>
  23
  24 static const char *
  25 vppcom_app_state_str (app_state_t state)
  26 {
  27   char *st;
  28
  29   switch (state)
  30     {
  31     case STATE_APP_START:
  32       st = "STATE_APP_START";
  33       break;
  34
  35     case STATE_APP_CONN_VPP:
  36       st = "STATE_APP_CONN_VPP";
  37       break;
  38
  39     case STATE_APP_ENABLED:
  40       st = "STATE_APP_ENABLED";
  41       break;
  42
  43     case STATE_APP_ATTACHED:
  44       st = "STATE_APP_ATTACHED";
  45       break;
  46
  47     default:
  48       st = "UNKNOWN_APP_STATE";
  49       break;
  50     }
  51
  52   return st;
  53 }
  54
  55 const char *
  56 vppcom_session_state_str (session_state_t state)
  57 {
  58   char *st;
  59
  60   switch (state)
  61     {
  62     case STATE_START:
  63       st = "STATE_START";
  64       break;
  65
  66     case STATE_CONNECT:
  67       st = "STATE_CONNECT";
  68       break;
  69
  70     case STATE_LISTEN:
  71       st = "STATE_LISTEN";
  72       break;
  73
  74     case STATE_ACCEPT:
  75       st = "STATE_ACCEPT";
  76       break;
  77
  78     case STATE_CLOSE_ON_EMPTY:
  79       st = "STATE_CLOSE_ON_EMPTY";
  80       break;
  81
  82     case STATE_DISCONNECT:
  83       st = "STATE_DISCONNECT";
  84       break;
  85
  86     case STATE_FAILED:
  87       st = "STATE_FAILED";
  88       break;
  89
  90     default:
  91       st = "UNKNOWN_STATE";
  92       break;
  93     }
  94
  95   return st;
  96 }
  97
  98 u8 *
  99 format_ip4_address (u8 * s, va_list * args)
 100 {
 101   u8 *a = va_arg (*args, u8 *);
 102   return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
 103 }
 104
 105 u8 *
 106 format_ip6_address (u8 * s, va_list * args)
 107 {
 108   ip6_address_t *a = va_arg (*args, ip6_address_t *);
 109   u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
 110
 111   i_max_n_zero = ARRAY_LEN (a->as_u16);
 112   max_n_zeros = 0;
 113   i_first_zero = i_max_n_zero;
 114   n_zeros = 0;
 115   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 116     {
 117       u32 is_zero = a->as_u16[i] == 0;
 118       if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
 119         {
 120           i_first_zero = i;
 121           n_zeros = 0;
 122         }
 123       n_zeros += is_zero;
 124       if ((!is_zero && n_zeros > max_n_zeros)
 125           || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
 126         {
 127           i_max_n_zero = i_first_zero;
 128           max_n_zeros = n_zeros;
 129           i_first_zero = ARRAY_LEN (a->as_u16);
 130           n_zeros = 0;
 131         }
 132     }
 133
 134   last_double_colon = 0;
 135   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 136     {
 137       if (i == i_max_n_zero && max_n_zeros > 1)
 138         {
 139           s = format (s, "::");
 140           i += max_n_zeros - 1;
 141           last_double_colon = 1;
 142         }
 143       else
 144         {
 145           s = format (s, "%s%x",
 146                       (last_double_colon || i == 0) ? "" : ":",
 147                       clib_net_to_host_u16 (a->as_u16[i]));
 148           last_double_colon = 0;
 149         }
 150     }
 151
 152   return s;
 153 }
 154
 155 /* Format an IP46 address. */
 156 u8 *
 157 format_ip46_address (u8 * s, va_list * args)
 158 {
 159   ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
 160   ip46_type_t type = va_arg (*args, ip46_type_t);
 161   int is_ip4 = 1;
 162
 163   switch (type)
 164     {
 165     case IP46_TYPE_ANY:
 166       is_ip4 = ip46_address_is_ip4 (ip46);
 167       break;
 168     case IP46_TYPE_IP4:
 169       is_ip4 = 1;
 170       break;
 171     case IP46_TYPE_IP6:
 172       is_ip4 = 0;
 173       break;
 174     }
 175
 176   return is_ip4 ?
 177     format (s, "%U", format_ip4_address, &ip46->ip4) :
 178     format (s, "%U", format_ip6_address, &ip46->ip6);
 179 }
 180
 181 /*
 182  * VPPCOM Utility Functions
 183  */
 184
 185 static inline void
 186 vppcom_session_table_del_listener (u64 listener_handle)
 187 {
 188   listener_handle |= 1ULL << 63;
 189   hash_unset (vcm->session_index_by_vpp_handles, listener_handle);
 190 }
 191
 192 static inline int
 193 vppcom_wait_for_app_state_change (app_state_t app_state)
 194 {
 195   f64 timeout = clib_time_now (&vcm->clib_time) + vcm->cfg.app_timeout;
 196
 197   while (clib_time_now (&vcm->clib_time) < timeout)
 198     {
 199       if (vcm->app_state == app_state)
 200         return VPPCOM_OK;
 201     }
 202   VDBG (0, "VCL<%d>: timeout waiting for state %s (%d)", getpid (),
 203         vppcom_app_state_str (app_state), app_state);
 204   vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, app_state);
 205
 206   return VPPCOM_ETIMEDOUT;
 207 }
 208
 209 static inline int
 210 vppcom_wait_for_session_state_change (u32 session_index,
 211                                       session_state_t state,
 212                                       f64 wait_for_time)
 213 {
 214   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
 215   vcl_session_t *volatile session;
 216   int rv;
 217
 218   do
 219     {
 220       VCL_SESSION_LOCK ();
 221       rv = vppcom_session_at_index (session_index, &session);
 222       if (PREDICT_FALSE (rv))
 223         {
 224           VCL_SESSION_UNLOCK ();
 225           return rv;
 226         }
 227       if (session->session_state & state)
 228         {
 229           VCL_SESSION_UNLOCK ();
 230           return VPPCOM_OK;
 231         }
 232       if (session->session_state & STATE_FAILED)
 233         {
 234           VCL_SESSION_UNLOCK ();
 235           return VPPCOM_ECONNREFUSED;
 236         }
 237
 238       VCL_SESSION_UNLOCK ();
 239     }
 240   while (clib_time_now (&vcm->clib_time) < timeout);
 241
 242   VDBG (0, "VCL<%d>: timeout waiting for state 0x%x (%s)", getpid (), state,
 243         vppcom_session_state_str (state));
 244   vcl_evt (VCL_EVT_SESSION_TIMEOUT, session, session_state);
 245
 246   return VPPCOM_ETIMEDOUT;
 247 }
 248
 249 static int
 250 vppcom_app_session_enable (void)
 251 {
 252   int rv;
 253
 254   if (vcm->app_state != STATE_APP_ENABLED)
 255     {
 256       vppcom_send_session_enable_disable (1 /* is_enabled == TRUE */ );
 257       rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
 258       if (PREDICT_FALSE (rv))
 259         {
 260           VDBG (0, "VCL<%d>: application session enable timed out! "
 261                 "returning %d (%s)", getpid (), rv, vppcom_retval_str (rv));
 262           return rv;
 263         }
 264     }
 265   return VPPCOM_OK;
 266 }
 267
 268 static int
 269 vppcom_app_attach (void)
 270 {
 271   int rv;
 272
 273   vppcom_app_send_attach ();
 274   rv = vppcom_wait_for_app_state_change (STATE_APP_ATTACHED);
 275   if (PREDICT_FALSE (rv))
 276     {
 277       VDBG (0, "VCL<%d>: application attach timed out! returning %d (%s)",
 278             getpid (), rv, vppcom_retval_str (rv));
 279       return rv;
 280     }
 281
 282   return VPPCOM_OK;
 283 }
 284
 285 static int
 286 vppcom_session_unbind (u32 session_index)
 287 {
 288   vcl_session_t *session = 0;
 289   int rv;
 290   u64 vpp_handle;
 291
 292   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 293
 294   vpp_handle = session->vpp_handle;
 295   vppcom_session_table_del_listener (vpp_handle);
 296   session->vpp_handle = ~0;
 297   session->session_state = STATE_DISCONNECT;
 298
 299   VCL_SESSION_UNLOCK ();
 300
 301   VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending unbind msg! new state"
 302         " 0x%x (%s)", getpid (), vpp_handle, session_index, STATE_DISCONNECT,
 303         vppcom_session_state_str (STATE_DISCONNECT));
 304   vcl_evt (VCL_EVT_UNBIND, session);
 305   vppcom_send_unbind_sock (vpp_handle);
 306
 307 done:
 308   return rv;
 309 }
 310
 311 static int
 312 vppcom_session_disconnect (u32 session_index)
 313 {
 314   int rv;
 315   vcl_session_t *session;
 316   u64 vpp_handle;
 317   session_state_t state;
 318
 319   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 320
 321   vpp_handle = session->vpp_handle;
 322   state = session->session_state;
 323   VCL_SESSION_UNLOCK ();
 324
 325   VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u state 0x%x (%s)", getpid (),
 326         vpp_handle, session_index, state, vppcom_session_state_str (state));
 327
 328   if (PREDICT_FALSE (state & STATE_LISTEN))
 329     {
 330       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
 331                     "Cannot disconnect a listen socket!",
 332                     getpid (), vpp_handle, session_index);
 333       rv = VPPCOM_EBADFD;
 334       goto done;
 335     }
 336
 337   /* The peer has already initiated the close,
 338    * so send the disconnect session reply.
 339    */
 340   if (state & STATE_CLOSE_ON_EMPTY)
 341     {
 342       //XXX alagalah - Check and drain here?
 343       vppcom_send_disconnect_session_reply (vpp_handle,
 344                                             session_index, 0 /* rv */ );
 345       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect "
 346             "REPLY...", getpid (), vpp_handle, session_index);
 347     }
 348
 349   /* Otherwise, send a disconnect session msg...
 350    */
 351   else
 352     {
 353       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect...",
 354             getpid (), vpp_handle, session_index);
 355
 356       vppcom_send_disconnect_session (vpp_handle, session_index);
 357     }
 358
 359 done:
 360   return rv;
 361 }
 362
 363 /*
 364  * VPPCOM Public API functions
 365  */
 366 int
 367 vppcom_app_create (char *app_name)
 368 {
 369   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
 370   u8 *heap;
 371   mheap_t *h;
 372   int rv;
 373
 374   if (!vcm->init)
 375     {
 376       vcm->init = 1;
 377       clib_spinlock_init (&vcm->session_fifo_lockp);
 378       clib_fifo_validate (vcm->client_session_index_fifo,
 379                           vcm->cfg.listen_queue_size);
 380       clib_spinlock_init (&vcm->sessions_lockp);
 381
 382       vppcom_cfg (&vcm->cfg);
 383
 384       vcm->main_cpu = os_get_thread_index ();
 385       heap = clib_mem_get_per_cpu_heap ();
 386       h = mheap_header (heap);
 387       /* make the main heap thread-safe */
 388       h->flags |= MHEAP_FLAG_THREAD_SAFE;
 389
 390       vcm->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
 391
 392       clib_time_init (&vcm->clib_time);
 393       vppcom_init_error_string_table ();
 394       svm_fifo_segment_main_init (vcl_cfg->segment_baseva,
 395                                   20 /* timeout in secs */ );
 396     }
 397
 398   if (vcm->my_client_index == ~0)
 399     {
 400       /* API hookup and connect to VPP */
 401       vppcom_api_hookup ();
 402       vcl_elog_init (vcm);
 403       vcm->app_state = STATE_APP_START;
 404       rv = vppcom_connect_to_vpp (app_name);
 405       if (rv)
 406         {
 407           clib_warning ("VCL<%d>: ERROR: couldn't connect to VPP!",
 408                         getpid ());
 409           return rv;
 410         }
 411
 412       /* State event handling thread */
 413
 414       rv = vce_start_event_thread (&(vcm->event_thread), 20);
 415
 416       VDBG (0, "VCL<%d>: sending session enable", getpid ());
 417
 418       rv = vppcom_app_session_enable ();
 419       if (rv)
 420         {
 421           clib_warning ("VCL<%d>: ERROR: vppcom_app_session_enable() "
 422                         "failed!", getpid ());
 423           return rv;
 424         }
 425
 426       VDBG (0, "VCL<%d>: sending app attach", getpid ());
 427
 428       rv = vppcom_app_attach ();
 429       if (rv)
 430         {
 431           clib_warning ("VCL<%d>: ERROR: vppcom_app_attach() failed!",
 432                         getpid ());
 433           return rv;
 434         }
 435
 436       VDBG (0, "VCL<%d>: app_name '%s', my_client_index %d (0x%x)",
 437             getpid (), app_name, vcm->my_client_index, vcm->my_client_index);
 438     }
 439
 440   return VPPCOM_OK;
 441 }
 442
 443 void
 444 vppcom_app_destroy (void)
 445 {
 446   int rv;
 447   f64 orig_app_timeout;
 448
 449   if (vcm->my_client_index == ~0)
 450     return;
 451
 452   VDBG (0, "VCL<%d>: detaching from VPP, my_client_index %d (0x%x)",
 453         getpid (), vcm->my_client_index, vcm->my_client_index);
 454   vcl_evt (VCL_EVT_DETACH, vcm);
 455
 456   vppcom_app_send_detach ();
 457   orig_app_timeout = vcm->cfg.app_timeout;
 458   vcm->cfg.app_timeout = 2.0;
 459   rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
 460   vcm->cfg.app_timeout = orig_app_timeout;
 461   if (PREDICT_FALSE (rv))
 462     VDBG (0, "VCL<%d>: application detach timed out! returning %d (%s)",
 463           getpid (), rv, vppcom_retval_str (rv));
 464
 465   vcl_elog_stop (vcm);
 466   vl_client_disconnect_from_vlib ();
 467   vcm->my_client_index = ~0;
 468   vcm->app_state = STATE_APP_START;
 469 }
 470
 471 int
 472 vppcom_session_create (u8 proto, u8 is_nonblocking)
 473 {
 474   vcl_session_t *session;
 475   u32 session_index;
 476
 477   VCL_SESSION_LOCK ();
 478   pool_get (vcm->sessions, session);
 479   memset (session, 0, sizeof (*session));
 480   session_index = session - vcm->sessions;
 481
 482   session->session_type = proto;
 483   session->session_state = STATE_START;
 484   session->vpp_handle = ~0;
 485
 486   if (is_nonblocking)
 487     VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
 488   else
 489     VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_NONBLOCK);
 490
 491   vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
 492            is_nonblocking, session_index);
 493
 494   VCL_SESSION_UNLOCK ();
 495
 496   VDBG (0, "VCL<%d>: sid %u", getpid (), session_index);
 497
 498   return (int) session_index;
 499 }
 500
 501 int
 502 vppcom_session_close (uint32_t session_index)
 503 {
 504   vcl_session_t *session = 0;
 505   int rv;
 506   u8 is_vep;
 507   u8 is_vep_session;
 508   u32 next_sid;
 509   u32 vep_idx;
 510   u64 vpp_handle;
 511   uword *p;
 512   session_state_t state;
 513
 514   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 515   is_vep = session->is_vep;
 516   is_vep_session = session->is_vep_session;
 517   next_sid = session->vep.next_sid;
 518   vep_idx = session->vep.vep_idx;
 519   state = session->session_state;
 520   vpp_handle = session->vpp_handle;
 521   VCL_SESSION_UNLOCK ();
 522
 523   if (VPPCOM_DEBUG > 0)
 524     {
 525       if (is_vep)
 526         clib_warning ("VCL<%d>: vep_idx %u / sid %u: "
 527                       "closing epoll session...",
 528                       getpid (), session_index, session_index);
 529       else
 530         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %d: "
 531                       "closing session...",
 532                       getpid (), vpp_handle, session_index);
 533     }
 534
 535   if (is_vep)
 536     {
 537       while (next_sid != ~0)
 538         {
 539           rv = vppcom_epoll_ctl (session_index, EPOLL_CTL_DEL, next_sid, 0);
 540           if (PREDICT_FALSE (rv < 0))
 541             VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL "
 542                   "vep_idx %u failed! rv %d (%s)",
 543                   getpid (), vpp_handle, next_sid, vep_idx,
 544                   rv, vppcom_retval_str (rv));
 545
 546           VCL_SESSION_LOCK_AND_GET (session_index, &session);
 547           next_sid = session->vep.next_sid;
 548           VCL_SESSION_UNLOCK ();
 549         }
 550     }
 551   else
 552     {
 553       if (is_vep_session)
 554         {
 555           rv = vppcom_epoll_ctl (vep_idx, EPOLL_CTL_DEL, session_index, 0);
 556           if (rv < 0)
 557             VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL "
 558                   "vep_idx %u failed! rv %d (%s)",
 559                   getpid (), vpp_handle, session_index,
 560                   vep_idx, rv, vppcom_retval_str (rv));
 561         }
 562
 563       if (state & STATE_LISTEN)
 564         {
 565           rv = vppcom_session_unbind (session_index);
 566           if (PREDICT_FALSE (rv < 0))
 567             VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: listener unbind "
 568                   "failed! rv %d (%s)",
 569                   getpid (), vpp_handle, session_index,
 570                   rv, vppcom_retval_str (rv));
 571         }
 572
 573       else if (state & (CLIENT_STATE_OPEN | SERVER_STATE_OPEN))
 574         {
 575           rv = vppcom_session_disconnect (session_index);
 576           if (PREDICT_FALSE (rv < 0))
 577             clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
 578                           "session disconnect failed! rv %d (%s)",
 579                           getpid (), vpp_handle, session_index,
 580                           rv, vppcom_retval_str (rv));
 581         }
 582     }
 583
 584   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 585   vpp_handle = session->vpp_handle;
 586   if (vpp_handle != ~0)
 587     {
 588       p = hash_get (vcm->session_index_by_vpp_handles, vpp_handle);
 589       if (p)
 590         hash_unset (vcm->session_index_by_vpp_handles, vpp_handle);
 591     }
 592   pool_put_index (vcm->sessions, session_index);
 593
 594   VCL_SESSION_UNLOCK ();
 595
 596   if (VPPCOM_DEBUG > 0)
 597     {
 598       if (is_vep)
 599         clib_warning ("VCL<%d>: vep_idx %u / sid %u: epoll session removed.",
 600                       getpid (), session_index, session_index);
 601       else
 602         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: session removed.",
 603                       getpid (), vpp_handle, session_index);
 604     }
 605 done:
 606
 607   vcl_evt (VCL_EVT_CLOSE, session, rv);
 608
 609   return rv;
 610 }
 611
 612 int
 613 vppcom_session_bind (uint32_t session_index, vppcom_endpt_t * ep)
 614 {
 615   vcl_session_t *session = 0;
 616   int rv;
 617
 618   if (!ep || !ep->ip)
 619     return VPPCOM_EINVAL;
 620
 621   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 622
 623   if (session->is_vep)
 624     {
 625       VCL_SESSION_UNLOCK ();
 626       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
 627                     "bind to an epoll session!", getpid (), session_index);
 628       rv = VPPCOM_EBADFD;
 629       goto done;
 630     }
 631
 632   session->transport.is_ip4 = ep->is_ip4;
 633   session->transport.lcl_ip = to_ip46 (ep->is_ip4 ? IP46_TYPE_IP4 :
 634                                        IP46_TYPE_IP6, ep->ip);
 635   session->transport.lcl_port = ep->port;
 636
 637   VDBG (0, "VCL<%d>: sid %u: binding to local %s address %U port %u, "
 638         "proto %s", getpid (), session_index,
 639         session->transport.is_ip4 ? "IPv4" : "IPv6",
 640         format_ip46_address, &session->transport.lcl_ip,
 641         session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
 642         clib_net_to_host_u16 (session->transport.lcl_port),
 643         session->session_type ? "UDP" : "TCP");
 644   vcl_evt (VCL_EVT_BIND, session);
 645   VCL_SESSION_UNLOCK ();
 646 done:
 647   return rv;
 648 }
 649
 650 int
 651 vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len)
 652 {
 653   vcl_session_t *listen_session = 0;
 654   u64 listen_vpp_handle;
 655   int rv, retval;
 656
 657   if (q_len == 0 || q_len == ~0)
 658     q_len = vcm->cfg.listen_queue_size;
 659
 660   VCL_SESSION_LOCK_AND_GET (listen_session_index, &listen_session);
 661
 662   if (listen_session->is_vep)
 663     {
 664       VCL_SESSION_UNLOCK ();
 665       clib_warning ("VCL<%d>: ERROR: sid %u: cannot listen on an "
 666                     "epoll session!", getpid (), listen_session_index);
 667       rv = VPPCOM_EBADFD;
 668       goto done;
 669     }
 670
 671   listen_vpp_handle = listen_session->vpp_handle;
 672   if (listen_session->session_state & STATE_LISTEN)
 673     {
 674       VCL_SESSION_UNLOCK ();
 675       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: already in listen state!",
 676             getpid (), listen_vpp_handle, listen_session_index);
 677       rv = VPPCOM_OK;
 678       goto done;
 679     }
 680
 681   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: sending VPP bind+listen "
 682         "request...", getpid (), listen_vpp_handle, listen_session_index);
 683
 684   vppcom_send_bind_sock (listen_session, listen_session_index);
 685   VCL_SESSION_UNLOCK ();
 686   retval =
 687     vppcom_wait_for_session_state_change (listen_session_index, STATE_LISTEN,
 688                                           vcm->cfg.session_timeout);
 689
 690   VCL_SESSION_LOCK_AND_GET (listen_session_index, &listen_session);
 691   if (PREDICT_FALSE (retval))
 692     {
 693       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: bind+listen failed! "
 694             "returning %d (%s)", getpid (), listen_session->vpp_handle,
 695             listen_session_index, retval, vppcom_retval_str (retval));
 696       VCL_SESSION_UNLOCK ();
 697       rv = retval;
 698       goto done;
 699     }
 700
 701   VCL_ACCEPT_FIFO_LOCK ();
 702   clib_fifo_validate (vcm->client_session_index_fifo, q_len);
 703   VCL_ACCEPT_FIFO_UNLOCK ();
 704
 705   VCL_SESSION_UNLOCK ();
 706
 707 done:
 708   return rv;
 709 }
 710
 711 int
 712 validate_args_session_accept_ (vcl_session_t * listen_session)
 713 {
 714   u32 listen_session_index = listen_session - vcm->sessions;
 715
 716   /* Input validation - expects spinlock on sessions_lockp */
 717   if (listen_session->is_vep)
 718     {
 719       clib_warning ("VCL<%d>: ERROR: sid %u: cannot accept on an "
 720                     "epoll session!", getpid (), listen_session_index);
 721       return VPPCOM_EBADFD;
 722     }
 723
 724   if (listen_session->session_state != STATE_LISTEN)
 725     {
 726       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
 727                     "not in listen state! state 0x%x (%s)", getpid (),
 728                     listen_session->vpp_handle, listen_session_index,
 729                     listen_session->session_state,
 730                     vppcom_session_state_str (listen_session->session_state));
 731       return VPPCOM_EBADFD;
 732     }
 733   return VPPCOM_OK;
 734 }
 735
 736 int
 737 vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep,
 738                        uint32_t flags)
 739 {
 740   vcl_session_t *listen_session = 0;
 741   vcl_session_t *client_session = 0;
 742   u32 client_session_index = ~0;
 743   int rv;
 744   u64 listen_vpp_handle;
 745   vce_event_handler_reg_t *reg;
 746   vce_event_t *ev;
 747   vce_event_connect_request_t *result;
 748   struct timespec ts;
 749   struct timeval tv;
 750   int millisecond_timeout = 1;
 751   int hours_timeout = 20 * 60 * 60;
 752
 753   VCL_SESSION_LOCK_AND_GET (listen_session_index, &listen_session);
 754   listen_vpp_handle = listen_session->vpp_handle;       // For debugging
 755
 756   rv = validate_args_session_accept_ (listen_session);
 757   if (rv)
 758     {
 759       VCL_SESSION_UNLOCK ();
 760       goto done;
 761     }
 762
 763   /* Using an aggressive timer of 1ms and a generous timer of
 764    * 20 hours, we can implement a blocking and non-blocking listener
 765    * as both event and time driven */
 766   gettimeofday (&tv, NULL);
 767   ts.tv_nsec = (tv.tv_usec * 1000) + (1000 * millisecond_timeout);
 768   ts.tv_sec = tv.tv_sec;
 769
 770   /* Predict that the Listener is blocking more often than not */
 771   if (PREDICT_TRUE (!VCL_SESS_ATTR_TEST (listen_session->attr,
 772                                          VCL_SESS_ATTR_NONBLOCK)))
 773     ts.tv_sec += hours_timeout;
 774
 775   VCL_SESSION_UNLOCK ();
 776
 777   /* Register handler for connect_request event on listen_session_index */
 778   vce_event_key_t evk;
 779   evk.session_index = listen_session_index;
 780   evk.eid = VCL_EVENT_CONNECT_REQ_ACCEPTED;
 781   reg = vce_register_handler (&vcm->event_thread, &evk,
 782                               vce_connect_request_handler_fn, 0);
 783   VCL_EVENTS_LOCK ();
 784   ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx);
 785   pthread_mutex_lock (&reg->handler_lock);
 786   while (!ev)
 787     {
 788       VCL_EVENTS_UNLOCK ();
 789       rv = pthread_cond_timedwait (&reg->handler_cond,
 790                                    &reg->handler_lock, &ts);
 791       if (rv == ETIMEDOUT)
 792         {
 793           rv = VPPCOM_EAGAIN;
 794           goto cleanup;
 795         }
 796       VCL_EVENTS_LOCK ();
 797       ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx);
 798     }
 799   result = vce_get_event_data (ev, sizeof (*result));
 800   client_session_index = result->accepted_session_index;
 801   VCL_EVENTS_UNLOCK ();
 802
 803   /* Remove from the FIFO used to service epoll */
 804   VCL_ACCEPT_FIFO_LOCK ();
 805   if (clib_fifo_elts (vcm->client_session_index_fifo))
 806     {
 807       u32 tmp_client_session_index;
 808       clib_fifo_sub1 (vcm->client_session_index_fifo,
 809                       tmp_client_session_index);
 810       /* It wasn't ours... put it back ... */
 811       if (tmp_client_session_index != client_session_index)
 812         clib_fifo_add1 (vcm->client_session_index_fifo,
 813                         tmp_client_session_index);
 814     }
 815   VCL_ACCEPT_FIFO_UNLOCK ();
 816
 817   VCL_SESSION_LOCK ();
 818
 819   rv = vppcom_session_at_index (client_session_index, &client_session);
 820   if (PREDICT_FALSE (rv))
 821     {
 822       rv = VPPCOM_ECONNABORTED;
 823       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: client sid %u "
 824                     "lookup failed! returning %d (%s)", getpid (),
 825                     listen_vpp_handle, listen_session_index,
 826                     client_session_index, rv, vppcom_retval_str (rv));
 827       goto cleanup;
 828     }
 829
 830   if (flags & O_NONBLOCK)
 831     VCL_SESS_ATTR_SET (client_session->attr, VCL_SESS_ATTR_NONBLOCK);
 832   else
 833     VCL_SESS_ATTR_CLR (client_session->attr, VCL_SESS_ATTR_NONBLOCK);
 834
 835   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: Got a client request! "
 836         "vpp handle 0x%llx, sid %u, flags %d, is_nonblocking %u",
 837         getpid (), listen_vpp_handle, listen_session_index,
 838         client_session->vpp_handle, client_session_index,
 839         flags, VCL_SESS_ATTR_TEST (client_session->attr,
 840                                    VCL_SESS_ATTR_NONBLOCK));
 841
 842   if (ep)
 843     {
 844       ep->is_ip4 = client_session->transport.is_ip4;
 845       ep->port = client_session->transport.rmt_port;
 846       if (client_session->transport.is_ip4)
 847         clib_memcpy (ep->ip, &client_session->transport.rmt_ip.ip4,
 848                      sizeof (ip4_address_t));
 849       else
 850         clib_memcpy (ep->ip, &client_session->transport.rmt_ip.ip6,
 851                      sizeof (ip6_address_t));
 852     }
 853
 854   vppcom_send_accept_session_reply (client_session->vpp_handle,
 855                                     client_session->client_context,
 856                                     0 /* retval OK */ );
 857
 858   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: accepted vpp handle 0x%llx,"
 859         " sid %u connection from peer %s address %U port %u to local %s address"
 860         " %U port %u",
 861         getpid (), listen_vpp_handle,
 862         listen_session_index, client_session->vpp_handle,
 863         client_session_index,
 864         client_session->transport.is_ip4 ? "IPv4" : "IPv6",
 865         format_ip46_address, &client_session->transport.rmt_ip,
 866         client_session->transport.is_ip4 ?
 867         IP46_TYPE_IP4 : IP46_TYPE_IP6,
 868         clib_net_to_host_u16 (client_session->transport.rmt_port),
 869         client_session->transport.is_ip4 ? "IPv4" : "IPv6",
 870         format_ip46_address, &client_session->transport.lcl_ip,
 871         client_session->transport.is_ip4 ?
 872         IP46_TYPE_IP4 : IP46_TYPE_IP6,
 873         clib_net_to_host_u16 (client_session->transport.lcl_port));
 874   vcl_evt (VCL_EVT_ACCEPT, client_session, listen_session,
 875            client_session_index);
 876   VCL_SESSION_UNLOCK ();
 877
 878   rv = (int) client_session_index;
 879   vce_clear_event (&vcm->event_thread, reg->ev_idx);
 880   if (vcm->session_io_thread.io_sessions_lockp)
 881     {
 882       /* Throw this new accepted session index into the rx poll thread pool */
 883       VCL_IO_SESSIONS_LOCK ();
 884       u32 *active_session_index;
 885       pool_get (vcm->session_io_thread.active_session_indexes,
 886                 active_session_index);
 887       *active_session_index = client_session_index;
 888       VCL_IO_SESSIONS_UNLOCK ();
 889     }
 890 cleanup:
 891   vce_unregister_handler (&vcm->event_thread, reg);
 892   pthread_mutex_unlock (&reg->handler_lock);
 893
 894 done:
 895   return rv;
 896 }
 897
 898 int
 899 vppcom_session_connect (uint32_t session_index, vppcom_endpt_t * server_ep)
 900 {
 901   vcl_session_t *session = 0;
 902   u64 vpp_handle = 0;
 903   int rv, retval = VPPCOM_OK;
 904
 905   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 906
 907   if (PREDICT_FALSE (session->is_vep))
 908     {
 909       VCL_SESSION_UNLOCK ();
 910       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
 911                     "connect on an epoll session!", getpid (), session_index);
 912       rv = VPPCOM_EBADFD;
 913       goto done;
 914     }
 915
 916   if (PREDICT_FALSE (session->session_state & CLIENT_STATE_OPEN))
 917     {
 918       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: session already "
 919             "connected to %s %U port %d proto %s, state 0x%x (%s)",
 920             getpid (), session->vpp_handle, session_index,
 921             session->transport.is_ip4 ? "IPv4" : "IPv6",
 922             format_ip46_address,
 923             &session->transport.rmt_ip, session->transport.is_ip4 ?
 924             IP46_TYPE_IP4 : IP46_TYPE_IP6,
 925             clib_net_to_host_u16 (session->transport.rmt_port),
 926             session->session_type ? "UDP" : "TCP", session->session_state,
 927             vppcom_session_state_str (session->session_state));
 928
 929       VCL_SESSION_UNLOCK ();
 930       goto done;
 931     }
 932
 933   session->transport.is_ip4 = server_ep->is_ip4;
 934   if (session->transport.is_ip4)
 935     clib_memcpy (&session->transport.rmt_ip.ip4, server_ep->ip,
 936                  sizeof (ip4_address_t));
 937   else
 938     clib_memcpy (&session->transport.rmt_ip.ip6, server_ep->ip,
 939                  sizeof (ip6_address_t));
 940   session->transport.rmt_port = server_ep->port;
 941
 942   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connecting to server %s %U "
 943         "port %d proto %s",
 944         getpid (), session->vpp_handle, session_index,
 945         session->transport.is_ip4 ? "IPv4" : "IPv6",
 946         format_ip46_address,
 947         &session->transport.rmt_ip, session->transport.is_ip4 ?
 948         IP46_TYPE_IP4 : IP46_TYPE_IP6,
 949         clib_net_to_host_u16 (session->transport.rmt_port),
 950         session->session_type ? "UDP" : "TCP");
 951
 952   vppcom_send_connect_sock (session, session_index);
 953   VCL_SESSION_UNLOCK ();
 954
 955   retval =
 956     vppcom_wait_for_session_state_change (session_index, STATE_CONNECT,
 957                                           vcm->cfg.session_timeout);
 958
 959   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 960   vpp_handle = session->vpp_handle;
 961   VCL_SESSION_UNLOCK ();
 962
 963 done:
 964   if (PREDICT_FALSE (retval))
 965     {
 966       rv = retval;
 967       if (VPPCOM_DEBUG > 0)
 968         {
 969           if (session)
 970             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connect "
 971                           "failed! returning %d (%s)", getpid (), vpp_handle,
 972                           session_index, rv, vppcom_retval_str (rv));
 973           else
 974             clib_warning ("VCL<%d>: no session for sid %u: connect failed! "
 975                           "returning %d (%s)", getpid (),
 976                           session_index, rv, vppcom_retval_str (rv));
 977         }
 978     }
 979   else
 980     VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connected!",
 981           getpid (), vpp_handle, session_index);
 982
 983   return rv;
 984 }
 985
 986 static inline int
 987 vppcom_session_read_internal (uint32_t session_index, void *buf, int n,
 988                               u8 peek)
 989 {
 990   vcl_session_t *session = 0;
 991   svm_fifo_t *rx_fifo;
 992   int n_read = 0;
 993   int rv;
 994   int is_nonblocking;
 995
 996   u64 vpp_handle;
 997   u32 poll_et;
 998   session_state_t state;
 999
1000   ASSERT (buf);
1001
1002   VCL_SESSION_LOCK_AND_GET (session_index, &session);
1003
1004   is_nonblocking = VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK);
1005   rx_fifo = session->rx_fifo;
1006   state = session->session_state;
1007   vpp_handle = session->vpp_handle;
1008
1009   if (PREDICT_FALSE (session->is_vep))
1010     {
1011       VCL_SESSION_UNLOCK ();
1012       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
1013                     "read from an epoll session!", getpid (), session_index);
1014       rv = VPPCOM_EBADFD;
1015       goto done;
1016     }
1017
1018   if (PREDICT_FALSE (!(state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN))))
1019     {
1020       VCL_SESSION_UNLOCK ();
1021       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1022
1023       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: %s session is not open! "
1024             "state 0x%x (%s), returning %d (%s)",
1025             getpid (), vpp_handle, session_index, state,
1026             vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
1027       goto done;
1028     }
1029
1030   VCL_SESSION_UNLOCK ();
1031
1032   do
1033     {
1034       if (peek)
1035         n_read = svm_fifo_peek (rx_fifo, 0, n, buf);
1036       else
1037         n_read = svm_fifo_dequeue_nowait (rx_fifo, n, buf);
1038     }
1039   while (!is_nonblocking && (n_read <= 0));
1040
1041   if (n_read <= 0)
1042     {
1043       VCL_SESSION_LOCK_AND_GET (session_index, &session);
1044
1045       poll_et = (((EPOLLET | EPOLLIN) & session->vep.ev.events) ==
1046                  (EPOLLET | EPOLLIN));
1047       if (poll_et)
1048         session->vep.et_mask |= EPOLLIN;
1049
1050       if (state & STATE_CLOSE_ON_EMPTY)
1051         {
1052           rv = VPPCOM_ECONNRESET;
1053
1054           VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
1055                 "session state 0x%x (%s)! Setting state to 0x%x (%s), "
1056                 "returning %d (%s)",
1057                 getpid (), session->vpp_handle, session_index,
1058                 state, vppcom_session_state_str (state),
1059                 STATE_DISCONNECT,
1060                 vppcom_session_state_str (STATE_DISCONNECT), rv,
1061                 vppcom_retval_str (rv));
1062
1063           session->session_state = STATE_DISCONNECT;
1064         }
1065       else
1066         rv = VPPCOM_EAGAIN;
1067
1068       VCL_SESSION_UNLOCK ();
1069     }
1070   else
1071     rv = n_read;
1072
1073   if (VPPCOM_DEBUG > 2)
1074     {
1075       if (rv > 0)
1076         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: read %d bytes "
1077                       "from (%p)", getpid (), vpp_handle,
1078                       session_index, n_read, rx_fifo);
1079       else
1080         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: nothing read! "
1081                       "returning %d (%s)", getpid (), vpp_handle,
1082                       session_index, rv, vppcom_retval_str (rv));
1083     }
1084 done:
1085   return rv;
1086 }
1087
1088 int
1089 vppcom_session_read (uint32_t session_index, void *buf, size_t n)
1090 {
1091   return (vppcom_session_read_internal (session_index, buf, n, 0));
1092 }
1093
1094 static int
1095 vppcom_session_peek (uint32_t session_index, void *buf, int n)
1096 {
1097   return (vppcom_session_read_internal (session_index, buf, n, 1));
1098 }
1099
1100 static inline int
1101 vppcom_session_read_ready (vcl_session_t * session, u32 session_index)
1102 {
1103   int ready = 0;
1104   u32 poll_et;
1105   int rv;
1106   session_state_t state = session->session_state;
1107   u64 vpp_handle = session->vpp_handle;
1108
1109   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
1110   if (PREDICT_FALSE (session->is_vep))
1111     {
1112       clib_warning ("VCL<%d>: ERROR: sid %u: cannot read from an "
1113                     "epoll session!", getpid (), session_index);
1114       rv = VPPCOM_EBADFD;
1115       goto done;
1116     }
1117
1118   if (session->session_state & STATE_LISTEN)
1119     {
1120       VCL_ACCEPT_FIFO_LOCK ();
1121       ready = clib_fifo_elts (vcm->client_session_index_fifo);
1122       VCL_ACCEPT_FIFO_UNLOCK ();
1123     }
1124   else
1125     {
1126       if (!(state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN | STATE_LISTEN)))
1127         {
1128           rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
1129                 VPPCOM_ENOTCONN);
1130
1131           VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open!"
1132                 " state 0x%x (%s), returning %d (%s)",
1133                 getpid (), vpp_handle, session_index,
1134                 state, vppcom_session_state_str (state),
1135                 rv, vppcom_retval_str (rv));
1136           goto done;
1137         }
1138
1139       ready = svm_fifo_max_dequeue (session->rx_fifo);
1140     }
1141
1142   if (ready == 0)
1143     {
1144       poll_et =
1145         ((EPOLLET | EPOLLIN) & session->vep.ev.events) == (EPOLLET | EPOLLIN);
1146       if (poll_et)
1147         session->vep.et_mask |= EPOLLIN;
1148
1149       if (state & STATE_CLOSE_ON_EMPTY)
1150         {
1151           rv = VPPCOM_ECONNRESET;
1152
1153           VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
1154                 "session state 0x%x (%s)! Setting state to 0x%x (%s), "
1155                 "returning %d (%s)",
1156                 getpid (), session_index, vpp_handle,
1157                 state, vppcom_session_state_str (state),
1158                 STATE_DISCONNECT,
1159                 vppcom_session_state_str (STATE_DISCONNECT), rv,
1160                 vppcom_retval_str (rv));
1161           session->session_state = STATE_DISCONNECT;
1162           goto done;
1163         }
1164     }
1165   rv = ready;
1166
1167   if (vcm->app_event_queue->cursize &&
1168       !pthread_mutex_trylock (&vcm->app_event_queue->mutex))
1169     {
1170       u32 i, n_to_dequeue = vcm->app_event_queue->cursize;
1171       session_fifo_event_t e;
1172
1173       for (i = 0; i < n_to_dequeue; i++)
1174         svm_queue_sub_raw (vcm->app_event_queue, (u8 *) & e);
1175
1176       pthread_mutex_unlock (&vcm->app_event_queue->mutex);
1177     }
1178 done:
1179   return rv;
1180 }
1181
1182 int
1183 vppcom_session_write (uint32_t session_index, void *buf, size_t n)
1184 {
1185   vcl_session_t *session = 0;
1186   svm_fifo_t *tx_fifo = 0;
1187   svm_queue_t *q;
1188   session_fifo_event_t evt;
1189   session_state_t state;
1190   int rv, n_write, is_nonblocking;
1191   u32 poll_et;
1192   u64 vpp_handle;
1193
1194   ASSERT (buf);
1195
1196   VCL_SESSION_LOCK_AND_GET (session_index, &session);
1197
1198   tx_fifo = session->tx_fifo;
1199   is_nonblocking = VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK);
1200   vpp_handle = session->vpp_handle;
1201   state = session->session_state;
1202
1203   if (PREDICT_FALSE (session->is_vep))
1204     {
1205       VCL_SESSION_UNLOCK ();
1206       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1207                     "cannot write to an epoll session!",
1208                     getpid (), vpp_handle, session_index);
1209
1210       rv = VPPCOM_EBADFD;
1211       goto done;
1212     }
1213
1214   if (!(session->session_state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
1215     {
1216       rv =
1217         ((session->session_state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
1218          VPPCOM_ENOTCONN);
1219
1220       VCL_SESSION_UNLOCK ();
1221       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open! "
1222             "state 0x%x (%s)",
1223             getpid (), vpp_handle, session_index,
1224             state, vppcom_session_state_str (state));
1225       goto done;
1226     }
1227
1228   VCL_SESSION_UNLOCK ();
1229
1230   do
1231     {
1232       n_write = svm_fifo_enqueue_nowait (tx_fifo, n, (void *) buf);
1233     }
1234   while (!is_nonblocking && (n_write <= 0));
1235
1236   /* If event wasn't set, add one
1237    *
1238    * To reduce context switching, can check if an
1239    * event is already there for this event_key, but for now
1240    * this will suffice. */
1241
1242   if ((n_write > 0) && svm_fifo_set_event (tx_fifo))
1243     {
1244       /* Fabricate TX event, send to vpp */
1245       evt.fifo = tx_fifo;
1246       evt.event_type = FIFO_EVENT_APP_TX;
1247
1248       VCL_SESSION_LOCK_AND_GET (session_index, &session);
1249       q = session->vpp_evt_q;
1250       ASSERT (q);
1251       svm_queue_add (q, (u8 *) & evt, 0 /* do wait for mutex */ );
1252       VCL_SESSION_UNLOCK ();
1253       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: added FIFO_EVENT_APP_TX "
1254             "to vpp_event_q %p, n_write %d", getpid (),
1255             vpp_handle, session_index, q, n_write);
1256     }
1257
1258   if (n_write <= 0)
1259     {
1260       VCL_SESSION_LOCK_AND_GET (session_index, &session);
1261
1262       poll_et = (((EPOLLET | EPOLLOUT) & session->vep.ev.events) ==
1263                  (EPOLLET | EPOLLOUT));
1264       if (poll_et)
1265         session->vep.et_mask |= EPOLLOUT;
1266
1267       if (session->session_state & STATE_CLOSE_ON_EMPTY)
1268         {
1269           rv = VPPCOM_ECONNRESET;
1270
1271           VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
1272                 "session state 0x%x (%s)! Setting state to 0x%x (%s), "
1273                 "returning %d (%s)",
1274                 getpid (), session->vpp_handle, session_index,
1275                 session->session_state,
1276                 vppcom_session_state_str (session->session_state),
1277                 STATE_DISCONNECT,
1278                 vppcom_session_state_str (STATE_DISCONNECT), rv,
1279                 vppcom_retval_str (rv));
1280
1281           session->session_state = STATE_DISCONNECT;
1282         }
1283       else
1284         rv = VPPCOM_EAGAIN;
1285
1286       VCL_SESSION_UNLOCK ();
1287     }
1288   else
1289     rv = n_write;
1290
1291   if (VPPCOM_DEBUG > 2)
1292     {
1293       if (n_write <= 0)
1294         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
1295                       "FIFO-FULL (%p)", getpid (), vpp_handle,
1296                       session_index, tx_fifo);
1297       else
1298         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
1299                       "wrote %d bytes tx-fifo: (%p)", getpid (),
1300                       vpp_handle, session_index, n_write, tx_fifo);
1301     }
1302 done:
1303   return rv;
1304 }
1305
1306 static inline int
1307 vppcom_session_write_ready (vcl_session_t * session, u32 session_index)
1308 {
1309   int ready;
1310   u32 poll_et;
1311   int rv;
1312
1313   ASSERT (session);
1314
1315   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
1316   if (PREDICT_FALSE (session->is_vep))
1317     {
1318       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1319                     "cannot write to an epoll session!",
1320                     getpid (), session->vpp_handle, session_index);
1321       rv = VPPCOM_EBADFD;
1322       goto done;
1323     }
1324
1325   if (PREDICT_FALSE (session->session_state & STATE_LISTEN))
1326     {
1327       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1328                     "cannot write to a listen session!",
1329                     getpid (), session->vpp_handle, session_index);
1330       rv = VPPCOM_EBADFD;
1331       goto done;
1332     }
1333
1334   if (!(session->session_state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
1335     {
1336       session_state_t state = session->session_state;
1337
1338       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1339
1340       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1341                     "session is not open! state 0x%x (%s), "
1342                     "returning %d (%s)", getpid (), session->vpp_handle,
1343                     session_index,
1344                     state, vppcom_session_state_str (state),
1345                     rv, vppcom_retval_str (rv));
1346       goto done;
1347     }
1348
1349   ready = svm_fifo_max_enqueue (session->tx_fifo);
1350
1351   VDBG (3, "VCL<%d>: vpp handle 0x%llx, sid %u: peek %s (%p), ready = %d",
1352         getpid (), session->vpp_handle, session_index, session->tx_fifo,
1353         ready);
1354
1355   if (ready == 0)
1356     {
1357       poll_et = (((EPOLLET | EPOLLOUT) & session->vep.ev.events) ==
1358                  (EPOLLET | EPOLLOUT));
1359       if (poll_et)
1360         session->vep.et_mask |= EPOLLOUT;
1361
1362       if (session->session_state & STATE_CLOSE_ON_EMPTY)
1363         {
1364           rv = VPPCOM_ECONNRESET;
1365
1366           VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
1367                 "session state 0x%x (%s)! Setting state to 0x%x (%s), "
1368                 "returning %d (%s)", getpid (),
1369                 session->vpp_handle, session_index,
1370                 session->session_state,
1371                 vppcom_session_state_str (session->session_state),
1372                 STATE_DISCONNECT,
1373                 vppcom_session_state_str (STATE_DISCONNECT), rv,
1374                 vppcom_retval_str (rv));
1375           session->session_state = STATE_DISCONNECT;
1376           goto done;
1377         }
1378     }
1379   rv = ready;
1380 done:
1381   return rv;
1382 }
1383
1384 int
1385 vppcom_select (unsigned long n_bits, unsigned long *read_map,
1386                unsigned long *write_map, unsigned long *except_map,
1387                double time_to_wait)
1388 {
1389   u32 session_index;
1390   vcl_session_t *session = 0;
1391   int rv, bits_set = 0;
1392   f64 timeout = clib_time_now (&vcm->clib_time) + time_to_wait;
1393   u32 minbits = clib_max (n_bits, BITS (uword));
1394
1395   ASSERT (sizeof (clib_bitmap_t) == sizeof (long int));
1396
1397   if (n_bits && read_map)
1398     {
1399       clib_bitmap_validate (vcm->rd_bitmap, minbits);
1400       clib_memcpy (vcm->rd_bitmap, read_map,
1401                    vec_len (vcm->rd_bitmap) * sizeof (clib_bitmap_t));
1402       memset (read_map, 0, vec_len (vcm->rd_bitmap) * sizeof (clib_bitmap_t));
1403     }
1404   if (n_bits && write_map)
1405     {
1406       clib_bitmap_validate (vcm->wr_bitmap, minbits);
1407       clib_memcpy (vcm->wr_bitmap, write_map,
1408                    vec_len (vcm->wr_bitmap) * sizeof (clib_bitmap_t));
1409       memset (write_map, 0,
1410               vec_len (vcm->wr_bitmap) * sizeof (clib_bitmap_t));
1411     }
1412   if (n_bits && except_map)
1413     {
1414       clib_bitmap_validate (vcm->ex_bitmap, minbits);
1415       clib_memcpy (vcm->ex_bitmap, except_map,
1416                    vec_len (vcm->ex_bitmap) * sizeof (clib_bitmap_t));
1417       memset (except_map, 0,
1418               vec_len (vcm->ex_bitmap) * sizeof (clib_bitmap_t));
1419     }
1420
1421   do
1422     {
1423       /* *INDENT-OFF* */
1424       if (n_bits)
1425         {
1426           if (read_map)
1427             {
1428               clib_bitmap_foreach (session_index, vcm->rd_bitmap,
1429                 ({
1430                   VCL_SESSION_LOCK();
1431                   rv = vppcom_session_at_index (session_index, &session);
1432                   if (rv < 0)
1433                     {
1434                       VCL_SESSION_UNLOCK();
1435                       VDBG (1, "VCL<%d>: session %d specified in read_map is"
1436                           " closed.", getpid (),
1437                                       session_index);
1438                       bits_set = VPPCOM_EBADFD;
1439                       goto select_done;
1440                     }
1441                   if (session->session_state & STATE_LISTEN)
1442                     {
1443                       vce_event_handler_reg_t *reg = 0;
1444                       vce_event_key_t evk;
1445
1446                       /* Check if handler already registered for this
1447                        * event.
1448                        * If not, register handler for connect_request event
1449                        * on listen_session_index
1450                        */
1451                       evk.session_index = session_index;
1452                       evk.eid = VCL_EVENT_CONNECT_REQ_ACCEPTED;
1453                       reg = vce_get_event_handler (&vcm->event_thread, &evk);
1454                       if (!reg)
1455                         reg = vce_register_handler (&vcm->event_thread, &evk,
1456                                     vce_poll_wait_connect_request_handler_fn,
1457                                                     0 /* No callback args */);
1458                       rv = vppcom_session_read_ready (session, session_index);
1459                       if (rv > 0)
1460                         {
1461                           vce_unregister_handler (&vcm->event_thread, reg);
1462                         }
1463                     }
1464                   else
1465                     rv = vppcom_session_read_ready (session, session_index);
1466                   VCL_SESSION_UNLOCK();
1467                   if (except_map && vcm->ex_bitmap &&
1468                       clib_bitmap_get (vcm->ex_bitmap, session_index) &&
1469                       (rv < 0))
1470                     {
1471                       clib_bitmap_set_no_check (except_map, session_index, 1);
1472                       bits_set++;
1473                     }
1474                   else if (rv > 0)
1475                     {
1476                       clib_bitmap_set_no_check (read_map, session_index, 1);
1477                       bits_set++;
1478                     }
1479                 }));
1480             }
1481
1482           if (write_map)
1483             {
1484               clib_bitmap_foreach (session_index, vcm->wr_bitmap,
1485                 ({
1486                   VCL_SESSION_LOCK();
1487                   rv = vppcom_session_at_index (session_index, &session);
1488                   if (rv < 0)
1489                     {
1490                       VCL_SESSION_UNLOCK();
1491                       VDBG (0, "VCL<%d>: session %d specified in "
1492                                       "write_map is closed.", getpid (),
1493                                       session_index);
1494                       bits_set = VPPCOM_EBADFD;
1495                       goto select_done;
1496                     }
1497
1498                   rv = vppcom_session_write_ready (session, session_index);
1499                   VCL_SESSION_UNLOCK();
1500                   if (write_map && (rv > 0))
1501                     {
1502                       clib_bitmap_set_no_check (write_map, session_index, 1);
1503                       bits_set++;
1504                     }
1505                 }));
1506             }
1507
1508           if (except_map)
1509             {
1510               clib_bitmap_foreach (session_index, vcm->ex_bitmap,
1511                 ({
1512                   VCL_SESSION_LOCK();
1513                   rv = vppcom_session_at_index (session_index, &session);
1514                   if (rv < 0)
1515                     {
1516                       VCL_SESSION_UNLOCK();
1517                       VDBG (1, "VCL<%d>: session %d specified in except_map "
1518                           "is closed.", getpid (),
1519                                       session_index);
1520                       bits_set = VPPCOM_EBADFD;
1521                       goto select_done;
1522                     }
1523
1524                   rv = vppcom_session_read_ready (session, session_index);
1525                   VCL_SESSION_UNLOCK();
1526                   if (rv < 0)
1527                     {
1528                       clib_bitmap_set_no_check (except_map, session_index, 1);
1529                       bits_set++;
1530                     }
1531                 }));
1532             }
1533         }
1534       /* *INDENT-ON* */
1535     }
1536   while ((time_to_wait == -1) || (clib_time_now (&vcm->clib_time) < timeout));
1537
1538 select_done:
1539   return (bits_set);
1540 }
1541
1542 static inline void
1543 vep_verify_epoll_chain (u32 vep_idx)
1544 {
1545   vcl_session_t *session;
1546   vppcom_epoll_t *vep;
1547   int rv;
1548   u32 sid = vep_idx;
1549
1550   if (VPPCOM_DEBUG <= 1)
1551     return;
1552
1553   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
1554   rv = vppcom_session_at_index (vep_idx, &session);
1555   if (PREDICT_FALSE (rv))
1556     {
1557       clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!",
1558                     getpid (), vep_idx);
1559       goto done;
1560     }
1561   if (PREDICT_FALSE (!session->is_vep))
1562     {
1563       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
1564                     getpid (), vep_idx);
1565       goto done;
1566     }
1567   vep = &session->vep;
1568   clib_warning ("VCL<%d>: vep_idx (%u): Dumping epoll chain\n"
1569                 "{\n"
1570                 "   is_vep         = %u\n"
1571                 "   is_vep_session = %u\n"
1572                 "   next_sid       = 0x%x (%u)\n"
1573                 "   wait_cont_idx  = 0x%x (%u)\n"
1574                 "}\n", getpid (), vep_idx,
1575                 session->is_vep, session->is_vep_session,
1576                 vep->next_sid, vep->next_sid,
1577                 session->wait_cont_idx, session->wait_cont_idx);
1578
1579   for (sid = vep->next_sid; sid != ~0; sid = vep->next_sid)
1580     {
1581       rv = vppcom_session_at_index (sid, &session);
1582       if (PREDICT_FALSE (rv))
1583         {
1584           clib_warning ("VCL<%d>: ERROR: Invalid sid (%u)!", getpid (), sid);
1585           goto done;
1586         }
1587       if (PREDICT_FALSE (session->is_vep))
1588         clib_warning ("VCL<%d>: ERROR: sid (%u) is a vep!",
1589                       getpid (), vep_idx);
1590       else if (PREDICT_FALSE (!session->is_vep_session))
1591         {
1592           clib_warning ("VCL<%d>: ERROR: session (%u) "
1593                         "is not a vep session!", getpid (), sid);
1594           goto done;
1595         }
1596       vep = &session->vep;
1597       if (PREDICT_FALSE (vep->vep_idx != vep_idx))
1598         clib_warning ("VCL<%d>: ERROR: session (%u) vep_idx (%u) != "
1599                       "vep_idx (%u)!", getpid (),
1600                       sid, session->vep.vep_idx, vep_idx);
1601       if (session->is_vep_session)
1602         {
1603           clib_warning ("vep_idx[%u]: sid 0x%x (%u)\n"
1604                         "{\n"
1605                         "   next_sid       = 0x%x (%u)\n"
1606                         "   prev_sid       = 0x%x (%u)\n"
1607                         "   vep_idx        = 0x%x (%u)\n"
1608                         "   ev.events      = 0x%x\n"
1609                         "   ev.data.u64    = 0x%llx\n"
1610                         "   et_mask        = 0x%x\n"
1611                         "}\n",
1612                         vep_idx, sid, sid,
1613                         vep->next_sid, vep->next_sid,
1614                         vep->prev_sid, vep->prev_sid,
1615                         vep->vep_idx, vep->vep_idx,
1616                         vep->ev.events, vep->ev.data.u64, vep->et_mask);
1617         }
1618     }
1619
1620 done:
1621   clib_warning ("VCL<%d>: vep_idx (%u): Dump complete!\n",
1622                 getpid (), vep_idx);
1623 }
1624
1625 int
1626 vppcom_epoll_create (void)
1627 {
1628   vcl_session_t *vep_session;
1629   u32 vep_idx;
1630
1631   VCL_SESSION_LOCK ();
1632   pool_get (vcm->sessions, vep_session);
1633   memset (vep_session, 0, sizeof (*vep_session));
1634   vep_idx = vep_session - vcm->sessions;
1635
1636   vep_session->is_vep = 1;
1637   vep_session->vep.vep_idx = ~0;
1638   vep_session->vep.next_sid = ~0;
1639   vep_session->vep.prev_sid = ~0;
1640   vep_session->wait_cont_idx = ~0;
1641   vep_session->vpp_handle = ~0;
1642   vep_session->poll_reg = 0;
1643
1644   vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, vep_idx);
1645   VCL_SESSION_UNLOCK ();
1646
1647   VDBG (0, "VCL<%d>: Created vep_idx %u / sid %u!",
1648         getpid (), vep_idx, vep_idx);
1649
1650   return (vep_idx);
1651 }
1652
1653 int
1654 vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
1655                   struct epoll_event *event)
1656 {
1657   vcl_session_t *vep_session;
1658   vcl_session_t *session;
1659   int rv;
1660
1661   if (vep_idx == session_index)
1662     {
1663       clib_warning ("VCL<%d>: ERROR: vep_idx == session_index (%u)!",
1664                     getpid (), vep_idx);
1665       return VPPCOM_EINVAL;
1666     }
1667
1668   VCL_SESSION_LOCK ();
1669   rv = vppcom_session_at_index (vep_idx, &vep_session);
1670   if (PREDICT_FALSE (rv))
1671     {
1672       clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!", vep_idx);
1673       goto done;
1674     }
1675   if (PREDICT_FALSE (!vep_session->is_vep))
1676     {
1677       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
1678                     getpid (), vep_idx);
1679       rv = VPPCOM_EINVAL;
1680       goto done;
1681     }
1682
1683   ASSERT (vep_session->vep.vep_idx == ~0);
1684   ASSERT (vep_session->vep.prev_sid == ~0);
1685
1686   rv = vppcom_session_at_index (session_index, &session);
1687   if (PREDICT_FALSE (rv))
1688     {
1689       VDBG (0, "VCL<%d>: ERROR: Invalid session_index (%u)!",
1690             getpid (), session_index);
1691       goto done;
1692     }
1693   if (PREDICT_FALSE (session->is_vep))
1694     {
1695       clib_warning ("ERROR: session_index (%u) is a vep!", vep_idx);
1696       rv = VPPCOM_EINVAL;
1697       goto done;
1698     }
1699
1700   switch (op)
1701     {
1702     case EPOLL_CTL_ADD:
1703       if (PREDICT_FALSE (!event))
1704         {
1705           clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: NULL pointer to "
1706                         "epoll_event structure!", getpid ());
1707           rv = VPPCOM_EINVAL;
1708           goto done;
1709         }
1710       if (vep_session->vep.next_sid != ~0)
1711         {
1712           vcl_session_t *next_session;
1713           rv = vppcom_session_at_index (vep_session->vep.next_sid,
1714                                         &next_session);
1715           if (PREDICT_FALSE (rv))
1716             {
1717               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: Invalid "
1718                             "vep.next_sid (%u) on vep_idx (%u)!",
1719                             getpid (), vep_session->vep.next_sid, vep_idx);
1720               goto done;
1721             }
1722           ASSERT (next_session->vep.prev_sid == vep_idx);
1723           next_session->vep.prev_sid = session_index;
1724         }
1725       session->vep.next_sid = vep_session->vep.next_sid;
1726       session->vep.prev_sid = vep_idx;
1727       session->vep.vep_idx = vep_idx;
1728       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
1729       session->vep.ev = *event;
1730       session->is_vep = 0;
1731       session->is_vep_session = 1;
1732       vep_session->vep.next_sid = session_index;
1733
1734       /* VCL Event Register handler */
1735       if (session->session_state & STATE_LISTEN)
1736         {
1737           /* Register handler for connect_request event on listen_session_index */
1738           vce_event_key_t evk;
1739           evk.session_index = session_index;
1740           evk.eid = VCL_EVENT_CONNECT_REQ_ACCEPTED;
1741           vep_session->poll_reg =
1742             vce_register_handler (&vcm->event_thread, &evk,
1743                                   vce_poll_wait_connect_request_handler_fn,
1744                                   0 /* No callback args */ );
1745         }
1746       VDBG (1, "VCL<%d>: EPOLL_CTL_ADD: vep_idx %u, "
1747             "sid %u, events 0x%x, data 0x%llx!",
1748             getpid (), vep_idx, session_index,
1749             event->events, event->data.u64);
1750       vcl_evt (VCL_EVT_EPOLL_CTLADD, session, event->events, event->data.u64);
1751       break;
1752
1753     case EPOLL_CTL_MOD:
1754       if (PREDICT_FALSE (!event))
1755         {
1756           clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_MOD: NULL pointer to "
1757                         "epoll_event structure!", getpid ());
1758           rv = VPPCOM_EINVAL;
1759           goto done;
1760         }
1761       else if (PREDICT_FALSE (!session->is_vep_session))
1762         {
1763           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
1764                         "not a vep session!", getpid (), session_index);
1765           rv = VPPCOM_EINVAL;
1766           goto done;
1767         }
1768       else if (PREDICT_FALSE (session->vep.vep_idx != vep_idx))
1769         {
1770           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
1771                         "vep_idx (%u) != vep_idx (%u)!",
1772                         getpid (), session_index,
1773                         session->vep.vep_idx, vep_idx);
1774           rv = VPPCOM_EINVAL;
1775           goto done;
1776         }
1777       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
1778       session->vep.ev = *event;
1779       VDBG (1, "VCL<%d>: EPOLL_CTL_MOD: vep_idx %u, sid %u, events 0x%x,"
1780             " data 0x%llx!", getpid (), vep_idx, session_index, event->events,
1781             event->data.u64);
1782       break;
1783
1784     case EPOLL_CTL_DEL:
1785       if (PREDICT_FALSE (!session->is_vep_session))
1786         {
1787           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
1788                         "not a vep session!", getpid (), session_index);
1789           rv = VPPCOM_EINVAL;
1790           goto done;
1791         }
1792       else if (PREDICT_FALSE (session->vep.vep_idx != vep_idx))
1793         {
1794           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
1795                         "vep_idx (%u) != vep_idx (%u)!",
1796                         getpid (), session_index,
1797                         session->vep.vep_idx, vep_idx);
1798           rv = VPPCOM_EINVAL;
1799           goto done;
1800         }
1801
1802       /* VCL Event Un-register handler */
1803       if ((session->session_state & STATE_LISTEN) && vep_session->poll_reg)
1804         {
1805           (void) vce_unregister_handler (&vcm->event_thread,
1806                                          vep_session->poll_reg);
1807         }
1808
1809       vep_session->wait_cont_idx =
1810         (vep_session->wait_cont_idx == session_index) ?
1811         session->vep.next_sid : vep_session->wait_cont_idx;
1812
1813       if (session->vep.prev_sid == vep_idx)
1814         vep_session->vep.next_sid = session->vep.next_sid;
1815       else
1816         {
1817           vcl_session_t *prev_session;
1818           rv = vppcom_session_at_index (session->vep.prev_sid, &prev_session);
1819           if (PREDICT_FALSE (rv))
1820             {
1821               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
1822                             "vep.prev_sid (%u) on sid (%u)!",
1823                             getpid (), session->vep.prev_sid, session_index);
1824               goto done;
1825             }
1826           ASSERT (prev_session->vep.next_sid == session_index);
1827           prev_session->vep.next_sid = session->vep.next_sid;
1828         }
1829       if (session->vep.next_sid != ~0)
1830         {
1831           vcl_session_t *next_session;
1832           rv = vppcom_session_at_index (session->vep.next_sid, &next_session);
1833           if (PREDICT_FALSE (rv))
1834             {
1835               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
1836                             "vep.next_sid (%u) on sid (%u)!",
1837                             getpid (), session->vep.next_sid, session_index);
1838               goto done;
1839             }
1840           ASSERT (next_session->vep.prev_sid == session_index);
1841           next_session->vep.prev_sid = session->vep.prev_sid;
1842         }
1843
1844       memset (&session->vep, 0, sizeof (session->vep));
1845       session->vep.next_sid = ~0;
1846       session->vep.prev_sid = ~0;
1847       session->vep.vep_idx = ~0;
1848       session->is_vep_session = 0;
1849       VDBG (1, "VCL<%d>: EPOLL_CTL_DEL: vep_idx %u, sid %u!",
1850             getpid (), vep_idx, session_index);
1851       vcl_evt (VCL_EVT_EPOLL_CTLDEL, session, vep_idx);
1852       break;
1853
1854     default:
1855       clib_warning ("VCL<%d>: ERROR: Invalid operation (%d)!", getpid (), op);
1856       rv = VPPCOM_EINVAL;
1857     }
1858
1859   vep_verify_epoll_chain (vep_idx);
1860
1861 done:
1862   VCL_SESSION_UNLOCK ();
1863   return rv;
1864 }
1865
1866 int
1867 vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
1868                    int maxevents, double wait_for_time)
1869 {
1870   vcl_session_t *vep_session;
1871   int rv;
1872   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
1873   u32 keep_trying = 1;
1874   int num_ev = 0;
1875   u32 vep_next_sid, wait_cont_idx;
1876   u8 is_vep;
1877
1878   if (PREDICT_FALSE (maxevents <= 0))
1879     {
1880       clib_warning ("VCL<%d>: ERROR: Invalid maxevents (%d)!",
1881                     getpid (), maxevents);
1882       return VPPCOM_EINVAL;
1883     }
1884   memset (events, 0, sizeof (*events) * maxevents);
1885
1886   VCL_SESSION_LOCK_AND_GET (vep_idx, &vep_session);
1887   vep_next_sid = vep_session->vep.next_sid;
1888   is_vep = vep_session->is_vep;
1889   wait_cont_idx = vep_session->wait_cont_idx;
1890   VCL_SESSION_UNLOCK ();
1891
1892   if (PREDICT_FALSE (!is_vep))
1893     {
1894       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
1895                     getpid (), vep_idx);
1896       rv = VPPCOM_EINVAL;
1897       goto done;
1898     }
1899   if (PREDICT_FALSE (vep_next_sid == ~0))
1900     {
1901       VDBG (1, "VCL<%d>: WARNING: vep_idx (%u) is empty!",
1902             getpid (), vep_idx);
1903       goto done;
1904     }
1905
1906   do
1907     {
1908       u32 sid;
1909       u32 next_sid = ~0;
1910       vcl_session_t *session;
1911
1912       for (sid = (wait_cont_idx == ~0) ? vep_next_sid : wait_cont_idx;
1913            sid != ~0; sid = next_sid)
1914         {
1915           u32 session_events, et_mask, clear_et_mask, session_vep_idx;
1916           u8 add_event, is_vep_session;
1917           int ready;
1918           u64 session_ev_data;
1919
1920           VCL_SESSION_LOCK_AND_GET (sid, &session);
1921           next_sid = session->vep.next_sid;
1922           session_events = session->vep.ev.events;
1923           et_mask = session->vep.et_mask;
1924           is_vep = session->is_vep;
1925           is_vep_session = session->is_vep_session;
1926           session_vep_idx = session->vep.vep_idx;
1927           session_ev_data = session->vep.ev.data.u64;
1928
1929           VCL_SESSION_UNLOCK ();
1930
1931           if (PREDICT_FALSE (is_vep))
1932             {
1933               VDBG (0, "VCL<%d>: ERROR: sid (%u) is a vep!",
1934                     getpid (), vep_idx);
1935               rv = VPPCOM_EINVAL;
1936               goto done;
1937             }
1938           if (PREDICT_FALSE (!is_vep_session))
1939             {
1940               VDBG (0, "VCL<%d>: ERROR: session (%u) is not "
1941                     "a vep session!", getpid (), sid);
1942               rv = VPPCOM_EINVAL;
1943               goto done;
1944             }
1945           if (PREDICT_FALSE (session_vep_idx != vep_idx))
1946             {
1947               clib_warning ("VCL<%d>: ERROR: session (%u) "
1948                             "vep_idx (%u) != vep_idx (%u)!",
1949                             getpid (), sid, session_vep_idx, vep_idx);
1950               rv = VPPCOM_EINVAL;
1951               goto done;
1952             }
1953
1954           add_event = clear_et_mask = 0;
1955
1956           if (EPOLLIN & session_events)
1957             {
1958               VCL_SESSION_LOCK_AND_GET (sid, &session);
1959               ready = vppcom_session_read_ready (session, sid);
1960               VCL_SESSION_UNLOCK ();
1961               if ((ready > 0) && (EPOLLIN & et_mask))
1962                 {
1963                   add_event = 1;
1964                   events[num_ev].events |= EPOLLIN;
1965                   if (((EPOLLET | EPOLLIN) & session_events) ==
1966                       (EPOLLET | EPOLLIN))
1967                     clear_et_mask |= EPOLLIN;
1968                 }
1969               else if (ready < 0)
1970                 {
1971                   add_event = 1;
1972                   switch (ready)
1973                     {
1974                     case VPPCOM_ECONNRESET:
1975                       events[num_ev].events |= EPOLLHUP | EPOLLRDHUP;
1976                       break;
1977
1978                     default:
1979                       events[num_ev].events |= EPOLLERR;
1980                       break;
1981                     }
1982                 }
1983             }
1984
1985           if (EPOLLOUT & session_events)
1986             {
1987               VCL_SESSION_LOCK_AND_GET (sid, &session);
1988               ready = vppcom_session_write_ready (session, sid);
1989               VCL_SESSION_UNLOCK ();
1990               if ((ready > 0) && (EPOLLOUT & et_mask))
1991                 {
1992                   add_event = 1;
1993                   events[num_ev].events |= EPOLLOUT;
1994                   if (((EPOLLET | EPOLLOUT) & session_events) ==
1995                       (EPOLLET | EPOLLOUT))
1996                     clear_et_mask |= EPOLLOUT;
1997                 }
1998               else if (ready < 0)
1999                 {
2000                   add_event = 1;
2001                   switch (ready)
2002                     {
2003                     case VPPCOM_ECONNRESET:
2004                       events[num_ev].events |= EPOLLHUP;
2005                       break;
2006
2007                     default:
2008                       events[num_ev].events |= EPOLLERR;
2009                       break;
2010                     }
2011                 }
2012             }
2013
2014           if (add_event)
2015             {
2016               events[num_ev].data.u64 = session_ev_data;
2017               if (EPOLLONESHOT & session_events)
2018                 {
2019                   VCL_SESSION_LOCK_AND_GET (sid, &session);
2020                   session->vep.ev.events = 0;
2021                   VCL_SESSION_UNLOCK ();
2022                 }
2023               num_ev++;
2024               if (num_ev == maxevents)
2025                 {
2026                   VCL_SESSION_LOCK_AND_GET (vep_idx, &vep_session);
2027                   vep_session->wait_cont_idx = next_sid;
2028                   VCL_SESSION_UNLOCK ();
2029                   goto done;
2030                 }
2031             }
2032           if (wait_cont_idx != ~0)
2033             {
2034               if (next_sid == ~0)
2035                 next_sid = vep_next_sid;
2036               else if (next_sid == wait_cont_idx)
2037                 next_sid = ~0;
2038             }
2039         }
2040       if (wait_for_time != -1)
2041         keep_trying = (clib_time_now (&vcm->clib_time) <= timeout) ? 1 : 0;
2042     }
2043   while ((num_ev == 0) && keep_trying);
2044
2045   if (wait_cont_idx != ~0)
2046     {
2047       VCL_SESSION_LOCK_AND_GET (vep_idx, &vep_session);
2048       vep_session->wait_cont_idx = ~0;
2049       VCL_SESSION_UNLOCK ();
2050     }
2051 done:
2052   return (rv != VPPCOM_OK) ? rv : num_ev;
2053 }
2054
2055 int
2056 vppcom_session_attr (uint32_t session_index, uint32_t op,
2057                      void *buffer, uint32_t * buflen)
2058 {
2059   vcl_session_t *session;
2060   int rv = VPPCOM_OK;
2061   u32 *flags = buffer;
2062   vppcom_endpt_t *ep = buffer;
2063
2064   VCL_SESSION_LOCK_AND_GET (session_index, &session);
2065
2066   ASSERT (session);
2067
2068   switch (op)
2069     {
2070     case VPPCOM_ATTR_GET_NREAD:
2071       rv = vppcom_session_read_ready (session, session_index);
2072       VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NREAD: sid %u, nread = %d",
2073             getpid (), rv);
2074       break;
2075
2076     case VPPCOM_ATTR_GET_NWRITE:
2077       rv = vppcom_session_write_ready (session, session_index);
2078       VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NWRITE: sid %u, nwrite = %d",
2079             getpid (), session_index, rv);
2080       break;
2081
2082     case VPPCOM_ATTR_GET_FLAGS:
2083       if (PREDICT_TRUE (buffer && buflen && (*buflen >= sizeof (*flags))))
2084         {
2085           *flags = O_RDWR | (VCL_SESS_ATTR_TEST (session->attr,
2086                                                  VCL_SESS_ATTR_NONBLOCK));
2087           *buflen = sizeof (*flags);
2088           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_FLAGS: sid %u, flags = 0x%08x, "
2089                 "is_nonblocking = %u", getpid (),
2090                 session_index, *flags,
2091                 VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
2092         }
2093       else
2094         rv = VPPCOM_EINVAL;
2095       break;
2096
2097     case VPPCOM_ATTR_SET_FLAGS:
2098       if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
2099         {
2100           if (*flags & O_NONBLOCK)
2101             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
2102           else
2103             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_NONBLOCK);
2104
2105           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_FLAGS: sid %u, flags = 0x%08x,"
2106                 " is_nonblocking = %u",
2107                 getpid (), session_index, *flags,
2108                 VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
2109         }
2110       else
2111         rv = VPPCOM_EINVAL;
2112       break;
2113
2114     case VPPCOM_ATTR_GET_PEER_ADDR:
2115       if (PREDICT_TRUE (buffer && buflen &&
2116                         (*buflen >= sizeof (*ep)) && ep->ip))
2117         {
2118           ep->is_ip4 = session->transport.is_ip4;
2119           ep->port = session->transport.rmt_port;
2120           if (session->transport.is_ip4)
2121             clib_memcpy (ep->ip, &session->transport.rmt_ip.ip4,
2122                          sizeof (ip4_address_t));
2123           else
2124             clib_memcpy (ep->ip, &session->transport.rmt_ip.ip6,
2125                          sizeof (ip6_address_t));
2126           *buflen = sizeof (*ep);
2127           VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_PEER_ADDR: sid %u, is_ip4 = %u, "
2128                 "addr = %U, port %u", getpid (),
2129                 session_index, ep->is_ip4, format_ip46_address,
2130                 &session->transport.rmt_ip,
2131                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
2132                 clib_net_to_host_u16 (ep->port));
2133         }
2134       else
2135         rv = VPPCOM_EINVAL;
2136       break;
2137
2138     case VPPCOM_ATTR_GET_LCL_ADDR:
2139       if (PREDICT_TRUE (buffer && buflen &&
2140                         (*buflen >= sizeof (*ep)) && ep->ip))
2141         {
2142           ep->is_ip4 = session->transport.is_ip4;
2143           ep->port = session->transport.lcl_port;
2144           if (session->transport.is_ip4)
2145             clib_memcpy (ep->ip, &session->transport.lcl_ip.ip4,
2146                          sizeof (ip4_address_t));
2147           else
2148             clib_memcpy (ep->ip, &session->transport.lcl_ip.ip6,
2149                          sizeof (ip6_address_t));
2150           *buflen = sizeof (*ep);
2151           VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_LCL_ADDR: sid %u, is_ip4 = %u,"
2152                 " addr = %U port %d", getpid (),
2153                 session_index, ep->is_ip4, format_ip46_address,
2154                 &session->transport.lcl_ip,
2155                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
2156                 clib_net_to_host_u16 (ep->port));
2157         }
2158       else
2159         rv = VPPCOM_EINVAL;
2160       break;
2161
2162     case VPPCOM_ATTR_GET_LIBC_EPFD:
2163       rv = session->libc_epfd;
2164       VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d",
2165             getpid (), rv);
2166       break;
2167
2168     case VPPCOM_ATTR_SET_LIBC_EPFD:
2169       if (PREDICT_TRUE (buffer && buflen &&
2170                         (*buflen == sizeof (session->libc_epfd))))
2171         {
2172           session->libc_epfd = *(int *) buffer;
2173           *buflen = sizeof (session->libc_epfd);
2174
2175           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, "
2176                 "buflen %d", getpid (), session->libc_epfd, *buflen);
2177         }
2178       else
2179         rv = VPPCOM_EINVAL;
2180       break;
2181
2182     case VPPCOM_ATTR_GET_PROTOCOL:
2183       if (buffer && buflen && (*buflen >= sizeof (int)))
2184         {
2185           *(int *) buffer = session->session_type;
2186           *buflen = sizeof (int);
2187
2188           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_PROTOCOL: %d (%s), buflen %d",
2189                 getpid (), *(int *) buffer, *(int *) buffer ? "UDP" : "TCP",
2190                 *buflen);
2191         }
2192       else
2193         rv = VPPCOM_EINVAL;
2194       break;
2195
2196     case VPPCOM_ATTR_GET_LISTEN:
2197       if (buffer && buflen && (*buflen >= sizeof (int)))
2198         {
2199           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2200                                                 VCL_SESS_ATTR_LISTEN);
2201           *buflen = sizeof (int);
2202
2203           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LISTEN: %d, buflen %d",
2204                 getpid (), *(int *) buffer, *buflen);
2205         }
2206       else
2207         rv = VPPCOM_EINVAL;
2208       break;
2209
2210     case VPPCOM_ATTR_GET_ERROR:
2211       if (buffer && buflen && (*buflen >= sizeof (int)))
2212         {
2213           *(int *) buffer = 0;
2214           *buflen = sizeof (int);
2215
2216           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_ERROR: %d, buflen %d, #VPP-TBD#",
2217                 getpid (), *(int *) buffer, *buflen);
2218         }
2219       else
2220         rv = VPPCOM_EINVAL;
2221       break;
2222
2223     case VPPCOM_ATTR_GET_TX_FIFO_LEN:
2224       if (buffer && buflen && (*buflen >= sizeof (u32)))
2225         {
2226
2227           /* VPP-TBD */
2228           *(size_t *) buffer = (session->sndbuf_size ? session->sndbuf_size :
2229                                 session->tx_fifo ? session->tx_fifo->nitems :
2230                                 vcm->cfg.tx_fifo_size);
2231           *buflen = sizeof (u32);
2232
2233           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), "
2234                 "buflen %d, #VPP-TBD#", getpid (),
2235                 *(size_t *) buffer, *(size_t *) buffer, *buflen);
2236         }
2237       else
2238         rv = VPPCOM_EINVAL;
2239       break;
2240
2241     case VPPCOM_ATTR_SET_TX_FIFO_LEN:
2242       if (buffer && buflen && (*buflen == sizeof (u32)))
2243         {
2244           /* VPP-TBD */
2245           session->sndbuf_size = *(u32 *) buffer;
2246           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), "
2247                 "buflen %d, #VPP-TBD#", getpid (),
2248                 session->sndbuf_size, session->sndbuf_size, *buflen);
2249         }
2250       else
2251         rv = VPPCOM_EINVAL;
2252       break;
2253
2254     case VPPCOM_ATTR_GET_RX_FIFO_LEN:
2255       if (buffer && buflen && (*buflen >= sizeof (u32)))
2256         {
2257
2258           /* VPP-TBD */
2259           *(size_t *) buffer = (session->rcvbuf_size ? session->rcvbuf_size :
2260                                 session->rx_fifo ? session->rx_fifo->nitems :
2261                                 vcm->cfg.rx_fifo_size);
2262           *buflen = sizeof (u32);
2263
2264           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), "
2265                 "buflen %d, #VPP-TBD#", getpid (),
2266                 *(size_t *) buffer, *(size_t *) buffer, *buflen);
2267         }
2268       else
2269         rv = VPPCOM_EINVAL;
2270       break;
2271
2272     case VPPCOM_ATTR_SET_RX_FIFO_LEN:
2273       if (buffer && buflen && (*buflen == sizeof (u32)))
2274         {
2275           /* VPP-TBD */
2276           session->rcvbuf_size = *(u32 *) buffer;
2277           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), "
2278                 "buflen %d, #VPP-TBD#", getpid (),
2279                 session->sndbuf_size, session->sndbuf_size, *buflen);
2280         }
2281       else
2282         rv = VPPCOM_EINVAL;
2283       break;
2284
2285     case VPPCOM_ATTR_GET_REUSEADDR:
2286       if (buffer && buflen && (*buflen >= sizeof (int)))
2287         {
2288           /* VPP-TBD */
2289           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2290                                                 VCL_SESS_ATTR_REUSEADDR);
2291           *buflen = sizeof (int);
2292
2293           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEADDR: %d, "
2294                 "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2295         }
2296       else
2297         rv = VPPCOM_EINVAL;
2298       break;
2299
2300     case VPPCOM_ATTR_SET_REUSEADDR:
2301       if (buffer && buflen && (*buflen == sizeof (int)) &&
2302           !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
2303         {
2304           /* VPP-TBD */
2305           if (*(int *) buffer)
2306             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEADDR);
2307           else
2308             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEADDR);
2309
2310           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d,"
2311                 " #VPP-TBD#", getpid (),
2312                 VCL_SESS_ATTR_TEST (session->attr,
2313                                     VCL_SESS_ATTR_REUSEADDR), *buflen);
2314         }
2315       else
2316         rv = VPPCOM_EINVAL;
2317       break;
2318
2319     case VPPCOM_ATTR_GET_REUSEPORT:
2320       if (buffer && buflen && (*buflen >= sizeof (int)))
2321         {
2322           /* VPP-TBD */
2323           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2324                                                 VCL_SESS_ATTR_REUSEPORT);
2325           *buflen = sizeof (int);
2326
2327           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d,"
2328                 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2329         }
2330       else
2331         rv = VPPCOM_EINVAL;
2332       break;
2333
2334     case VPPCOM_ATTR_SET_REUSEPORT:
2335       if (buffer && buflen && (*buflen == sizeof (int)) &&
2336           !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
2337         {
2338           /* VPP-TBD */
2339           if (*(int *) buffer)
2340             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEPORT);
2341           else
2342             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEPORT);
2343
2344           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d,"
2345                 " #VPP-TBD#", getpid (),
2346                 VCL_SESS_ATTR_TEST (session->attr,
2347                                     VCL_SESS_ATTR_REUSEPORT), *buflen);
2348         }
2349       else
2350         rv = VPPCOM_EINVAL;
2351       break;
2352
2353     case VPPCOM_ATTR_GET_BROADCAST:
2354       if (buffer && buflen && (*buflen >= sizeof (int)))
2355         {
2356           /* VPP-TBD */
2357           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2358                                                 VCL_SESS_ATTR_BROADCAST);
2359           *buflen = sizeof (int);
2360
2361           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d,"
2362                 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2363         }
2364       else
2365         rv = VPPCOM_EINVAL;
2366       break;
2367
2368     case VPPCOM_ATTR_SET_BROADCAST:
2369       if (buffer && buflen && (*buflen == sizeof (int)))
2370         {
2371           /* VPP-TBD */
2372           if (*(int *) buffer)
2373             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_BROADCAST);
2374           else
2375             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_BROADCAST);
2376
2377           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, "
2378                 "#VPP-TBD#", getpid (),
2379                 VCL_SESS_ATTR_TEST (session->attr,
2380                                     VCL_SESS_ATTR_BROADCAST), *buflen);
2381         }
2382       else
2383         rv = VPPCOM_EINVAL;
2384       break;
2385
2386     case VPPCOM_ATTR_GET_V6ONLY:
2387       if (buffer && buflen && (*buflen >= sizeof (int)))
2388         {
2389           /* VPP-TBD */
2390           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2391                                                 VCL_SESS_ATTR_V6ONLY);
2392           *buflen = sizeof (int);
2393
2394           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, "
2395                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2396         }
2397       else
2398         rv = VPPCOM_EINVAL;
2399       break;
2400
2401     case VPPCOM_ATTR_SET_V6ONLY:
2402       if (buffer && buflen && (*buflen == sizeof (int)))
2403         {
2404           /* VPP-TBD */
2405           if (*(int *) buffer)
2406             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_V6ONLY);
2407           else
2408             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_V6ONLY);
2409
2410           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, "
2411                 "#VPP-TBD#", getpid (),
2412                 VCL_SESS_ATTR_TEST (session->attr,
2413                                     VCL_SESS_ATTR_V6ONLY), *buflen);
2414         }
2415       else
2416         rv = VPPCOM_EINVAL;
2417       break;
2418
2419     case VPPCOM_ATTR_GET_KEEPALIVE:
2420       if (buffer && buflen && (*buflen >= sizeof (int)))
2421         {
2422           /* VPP-TBD */
2423           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2424                                                 VCL_SESS_ATTR_KEEPALIVE);
2425           *buflen = sizeof (int);
2426
2427           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, "
2428                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2429         }
2430       else
2431         rv = VPPCOM_EINVAL;
2432       break;
2433
2434     case VPPCOM_ATTR_SET_KEEPALIVE:
2435       if (buffer && buflen && (*buflen == sizeof (int)))
2436         {
2437           /* VPP-TBD */
2438           if (*(int *) buffer)
2439             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_KEEPALIVE);
2440           else
2441             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_KEEPALIVE);
2442
2443           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, "
2444                 "#VPP-TBD#", getpid (),
2445                 VCL_SESS_ATTR_TEST (session->attr,
2446                                     VCL_SESS_ATTR_KEEPALIVE), *buflen);
2447         }
2448       else
2449         rv = VPPCOM_EINVAL;
2450       break;
2451
2452     case VPPCOM_ATTR_GET_TCP_NODELAY:
2453       if (buffer && buflen && (*buflen >= sizeof (int)))
2454         {
2455           /* VPP-TBD */
2456           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2457                                                 VCL_SESS_ATTR_TCP_NODELAY);
2458           *buflen = sizeof (int);
2459
2460           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, "
2461                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2462         }
2463       else
2464         rv = VPPCOM_EINVAL;
2465       break;
2466
2467     case VPPCOM_ATTR_SET_TCP_NODELAY:
2468       if (buffer && buflen && (*buflen == sizeof (int)))
2469         {
2470           /* VPP-TBD */
2471           if (*(int *) buffer)
2472             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
2473           else
2474             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
2475
2476           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, "
2477                 "#VPP-TBD#", getpid (),
2478                 VCL_SESS_ATTR_TEST (session->attr,
2479                                     VCL_SESS_ATTR_TCP_NODELAY), *buflen);
2480         }
2481       else
2482         rv = VPPCOM_EINVAL;
2483       break;
2484
2485     case VPPCOM_ATTR_GET_TCP_KEEPIDLE:
2486       if (buffer && buflen && (*buflen >= sizeof (int)))
2487         {
2488           /* VPP-TBD */
2489           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2490                                                 VCL_SESS_ATTR_TCP_KEEPIDLE);
2491           *buflen = sizeof (int);
2492
2493           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, "
2494                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2495         }
2496       else
2497         rv = VPPCOM_EINVAL;
2498       break;
2499
2500     case VPPCOM_ATTR_SET_TCP_KEEPIDLE:
2501       if (buffer && buflen && (*buflen == sizeof (int)))
2502         {
2503           /* VPP-TBD */
2504           if (*(int *) buffer)
2505             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
2506           else
2507             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
2508
2509           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, "
2510                 "#VPP-TBD#", getpid (),
2511                 VCL_SESS_ATTR_TEST (session->attr,
2512                                     VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
2513         }
2514       else
2515         rv = VPPCOM_EINVAL;
2516       break;
2517
2518     case VPPCOM_ATTR_GET_TCP_KEEPINTVL:
2519       if (buffer && buflen && (*buflen >= sizeof (int)))
2520         {
2521           /* VPP-TBD */
2522           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2523                                                 VCL_SESS_ATTR_TCP_KEEPINTVL);
2524           *buflen = sizeof (int);
2525
2526           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, "
2527                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2528         }
2529       else
2530         rv = VPPCOM_EINVAL;
2531       break;
2532
2533     case VPPCOM_ATTR_SET_TCP_KEEPINTVL:
2534       if (buffer && buflen && (*buflen == sizeof (int)))
2535         {
2536           /* VPP-TBD */
2537           if (*(int *) buffer)
2538             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
2539           else
2540             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
2541
2542           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, "
2543                 "#VPP-TBD#", getpid (),
2544                 VCL_SESS_ATTR_TEST (session->attr,
2545                                     VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
2546         }
2547       else
2548         rv = VPPCOM_EINVAL;
2549       break;
2550
2551     case VPPCOM_ATTR_GET_TCP_USER_MSS:
2552       if (buffer && buflen && (*buflen >= sizeof (u32)))
2553         {
2554           /* VPP-TBD */
2555           *(u32 *) buffer = session->user_mss;
2556           *buflen = sizeof (int);
2557
2558           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d,"
2559                 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2560         }
2561       else
2562         rv = VPPCOM_EINVAL;
2563       break;
2564
2565     case VPPCOM_ATTR_SET_TCP_USER_MSS:
2566       if (buffer && buflen && (*buflen == sizeof (u32)))
2567         {
2568           /* VPP-TBD */
2569           session->user_mss = *(u32 *) buffer;
2570
2571           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d, "
2572                 "#VPP-TBD#", getpid (), session->user_mss, *buflen);
2573         }
2574       else
2575         rv = VPPCOM_EINVAL;
2576       break;
2577
2578     default:
2579       rv = VPPCOM_EINVAL;
2580       break;
2581     }
2582
2583 done:
2584   VCL_SESSION_UNLOCK ();
2585   return rv;
2586 }
2587
2588 int
2589 vppcom_session_recvfrom (uint32_t session_index, void *buffer,
2590                          uint32_t buflen, int flags, vppcom_endpt_t * ep)
2591 {
2592   int rv = VPPCOM_OK;
2593   vcl_session_t *session = 0;
2594
2595   if (ep)
2596     {
2597       VCL_SESSION_LOCK ();
2598       rv = vppcom_session_at_index (session_index, &session);
2599       if (PREDICT_FALSE (rv))
2600         {
2601           VCL_SESSION_UNLOCK ();
2602           VDBG (0, "VCL<%d>: invalid session, sid (%u) has been closed!",
2603                 getpid (), session_index);
2604           rv = VPPCOM_EBADFD;
2605           VCL_SESSION_UNLOCK ();
2606           goto done;
2607         }
2608       ep->is_ip4 = session->transport.is_ip4;
2609       ep->port = session->transport.rmt_port;
2610       if (session->transport.is_ip4)
2611         clib_memcpy (ep->ip, &session->transport.rmt_ip.ip4,
2612                      sizeof (ip4_address_t));
2613       else
2614         clib_memcpy (ep->ip, &session->transport.rmt_ip.ip6,
2615                      sizeof (ip6_address_t));
2616       VCL_SESSION_UNLOCK ();
2617     }
2618
2619   if (flags == 0)
2620     rv = vppcom_session_read (session_index, buffer, buflen);
2621   else if (flags & MSG_PEEK)
2622     rv = vppcom_session_peek (session_index, buffer, buflen);
2623   else
2624     {
2625       clib_warning ("VCL<%d>: Unsupport flags for recvfrom %d",
2626                     getpid (), flags);
2627       rv = VPPCOM_EAFNOSUPPORT;
2628     }
2629
2630 done:
2631   return rv;
2632 }
2633
2634 int
2635 vppcom_session_sendto (uint32_t session_index, void *buffer,
2636                        uint32_t buflen, int flags, vppcom_endpt_t * ep)
2637 {
2638   if (!buffer)
2639     return VPPCOM_EINVAL;
2640
2641   if (ep)
2642     {
2643       // TBD
2644       return VPPCOM_EINVAL;
2645     }
2646
2647   if (flags)
2648     {
2649       // TBD check the flags and do the right thing
2650       VDBG (2, "VCL<%d>: handling flags 0x%u (%d) not implemented yet.",
2651             getpid (), flags, flags);
2652     }
2653
2654   return (vppcom_session_write (session_index, buffer, buflen));
2655 }
2656
2657 int
2658 vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
2659 {
2660   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
2661   u32 i, keep_trying = 1;
2662   int rv, num_ev = 0;
2663
2664   VDBG (3, "VCL<%d>: vp %p, nsids %u, wait_for_time %f",
2665         getpid (), vp, n_sids, wait_for_time);
2666
2667   if (!vp)
2668     return VPPCOM_EFAULT;
2669
2670   do
2671     {
2672       vcl_session_t *session;
2673
2674       for (i = 0; i < n_sids; i++)
2675         {
2676           ASSERT (vp[i].revents);
2677
2678           VCL_SESSION_LOCK_AND_GET (vp[i].sid, &session);
2679           VCL_SESSION_UNLOCK ();
2680
2681           if (*vp[i].revents)
2682             *vp[i].revents = 0;
2683
2684           if (POLLIN & vp[i].events)
2685             {
2686               VCL_SESSION_LOCK_AND_GET (vp[i].sid, &session);
2687               rv = vppcom_session_read_ready (session, vp[i].sid);
2688               VCL_SESSION_UNLOCK ();
2689               if (rv > 0)
2690                 {
2691                   *vp[i].revents |= POLLIN;
2692                   num_ev++;
2693                 }
2694               else if (rv < 0)
2695                 {
2696                   switch (rv)
2697                     {
2698                     case VPPCOM_ECONNRESET:
2699                       *vp[i].revents = POLLHUP;
2700                       break;
2701
2702                     default:
2703                       *vp[i].revents = POLLERR;
2704                       break;
2705                     }
2706                   num_ev++;
2707                 }
2708             }
2709
2710           if (POLLOUT & vp[i].events)
2711             {
2712               VCL_SESSION_LOCK_AND_GET (vp[i].sid, &session);
2713               rv = vppcom_session_write_ready (session, vp[i].sid);
2714               VCL_SESSION_UNLOCK ();
2715               if (rv > 0)
2716                 {
2717                   *vp[i].revents |= POLLOUT;
2718                   num_ev++;
2719                 }
2720               else if (rv < 0)
2721                 {
2722                   switch (rv)
2723                     {
2724                     case VPPCOM_ECONNRESET:
2725                       *vp[i].revents = POLLHUP;
2726                       break;
2727
2728                     default:
2729                       *vp[i].revents = POLLERR;
2730                       break;
2731                     }
2732                   num_ev++;
2733                 }
2734             }
2735
2736           if (0)                // Note "done:" label used by VCL_SESSION_LOCK_AND_GET()
2737             {
2738             done:
2739               *vp[i].revents = POLLNVAL;
2740               num_ev++;
2741             }
2742         }
2743       if (wait_for_time != -1)
2744         keep_trying = (clib_time_now (&vcm->clib_time) <= timeout) ? 1 : 0;
2745     }
2746   while ((num_ev == 0) && keep_trying);
2747
2748   if (VPPCOM_DEBUG > 3)
2749     {
2750       clib_warning ("VCL<%d>: returning %d", getpid (), num_ev);
2751       for (i = 0; i < n_sids; i++)
2752         {
2753           clib_warning ("VCL<%d>: vp[%d].sid %d (0x%x), .events 0x%x, "
2754                         ".revents 0x%x", getpid (), i, vp[i].sid, vp[i].sid,
2755                         vp[i].events, *vp[i].revents);
2756         }
2757     }
2758   return num_ev;
2759 }
2760
2761 /*
2762  * fd.io coding-style-patch-verification: ON
2763  *
2764  * Local Variables:
2765  * eval: (c-set-style "gnu")
2766  * End:
2767  */