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 <signal.h>
  19 #include <svm/svm_fifo_segment.h>
  20 #include <vlibmemory/api.h>
  21 #include <vpp/api/vpe_msg_enum.h>
  22 #include <vnet/session/application_interface.h>
  23 #include <vcl/vppcom.h>
  24 #include <vlib/unix/unix.h>
  25 #include <vppinfra/vec_bootstrap.h>
  26 #include <vppinfra/elog.h>
  27
  28 #define vl_typedefs             /* define message structures */
  29 #include <vpp/api/vpe_all_api_h.h>
  30 #undef vl_typedefs
  31
  32 /* declare message handlers for each api */
  33
  34 #define vl_endianfun            /* define message structures */
  35 #include <vpp/api/vpe_all_api_h.h>
  36 #undef vl_endianfun
  37
  38 /* instantiate all the print functions we know about */
  39 #define vl_print(handle, ...)
  40 #define vl_printfun
  41 #include <vpp/api/vpe_all_api_h.h>
  42 #undef vl_printfun
  43
  44 #if (CLIB_DEBUG > 0)
  45 /* Set VPPCOM_DEBUG_INIT 2 for connection debug,
  46  *                       3 for read/write debug output
  47  * or
  48  *    export VCL_DEBUG=<#> to set dynamically.
  49  */
  50 #define VPPCOM_DEBUG_INIT 1
  51 #else
  52 #define VPPCOM_DEBUG_INIT 0
  53 #endif
  54
  55 #define VPPCOM_DEBUG vcm->debug
  56
  57 /*
  58  * VPPCOM Private definitions and functions.
  59  */
  60 typedef enum
  61 {
  62   STATE_APP_START,
  63   STATE_APP_CONN_VPP,
  64   STATE_APP_ENABLED,
  65   STATE_APP_ATTACHED,
  66 } app_state_t;
  67
  68 typedef enum
  69 {
  70   STATE_START = 0x01,
  71   STATE_CONNECT = 0x02,
  72   STATE_LISTEN = 0x04,
  73   STATE_ACCEPT = 0x08,
  74   STATE_CLOSE_ON_EMPTY = 0x10,
  75   STATE_DISCONNECT = 0x20,
  76   STATE_FAILED = 0x40
  77 } session_state_t;
  78
  79 #define SERVER_STATE_OPEN  (STATE_ACCEPT|STATE_CLOSE_ON_EMPTY)
  80 #define CLIENT_STATE_OPEN  (STATE_CONNECT|STATE_CLOSE_ON_EMPTY)
  81
  82 typedef struct epoll_event vppcom_epoll_event_t;
  83
  84 typedef struct
  85 {
  86   u32 next_sid;
  87   u32 prev_sid;
  88   u32 vep_idx;
  89   vppcom_epoll_event_t ev;
  90 #define VEP_DEFAULT_ET_MASK  (EPOLLIN|EPOLLOUT)
  91 #define VEP_UNSUPPORTED_EVENTS (EPOLLONESHOT|EPOLLEXCLUSIVE)
  92   u32 et_mask;
  93 } vppcom_epoll_t;
  94
  95 typedef struct
  96 {
  97   u8 is_ip4;
  98   ip46_address_t ip46;
  99 } vppcom_ip46_t;
 100
 101 enum
 102 {
 103   VCL_SESS_ATTR_SERVER,
 104   VCL_SESS_ATTR_CUT_THRU,
 105   VCL_SESS_ATTR_VEP,
 106   VCL_SESS_ATTR_VEP_SESSION,
 107   VCL_SESS_ATTR_LISTEN,         // SOL_SOCKET,SO_ACCEPTCONN
 108   VCL_SESS_ATTR_NONBLOCK,       // fcntl,O_NONBLOCK
 109   VCL_SESS_ATTR_REUSEADDR,      // SOL_SOCKET,SO_REUSEADDR
 110   VCL_SESS_ATTR_REUSEPORT,      // SOL_SOCKET,SO_REUSEPORT
 111   VCL_SESS_ATTR_BROADCAST,      // SOL_SOCKET,SO_BROADCAST
 112   VCL_SESS_ATTR_V6ONLY,         // SOL_TCP,IPV6_V6ONLY
 113   VCL_SESS_ATTR_KEEPALIVE,      // SOL_SOCKET,SO_KEEPALIVE
 114   VCL_SESS_ATTR_TCP_NODELAY,    // SOL_TCP,TCP_NODELAY
 115   VCL_SESS_ATTR_TCP_KEEPIDLE,   // SOL_TCP,TCP_KEEPIDLE
 116   VCL_SESS_ATTR_TCP_KEEPINTVL,  // SOL_TCP,TCP_KEEPINTVL
 117   VCL_SESS_ATTR_MAX
 118 } vppcom_session_attr_t;
 119
 120 #define VCL_SESS_ATTR_SET(ATTR, VAL)            \
 121 do {                                            \
 122   (ATTR) |= 1 << (VAL);                         \
 123  } while (0)
 124
 125 #define VCL_SESS_ATTR_CLR(ATTR, VAL)            \
 126 do {                                            \
 127   (ATTR) &= ~(1 << (VAL));                      \
 128  } while (0)
 129
 130 #define VCL_SESS_ATTR_TEST(ATTR, VAL)           \
 131   ((ATTR) & (1 << (VAL)) ? 1 : 0)
 132
 133 typedef struct
 134 {
 135   volatile session_state_t state;
 136
 137   svm_fifo_t *server_rx_fifo;
 138   svm_fifo_t *server_tx_fifo;
 139   u32 sndbuf_size;              // VPP-TBD: Hack until support setsockopt(SO_SNDBUF)
 140   u32 rcvbuf_size;              // VPP-TBD: Hack until support setsockopt(SO_RCVBUF)
 141   u32 user_mss;                 // VPP-TBD: Hack until support setsockopt(TCP_MAXSEG)
 142   u8 *segment_name;
 143   u32 sm_seg_index;
 144   u32 client_context;
 145   u64 vpp_handle;
 146   svm_queue_t *vpp_event_queue;
 147
 148   /* Socket configuration state */
 149   /* TBD: covert 'is_*' vars to bit in session->attr; */
 150   u8 is_server;
 151   u8 is_listen;
 152   u8 is_cut_thru;
 153   u8 is_nonblocking;
 154   u8 is_vep;
 155   u8 is_vep_session;
 156   u32 attr;
 157   u32 wait_cont_idx;
 158   vppcom_epoll_t vep;
 159   int libc_epfd;
 160   u32 vrf;
 161   vppcom_ip46_t lcl_addr;
 162   vppcom_ip46_t peer_addr;
 163   u16 lcl_port;                 // network order
 164   u16 peer_port;                // network order
 165   u8 proto;
 166   u64 client_queue_address;
 167   u64 options[16];
 168   elog_track_t elog_track;
 169 } session_t;
 170
 171 typedef struct vppcom_cfg_t_
 172 {
 173   u64 heapsize;
 174   u32 vpp_api_q_length;
 175   u64 segment_baseva;
 176   u32 segment_size;
 177   u32 add_segment_size;
 178   u32 preallocated_fifo_pairs;
 179   u32 rx_fifo_size;
 180   u32 tx_fifo_size;
 181   u32 event_queue_size;
 182   u32 listen_queue_size;
 183   u8 app_proxy_transport_tcp;
 184   u8 app_proxy_transport_udp;
 185   u8 app_scope_local;
 186   u8 app_scope_global;
 187   u8 *namespace_id;
 188   u64 namespace_secret;
 189   f64 app_timeout;
 190   f64 session_timeout;
 191   f64 accept_timeout;
 192   u32 event_ring_size;
 193   char *event_log_path;
 194 } vppcom_cfg_t;
 195
 196 typedef struct vppcom_main_t_
 197 {
 198   u8 init;
 199   u32 debug;
 200   u32 *client_session_index_fifo;
 201   int main_cpu;
 202
 203   /* vpe input queue */
 204   svm_queue_t *vl_input_queue;
 205
 206   /* API client handle */
 207   u32 my_client_index;
 208
 209   /* Session pool */
 210   clib_spinlock_t sessions_lockp;
 211   session_t *sessions;
 212
 213   /* Hash table for disconnect processing */
 214   uword *session_index_by_vpp_handles;
 215
 216   /* Select bitmaps */
 217   clib_bitmap_t *rd_bitmap;
 218   clib_bitmap_t *wr_bitmap;
 219   clib_bitmap_t *ex_bitmap;
 220
 221   /* Our event queue */
 222   svm_queue_t *app_event_queue;
 223
 224   /* unique segment name counter */
 225   u32 unique_segment_index;
 226
 227   /* For deadman timers */
 228   clib_time_t clib_time;
 229
 230   /* State of the connection, shared between msg RX thread and main thread */
 231   volatile app_state_t app_state;
 232
 233   vppcom_cfg_t cfg;
 234
 235   /* Event logging */
 236   elog_main_t elog_main;
 237   elog_track_t elog_track;
 238
 239   /* VNET_API_ERROR_FOO -> "Foo" hash table */
 240   uword *error_string_by_error_number;
 241 } vppcom_main_t;
 242
 243 /* NOTE: _vppcom_main is only used until the heap is allocated.
 244  *       Do not access it directly -- use vcm which will point to
 245  *       the heap allocated copy after init.
 246  */
 247 static vppcom_main_t _vppcom_main = {
 248   .debug = VPPCOM_DEBUG_INIT,
 249   .my_client_index = ~0
 250 };
 251
 252 static vppcom_main_t *vcm = &_vppcom_main;
 253
 254 #define VCL_LOCK_AND_GET_SESSION(I, S)                          \
 255 do {                                                            \
 256   clib_spinlock_lock (&vcm->sessions_lockp);                    \
 257   rv = vppcom_session_at_index (I, S);                          \
 258   if (PREDICT_FALSE (rv))                                       \
 259     {                                                           \
 260       clib_spinlock_unlock (&vcm->sessions_lockp);              \
 261       clib_warning ("VCL<%d>: ERROR: Invalid ##I (%u)!",        \
 262                     getpid (), I);                              \
 263       goto done;                                                \
 264     }                                                           \
 265 } while (0)
 266
 267 static const char *
 268 vppcom_app_state_str (app_state_t state)
 269 {
 270   char *st;
 271
 272   switch (state)
 273     {
 274     case STATE_APP_START:
 275       st = "STATE_APP_START";
 276       break;
 277
 278     case STATE_APP_CONN_VPP:
 279       st = "STATE_APP_CONN_VPP";
 280       break;
 281
 282     case STATE_APP_ENABLED:
 283       st = "STATE_APP_ENABLED";
 284       break;
 285
 286     case STATE_APP_ATTACHED:
 287       st = "STATE_APP_ATTACHED";
 288       break;
 289
 290     default:
 291       st = "UNKNOWN_APP_STATE";
 292       break;
 293     }
 294
 295   return st;
 296 }
 297
 298 static const char *
 299 vppcom_session_state_str (session_state_t state)
 300 {
 301   char *st;
 302
 303   switch (state)
 304     {
 305     case STATE_START:
 306       st = "STATE_START";
 307       break;
 308
 309     case STATE_CONNECT:
 310       st = "STATE_CONNECT";
 311       break;
 312
 313     case STATE_LISTEN:
 314       st = "STATE_LISTEN";
 315       break;
 316
 317     case STATE_ACCEPT:
 318       st = "STATE_ACCEPT";
 319       break;
 320
 321     case STATE_CLOSE_ON_EMPTY:
 322       st = "STATE_CLOSE_ON_EMPTY";
 323       break;
 324
 325     case STATE_DISCONNECT:
 326       st = "STATE_DISCONNECT";
 327       break;
 328
 329     case STATE_FAILED:
 330       st = "STATE_FAILED";
 331       break;
 332
 333     default:
 334       st = "UNKNOWN_STATE";
 335       break;
 336     }
 337
 338   return st;
 339 }
 340
 341 /*
 342  * VPPCOM Utility Functions
 343  */
 344 static inline int
 345 vppcom_session_at_index (u32 session_index, session_t * volatile *sess)
 346 {
 347   /* Assumes that caller has acquired spinlock: vcm->sessions_lockp */
 348   if (PREDICT_FALSE ((session_index == ~0) ||
 349                      pool_is_free_index (vcm->sessions, session_index)))
 350     {
 351       clib_warning ("VCL<%d>: invalid session, sid (%u) has been closed!",
 352                     getpid (), session_index);
 353       return VPPCOM_EBADFD;
 354     }
 355   *sess = pool_elt_at_index (vcm->sessions, session_index);
 356   return VPPCOM_OK;
 357 }
 358
 359 static inline void
 360 vppcom_session_table_add_listener (u64 listener_handle, u32 value)
 361 {
 362   /* Session and listener handles have different formats. The latter has
 363    * the thread index in the upper 32 bits while the former has the session
 364    * type. Knowing that, for listeners we just flip the MSB to 1 */
 365   listener_handle |= 1ULL << 63;
 366   hash_set (vcm->session_index_by_vpp_handles, listener_handle, value);
 367 }
 368
 369 static inline session_t *
 370 vppcom_session_table_lookup_listener (u64 listener_handle)
 371 {
 372   uword *p;
 373   u64 handle = listener_handle | (1ULL << 63);
 374   session_t *session;
 375
 376   p = hash_get (vcm->session_index_by_vpp_handles, handle);
 377   if (!p)
 378     {
 379       clib_warning ("VCL<%d>: couldn't find listen session: unknown vpp "
 380                     "listener handle %llx", getpid (), listener_handle);
 381       return 0;
 382     }
 383   if (pool_is_free_index (vcm->sessions, p[0]))
 384     {
 385       if (VPPCOM_DEBUG > 1)
 386         clib_warning ("VCL<%d>: invalid listen session, sid (%u)",
 387                       getpid (), p[0]);
 388       return 0;
 389     }
 390
 391   session = pool_elt_at_index (vcm->sessions, p[0]);
 392   ASSERT (session->is_listen);
 393   return session;
 394 }
 395
 396 static inline void
 397 vppcom_session_table_del_listener (u64 listener_handle)
 398 {
 399   listener_handle |= 1ULL << 63;
 400   hash_unset (vcm->session_index_by_vpp_handles, listener_handle);
 401 }
 402
 403 static void
 404 write_elog (void)
 405 {
 406   elog_main_t *em = &vcm->elog_main;
 407   char *chroot_file;
 408   clib_error_t *error = 0;
 409
 410   chroot_file =
 411     (char *) format (0, "%s/%d-%d-vcl-elog%c", vcm->cfg.event_log_path,
 412                      vcm->my_client_index, getpid (), 0);
 413   error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
 414   if (error)
 415     {
 416       clib_error_report (error);
 417     }
 418   if (VPPCOM_DEBUG > 0)
 419     clib_warning ("[%d] Event Log:'%s' ", getpid (), chroot_file);
 420
 421 }
 422
 423 static int
 424 vppcom_connect_to_vpp (char *app_name)
 425 {
 426   api_main_t *am = &api_main;
 427   int rv = VPPCOM_OK;
 428
 429   if (VPPCOM_DEBUG > 0)
 430     clib_warning ("VCL<%d>: app (%s) connecting to VPP api...",
 431                   getpid (), app_name);
 432
 433   if (vl_client_connect_to_vlib ("/vpe-api", app_name,
 434                                  vcm->cfg.vpp_api_q_length) < 0)
 435     {
 436       clib_warning ("VCL<%d>: app (%s) connect failed!", getpid (), app_name);
 437       rv = VPPCOM_ECONNREFUSED;
 438     }
 439   else
 440     {
 441       vcm->vl_input_queue = am->shmem_hdr->vl_input_queue;
 442       vcm->my_client_index = am->my_client_index;
 443       vcm->app_state = STATE_APP_CONN_VPP;
 444
 445       if (VPPCOM_DEBUG > 0)
 446         clib_warning ("VCL<%d>: app (%s) is connected to VPP!",
 447                       getpid (), app_name);
 448     }
 449
 450   if (VPPCOM_DEBUG > 0)
 451     {
 452       vcm->elog_main.lock =
 453         clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES);
 454       vcm->elog_main.lock[0] = 0;
 455       vcm->elog_main.event_ring_size = vcm->cfg.event_ring_size;
 456       elog_init (&vcm->elog_main, vcm->elog_main.event_ring_size);
 457       elog_enable_disable (&vcm->elog_main, 1);
 458
 459       vcm->elog_track.name =
 460         (char *) format (0, "P:%d:C:%d%c", getpid (),
 461                          vcm->my_client_index, 0);
 462       elog_track_register (&vcm->elog_main, &vcm->elog_track);
 463
 464       /* *INDENT-OFF* */
 465       ELOG_TYPE_DECLARE (e) =
 466       {
 467         .format = "connect_vpp:rv:%d",
 468         .format_args = "i4",
 469       };
 470       struct
 471       {
 472         u32 data;
 473       } *ed;
 474       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
 475       ed->data = rv;
 476       /* *INDENT-ON* */
 477     }
 478   return rv;
 479 }
 480
 481 static u8 *
 482 format_api_error (u8 * s, va_list * args)
 483 {
 484   i32 error = va_arg (*args, u32);
 485   uword *p;
 486
 487   p = hash_get (vcm->error_string_by_error_number, -error);
 488
 489   if (p)
 490     s = format (s, "%s (%d)", p[0], error);
 491   else
 492     s = format (s, "%d", error);
 493   return s;
 494 }
 495
 496 static void
 497 vppcom_init_error_string_table (void)
 498 {
 499   vcm->error_string_by_error_number = hash_create (0, sizeof (uword));
 500
 501 #define _(n,v,s) hash_set (vcm->error_string_by_error_number, -v, s);
 502   foreach_vnet_api_error;
 503 #undef _
 504
 505   hash_set (vcm->error_string_by_error_number, 99, "Misc");
 506 }
 507
 508 static inline int
 509 vppcom_wait_for_app_state_change (app_state_t app_state)
 510 {
 511   f64 timeout = clib_time_now (&vcm->clib_time) + vcm->cfg.app_timeout;
 512
 513   while (clib_time_now (&vcm->clib_time) < timeout)
 514     {
 515       if (vcm->app_state == app_state)
 516         return VPPCOM_OK;
 517     }
 518   if (VPPCOM_DEBUG > 0)
 519     clib_warning ("VCL<%d>: timeout waiting for state %s (%d)", getpid (),
 520                   vppcom_app_state_str (app_state), app_state);
 521
 522   if (VPPCOM_DEBUG > 0)
 523     {
 524       /* *INDENT-OFF* */
 525       ELOG_TYPE_DECLARE (e) =
 526         {
 527           .format = "ERR: timeout state:%d",
 528           .format_args = "i4",
 529         };
 530       struct
 531       {
 532         u32 data;
 533       } *ed;
 534
 535       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
 536
 537       ed->data = app_state;
 538       /* *INDENT-ON* */
 539     }
 540
 541   return VPPCOM_ETIMEDOUT;
 542 }
 543
 544 static inline int
 545 vppcom_wait_for_session_state_change (u32 session_index,
 546                                       session_state_t state,
 547                                       f64 wait_for_time)
 548 {
 549   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
 550   session_t *volatile session;
 551   int rv;
 552
 553   do
 554     {
 555       clib_spinlock_lock (&vcm->sessions_lockp);
 556       rv = vppcom_session_at_index (session_index, &session);
 557       if (PREDICT_FALSE (rv))
 558         {
 559           clib_spinlock_unlock (&vcm->sessions_lockp);
 560           return rv;
 561         }
 562       if (session->state == state)
 563         {
 564           clib_spinlock_unlock (&vcm->sessions_lockp);
 565           return VPPCOM_OK;
 566         }
 567       if (session->state == STATE_FAILED)
 568         {
 569           clib_spinlock_unlock (&vcm->sessions_lockp);
 570           return VPPCOM_ECONNREFUSED;
 571         }
 572
 573       clib_spinlock_unlock (&vcm->sessions_lockp);
 574     }
 575   while (clib_time_now (&vcm->clib_time) < timeout);
 576
 577   if (VPPCOM_DEBUG > 0)
 578     clib_warning ("VCL<%d>: timeout waiting for state 0x%x (%s)", getpid (),
 579                   state, vppcom_session_state_str (state));
 580
 581   if (VPPCOM_DEBUG > 0)
 582     {
 583       /* *INDENT-OFF* */
 584       ELOG_TYPE_DECLARE (e) =
 585         {
 586           .format = "ERR: timeout state:%d",
 587           .format_args = "i4",
 588         };
 589       struct
 590       {
 591         u32 data;
 592       } *ed;
 593
 594       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
 595
 596       ed->data = state;
 597       /* *INDENT-ON* */
 598     }
 599
 600   return VPPCOM_ETIMEDOUT;
 601 }
 602
 603 static inline int
 604 vppcom_wait_for_client_session_index (f64 wait_for_time)
 605 {
 606   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
 607
 608   do
 609     {
 610       if (clib_fifo_elts (vcm->client_session_index_fifo))
 611         return VPPCOM_OK;
 612     }
 613   while (clib_time_now (&vcm->clib_time) < timeout);
 614
 615   if (wait_for_time == 0)
 616     return VPPCOM_EAGAIN;
 617
 618   if (VPPCOM_DEBUG > 0)
 619     clib_warning ("VCL<%d>: timeout waiting for client_session_index",
 620                   getpid ());
 621
 622   if (VPPCOM_DEBUG > 0)
 623     {
 624       /* *INDENT-OFF* */
 625       ELOG_TYPE_DECLARE (e) =
 626         {
 627           .format = "ERR: timeout waiting for session index :%d",
 628           .format_args = "i4",
 629         };
 630       struct
 631       {
 632         u32 data;
 633       } *ed;
 634
 635       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
 636
 637       ed->data = getpid();
 638       /* *INDENT-ON* */
 639     }
 640
 641   return VPPCOM_ETIMEDOUT;
 642 }
 643
 644 /*
 645  * VPP-API message functions
 646  */
 647 static void
 648 vppcom_send_session_enable_disable (u8 is_enable)
 649 {
 650   vl_api_session_enable_disable_t *bmp;
 651   bmp = vl_msg_api_alloc (sizeof (*bmp));
 652   memset (bmp, 0, sizeof (*bmp));
 653
 654   bmp->_vl_msg_id = ntohs (VL_API_SESSION_ENABLE_DISABLE);
 655   bmp->client_index = vcm->my_client_index;
 656   bmp->context = htonl (0xfeedface);
 657   bmp->is_enable = is_enable;
 658   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
 659 }
 660
 661 static int
 662 vppcom_app_session_enable (void)
 663 {
 664   int rv;
 665
 666   if (vcm->app_state != STATE_APP_ENABLED)
 667     {
 668       vppcom_send_session_enable_disable (1 /* is_enabled == TRUE */ );
 669       rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
 670       if (PREDICT_FALSE (rv))
 671         {
 672           if (VPPCOM_DEBUG > 0)
 673             clib_warning ("VCL<%d>: application session enable timed out! "
 674                           "returning %d (%s)",
 675                           getpid (), rv, vppcom_retval_str (rv));
 676           return rv;
 677         }
 678     }
 679   return VPPCOM_OK;
 680 }
 681
 682 static void
 683   vl_api_session_enable_disable_reply_t_handler
 684   (vl_api_session_enable_disable_reply_t * mp)
 685 {
 686   if (mp->retval)
 687     {
 688       clib_warning ("VCL<%d>: session_enable_disable failed: %U", getpid (),
 689                     format_api_error, ntohl (mp->retval));
 690     }
 691   else
 692     vcm->app_state = STATE_APP_ENABLED;
 693 }
 694
 695 static void
 696 vppcom_app_send_attach (void)
 697 {
 698   vl_api_application_attach_t *bmp;
 699   u8 nsid_len = vec_len (vcm->cfg.namespace_id);
 700   u8 app_is_proxy = (vcm->cfg.app_proxy_transport_tcp ||
 701                      vcm->cfg.app_proxy_transport_udp);
 702
 703   bmp = vl_msg_api_alloc (sizeof (*bmp));
 704   memset (bmp, 0, sizeof (*bmp));
 705
 706   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
 707   bmp->client_index = vcm->my_client_index;
 708   bmp->context = htonl (0xfeedface);
 709   bmp->options[APP_OPTIONS_FLAGS] =
 710     APP_OPTIONS_FLAGS_ACCEPT_REDIRECT | APP_OPTIONS_FLAGS_ADD_SEGMENT |
 711     (vcm->cfg.app_scope_local ? APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE : 0) |
 712     (vcm->cfg.app_scope_global ? APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE : 0) |
 713     (app_is_proxy ? APP_OPTIONS_FLAGS_IS_PROXY : 0);
 714   bmp->options[APP_OPTIONS_PROXY_TRANSPORT] =
 715     (vcm->cfg.app_proxy_transport_tcp ? 1 << TRANSPORT_PROTO_TCP : 0) |
 716     (vcm->cfg.app_proxy_transport_udp ? 1 << TRANSPORT_PROTO_UDP : 0);
 717   bmp->options[APP_OPTIONS_SEGMENT_SIZE] = vcm->cfg.segment_size;
 718   bmp->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = vcm->cfg.add_segment_size;
 719   bmp->options[APP_OPTIONS_RX_FIFO_SIZE] = vcm->cfg.rx_fifo_size;
 720   bmp->options[APP_OPTIONS_TX_FIFO_SIZE] = vcm->cfg.tx_fifo_size;
 721   bmp->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] =
 722     vcm->cfg.preallocated_fifo_pairs;
 723   bmp->options[APP_OPTIONS_EVT_QUEUE_SIZE] = vcm->cfg.event_queue_size;
 724   if (nsid_len)
 725     {
 726       bmp->namespace_id_len = nsid_len;
 727       clib_memcpy (bmp->namespace_id, vcm->cfg.namespace_id, nsid_len);
 728       bmp->options[APP_OPTIONS_NAMESPACE_SECRET] = vcm->cfg.namespace_secret;
 729     }
 730   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
 731 }
 732
 733 static int
 734 vppcom_app_attach (void)
 735 {
 736   int rv;
 737
 738   vppcom_app_send_attach ();
 739   rv = vppcom_wait_for_app_state_change (STATE_APP_ATTACHED);
 740   if (PREDICT_FALSE (rv))
 741     {
 742       if (VPPCOM_DEBUG > 0)
 743         clib_warning ("VCL<%d>: application attach timed out! "
 744                       "returning %d (%s)",
 745                       getpid (), rv, vppcom_retval_str (rv));
 746       return rv;
 747     }
 748   return VPPCOM_OK;
 749 }
 750
 751 static void
 752 vppcom_app_detach (void)
 753 {
 754   vl_api_application_detach_t *bmp;
 755   bmp = vl_msg_api_alloc (sizeof (*bmp));
 756   memset (bmp, 0, sizeof (*bmp));
 757
 758   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
 759   bmp->client_index = vcm->my_client_index;
 760   bmp->context = htonl (0xfeedface);
 761   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
 762 }
 763
 764 static void
 765 vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
 766                                            mp)
 767 {
 768   static svm_fifo_segment_create_args_t _a;
 769   svm_fifo_segment_create_args_t *a = &_a;
 770   int rv;
 771
 772   memset (a, 0, sizeof (*a));
 773   if (mp->retval)
 774     {
 775       clib_warning ("VCL<%d>: attach failed: %U", getpid (),
 776                     format_api_error, ntohl (mp->retval));
 777       return;
 778     }
 779
 780   if (mp->segment_name_length == 0)
 781     {
 782       clib_warning ("VCL<%d>: segment_name_length zero", getpid ());
 783       return;
 784     }
 785
 786   a->segment_name = (char *) mp->segment_name;
 787   a->segment_size = mp->segment_size;
 788
 789   ASSERT (mp->app_event_queue_address);
 790
 791   /* Attach to the segment vpp created */
 792   rv = svm_fifo_segment_attach (a);
 793   vec_reset_length (a->new_segment_indices);
 794   if (PREDICT_FALSE (rv))
 795     {
 796       clib_warning ("VCL<%d>: svm_fifo_segment_attach ('%s') failed",
 797                     getpid (), mp->segment_name);
 798       return;
 799     }
 800
 801   vcm->app_event_queue =
 802     uword_to_pointer (mp->app_event_queue_address, svm_queue_t *);
 803
 804   vcm->app_state = STATE_APP_ATTACHED;
 805 }
 806
 807 static void
 808 vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
 809                                            mp)
 810 {
 811   if (mp->retval)
 812     clib_warning ("VCL<%d>: detach failed: %U", getpid (), format_api_error,
 813                   ntohl (mp->retval));
 814
 815   vcm->app_state = STATE_APP_ENABLED;
 816 }
 817
 818 static void
 819 vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
 820                                            mp)
 821 {
 822   if (mp->retval)
 823     clib_warning ("VCL<%d>: vpp handle 0x%llx: disconnect session failed: %U",
 824                   getpid (), mp->handle, format_api_error,
 825                   ntohl (mp->retval));
 826 }
 827
 828 static void
 829 vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
 830 {
 831   static svm_fifo_segment_create_args_t _a;
 832   svm_fifo_segment_create_args_t *a = &_a;
 833   int rv;
 834
 835   memset (a, 0, sizeof (*a));
 836   a->segment_name = (char *) mp->segment_name;
 837   a->segment_size = mp->segment_size;
 838   /* Attach to the segment vpp created */
 839   rv = svm_fifo_segment_attach (a);
 840   vec_reset_length (a->new_segment_indices);
 841   if (PREDICT_FALSE (rv))
 842     {
 843       clib_warning ("VCL<%d>: svm_fifo_segment_attach ('%s') failed",
 844                     getpid (), mp->segment_name);
 845       return;
 846     }
 847   if (VPPCOM_DEBUG > 1)
 848     clib_warning ("VCL<%d>: mapped new segment '%s' size %d", getpid (),
 849                   mp->segment_name, mp->segment_size);
 850 }
 851
 852 static void
 853 vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
 854 {
 855   uword *p;
 856
 857   p = hash_get (vcm->session_index_by_vpp_handles, mp->handle);
 858   if (p)
 859     {
 860       int rv;
 861       session_t *session = 0;
 862       u32 session_index = p[0];
 863
 864       VCL_LOCK_AND_GET_SESSION (session_index, &session);
 865       session->state = STATE_CLOSE_ON_EMPTY;
 866
 867       if (VPPCOM_DEBUG > 1)
 868         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
 869                       "setting state to 0x%x (%s)",
 870                       getpid (), mp->handle, session_index, session->state,
 871                       vppcom_session_state_str (session->state));
 872       clib_spinlock_unlock (&vcm->sessions_lockp);
 873       return;
 874
 875     done:
 876       if (VPPCOM_DEBUG > 1)
 877         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
 878                       "session lookup failed!",
 879                       getpid (), mp->handle, session_index);
 880     }
 881   else
 882     clib_warning ("VCL<%d>: vpp handle 0x%llx: session lookup by "
 883                   "handle failed!", getpid (), mp->handle);
 884 }
 885
 886 static void
 887 vl_api_reset_session_t_handler (vl_api_reset_session_t * mp)
 888 {
 889   session_t *session = 0;
 890   vl_api_reset_session_reply_t *rmp;
 891   uword *p;
 892   int rv = 0;
 893
 894   p = hash_get (vcm->session_index_by_vpp_handles, mp->handle);
 895   if (p)
 896     {
 897       int rval;
 898       clib_spinlock_lock (&vcm->sessions_lockp);
 899       rval = vppcom_session_at_index (p[0], &session);
 900       if (PREDICT_FALSE (rval))
 901         {
 902           rv = VNET_API_ERROR_INVALID_VALUE_2;
 903           clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
 904                         "session lookup failed! returning %d %U",
 905                         getpid (), mp->handle, p[0],
 906                         rv, format_api_error, rv);
 907         }
 908       else
 909         {
 910           /* TBD: should this disconnect immediately and
 911            * flush the fifos?
 912            */
 913           session->state = STATE_CLOSE_ON_EMPTY;
 914
 915           if (VPPCOM_DEBUG > 1)
 916             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
 917                           "state set to %d (%s)!", getpid (),
 918                           mp->handle, p[0], session->state,
 919                           vppcom_session_state_str (session->state));
 920         }
 921       clib_spinlock_unlock (&vcm->sessions_lockp);
 922     }
 923   else
 924     {
 925       rv = VNET_API_ERROR_INVALID_VALUE;
 926       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx: session lookup "
 927                     "failed! returning %d %U",
 928                     getpid (), mp->handle, rv, format_api_error, rv);
 929     }
 930
 931   rmp = vl_msg_api_alloc (sizeof (*rmp));
 932   memset (rmp, 0, sizeof (*rmp));
 933   rmp->_vl_msg_id = ntohs (VL_API_RESET_SESSION_REPLY);
 934   rmp->retval = htonl (rv);
 935   rmp->handle = mp->handle;
 936   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
 937 }
 938
 939 static void
 940 vl_api_connect_session_reply_t_handler (vl_api_connect_session_reply_t * mp)
 941 {
 942   session_t *session = 0;
 943   u32 session_index;
 944   svm_fifo_t *rx_fifo, *tx_fifo;
 945   u8 is_cut_thru = 0;
 946   int rv;
 947
 948   session_index = mp->context;
 949   VCL_LOCK_AND_GET_SESSION (session_index, &session);
 950 done:
 951   if (mp->retval)
 952     {
 953       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
 954                     "connect failed! %U",
 955                     getpid (), mp->handle, session_index,
 956                     format_api_error, ntohl (mp->retval));
 957       if (rv == VPPCOM_OK)
 958         {
 959           session->state = STATE_FAILED;
 960           session->vpp_handle = mp->handle;
 961         }
 962       else
 963         {
 964           clib_warning ("[%s] ERROR: vpp handle 0x%llx, sid %u: "
 965                         "Invalid session index (%u)!",
 966                         getpid (), mp->handle, session_index);
 967         }
 968       goto done_unlock;
 969     }
 970
 971   if (rv)
 972     goto done_unlock;
 973
 974   /* We've been redirected */
 975   if (mp->segment_name_length > 0)
 976     {
 977       static svm_fifo_segment_create_args_t _a;
 978       svm_fifo_segment_create_args_t *a = &_a;
 979
 980       is_cut_thru = 1;
 981       memset (a, 0, sizeof (*a));
 982       a->segment_name = (char *) mp->segment_name;
 983       if (VPPCOM_DEBUG > 1)
 984         clib_warning ("VCL<%d>: cut-thru segment: %s\n",
 985                       getpid (), a->segment_name);
 986
 987       rv = svm_fifo_segment_attach (a);
 988       vec_reset_length (a->new_segment_indices);
 989       if (PREDICT_FALSE (rv))
 990         {
 991           clib_warning ("VCL<%d>: sm_fifo_segment_attach ('%s') failed",
 992                         getpid (), a->segment_name);
 993           goto done_unlock;
 994         }
 995     }
 996
 997   /*
 998    * Setup session
 999    */
1000   session->is_cut_thru = is_cut_thru;
1001   session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
1002                                                svm_queue_t *);
1003
1004   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
1005   rx_fifo->client_session_index = session_index;
1006   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
1007   tx_fifo->client_session_index = session_index;
1008
1009   session->server_rx_fifo = rx_fifo;
1010   session->server_tx_fifo = tx_fifo;
1011   session->vpp_handle = mp->handle;
1012   session->lcl_addr.is_ip4 = mp->is_ip4;
1013   clib_memcpy (&session->lcl_addr.ip46, mp->lcl_ip,
1014                sizeof (session->peer_addr.ip46));
1015   session->lcl_port = mp->lcl_port;
1016   session->state = STATE_CONNECT;
1017
1018   /* Add it to lookup table */
1019   hash_set (vcm->session_index_by_vpp_handles, mp->handle, session_index);
1020
1021   if (VPPCOM_DEBUG > 1)
1022     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connect succeeded!"
1023                   " session_rx_fifo %p, refcnt %d,"
1024                   " session_tx_fifo %p, refcnt %d",
1025                   getpid (), mp->handle, session_index,
1026                   session->server_rx_fifo,
1027                   session->server_rx_fifo->refcnt,
1028                   session->server_tx_fifo, session->server_tx_fifo->refcnt);
1029 done_unlock:
1030   clib_spinlock_unlock (&vcm->sessions_lockp);
1031 }
1032
1033 static void
1034 vppcom_send_connect_sock (session_t * session, u32 session_index)
1035 {
1036   vl_api_connect_sock_t *cmp;
1037
1038   /* Assumes caller as acquired the spinlock: vcm->sessions_lockp */
1039   session->is_server = 0;
1040   cmp = vl_msg_api_alloc (sizeof (*cmp));
1041   memset (cmp, 0, sizeof (*cmp));
1042   cmp->_vl_msg_id = ntohs (VL_API_CONNECT_SOCK);
1043   cmp->client_index = vcm->my_client_index;
1044   cmp->context = session_index;
1045
1046   cmp->vrf = session->vrf;
1047   cmp->is_ip4 = session->peer_addr.is_ip4;
1048   clib_memcpy (cmp->ip, &session->peer_addr.ip46, sizeof (cmp->ip));
1049   cmp->port = session->peer_port;
1050   cmp->proto = session->proto;
1051   clib_memcpy (cmp->options, session->options, sizeof (cmp->options));
1052   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & cmp);
1053 }
1054
1055 static inline void
1056 vppcom_send_disconnect_session_reply (u64 vpp_handle, u32 session_index,
1057                                       int rv)
1058 {
1059   vl_api_disconnect_session_reply_t *rmp;
1060
1061   if (VPPCOM_DEBUG > 1)
1062     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
1063                   "sending disconnect msg",
1064                   getpid (), vpp_handle, session_index);
1065
1066   rmp = vl_msg_api_alloc (sizeof (*rmp));
1067   memset (rmp, 0, sizeof (*rmp));
1068
1069   rmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION_REPLY);
1070   rmp->retval = htonl (rv);
1071   rmp->handle = vpp_handle;
1072   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
1073 }
1074
1075 static inline void
1076 vppcom_send_disconnect_session (u64 vpp_handle, u32 session_index)
1077 {
1078   vl_api_disconnect_session_t *dmp;
1079
1080   if (VPPCOM_DEBUG > 1)
1081     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
1082                   "sending disconnect msg",
1083                   getpid (), vpp_handle, session_index);
1084
1085   dmp = vl_msg_api_alloc (sizeof (*dmp));
1086   memset (dmp, 0, sizeof (*dmp));
1087   dmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION);
1088   dmp->client_index = vcm->my_client_index;
1089   dmp->handle = vpp_handle;
1090   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & dmp);
1091 }
1092
1093 static void
1094 vl_api_bind_sock_reply_t_handler (vl_api_bind_sock_reply_t * mp)
1095 {
1096   session_t *session = 0;
1097   u32 session_index = mp->context;
1098   int rv;
1099
1100   VCL_LOCK_AND_GET_SESSION (session_index, &session);
1101 done:
1102   if (mp->retval)
1103     {
1104       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, "
1105                     "sid %u: bind failed: %U",
1106                     getpid (), mp->handle, session_index,
1107                     format_api_error, ntohl (mp->retval));
1108       rv = vppcom_session_at_index (session_index, &session);
1109       if (rv == VPPCOM_OK)
1110         {
1111           session->state = STATE_FAILED;
1112           session->vpp_handle = mp->handle;
1113         }
1114       else
1115         {
1116           clib_warning ("[%s] ERROR: vpp handle 0x%llx, sid %u: "
1117                         "Invalid session index (%u)!",
1118                         getpid (), mp->handle, session_index);
1119         }
1120       goto done_unlock;
1121     }
1122
1123   session->vpp_handle = mp->handle;
1124   session->lcl_addr.is_ip4 = mp->lcl_is_ip4;
1125   clib_memcpy (&session->lcl_addr.ip46, mp->lcl_ip,
1126                sizeof (session->peer_addr.ip46));
1127   session->lcl_port = mp->lcl_port;
1128   vppcom_session_table_add_listener (mp->handle, session_index);
1129   session->is_listen = 1;
1130   session->state = STATE_LISTEN;
1131
1132   if (VPPCOM_DEBUG > 1)
1133     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: bind succeeded!",
1134                   getpid (), mp->handle, mp->context);
1135 done_unlock:
1136   clib_spinlock_unlock (&vcm->sessions_lockp);
1137 }
1138
1139 static void
1140 vl_api_unbind_sock_reply_t_handler (vl_api_unbind_sock_reply_t * mp)
1141 {
1142   if (mp->retval)
1143     clib_warning ("VCL<%d>: ERROR: sid %u: unbind failed: %U",
1144                   getpid (), mp->context, format_api_error,
1145                   ntohl (mp->retval));
1146
1147   else if (VPPCOM_DEBUG > 1)
1148     clib_warning ("VCL<%d>: sid %u: unbind succeeded!",
1149                   getpid (), mp->context);
1150 }
1151
1152 u8 *
1153 format_ip4_address (u8 * s, va_list * args)
1154 {
1155   u8 *a = va_arg (*args, u8 *);
1156   return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
1157 }
1158
1159 u8 *
1160 format_ip6_address (u8 * s, va_list * args)
1161 {
1162   ip6_address_t *a = va_arg (*args, ip6_address_t *);
1163   u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
1164
1165   i_max_n_zero = ARRAY_LEN (a->as_u16);
1166   max_n_zeros = 0;
1167   i_first_zero = i_max_n_zero;
1168   n_zeros = 0;
1169   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
1170     {
1171       u32 is_zero = a->as_u16[i] == 0;
1172       if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
1173         {
1174           i_first_zero = i;
1175           n_zeros = 0;
1176         }
1177       n_zeros += is_zero;
1178       if ((!is_zero && n_zeros > max_n_zeros)
1179           || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
1180         {
1181           i_max_n_zero = i_first_zero;
1182           max_n_zeros = n_zeros;
1183           i_first_zero = ARRAY_LEN (a->as_u16);
1184           n_zeros = 0;
1185         }
1186     }
1187
1188   last_double_colon = 0;
1189   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
1190     {
1191       if (i == i_max_n_zero && max_n_zeros > 1)
1192         {
1193           s = format (s, "::");
1194           i += max_n_zeros - 1;
1195           last_double_colon = 1;
1196         }
1197       else
1198         {
1199           s = format (s, "%s%x",
1200                       (last_double_colon || i == 0) ? "" : ":",
1201                       clib_net_to_host_u16 (a->as_u16[i]));
1202           last_double_colon = 0;
1203         }
1204     }
1205
1206   return s;
1207 }
1208
1209 /* Format an IP46 address. */
1210 u8 *
1211 format_ip46_address (u8 * s, va_list * args)
1212 {
1213   ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
1214   ip46_type_t type = va_arg (*args, ip46_type_t);
1215   int is_ip4 = 1;
1216
1217   switch (type)
1218     {
1219     case IP46_TYPE_ANY:
1220       is_ip4 = ip46_address_is_ip4 (ip46);
1221       break;
1222     case IP46_TYPE_IP4:
1223       is_ip4 = 1;
1224       break;
1225     case IP46_TYPE_IP6:
1226       is_ip4 = 0;
1227       break;
1228     }
1229
1230   return is_ip4 ?
1231     format (s, "%U", format_ip4_address, &ip46->ip4) :
1232     format (s, "%U", format_ip6_address, &ip46->ip6);
1233 }
1234
1235 static inline void
1236 vppcom_send_accept_session_reply (u64 handle, u32 context, int retval)
1237 {
1238   vl_api_accept_session_reply_t *rmp;
1239
1240   rmp = vl_msg_api_alloc (sizeof (*rmp));
1241   memset (rmp, 0, sizeof (*rmp));
1242   rmp->_vl_msg_id = ntohs (VL_API_ACCEPT_SESSION_REPLY);
1243   rmp->retval = htonl (retval);
1244   rmp->context = context;
1245   rmp->handle = handle;
1246   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
1247 }
1248
1249 static void
1250 vl_api_accept_session_t_handler (vl_api_accept_session_t * mp)
1251 {
1252   svm_fifo_t *rx_fifo, *tx_fifo;
1253   session_t *session, *listen_session;
1254   u32 session_index;
1255
1256   clib_spinlock_lock (&vcm->sessions_lockp);
1257   if (!clib_fifo_free_elts (vcm->client_session_index_fifo))
1258     {
1259       clib_warning ("VCL<%d>: client session queue is full!", getpid ());
1260       vppcom_send_accept_session_reply (mp->handle, mp->context,
1261                                         VNET_API_ERROR_QUEUE_FULL);
1262       clib_spinlock_unlock (&vcm->sessions_lockp);
1263       return;
1264     }
1265
1266   listen_session = vppcom_session_table_lookup_listener (mp->listener_handle);
1267   if (!listen_session)
1268     {
1269       clib_warning ("VCL<%d>: ERROR: couldn't find listen session: "
1270                     "unknown vpp listener handle %llx",
1271                     getpid (), mp->listener_handle);
1272       clib_spinlock_unlock (&vcm->sessions_lockp);
1273       return;
1274     }
1275
1276   /* Allocate local session and set it up */
1277   pool_get (vcm->sessions, session);
1278   memset (session, 0, sizeof (*session));
1279   session_index = session - vcm->sessions;
1280
1281   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
1282   rx_fifo->client_session_index = session_index;
1283   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
1284   tx_fifo->client_session_index = session_index;
1285
1286   session->vpp_handle = mp->handle;
1287   session->client_context = mp->context;
1288   session->server_rx_fifo = rx_fifo;
1289   session->server_tx_fifo = tx_fifo;
1290   session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
1291                                                svm_queue_t *);
1292   session->state = STATE_ACCEPT;
1293   session->is_cut_thru = 0;
1294   session->is_server = 1;
1295   session->peer_port = mp->port;
1296   session->peer_addr.is_ip4 = mp->is_ip4;
1297   clib_memcpy (&session->peer_addr.ip46, mp->ip,
1298                sizeof (session->peer_addr.ip46));
1299
1300   /* Add it to lookup table */
1301   hash_set (vcm->session_index_by_vpp_handles, mp->handle, session_index);
1302   session->lcl_port = listen_session->lcl_port;
1303   session->lcl_addr = listen_session->lcl_addr;
1304
1305   /* TBD: move client_session_index_fifo into listener session */
1306   clib_fifo_add1 (vcm->client_session_index_fifo, session_index);
1307
1308   clib_spinlock_unlock (&vcm->sessions_lockp);
1309
1310   if (VPPCOM_DEBUG > 1)
1311     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: client accept "
1312                   "request from %s address %U port %d queue %p!", getpid (),
1313                   mp->handle, session_index, mp->is_ip4 ? "IPv4" : "IPv6",
1314                   format_ip46_address, &mp->ip, mp->is_ip4,
1315                   clib_net_to_host_u16 (mp->port), session->vpp_event_queue);
1316
1317   if (VPPCOM_DEBUG > 0)
1318     {
1319       session->elog_track.name =
1320         (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
1321                          session_index, 0);
1322       elog_track_register (&vcm->elog_main, &session->elog_track);
1323
1324       if (session->peer_addr.is_ip4)
1325         {
1326           /* *INDENT-OFF* */
1327           ELOG_TYPE_DECLARE (e) =
1328           {
1329             .format =
1330             "client_accept:handle:%x addr:%d.%d.%d.%d:%d",
1331             .format_args = "i8i1i1i1i1i2",
1332           };
1333
1334           CLIB_PACKED (struct {
1335             u64 handle; //8
1336             u8 addr[4]; //4
1337             u16 port;   //2
1338           }) * ed;
1339
1340           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
1341
1342           ed->handle = mp->handle;
1343           ed->addr[0] = session->peer_addr.ip46.ip4.as_u8[0];
1344           ed->addr[1] = session->peer_addr.ip46.ip4.as_u8[1];
1345           ed->addr[2] = session->peer_addr.ip46.ip4.as_u8[2];
1346           ed->addr[3] = session->peer_addr.ip46.ip4.as_u8[3];
1347           ed->port = clib_net_to_host_u16 (session->peer_port);
1348           /* *INDENT-ON* */
1349         }
1350       else
1351         {
1352           clib_warning ("ip6");
1353         }
1354     }
1355
1356 }
1357
1358 static void
1359 vppcom_send_connect_session_reply (session_t * session, u32 session_index,
1360                                    u64 vpp_handle, u32 context, int retval)
1361 {
1362   vl_api_connect_session_reply_t *rmp;
1363   u32 len;
1364   svm_queue_t *client_q;
1365
1366   rmp = vl_msg_api_alloc (sizeof (*rmp));
1367   memset (rmp, 0, sizeof (*rmp));
1368   rmp->_vl_msg_id = ntohs (VL_API_CONNECT_SESSION_REPLY);
1369
1370   if (!session)
1371     {
1372       rmp->context = context;
1373       rmp->handle = vpp_handle;
1374       rmp->retval = htonl (retval);
1375       vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
1376       return;
1377     }
1378
1379   rmp->context = session->client_context;
1380   rmp->retval = htonl (retval);
1381   rmp->handle = session->vpp_handle;
1382   rmp->server_rx_fifo = pointer_to_uword (session->server_rx_fifo);
1383   rmp->server_tx_fifo = pointer_to_uword (session->server_tx_fifo);
1384   rmp->vpp_event_queue_address = pointer_to_uword (session->vpp_event_queue);
1385   rmp->segment_size = vcm->cfg.segment_size;
1386   len = vec_len (session->segment_name);
1387   rmp->segment_name_length = clib_min (len, sizeof (rmp->segment_name));
1388   clib_memcpy (rmp->segment_name, session->segment_name,
1389                rmp->segment_name_length - 1);
1390   clib_memcpy (rmp->lcl_ip, session->peer_addr.ip46.as_u8,
1391                sizeof (rmp->lcl_ip));
1392   rmp->is_ip4 = session->peer_addr.is_ip4;
1393   rmp->lcl_port = session->peer_port;
1394   client_q = uword_to_pointer (session->client_queue_address, svm_queue_t *);
1395   ASSERT (client_q);
1396   vl_msg_api_send_shmem (client_q, (u8 *) & rmp);
1397 }
1398
1399 /*
1400  * Acting as server for redirected connect requests
1401  */
1402 static void
1403 vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp)
1404 {
1405   u32 session_index;
1406   session_t *session = 0;
1407
1408   clib_spinlock_lock (&vcm->sessions_lockp);
1409   if (!clib_fifo_free_elts (vcm->client_session_index_fifo))
1410     {
1411       clib_spinlock_unlock (&vcm->sessions_lockp);
1412
1413       if (VPPCOM_DEBUG > 1)
1414         clib_warning ("VCL<%d>: client session queue is full!", getpid ());
1415
1416       /* TBD: Fix api to include vpp handle */
1417       vppcom_send_connect_session_reply (0 /* session */ , 0 /* sid */ ,
1418                                          0 /* handle */ , mp->context,
1419                                          VNET_API_ERROR_QUEUE_FULL);
1420       return;
1421     }
1422
1423   pool_get (vcm->sessions, session);
1424   memset (session, 0, sizeof (*session));
1425   session_index = session - vcm->sessions;
1426
1427   session->client_context = mp->context;
1428   session->vpp_handle = session_index;
1429   session->client_queue_address = mp->client_queue_address;
1430   session->is_cut_thru = 1;
1431   session->is_server = 1;
1432   session->lcl_port = mp->port;
1433   session->lcl_addr.is_ip4 = mp->is_ip4;
1434   clib_memcpy (&session->lcl_addr.ip46, mp->ip,
1435                sizeof (session->lcl_addr.ip46));
1436
1437   /* TBD: missing peer info in api msg.
1438    */
1439   session->peer_addr.is_ip4 = mp->is_ip4;
1440   ASSERT (session->lcl_addr.is_ip4 == session->peer_addr.is_ip4);
1441
1442   session->state = STATE_ACCEPT;
1443   clib_fifo_add1 (vcm->client_session_index_fifo, session_index);
1444   if (VPPCOM_DEBUG > 1)
1445     clib_warning ("VCL<%d>: sid %u: Got a cut-thru connect request! "
1446                   "clib_fifo_elts %u!\n", getpid (), session_index,
1447                   clib_fifo_elts (vcm->client_session_index_fifo));
1448
1449   if (VPPCOM_DEBUG > 0)
1450     {
1451       session->elog_track.name =
1452         (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
1453                          session_index, 0);
1454       elog_track_register (&vcm->elog_main, &session->elog_track);
1455
1456       /* *INDENT-OFF* */
1457       ELOG_TYPE_DECLARE (e) =
1458       {
1459         .format = "cut-thru-connect:S:%d clib_fifo_elts:%d",
1460         .format_args = "i4i4",
1461       };
1462
1463       struct
1464       {
1465         u32 data[2];
1466       } *ed;
1467
1468       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
1469
1470       ed->data[0] = session_index;
1471       ed->data[1] = clib_fifo_elts (vcm->client_session_index_fifo);
1472       /* *INDENT-ON* */
1473     }
1474
1475   clib_spinlock_unlock (&vcm->sessions_lockp);
1476 }
1477
1478 static void
1479 vppcom_send_bind_sock (session_t * session, u32 session_index)
1480 {
1481   vl_api_bind_sock_t *bmp;
1482
1483   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
1484   session->is_server = 1;
1485   bmp = vl_msg_api_alloc (sizeof (*bmp));
1486   memset (bmp, 0, sizeof (*bmp));
1487
1488   bmp->_vl_msg_id = ntohs (VL_API_BIND_SOCK);
1489   bmp->client_index = vcm->my_client_index;
1490   bmp->context = session_index;
1491   bmp->vrf = session->vrf;
1492   bmp->is_ip4 = session->lcl_addr.is_ip4;
1493   clib_memcpy (bmp->ip, &session->lcl_addr.ip46, sizeof (bmp->ip));
1494   bmp->port = session->lcl_port;
1495   bmp->proto = session->proto;
1496   clib_memcpy (bmp->options, session->options, sizeof (bmp->options));
1497   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
1498 }
1499
1500 static void
1501 vppcom_send_unbind_sock (u64 vpp_handle)
1502 {
1503   vl_api_unbind_sock_t *ump;
1504
1505   ump = vl_msg_api_alloc (sizeof (*ump));
1506   memset (ump, 0, sizeof (*ump));
1507
1508   ump->_vl_msg_id = ntohs (VL_API_UNBIND_SOCK);
1509   ump->client_index = vcm->my_client_index;
1510   ump->handle = vpp_handle;
1511   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & ump);
1512 }
1513
1514 static int
1515 vppcom_session_unbind (u32 session_index)
1516 {
1517   session_t *session = 0;
1518   int rv;
1519   u64 vpp_handle;
1520
1521   VCL_LOCK_AND_GET_SESSION (session_index, &session);
1522
1523   vpp_handle = session->vpp_handle;
1524   vppcom_session_table_del_listener (vpp_handle);
1525   session->vpp_handle = ~0;
1526   session->state = STATE_DISCONNECT;
1527
1528   clib_spinlock_unlock (&vcm->sessions_lockp);
1529
1530   if (VPPCOM_DEBUG > 1)
1531     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
1532                   "sending unbind msg! new state 0x%x (%s)",
1533                   getpid (), vpp_handle, session_index,
1534                   session->state, vppcom_session_state_str (session->state));
1535
1536   if (VPPCOM_DEBUG > 0)
1537     {
1538       /* *INDENT-OFF* */
1539       ELOG_TYPE_DECLARE (e) =
1540       {
1541         .format = "unbind: handle:%x",
1542         .format_args = "i8",
1543       };
1544
1545       struct
1546       {
1547         u64 handle;
1548       } *ed;
1549
1550       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
1551       ed->handle = vpp_handle;
1552       /* *INDENT-ON* */
1553     }
1554   vppcom_send_unbind_sock (vpp_handle);
1555
1556 done:
1557   return rv;
1558 }
1559
1560 static inline int
1561 vppcom_session_disconnect (u32 session_index)
1562 {
1563   int rv;
1564   session_t *session;
1565   u8 is_cut_thru, is_listen, is_server;
1566   u64 vpp_handle;
1567   session_state_t state;
1568
1569   VCL_LOCK_AND_GET_SESSION (session_index, &session);
1570
1571   vpp_handle = session->vpp_handle;
1572   is_server = session->is_server;
1573   is_listen = session->is_listen;
1574   is_cut_thru = session->is_cut_thru;
1575   state = session->state;
1576   clib_spinlock_unlock (&vcm->sessions_lockp);
1577
1578   if (VPPCOM_DEBUG > 1)
1579     {
1580       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: %s "
1581                     "state 0x%x (%s), is_cut_thru %d, is_listen %d",
1582                     getpid (), vpp_handle, session_index,
1583                     is_server ? "server" : "client",
1584                     state, vppcom_session_state_str (state),
1585                     is_cut_thru, is_listen);
1586     }
1587
1588   if (PREDICT_FALSE (is_listen))
1589     {
1590       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1591                     "Cannot disconnect a listen socket!",
1592                     getpid (), vpp_handle, session_index);
1593       rv = VPPCOM_EBADFD;
1594       goto done;
1595     }
1596
1597   /* Through the VPP host stack...
1598    */
1599   else if (!is_cut_thru)
1600     {
1601       /* The peer has already initiated the close,
1602        * so send the disconnect session reply.
1603        */
1604       if (state & STATE_CLOSE_ON_EMPTY)
1605         {
1606           vppcom_send_disconnect_session_reply (vpp_handle,
1607                                                 session_index, 0 /* rv */ );
1608           if (VPPCOM_DEBUG > 1)
1609             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
1610                           "sending disconnect REPLY...",
1611                           getpid (), vpp_handle, session_index);
1612         }
1613
1614       /* Otherwise, send a disconnect session msg...
1615        */
1616       else
1617         {
1618           if (VPPCOM_DEBUG > 1)
1619             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
1620                           "sending disconnect...",
1621                           getpid (), vpp_handle, session_index);
1622
1623           vppcom_send_disconnect_session (vpp_handle, session_index);
1624         }
1625     }
1626
1627   /* Cut-thru connections...
1628    *
1629    *   server: free fifos and segment allocated during connect/redirect
1630    *   client: no cleanup required
1631    */
1632   else
1633     {
1634       if (is_server)
1635         {
1636           svm_fifo_segment_private_t *seg;
1637
1638           VCL_LOCK_AND_GET_SESSION (session_index, &session);
1639
1640           if (VPPCOM_DEBUG > 1)
1641             clib_warning ("VCL<%d>: sid %d: freeing cut-thru fifos in "
1642                           "sm_seg_index %d! "
1643                           " server_rx_fifo %p, refcnt = %d"
1644                           " server_tx_fifo %p, refcnt = %d",
1645                           getpid (), session_index, session->sm_seg_index,
1646                           session->server_rx_fifo,
1647                           session->server_rx_fifo->refcnt,
1648                           session->server_tx_fifo,
1649                           session->server_tx_fifo->refcnt);
1650
1651           seg = svm_fifo_segment_get_segment (session->sm_seg_index);
1652           svm_fifo_segment_free_fifo (seg, session->server_rx_fifo,
1653                                       FIFO_SEGMENT_RX_FREELIST);
1654           svm_fifo_segment_free_fifo (seg, session->server_tx_fifo,
1655                                       FIFO_SEGMENT_TX_FREELIST);
1656           svm_fifo_segment_delete (seg);
1657
1658           /* TBD: Send cut-thru disconnect event to client */
1659
1660           clib_spinlock_unlock (&vcm->sessions_lockp);
1661         }
1662       else
1663         {
1664           /* TBD: Send cut-thru disconnect event to server */
1665         }
1666     }
1667
1668 done:
1669   return rv;
1670 }
1671
1672 #define foreach_sock_msg                                        \
1673 _(SESSION_ENABLE_DISABLE_REPLY, session_enable_disable_reply)   \
1674 _(BIND_SOCK_REPLY, bind_sock_reply)                             \
1675 _(UNBIND_SOCK_REPLY, unbind_sock_reply)                         \
1676 _(ACCEPT_SESSION, accept_session)                               \
1677 _(CONNECT_SOCK, connect_sock)                                   \
1678 _(CONNECT_SESSION_REPLY, connect_session_reply)                 \
1679 _(DISCONNECT_SESSION, disconnect_session)                       \
1680 _(DISCONNECT_SESSION_REPLY, disconnect_session_reply)           \
1681 _(RESET_SESSION, reset_session)                                 \
1682 _(APPLICATION_ATTACH_REPLY, application_attach_reply)           \
1683 _(APPLICATION_DETACH_REPLY, application_detach_reply)           \
1684 _(MAP_ANOTHER_SEGMENT, map_another_segment)
1685
1686 static void
1687 vppcom_api_hookup (void)
1688 {
1689 #define _(N,n)                                                  \
1690     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1691                            vl_api_##n##_t_handler,              \
1692                            vl_noop_handler,                     \
1693                            vl_api_##n##_t_endian,               \
1694                            vl_api_##n##_t_print,                \
1695                            sizeof(vl_api_##n##_t), 1);
1696   foreach_sock_msg;
1697 #undef _
1698 }
1699
1700 static void
1701 vppcom_cfg_init (vppcom_cfg_t * vcl_cfg)
1702 {
1703   ASSERT (vcl_cfg);
1704
1705   vcl_cfg->heapsize = (256ULL << 20);
1706   vcl_cfg->vpp_api_q_length = 1024;
1707   vcl_cfg->segment_baseva = 0x200000000ULL;
1708   vcl_cfg->segment_size = (256 << 20);
1709   vcl_cfg->add_segment_size = (128 << 20);
1710   vcl_cfg->preallocated_fifo_pairs = 8;
1711   vcl_cfg->rx_fifo_size = (1 << 20);
1712   vcl_cfg->tx_fifo_size = (1 << 20);
1713   vcl_cfg->event_queue_size = 2048;
1714   vcl_cfg->listen_queue_size = CLIB_CACHE_LINE_BYTES / sizeof (u32);
1715   vcl_cfg->app_timeout = 10 * 60.0;
1716   vcl_cfg->session_timeout = 10 * 60.0;
1717   vcl_cfg->accept_timeout = 60.0;
1718   vcl_cfg->event_ring_size = (128 << 10);
1719   vcl_cfg->event_log_path = "/dev/shm";
1720 }
1721
1722 static void
1723 vppcom_cfg_heapsize (char *conf_fname)
1724 {
1725   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
1726   FILE *fp;
1727   char inbuf[4096];
1728   int argc = 1;
1729   char **argv = NULL;
1730   char *arg = NULL;
1731   char *p;
1732   int i;
1733   u8 *sizep;
1734   u32 size;
1735   void *vcl_mem;
1736   void *heap;
1737
1738   fp = fopen (conf_fname, "r");
1739   if (fp == NULL)
1740     {
1741       if (VPPCOM_DEBUG > 0)
1742         fprintf (stderr, "open configuration file '%s' failed\n", conf_fname);
1743       goto defaulted;
1744     }
1745   argv = calloc (1, sizeof (char *));
1746   if (argv == NULL)
1747     goto defaulted;
1748
1749   while (1)
1750     {
1751       if (fgets (inbuf, 4096, fp) == 0)
1752         break;
1753       p = strtok (inbuf, " \t\n");
1754       while (p != NULL)
1755         {
1756           if (*p == '#')
1757             break;
1758           argc++;
1759           char **tmp = realloc (argv, argc * sizeof (char *));
1760           if (tmp == NULL)
1761             goto defaulted;
1762           argv = tmp;
1763           arg = strndup (p, 1024);
1764           if (arg == NULL)
1765             goto defaulted;
1766           argv[argc - 1] = arg;
1767           p = strtok (NULL, " \t\n");
1768         }
1769     }
1770
1771   fclose (fp);
1772   fp = NULL;
1773
1774   char **tmp = realloc (argv, (argc + 1) * sizeof (char *));
1775   if (tmp == NULL)
1776     goto defaulted;
1777   argv = tmp;
1778   argv[argc] = NULL;
1779
1780   /*
1781    * Look for and parse the "heapsize" config parameter.
1782    * Manual since none of the clib infra has been bootstrapped yet.
1783    *
1784    * Format: heapsize <nn>[mM][gG]
1785    */
1786
1787   for (i = 1; i < (argc - 1); i++)
1788     {
1789       if (!strncmp (argv[i], "heapsize", 8))
1790         {
1791           sizep = (u8 *) argv[i + 1];
1792           size = 0;
1793           while (*sizep >= '0' && *sizep <= '9')
1794             {
1795               size *= 10;
1796               size += *sizep++ - '0';
1797             }
1798           if (size == 0)
1799             {
1800               if (VPPCOM_DEBUG > 0)
1801                 clib_warning ("VCL<%d>: parse error '%s %s', "
1802                               "using default heapsize %lld (0x%llx)",
1803                               getpid (), argv[i], argv[i + 1],
1804                               vcl_cfg->heapsize, vcl_cfg->heapsize);
1805               goto defaulted;
1806             }
1807
1808           if (*sizep == 'g' || *sizep == 'G')
1809             vcl_cfg->heapsize = size << 30;
1810           else if (*sizep == 'm' || *sizep == 'M')
1811             vcl_cfg->heapsize = size << 20;
1812           else
1813             {
1814               if (VPPCOM_DEBUG > 0)
1815                 clib_warning ("VCL<%d>: parse error '%s %s', "
1816                               "using default heapsize %lld (0x%llx)",
1817                               getpid (), argv[i], argv[i + 1],
1818                               vcl_cfg->heapsize, vcl_cfg->heapsize);
1819               goto defaulted;
1820             }
1821         }
1822     }
1823
1824 defaulted:
1825   if (fp != NULL)
1826     fclose (fp);
1827   if (argv != NULL)
1828     free (argv);
1829
1830   vcl_mem = mmap (0, vcl_cfg->heapsize, PROT_READ | PROT_WRITE,
1831                   MAP_SHARED | MAP_ANONYMOUS, -1, 0);
1832   if (vcl_mem == MAP_FAILED)
1833     {
1834       clib_unix_error ("VCL<%d>: ERROR: mmap(0, %lld == 0x%llx, "
1835                        "PROT_READ | PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS, "
1836                        "-1, 0) failed!",
1837                        getpid (), vcl_cfg->heapsize, vcl_cfg->heapsize);
1838       return;
1839     }
1840   heap = clib_mem_init (vcl_mem, vcl_cfg->heapsize);
1841   if (!heap)
1842     {
1843       clib_warning ("VCL<%d>: ERROR: clib_mem_init() failed!", getpid ());
1844       return;
1845     }
1846   vcl_mem = clib_mem_alloc (sizeof (_vppcom_main));
1847   if (!vcl_mem)
1848     {
1849       clib_warning ("VCL<%d>: ERROR: clib_mem_alloc() failed!", getpid ());
1850       return;
1851     }
1852
1853   clib_memcpy (vcl_mem, &_vppcom_main, sizeof (_vppcom_main));
1854   vcm = vcl_mem;
1855
1856   if (VPPCOM_DEBUG > 0)
1857     clib_warning ("VCL<%d>: allocated VCL heap = %p, size %lld (0x%llx)",
1858                   getpid (), heap, vcl_cfg->heapsize, vcl_cfg->heapsize);
1859 }
1860
1861 static void
1862 vppcom_cfg_read (char *conf_fname)
1863 {
1864   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
1865   int fd;
1866   unformat_input_t _input, *input = &_input;
1867   unformat_input_t _line_input, *line_input = &_line_input;
1868   u8 vc_cfg_input = 0;
1869   u8 *chroot_path;
1870   struct stat s;
1871   u32 uid, gid, q_len;
1872
1873   fd = open (conf_fname, O_RDONLY);
1874   if (fd < 0)
1875     {
1876       if (VPPCOM_DEBUG > 0)
1877         clib_warning ("VCL<%d>: open configuration file '%s' failed!",
1878                       getpid (), conf_fname);
1879       goto file_done;
1880     }
1881
1882   if (fstat (fd, &s) < 0)
1883     {
1884       if (VPPCOM_DEBUG > 0)
1885         clib_warning ("VCL<%d>: failed to stat `%s'", getpid (), conf_fname);
1886       goto file_done;
1887     }
1888
1889   if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
1890     {
1891       if (VPPCOM_DEBUG > 0)
1892         clib_warning ("VCL<%d>: not a regular file `%s'",
1893                       getpid (), conf_fname);
1894       goto file_done;
1895     }
1896
1897   unformat_init_clib_file (input, fd);
1898
1899   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1900     {
1901       (void) unformat_user (input, unformat_line_input, line_input);
1902       unformat_skip_white_space (line_input);
1903
1904       if (unformat (line_input, "vcl {"))
1905         {
1906           vc_cfg_input = 1;
1907           continue;
1908         }
1909
1910       if (vc_cfg_input)
1911         {
1912           if (unformat (line_input, "heapsize %s", &chroot_path))
1913             {
1914               vec_terminate_c_string (chroot_path);
1915               if (VPPCOM_DEBUG > 0)
1916                 clib_warning ("VCL<%d>: configured heapsize %s, "
1917                               "actual heapsize %lld (0x%llx)",
1918                               getpid (), chroot_path, vcl_cfg->heapsize,
1919                               vcl_cfg->heapsize);
1920               vec_free (chroot_path);
1921             }
1922           else if (unformat (line_input, "api-prefix %s", &chroot_path))
1923             {
1924               vec_terminate_c_string (chroot_path);
1925               vl_set_memory_root_path ((char *) chroot_path);
1926               if (VPPCOM_DEBUG > 0)
1927                 clib_warning ("VCL<%d>: configured api-prefix %s",
1928                               getpid (), chroot_path);
1929               chroot_path = 0;  /* Don't vec_free() it! */
1930             }
1931           else if (unformat (line_input, "vpp-api-q-length %d", &q_len))
1932             {
1933               if (q_len < vcl_cfg->vpp_api_q_length)
1934                 {
1935                   clib_warning ("VCL<%d>: ERROR: configured vpp-api-q-length "
1936                                 "(%u) is too small! Using default: %u ",
1937                                 getpid (), q_len, vcl_cfg->vpp_api_q_length);
1938                 }
1939               else
1940                 {
1941                   vcl_cfg->vpp_api_q_length = q_len;
1942
1943                   if (VPPCOM_DEBUG > 0)
1944                     clib_warning ("VCL<%d>: configured vpp-api-q-length %u",
1945                                   getpid (), vcl_cfg->vpp_api_q_length);
1946                 }
1947             }
1948           else if (unformat (line_input, "uid %d", &uid))
1949             {
1950               vl_set_memory_uid (uid);
1951               if (VPPCOM_DEBUG > 0)
1952                 clib_warning ("VCL<%d>: configured uid %d", getpid (), uid);
1953             }
1954           else if (unformat (line_input, "gid %d", &gid))
1955             {
1956               vl_set_memory_gid (gid);
1957               if (VPPCOM_DEBUG > 0)
1958                 clib_warning ("VCL<%d>: configured gid %d", getpid (), gid);
1959             }
1960           else if (unformat (line_input, "segment-baseva 0x%lx",
1961                              &vcl_cfg->segment_baseva))
1962             {
1963               if (VPPCOM_DEBUG > 0)
1964                 clib_warning ("VCL<%d>: configured segment_baseva 0x%lx",
1965                               getpid (), vcl_cfg->segment_baseva);
1966             }
1967           else if (unformat (line_input, "segment-size 0x%lx",
1968                              &vcl_cfg->segment_size))
1969             {
1970               if (VPPCOM_DEBUG > 0)
1971                 clib_warning ("VCL<%d>: configured segment_size 0x%lx (%ld)",
1972                               getpid (), vcl_cfg->segment_size,
1973                               vcl_cfg->segment_size);
1974             }
1975           else if (unformat (line_input, "segment-size %ld",
1976                              &vcl_cfg->segment_size))
1977             {
1978               if (VPPCOM_DEBUG > 0)
1979                 clib_warning ("VCL<%d>: configured segment_size %ld (0x%lx)",
1980                               getpid (), vcl_cfg->segment_size,
1981                               vcl_cfg->segment_size);
1982             }
1983           else if (unformat (line_input, "add-segment-size 0x%lx",
1984                              &vcl_cfg->add_segment_size))
1985             {
1986               if (VPPCOM_DEBUG > 0)
1987                 clib_warning
1988                   ("VCL<%d>: configured add_segment_size 0x%lx (%ld)",
1989                    getpid (), vcl_cfg->add_segment_size,
1990                    vcl_cfg->add_segment_size);
1991             }
1992           else if (unformat (line_input, "add-segment-size %ld",
1993                              &vcl_cfg->add_segment_size))
1994             {
1995               if (VPPCOM_DEBUG > 0)
1996                 clib_warning
1997                   ("VCL<%d>: configured add_segment_size %ld (0x%lx)",
1998                    getpid (), vcl_cfg->add_segment_size,
1999                    vcl_cfg->add_segment_size);
2000             }
2001           else if (unformat (line_input, "preallocated-fifo-pairs %d",
2002                              &vcl_cfg->preallocated_fifo_pairs))
2003             {
2004               if (VPPCOM_DEBUG > 0)
2005                 clib_warning ("VCL<%d>: configured preallocated_fifo_pairs "
2006                               "%d (0x%x)", getpid (),
2007                               vcl_cfg->preallocated_fifo_pairs,
2008                               vcl_cfg->preallocated_fifo_pairs);
2009             }
2010           else if (unformat (line_input, "rx-fifo-size 0x%lx",
2011                              &vcl_cfg->rx_fifo_size))
2012             {
2013               if (VPPCOM_DEBUG > 0)
2014                 clib_warning ("VCL<%d>: configured rx_fifo_size 0x%lx (%ld)",
2015                               getpid (), vcl_cfg->rx_fifo_size,
2016                               vcl_cfg->rx_fifo_size);
2017             }
2018           else if (unformat (line_input, "rx-fifo-size %ld",
2019                              &vcl_cfg->rx_fifo_size))
2020             {
2021               if (VPPCOM_DEBUG > 0)
2022                 clib_warning ("VCL<%d>: configured rx_fifo_size %ld (0x%lx)",
2023                               getpid (), vcl_cfg->rx_fifo_size,
2024                               vcl_cfg->rx_fifo_size);
2025             }
2026           else if (unformat (line_input, "tx-fifo-size 0x%lx",
2027                              &vcl_cfg->tx_fifo_size))
2028             {
2029               if (VPPCOM_DEBUG > 0)
2030                 clib_warning ("VCL<%d>: configured tx_fifo_size 0x%lx (%ld)",
2031                               getpid (), vcl_cfg->tx_fifo_size,
2032                               vcl_cfg->tx_fifo_size);
2033             }
2034           else if (unformat (line_input, "tx-fifo-size %ld",
2035                              &vcl_cfg->tx_fifo_size))
2036             {
2037               if (VPPCOM_DEBUG > 0)
2038                 clib_warning ("VCL<%d>: configured tx_fifo_size %ld (0x%lx)",
2039                               getpid (), vcl_cfg->tx_fifo_size,
2040                               vcl_cfg->tx_fifo_size);
2041             }
2042           else if (unformat (line_input, "event-queue-size 0x%lx",
2043                              &vcl_cfg->event_queue_size))
2044             {
2045               if (VPPCOM_DEBUG > 0)
2046                 clib_warning ("VCL<%d>: configured event_queue_size "
2047                               "0x%lx (%ld)",
2048                               getpid (), vcl_cfg->event_queue_size,
2049                               vcl_cfg->event_queue_size);
2050             }
2051           else if (unformat (line_input, "event-queue-size %ld",
2052                              &vcl_cfg->event_queue_size))
2053             {
2054               if (VPPCOM_DEBUG > 0)
2055                 clib_warning ("VCL<%d>: configured event_queue_size "
2056                               "%ld (0x%lx)",
2057                               getpid (), vcl_cfg->event_queue_size,
2058                               vcl_cfg->event_queue_size);
2059             }
2060           else if (unformat (line_input, "listen-queue-size 0x%lx",
2061                              &vcl_cfg->listen_queue_size))
2062             {
2063               if (VPPCOM_DEBUG > 0)
2064                 clib_warning ("VCL<%d>: configured listen_queue_size "
2065                               "0x%lx (%ld)",
2066                               getpid (), vcl_cfg->listen_queue_size,
2067                               vcl_cfg->listen_queue_size);
2068             }
2069           else if (unformat (line_input, "listen-queue-size %ld",
2070                              &vcl_cfg->listen_queue_size))
2071             {
2072               if (VPPCOM_DEBUG > 0)
2073                 clib_warning ("VCL<%d>: configured listen_queue_size "
2074                               "%ld (0x%lx)",
2075                               getpid (), vcl_cfg->listen_queue_size,
2076                               vcl_cfg->listen_queue_size);
2077             }
2078           else if (unformat (line_input, "app-timeout %f",
2079                              &vcl_cfg->app_timeout))
2080             {
2081               if (VPPCOM_DEBUG > 0)
2082                 clib_warning ("VCL<%d>: configured app_timeout %f",
2083                               getpid (), vcl_cfg->app_timeout);
2084             }
2085           else if (unformat (line_input, "session-timeout %f",
2086                              &vcl_cfg->session_timeout))
2087             {
2088               if (VPPCOM_DEBUG > 0)
2089                 clib_warning ("VCL<%d>: configured session_timeout %f",
2090                               getpid (), vcl_cfg->session_timeout);
2091             }
2092           else if (unformat (line_input, "accept-timeout %f",
2093                              &vcl_cfg->accept_timeout))
2094             {
2095               if (VPPCOM_DEBUG > 0)
2096                 clib_warning ("VCL<%d>: configured accept_timeout %f",
2097                               getpid (), vcl_cfg->accept_timeout);
2098             }
2099           else if (unformat (line_input, "app-proxy-transport-tcp"))
2100             {
2101               vcl_cfg->app_proxy_transport_tcp = 1;
2102               if (VPPCOM_DEBUG > 0)
2103                 clib_warning ("VCL<%d>: configured "
2104                               "app_proxy_transport_tcp (%d)",
2105                               getpid (), vcl_cfg->app_proxy_transport_tcp);
2106             }
2107           else if (unformat (line_input, "app-proxy-transport-udp"))
2108             {
2109               vcl_cfg->app_proxy_transport_udp = 1;
2110               if (VPPCOM_DEBUG > 0)
2111                 clib_warning ("VCL<%d>: configured "
2112                               "app_proxy_transport_udp (%d)",
2113                               getpid (), vcl_cfg->app_proxy_transport_udp);
2114             }
2115           else if (unformat (line_input, "app-scope-local"))
2116             {
2117               vcl_cfg->app_scope_local = 1;
2118               if (VPPCOM_DEBUG > 0)
2119                 clib_warning ("VCL<%d>: configured app_scope_local (%d)",
2120                               getpid (), vcl_cfg->app_scope_local);
2121             }
2122           else if (unformat (line_input, "app-scope-global"))
2123             {
2124               vcl_cfg->app_scope_global = 1;
2125               if (VPPCOM_DEBUG > 0)
2126                 clib_warning ("VCL<%d>: configured app_scope_global (%d)",
2127                               getpid (), vcl_cfg->app_scope_global);
2128             }
2129           else if (unformat (line_input, "namespace-secret %lu",
2130                              &vcl_cfg->namespace_secret))
2131             {
2132               if (VPPCOM_DEBUG > 0)
2133                 clib_warning
2134                   ("VCL<%d>: configured namespace_secret %lu (0x%lx)",
2135                    getpid (), vcl_cfg->namespace_secret,
2136                    vcl_cfg->namespace_secret);
2137             }
2138           else if (unformat (line_input, "namespace-id %v",
2139                              &vcl_cfg->namespace_id))
2140             {
2141               vl_api_application_attach_t *mp;
2142               u32 max_nsid_vec_len = sizeof (mp->namespace_id) - 1;
2143               u32 nsid_vec_len = vec_len (vcl_cfg->namespace_id);
2144               if (nsid_vec_len > max_nsid_vec_len)
2145                 {
2146                   _vec_len (vcl_cfg->namespace_id) = max_nsid_vec_len;
2147                   if (VPPCOM_DEBUG > 0)
2148                     clib_warning ("VCL<%d>: configured namespace_id is "
2149                                   "too long, truncated to %d characters!",
2150                                   getpid (), max_nsid_vec_len);
2151                 }
2152
2153               if (VPPCOM_DEBUG > 0)
2154                 clib_warning ("VCL<%d>: configured namespace_id %v",
2155                               getpid (), vcl_cfg->namespace_id);
2156             }
2157           else if (unformat (line_input, "}"))
2158             {
2159               vc_cfg_input = 0;
2160               if (VPPCOM_DEBUG > 0)
2161                 clib_warning ("VCL<%d>: completed parsing vppcom config!",
2162                               getpid ());
2163               goto input_done;
2164             }
2165           else
2166             {
2167               if (line_input->buffer[line_input->index] != '#')
2168                 {
2169                   clib_warning ("VCL<%d>: Unknown vppcom config option: '%s'",
2170                                 getpid (), (char *)
2171                                 &line_input->buffer[line_input->index]);
2172                 }
2173             }
2174         }
2175     }
2176
2177 input_done:
2178   unformat_free (input);
2179
2180 file_done:
2181   if (fd >= 0)
2182     close (fd);
2183 }
2184
2185 /*
2186  * VPPCOM Public API functions
2187  */
2188 int
2189 vppcom_app_create (char *app_name)
2190 {
2191   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
2192   u8 *heap;
2193   mheap_t *h;
2194   int rv;
2195
2196   if (!vcm->init)
2197     {
2198       char *conf_fname;
2199       char *env_var_str;
2200
2201       vcm->init = 1;
2202       vppcom_cfg_init (vcl_cfg);
2203       env_var_str = getenv (VPPCOM_ENV_DEBUG);
2204       if (env_var_str)
2205         {
2206           u32 tmp;
2207           if (sscanf (env_var_str, "%u", &tmp) != 1)
2208             clib_warning ("VCL<%d>: Invalid debug level specified in "
2209                           "the environment variable "
2210                           VPPCOM_ENV_DEBUG
2211                           " (%s)!\n", getpid (), env_var_str);
2212           else
2213             {
2214               vcm->debug = tmp;
2215               clib_warning ("VCL<%d>: configured VCL debug level (%u) from "
2216                             VPPCOM_ENV_DEBUG "!", getpid (), vcm->debug);
2217             }
2218         }
2219       conf_fname = getenv (VPPCOM_ENV_CONF);
2220       if (!conf_fname)
2221         {
2222           conf_fname = VPPCOM_CONF_DEFAULT;
2223           if (VPPCOM_DEBUG > 0)
2224             clib_warning ("VCL<%d>: getenv '%s' failed!", getpid (),
2225                           VPPCOM_ENV_CONF);
2226         }
2227       vppcom_cfg_heapsize (conf_fname);
2228       clib_fifo_validate (vcm->client_session_index_fifo,
2229                           vcm->cfg.listen_queue_size);
2230       vppcom_cfg_read (conf_fname);
2231       env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_ID);
2232       if (env_var_str)
2233         {
2234           u32 ns_id_vec_len = strlen (env_var_str);
2235
2236           vec_reset_length (vcm->cfg.namespace_id);
2237           vec_validate (vcm->cfg.namespace_id, ns_id_vec_len - 1);
2238           clib_memcpy (vcm->cfg.namespace_id, env_var_str, ns_id_vec_len);
2239
2240           if (VPPCOM_DEBUG > 0)
2241             clib_warning ("VCL<%d>: configured namespace_id (%v) from "
2242                           VPPCOM_ENV_APP_NAMESPACE_ID "!", getpid (),
2243                           vcm->cfg.namespace_id);
2244         }
2245       env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_SECRET);
2246       if (env_var_str)
2247         {
2248           u64 tmp;
2249           if (sscanf (env_var_str, "%lu", &tmp) != 1)
2250             clib_warning ("VCL<%d>: Invalid namespace secret specified in "
2251                           "the environment variable "
2252                           VPPCOM_ENV_APP_NAMESPACE_SECRET
2253                           " (%s)!\n", getpid (), env_var_str);
2254           else
2255             {
2256               vcm->cfg.namespace_secret = tmp;
2257               if (VPPCOM_DEBUG > 0)
2258                 clib_warning ("VCL<%d>: configured namespace secret "
2259                               "(%lu) from " VPPCOM_ENV_APP_NAMESPACE_ID "!",
2260                               getpid (), vcm->cfg.namespace_secret);
2261             }
2262         }
2263       if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP))
2264         {
2265           vcm->cfg.app_proxy_transport_tcp = 1;
2266           if (VPPCOM_DEBUG > 0)
2267             clib_warning ("VCL<%d>: configured app_proxy_transport_tcp "
2268                           "(%u) from " VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP
2269                           "!", getpid (), vcm->cfg.app_proxy_transport_tcp);
2270         }
2271       if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP))
2272         {
2273           vcm->cfg.app_proxy_transport_udp = 1;
2274           if (VPPCOM_DEBUG > 0)
2275             clib_warning ("VCL<%d>: configured app_proxy_transport_udp "
2276                           "(%u) from " VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP
2277                           "!", getpid (), vcm->cfg.app_proxy_transport_udp);
2278         }
2279       if (getenv (VPPCOM_ENV_APP_SCOPE_LOCAL))
2280         {
2281           vcm->cfg.app_scope_local = 1;
2282           if (VPPCOM_DEBUG > 0)
2283             clib_warning ("VCL<%d>: configured app_scope_local (%u) from "
2284                           VPPCOM_ENV_APP_SCOPE_LOCAL "!", getpid (),
2285                           vcm->cfg.app_scope_local);
2286         }
2287       if (getenv (VPPCOM_ENV_APP_SCOPE_GLOBAL))
2288         {
2289           vcm->cfg.app_scope_global = 1;
2290           if (VPPCOM_DEBUG > 0)
2291             clib_warning ("VCL<%d>: configured app_scope_global (%u) from "
2292                           VPPCOM_ENV_APP_SCOPE_GLOBAL "!", getpid (),
2293                           vcm->cfg.app_scope_global);
2294         }
2295
2296       vcm->main_cpu = os_get_thread_index ();
2297       heap = clib_mem_get_per_cpu_heap ();
2298       h = mheap_header (heap);
2299
2300       /* make the main heap thread-safe */
2301       h->flags |= MHEAP_FLAG_THREAD_SAFE;
2302
2303       vcm->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
2304
2305       clib_time_init (&vcm->clib_time);
2306       vppcom_init_error_string_table ();
2307       svm_fifo_segment_main_init (vcl_cfg->segment_baseva,
2308                                   20 /* timeout in secs */ );
2309       clib_spinlock_init (&vcm->sessions_lockp);
2310     }
2311
2312   if (vcm->my_client_index == ~0)
2313     {
2314       vppcom_api_hookup ();
2315       vcm->app_state = STATE_APP_START;
2316       rv = vppcom_connect_to_vpp (app_name);
2317       if (rv)
2318         {
2319           clib_warning ("VCL<%d>: ERROR: couldn't connect to VPP!",
2320                         getpid ());
2321           return rv;
2322         }
2323
2324       if (VPPCOM_DEBUG > 0)
2325         clib_warning ("VCL<%d>: sending session enable", getpid ());
2326
2327       rv = vppcom_app_session_enable ();
2328       if (rv)
2329         {
2330           clib_warning ("VCL<%d>: ERROR: vppcom_app_session_enable() "
2331                         "failed!", getpid ());
2332           return rv;
2333         }
2334
2335       if (VPPCOM_DEBUG > 0)
2336         clib_warning ("VCL<%d>: sending app attach", getpid ());
2337
2338       rv = vppcom_app_attach ();
2339       if (rv)
2340         {
2341           clib_warning ("VCL<%d>: ERROR: vppcom_app_attach() failed!",
2342                         getpid ());
2343           return rv;
2344         }
2345
2346       if (VPPCOM_DEBUG > 0)
2347         clib_warning ("VCL<%d>: app_name '%s', my_client_index %d (0x%x)",
2348                       getpid (), app_name, vcm->my_client_index,
2349                       vcm->my_client_index);
2350     }
2351
2352   return VPPCOM_OK;
2353 }
2354
2355 void
2356 vppcom_app_destroy (void)
2357 {
2358   int rv;
2359
2360   if (vcm->my_client_index == ~0)
2361     return;
2362
2363   if (VPPCOM_DEBUG > 0)
2364     clib_warning ("VCL<%d>: detaching from VPP, my_client_index %d (0x%x)",
2365                   getpid (), vcm->my_client_index, vcm->my_client_index);
2366
2367   if (VPPCOM_DEBUG > 0)
2368     {
2369       /* *INDENT-OFF* */
2370       ELOG_TYPE_DECLARE (e) =
2371       {
2372         .format = "app_detach:C:%d",
2373         .format_args = "i4",
2374       };
2375
2376       struct
2377       {
2378         u32 data;
2379       } *ed;
2380       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
2381       ed->data = vcm->my_client_index;
2382       /* *INDENT-ON* */
2383     }
2384
2385   vppcom_app_detach ();
2386   rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
2387   if (PREDICT_FALSE (rv))
2388     {
2389       if (VPPCOM_DEBUG > 0)
2390         clib_warning ("VCL<%d>: application detach timed out! "
2391                       "returning %d (%s)",
2392                       getpid (), rv, vppcom_retval_str (rv));
2393     }
2394
2395   /* Finished with logging before client gets reset to ~0 */
2396   if (VPPCOM_DEBUG > 0)
2397     write_elog ();
2398
2399   vl_client_disconnect_from_vlib ();
2400   vcm->my_client_index = ~0;
2401   vcm->app_state = STATE_APP_START;
2402 }
2403
2404 int
2405 vppcom_session_create (u32 vrf, u8 proto, u8 is_nonblocking)
2406 {
2407   session_t *session;
2408   u32 session_index;
2409
2410   clib_spinlock_lock (&vcm->sessions_lockp);
2411   pool_get (vcm->sessions, session);
2412   memset (session, 0, sizeof (*session));
2413   session_index = session - vcm->sessions;
2414
2415   session->vrf = vrf;
2416   session->proto = proto;
2417   session->state = STATE_START;
2418   session->is_nonblocking = is_nonblocking ? 1 : 0;
2419   session->vpp_handle = ~0;
2420   clib_spinlock_unlock (&vcm->sessions_lockp);
2421
2422   if (VPPCOM_DEBUG > 0)
2423     clib_warning ("VCL<%d>: sid %u", getpid (), session_index);
2424
2425   if (VPPCOM_DEBUG > 0)
2426     {
2427       session->elog_track.name =
2428         (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
2429                          session_index, 0);
2430       elog_track_register (&vcm->elog_main, &session->elog_track);
2431
2432       /* *INDENT-OFF* */
2433       ELOG_TYPE_DECLARE (e) =
2434       {
2435         .format = "session_create:vrf:%d proto:%d state:%d is_nonblocking:%d",
2436         .format_args = "i4i4i4i4",
2437       };
2438
2439       struct
2440       {
2441         u32 data[4];
2442       } *ed;
2443
2444       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
2445       ed->data[0] = session->vrf;
2446       ed->data[1] = session->proto;
2447       ed->data[2] = session->state;
2448       ed->data[3] = session->is_nonblocking;
2449       /* *INDENT-ON* */
2450     }
2451
2452   return (int) session_index;
2453 }
2454
2455 int
2456 vppcom_session_close (uint32_t session_index)
2457 {
2458   session_t *session = 0;
2459   int rv;
2460   u8 is_listen;
2461   u8 is_vep;
2462   u8 is_vep_session;
2463   u32 next_sid;
2464   u32 vep_idx;
2465   u64 vpp_handle;
2466   uword *p;
2467   session_state_t state;
2468
2469   VCL_LOCK_AND_GET_SESSION (session_index, &session);
2470   is_listen = session->is_listen;
2471   is_vep = session->is_vep;
2472   is_vep_session = session->is_vep_session;
2473   next_sid = session->vep.next_sid;
2474   vep_idx = session->vep.vep_idx;
2475   state = session->state;
2476   vpp_handle = session->vpp_handle;
2477   clib_spinlock_unlock (&vcm->sessions_lockp);
2478
2479   if (VPPCOM_DEBUG > 0)
2480     {
2481       if (is_vep)
2482         clib_warning ("VCL<%d>: vep_idx %u / sid %u: "
2483                       "closing epoll session...",
2484                       getpid (), session_index, session_index);
2485       else
2486         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %d: "
2487                       "closing session...",
2488                       getpid (), vpp_handle, session_index);
2489     }
2490
2491   if (is_vep)
2492     {
2493       while (next_sid != ~0)
2494         {
2495           rv = vppcom_epoll_ctl (session_index, EPOLL_CTL_DEL, next_sid, 0);
2496           if ((VPPCOM_DEBUG > 0) && PREDICT_FALSE (rv < 0))
2497             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
2498                           "EPOLL_CTL_DEL vep_idx %u failed! rv %d (%s)",
2499                           getpid (), vpp_handle, next_sid, vep_idx,
2500                           rv, vppcom_retval_str (rv));
2501
2502           VCL_LOCK_AND_GET_SESSION (session_index, &session);
2503           next_sid = session->vep.next_sid;
2504           clib_spinlock_unlock (&vcm->sessions_lockp);
2505         }
2506     }
2507   else
2508     {
2509       if (is_vep_session)
2510         {
2511           rv = vppcom_epoll_ctl (vep_idx, EPOLL_CTL_DEL, session_index, 0);
2512           if ((VPPCOM_DEBUG > 0) && (rv < 0))
2513             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
2514                           "EPOLL_CTL_DEL vep_idx %u failed! rv %d (%s)",
2515                           getpid (), vpp_handle, session_index,
2516                           vep_idx, rv, vppcom_retval_str (rv));
2517         }
2518
2519       if (is_listen)
2520         {
2521           if (state == STATE_LISTEN)
2522             {
2523               rv = vppcom_session_unbind (session_index);
2524               if (PREDICT_FALSE (rv < 0))
2525                 {
2526                   if (VPPCOM_DEBUG > 0)
2527                     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
2528                                   "listener unbind failed! rv %d (%s)",
2529                                   getpid (), vpp_handle, session_index,
2530                                   rv, vppcom_retval_str (rv));
2531                 }
2532             }
2533         }
2534
2535       else if (state & (CLIENT_STATE_OPEN | SERVER_STATE_OPEN))
2536         {
2537           rv = vppcom_session_disconnect (session_index);
2538           if (PREDICT_FALSE (rv < 0))
2539             clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
2540                           "session disconnect failed! rv %d (%s)",
2541                           getpid (), vpp_handle, session_index,
2542                           rv, vppcom_retval_str (rv));
2543         }
2544     }
2545
2546   VCL_LOCK_AND_GET_SESSION (session_index, &session);
2547   vpp_handle = session->vpp_handle;
2548   if (vpp_handle != ~0)
2549     {
2550       p = hash_get (vcm->session_index_by_vpp_handles, vpp_handle);
2551       if (p)
2552         hash_unset (vcm->session_index_by_vpp_handles, vpp_handle);
2553     }
2554   pool_put_index (vcm->sessions, session_index);
2555   clib_spinlock_unlock (&vcm->sessions_lockp);
2556
2557   if (VPPCOM_DEBUG > 0)
2558     {
2559       if (is_vep)
2560         clib_warning ("VCL<%d>: vep_idx %u / sid %u: epoll session removed.",
2561                       getpid (), session_index, session_index);
2562       else
2563         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: session removed.",
2564                       getpid (), vpp_handle, session_index);
2565     }
2566 done:
2567
2568   if (VPPCOM_DEBUG > 0)
2569     {
2570       /* *INDENT-OFF* */
2571       ELOG_TYPE_DECLARE (e) =
2572       {
2573         .format = "session_close:rv:%d",
2574         .format_args = "i4",
2575       };
2576
2577       struct
2578       {
2579         u32 data;
2580       } *ed;
2581
2582       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
2583       ed->data = rv;
2584       /* *INDENT-ON* */
2585     }
2586
2587   return rv;
2588 }
2589
2590 int
2591 vppcom_session_bind (uint32_t session_index, vppcom_endpt_t * ep)
2592 {
2593   session_t *session = 0;
2594   int rv;
2595
2596   if (!ep || !ep->ip)
2597     return VPPCOM_EINVAL;
2598
2599   VCL_LOCK_AND_GET_SESSION (session_index, &session);
2600
2601   if (session->is_vep)
2602     {
2603       clib_spinlock_unlock (&vcm->sessions_lockp);
2604       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
2605                     "bind to an epoll session!", getpid (), session_index);
2606       rv = VPPCOM_EBADFD;
2607       goto done;
2608     }
2609
2610   session->vrf = ep->vrf;
2611   session->lcl_addr.is_ip4 = ep->is_ip4;
2612   session->lcl_addr.ip46 = to_ip46 (!ep->is_ip4, ep->ip);
2613   session->lcl_port = ep->port;
2614
2615   if (VPPCOM_DEBUG > 0)
2616     clib_warning ("VCL<%d>: sid %u: binding to local %s address %U "
2617                   "port %u, proto %s", getpid (), session_index,
2618                   session->lcl_addr.is_ip4 ? "IPv4" : "IPv6",
2619                   format_ip46_address, &session->lcl_addr.ip46,
2620                   session->lcl_addr.is_ip4,
2621                   clib_net_to_host_u16 (session->lcl_port),
2622                   session->proto ? "UDP" : "TCP");
2623
2624   if (VPPCOM_DEBUG > 0)
2625     {
2626       if (session->lcl_addr.is_ip4)
2627         {
2628           /* *INDENT-OFF* */
2629           ELOG_TYPE_DECLARE (e) =
2630           {
2631             .format = "bind local:%s:%d.%d.%d.%d:%d ",
2632             .format_args = "t1i1i1i1i1i2",
2633             .n_enum_strings = 2,
2634             .enum_strings = {"TCP", "UDP",},
2635           };
2636
2637           CLIB_PACKED (struct {
2638             u8 proto;
2639             u8 addr[4];
2640             u16 port;
2641           }) * ed;
2642
2643           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
2644           ed->proto = session->proto;
2645           ed->addr[0] = session->lcl_addr.ip46.ip4.as_u8[0];
2646           ed->addr[1] = session->lcl_addr.ip46.ip4.as_u8[1];
2647           ed->addr[2] = session->lcl_addr.ip46.ip4.as_u8[2];
2648           ed->addr[3] = session->lcl_addr.ip46.ip4.as_u8[3];
2649           ed->port = clib_net_to_host_u16 (session->lcl_port);
2650           /* *INDENT-ON* */
2651         }
2652     }
2653
2654   clib_spinlock_unlock (&vcm->sessions_lockp);
2655 done:
2656   return rv;
2657 }
2658
2659 int
2660 vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len)
2661 {
2662   session_t *listen_session = 0;
2663   u64 listen_vpp_handle;
2664   int rv, retval;
2665
2666   VCL_LOCK_AND_GET_SESSION (listen_session_index, &listen_session);
2667
2668   if (listen_session->is_vep)
2669     {
2670       clib_spinlock_unlock (&vcm->sessions_lockp);
2671       clib_warning ("VCL<%d>: ERROR: sid %u: cannot listen on an "
2672                     "epoll session!", getpid (), listen_session_index);
2673       rv = VPPCOM_EBADFD;
2674       goto done;
2675     }
2676
2677   listen_vpp_handle = listen_session->vpp_handle;
2678   if (listen_session->is_listen)
2679     {
2680       clib_spinlock_unlock (&vcm->sessions_lockp);
2681       if (VPPCOM_DEBUG > 0)
2682         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
2683                       "already in listen state!",
2684                       getpid (), listen_vpp_handle, listen_session_index);
2685       rv = VPPCOM_OK;
2686       goto done;
2687     }
2688
2689   if (VPPCOM_DEBUG > 0)
2690     clib_warning ("VCL<%d>: vpp handle 0x%llx, "
2691                   "sid %u: sending bind request...",
2692                   getpid (), listen_vpp_handle, listen_session_index);
2693
2694   vppcom_send_bind_sock (listen_session, listen_session_index);
2695   clib_spinlock_unlock (&vcm->sessions_lockp);
2696   retval =
2697     vppcom_wait_for_session_state_change (listen_session_index, STATE_LISTEN,
2698                                           vcm->cfg.session_timeout);
2699
2700   VCL_LOCK_AND_GET_SESSION (listen_session_index, &listen_session);
2701   if (PREDICT_FALSE (retval))
2702     {
2703       if (VPPCOM_DEBUG > 0)
2704         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: bind failed! "
2705                       "returning %d (%s)", getpid (),
2706                       listen_session->vpp_handle, listen_session_index,
2707                       retval, vppcom_retval_str (retval));
2708       clib_spinlock_unlock (&vcm->sessions_lockp);
2709       rv = retval;
2710       goto done;
2711     }
2712
2713   clib_fifo_validate (vcm->client_session_index_fifo, q_len);
2714   clib_spinlock_unlock (&vcm->sessions_lockp);
2715 done:
2716   return rv;
2717 }
2718
2719 int
2720 vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep,
2721                        uint32_t flags)
2722 {
2723   session_t *listen_session = 0;
2724   session_t *client_session = 0;
2725   u32 client_session_index = ~0, n_fifos;
2726   int rv;
2727   f64 wait_for;
2728   char *cut_thru_str;
2729   u64 listen_vpp_handle;
2730
2731   VCL_LOCK_AND_GET_SESSION (listen_session_index, &listen_session);
2732
2733   if (listen_session->is_vep)
2734     {
2735       clib_spinlock_unlock (&vcm->sessions_lockp);
2736       clib_warning ("VCL<%d>: ERROR: sid %u: cannot accept on an "
2737                     "epoll session!", getpid (), listen_session_index);
2738       rv = VPPCOM_EBADFD;
2739       goto done;
2740     }
2741
2742   listen_vpp_handle = listen_session->vpp_handle;
2743   if (listen_session->state != STATE_LISTEN)
2744     {
2745       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
2746                     "not in listen state! state 0x%x (%s)", getpid (),
2747                     listen_vpp_handle, listen_session_index,
2748                     listen_session->state,
2749                     vppcom_session_state_str (listen_session->state));
2750       clib_spinlock_unlock (&vcm->sessions_lockp);
2751       rv = VPPCOM_EBADFD;
2752       goto done;
2753     }
2754   wait_for = (listen_session->is_nonblocking) ? 0 : vcm->cfg.accept_timeout;
2755
2756   clib_spinlock_unlock (&vcm->sessions_lockp);
2757
2758   while (1)
2759     {
2760       rv = vppcom_wait_for_client_session_index (wait_for);
2761       if (rv)
2762         {
2763           if ((VPPCOM_DEBUG > 0))
2764             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
2765                           "accept failed! returning %d (%s)", getpid (),
2766                           listen_vpp_handle, listen_session_index,
2767                           rv, vppcom_retval_str (rv));
2768           if (wait_for == 0)
2769             goto done;
2770         }
2771       else
2772         break;
2773     }
2774
2775   clib_spinlock_lock (&vcm->sessions_lockp);
2776   clib_fifo_sub1 (vcm->client_session_index_fifo, client_session_index);
2777   rv = vppcom_session_at_index (client_session_index, &client_session);
2778   if (PREDICT_FALSE (rv))
2779     {
2780       rv = VPPCOM_ECONNABORTED;
2781       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: client sid %u "
2782                     "lookup failed! returning %d (%s)", getpid (),
2783                     listen_vpp_handle, listen_session_index,
2784                     client_session_index, rv, vppcom_retval_str (rv));
2785       goto done;
2786     }
2787
2788   client_session->is_nonblocking = (flags & O_NONBLOCK) ? 1 : 0;
2789   if (VPPCOM_DEBUG > 0)
2790     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: Got a client request! "
2791                   "vpp handle 0x%llx, sid %u, flags %d, is_nonblocking %u",
2792                   getpid (), listen_vpp_handle, listen_session_index,
2793                   client_session->vpp_handle, client_session_index,
2794                   flags, client_session->is_nonblocking);
2795
2796   if (ep)
2797     {
2798       ep->vrf = client_session->vrf;
2799       ep->is_cut_thru = client_session->is_cut_thru;
2800       ep->is_ip4 = client_session->peer_addr.is_ip4;
2801       ep->port = client_session->peer_port;
2802       if (client_session->peer_addr.is_ip4)
2803         clib_memcpy (ep->ip, &client_session->peer_addr.ip46.ip4,
2804                      sizeof (ip4_address_t));
2805       else
2806         clib_memcpy (ep->ip, &client_session->peer_addr.ip46.ip6,
2807                      sizeof (ip6_address_t));
2808     }
2809
2810   if (client_session->is_server && client_session->is_cut_thru)
2811     {
2812       static svm_fifo_segment_create_args_t _a;
2813       svm_fifo_segment_create_args_t *a = &_a;
2814       svm_fifo_segment_private_t *seg;
2815
2816       cut_thru_str = " cut-thru ";
2817
2818       /* Create the segment */
2819       memset (a, 0, sizeof (*a));
2820       a->segment_name = (char *)
2821         format ((u8 *) a->segment_name, "%d:segment%d%c",
2822                 getpid (), vcm->unique_segment_index++, 0);
2823       a->segment_size = vcm->cfg.segment_size;
2824
2825       rv = svm_fifo_segment_create (a);
2826       if (PREDICT_FALSE (rv))
2827         {
2828           clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
2829                         "client sid %u svm_fifo_segment_create ('%s') "
2830                         "failed! rv %d", getpid (), listen_vpp_handle,
2831                         listen_session_index, client_session_index,
2832                         a->segment_name, rv);
2833           vec_reset_length (a->new_segment_indices);
2834           rv = VNET_API_ERROR_URI_FIFO_CREATE_FAILED;
2835           vppcom_send_connect_session_reply (client_session,
2836                                              client_session_index,
2837                                              client_session->vpp_handle,
2838                                              client_session->client_context,
2839                                              rv);
2840           clib_spinlock_unlock (&vcm->sessions_lockp);
2841           rv = VPPCOM_ENOMEM;
2842           goto done;
2843         }
2844
2845       client_session->segment_name = vec_dup ((u8 *) a->segment_name);
2846       client_session->sm_seg_index = a->new_segment_indices[0];
2847       vec_free (a->new_segment_indices);
2848
2849       seg = svm_fifo_segment_get_segment (client_session->sm_seg_index);
2850       if (vcm->cfg.preallocated_fifo_pairs)
2851         {
2852           n_fifos = vcm->cfg.preallocated_fifo_pairs;
2853           svm_fifo_segment_preallocate_fifo_pairs (seg, vcm->cfg.rx_fifo_size,
2854                                                    vcm->cfg.tx_fifo_size,
2855                                                    &n_fifos);
2856         }
2857
2858       client_session->server_rx_fifo =
2859         svm_fifo_segment_alloc_fifo (seg, vcm->cfg.rx_fifo_size,
2860                                      FIFO_SEGMENT_RX_FREELIST);
2861       if (PREDICT_FALSE (!client_session->server_rx_fifo))
2862         {
2863           svm_fifo_segment_delete (seg);
2864           clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
2865                         "client sid %u rx fifo alloc failed! "
2866                         "size %ld (0x%lx)", getpid (), listen_vpp_handle,
2867                         listen_session_index, client_session_index,
2868                         vcm->cfg.rx_fifo_size, vcm->cfg.rx_fifo_size);
2869           rv = VNET_API_ERROR_URI_FIFO_CREATE_FAILED;
2870           vppcom_send_connect_session_reply (client_session,
2871                                              client_session_index,
2872                                              client_session->vpp_handle,
2873                                              client_session->client_context,
2874                                              rv);
2875           clib_spinlock_unlock (&vcm->sessions_lockp);
2876           rv = VPPCOM_ENOMEM;
2877           goto done;
2878         }
2879       client_session->server_rx_fifo->master_session_index =
2880         client_session_index;
2881
2882       client_session->server_tx_fifo =
2883         svm_fifo_segment_alloc_fifo (seg, vcm->cfg.tx_fifo_size,
2884                                      FIFO_SEGMENT_TX_FREELIST);
2885       if (PREDICT_FALSE (!client_session->server_tx_fifo))
2886         {
2887           svm_fifo_segment_delete (seg);
2888           clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
2889                         "client sid %u tx fifo alloc failed! "
2890                         "size %ld (0x%lx)", getpid (), listen_vpp_handle,
2891                         listen_session_index, client_session_index,
2892                         vcm->cfg.tx_fifo_size, vcm->cfg.tx_fifo_size);
2893           rv = VNET_API_ERROR_URI_FIFO_CREATE_FAILED;
2894           vppcom_send_connect_session_reply (client_session,
2895                                              client_session_index,
2896                                              client_session->vpp_handle,
2897                                              client_session->client_context,
2898                                              rv);
2899           clib_spinlock_unlock (&vcm->sessions_lockp);
2900           rv = VPPCOM_ENOMEM;
2901           goto done;
2902         }
2903       client_session->server_tx_fifo->master_session_index =
2904         client_session_index;
2905
2906       if (VPPCOM_DEBUG > 1)
2907         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: client sid %u "
2908                       "created segment '%s', rx_fifo %p, tx_fifo %p",
2909                       getpid (), listen_vpp_handle, listen_session_index,
2910                       client_session_index, client_session->segment_name,
2911                       client_session->server_rx_fifo,
2912                       client_session->server_tx_fifo);
2913
2914 #ifdef CUT_THRU_EVENT_QUEUE     /* TBD */
2915       {
2916         void *oldheap;
2917         ssvm_shared_header_t *sh = seg->ssvm.sh;
2918
2919         ssvm_lock_non_recursive (sh, 1);
2920         oldheap = ssvm_push_heap (sh);
2921         event_q = client_session->vpp_event_queue =
2922           svm_queue_init (vcm->cfg.event_queue_size,
2923                           sizeof (session_fifo_event_t),
2924                           getpid (), 0 /* signal not sent */ );
2925         ssvm_pop_heap (oldheap);
2926         ssvm_unlock_non_recursive (sh);
2927       }
2928 #endif
2929       vppcom_send_connect_session_reply (client_session,
2930                                          client_session_index,
2931                                          client_session->vpp_handle,
2932                                          client_session->client_context,
2933                                          0 /* retval OK */ );
2934     }
2935   else
2936     {
2937       cut_thru_str = " ";
2938       vppcom_send_accept_session_reply (client_session->vpp_handle,
2939                                         client_session->client_context,
2940                                         0 /* retval OK */ );
2941     }
2942
2943   if (VPPCOM_DEBUG > 0)
2944     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: accepted vpp handle "
2945                   "0x%llx, sid %u%sconnection to local %s address "
2946                   "%U port %u", getpid (), listen_vpp_handle,
2947                   listen_session_index, client_session->vpp_handle,
2948                   client_session_index, cut_thru_str,
2949                   client_session->lcl_addr.is_ip4 ? "IPv4" : "IPv6",
2950                   format_ip46_address, &client_session->lcl_addr.ip46,
2951                   client_session->lcl_addr.is_ip4,
2952                   clib_net_to_host_u16 (client_session->lcl_port));
2953
2954   if (VPPCOM_DEBUG > 0)
2955     {
2956       client_session->elog_track.name =
2957         (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
2958                          client_session_index, 0);
2959       elog_track_register (&vcm->elog_main, &client_session->elog_track);
2960
2961       /* *INDENT-OFF* */
2962       ELOG_TYPE_DECLARE (e) =
2963       {
2964         .format = "accept cut-thru: listen_handle:%x from_handle:%x",
2965         .format_args = "i8i8",
2966       };
2967
2968       struct
2969       {
2970         u64 handle[2];
2971       } *ed;
2972
2973       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, client_session->elog_track);
2974       ed->handle[0] = listen_vpp_handle;
2975       ed->handle[1] = client_session->vpp_handle;
2976       /* *INDENT-ON* */
2977
2978       if (client_session->lcl_addr.is_ip4)
2979         {
2980           /* *INDENT-OFF* */
2981           ELOG_TYPE_DECLARE (e2) =
2982           {
2983             .format = "accept cut-thru: S:%d %d.%d.%d.%d:%d ",
2984             .format_args = "i4i1i1i1i1i2",
2985           };
2986
2987           CLIB_PACKED (struct {
2988             u32 session;
2989             u8 addr[4];
2990             u16 port;
2991           }) * ed2;
2992
2993           ed2 =
2994             ELOG_TRACK_DATA (&vcm->elog_main, e2, client_session->elog_track);
2995           ed2->session = client_session_index;
2996           ed2->addr[0] = client_session->lcl_addr.ip46.ip4.as_u8[0];
2997           ed2->addr[1] = client_session->lcl_addr.ip46.ip4.as_u8[1];
2998           ed2->addr[2] = client_session->lcl_addr.ip46.ip4.as_u8[2];
2999           ed2->addr[3] = client_session->lcl_addr.ip46.ip4.as_u8[3];
3000           ed2->port = clib_net_to_host_u16 (client_session->lcl_port);
3001           /* *INDENT-ON* */
3002         }
3003     }
3004
3005   clib_spinlock_unlock (&vcm->sessions_lockp);
3006   rv = (int) client_session_index;
3007 done:
3008   return rv;
3009 }
3010
3011 int
3012 vppcom_session_connect (uint32_t session_index, vppcom_endpt_t * server_ep)
3013 {
3014   session_t *session = 0;
3015   int rv, retval = VPPCOM_OK;
3016   u64 vpp_handle = ~0;
3017
3018   VCL_LOCK_AND_GET_SESSION (session_index, &session);
3019
3020   if (PREDICT_FALSE (session->is_vep))
3021     {
3022       clib_spinlock_unlock (&vcm->sessions_lockp);
3023       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
3024                     "connect on an epoll session!", getpid (), session_index);
3025       rv = VPPCOM_EBADFD;
3026       goto done;
3027     }
3028
3029   vpp_handle = session->vpp_handle;
3030   if (PREDICT_FALSE (session->is_server))
3031     {
3032       clib_spinlock_unlock (&vcm->sessions_lockp);
3033       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: is in use "
3034                     "as a server session!", getpid (), vpp_handle,
3035                     session_index);
3036       rv = VPPCOM_EBADFD;
3037       goto done;
3038     }
3039
3040   if (PREDICT_FALSE (session->state & CLIENT_STATE_OPEN))
3041     {
3042       if (VPPCOM_DEBUG > 0)
3043         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: session already "
3044                       "connected to %s %U port %d proto %s, state 0x%x (%s)",
3045                       getpid (), vpp_handle, session_index,
3046                       session->peer_addr.is_ip4 ? "IPv4" : "IPv6",
3047                       format_ip46_address,
3048                       &session->peer_addr.ip46, session->peer_addr.is_ip4,
3049                       clib_net_to_host_u16 (session->peer_port),
3050                       session->proto ? "UDP" : "TCP", session->state,
3051                       vppcom_session_state_str (session->state));
3052
3053       clib_spinlock_unlock (&vcm->sessions_lockp);
3054       goto done;
3055     }
3056
3057   session->vrf = server_ep->vrf;
3058   session->peer_addr.is_ip4 = server_ep->is_ip4;
3059   session->peer_addr.ip46 = to_ip46 (!server_ep->is_ip4, server_ep->ip);
3060   session->peer_port = server_ep->port;
3061
3062   if (VPPCOM_DEBUG > 0)
3063     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connecting to server "
3064                   "%s %U port %d proto %s",
3065                   getpid (), vpp_handle, session_index,
3066                   session->peer_addr.is_ip4 ? "IPv4" : "IPv6",
3067                   format_ip46_address,
3068                   &session->peer_addr.ip46, session->peer_addr.is_ip4,
3069                   clib_net_to_host_u16 (session->peer_port),
3070                   session->proto ? "UDP" : "TCP");
3071
3072   vppcom_send_connect_sock (session, session_index);
3073   clib_spinlock_unlock (&vcm->sessions_lockp);
3074
3075   retval =
3076     vppcom_wait_for_session_state_change (session_index, STATE_CONNECT,
3077                                           vcm->cfg.session_timeout);
3078
3079   VCL_LOCK_AND_GET_SESSION (session_index, &session);
3080   vpp_handle = session->vpp_handle;
3081   clib_spinlock_unlock (&vcm->sessions_lockp);
3082
3083 done:
3084   if (PREDICT_FALSE (retval))
3085     {
3086       rv = retval;
3087       if (VPPCOM_DEBUG > 0)
3088         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connect failed! "
3089                       "returning %d (%s)", getpid (), vpp_handle,
3090                       session_index, rv, vppcom_retval_str (rv));
3091     }
3092   else if (VPPCOM_DEBUG > 0)
3093     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connected!",
3094                   getpid (), vpp_handle, session_index);
3095
3096   return rv;
3097 }
3098
3099 static inline int
3100 vppcom_session_read_internal (uint32_t session_index, void *buf, int n,
3101                               u8 peek)
3102 {
3103   session_t *session = 0;
3104   svm_fifo_t *rx_fifo;
3105   int n_read = 0;
3106   int rv;
3107   char *fifo_str;
3108   u32 poll_et;
3109   session_state_t state;
3110   u8 is_server;
3111   u8 is_nonblocking;
3112   u64 vpp_handle;
3113
3114   ASSERT (buf);
3115
3116   VCL_LOCK_AND_GET_SESSION (session_index, &session);
3117
3118   if (PREDICT_FALSE (session->is_vep))
3119     {
3120       clib_spinlock_unlock (&vcm->sessions_lockp);
3121       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
3122                     "read from an epoll session!", getpid (), session_index);
3123       rv = VPPCOM_EBADFD;
3124       goto done;
3125     }
3126
3127   vpp_handle = session->vpp_handle;
3128   is_server = session->is_server;
3129   is_nonblocking = session->is_nonblocking;
3130   state = session->state;
3131   if (PREDICT_FALSE (!(state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN))))
3132     {
3133       clib_spinlock_unlock (&vcm->sessions_lockp);
3134       rv = ((state == STATE_DISCONNECT) ?
3135             VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
3136
3137       if (VPPCOM_DEBUG > 0)
3138         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: %s session is "
3139                       "not open! state 0x%x (%s), returning %d (%s)",
3140                       getpid (), vpp_handle, session_index,
3141                       is_server ? "server" : "client", state,
3142                       vppcom_session_state_str (state),
3143                       rv, vppcom_retval_str (rv));
3144       goto done;
3145     }
3146
3147   rx_fifo = ((!session->is_cut_thru || is_server) ?
3148              session->server_rx_fifo : session->server_tx_fifo);
3149   fifo_str = ((!session->is_cut_thru || is_server) ?
3150               "server_rx_fifo" : "server_tx_fifo");
3151   clib_spinlock_unlock (&vcm->sessions_lockp);
3152
3153   do
3154     {
3155       if (peek)
3156         n_read = svm_fifo_peek (rx_fifo, 0, n, buf);
3157       else
3158         n_read = svm_fifo_dequeue_nowait (rx_fifo, n, buf);
3159     }
3160   while (!is_nonblocking && (n_read <= 0));
3161
3162   if (n_read <= 0)
3163     {
3164       VCL_LOCK_AND_GET_SESSION (session_index, &session);
3165
3166       poll_et = (((EPOLLET | EPOLLIN) & session->vep.ev.events) ==
3167                  (EPOLLET | EPOLLIN));
3168       if (poll_et)
3169         session->vep.et_mask |= EPOLLIN;
3170
3171       if (state == STATE_CLOSE_ON_EMPTY)
3172         {
3173           session_state_t new_state = STATE_DISCONNECT;
3174           rv = VPPCOM_ECONNRESET;
3175
3176           if (VPPCOM_DEBUG > 1)
3177             {
3178               clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo "
3179                             "with %s session state 0x%x (%s)!"
3180                             "  Setting state to 0x%x (%s), returning %d (%s)",
3181                             getpid (), vpp_handle, session_index,
3182                             is_server ? "server" : "client",
3183                             state, vppcom_session_state_str (state),
3184                             new_state, vppcom_session_state_str (new_state),
3185                             rv, vppcom_retval_str (rv));
3186             }
3187
3188           session->state = new_state;
3189         }
3190       else
3191         rv = VPPCOM_EAGAIN;
3192
3193       clib_spinlock_unlock (&vcm->sessions_lockp);
3194     }
3195   else
3196     rv = n_read;
3197
3198   if (VPPCOM_DEBUG > 2)
3199     {
3200       if (rv > 0)
3201         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: read %d bytes "
3202                       "from %s (%p)", getpid (), vpp_handle,
3203                       session_index, n_read, fifo_str, rx_fifo);
3204       else
3205         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: nothing read! "
3206                       "returning %d (%s)", getpid (), vpp_handle,
3207                       session_index, rv, vppcom_retval_str (rv));
3208     }
3209 done:
3210   return rv;
3211 }
3212
3213 int
3214 vppcom_session_read (uint32_t session_index, void *buf, size_t n)
3215 {
3216   return (vppcom_session_read_internal (session_index, buf, n, 0));
3217 }
3218
3219 static int
3220 vppcom_session_peek (uint32_t session_index, void *buf, int n)
3221 {
3222   return (vppcom_session_read_internal (session_index, buf, n, 1));
3223 }
3224
3225 static inline int
3226 vppcom_session_read_ready (session_t * session, u32 session_index)
3227 {
3228   svm_fifo_t *rx_fifo = 0;
3229   int ready = 0;
3230   u32 poll_et;
3231   int rv;
3232   u8 is_server = session->is_server;
3233   session_state_t state = session->state;
3234   u64 vpp_handle = session->vpp_handle;
3235
3236   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
3237   if (PREDICT_FALSE (session->is_vep))
3238     {
3239       clib_warning ("VCL<%d>: ERROR: sid %u: cannot read from an "
3240                     "epoll session!", getpid (), session_index);
3241       rv = VPPCOM_EBADFD;
3242       goto done;
3243     }
3244
3245   if (session->is_listen)
3246     ready = clib_fifo_elts (vcm->client_session_index_fifo);
3247   else
3248     {
3249       if (!(state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN | STATE_LISTEN)))
3250         {
3251           rv = ((state == STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
3252                 VPPCOM_ENOTCONN);
3253
3254           if (VPPCOM_DEBUG > 1)
3255             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: %s session is "
3256                           "not open! state 0x%x (%s), returning %d (%s)",
3257                           getpid (), vpp_handle, session_index,
3258                           is_server ? "server" : "client",
3259                           state, vppcom_session_state_str (state),
3260                           rv, vppcom_retval_str (rv));
3261           goto done;
3262         }
3263
3264       rx_fifo = ((!session->is_cut_thru || is_server) ?
3265                  session->server_rx_fifo : session->server_tx_fifo);
3266
3267       ready = svm_fifo_max_dequeue (rx_fifo);
3268     }
3269
3270   if (ready == 0)
3271     {
3272       poll_et =
3273         ((EPOLLET | EPOLLIN) & session->vep.ev.events) == (EPOLLET | EPOLLIN);
3274       if (poll_et)
3275         session->vep.et_mask |= EPOLLIN;
3276
3277       if (state == STATE_CLOSE_ON_EMPTY)
3278         {
3279           rv = VPPCOM_ECONNRESET;
3280           session_state_t new_state = STATE_DISCONNECT;
3281
3282           if (VPPCOM_DEBUG > 1)
3283             {
3284               clib_warning ("VCL<%d>: vpp handle 0x%llx, "
3285                             "sid %u: Empty fifo with"
3286                             " %s session state 0x%x (%s)! Setting state to "
3287                             "0x%x (%s), returning %d (%s)",
3288                             getpid (), session_index, vpp_handle,
3289                             is_server ? "server" : "client",
3290                             state, vppcom_session_state_str (state),
3291                             new_state, vppcom_session_state_str (new_state),
3292                             rv, vppcom_retval_str (rv));
3293             }
3294           session->state = new_state;
3295           goto done;
3296         }
3297     }
3298   rv = ready;
3299
3300   if (vcm->app_event_queue->cursize &&
3301       !pthread_mutex_trylock (&vcm->app_event_queue->mutex))
3302     {
3303       u32 i, n_to_dequeue = vcm->app_event_queue->cursize;
3304       session_fifo_event_t e;
3305
3306       for (i = 0; i < n_to_dequeue; i++)
3307         svm_queue_sub_raw (vcm->app_event_queue, (u8 *) & e);
3308
3309       pthread_mutex_unlock (&vcm->app_event_queue->mutex);
3310     }
3311 done:
3312   return rv;
3313 }
3314
3315 int
3316 vppcom_session_write (uint32_t session_index, void *buf, size_t n)
3317 {
3318   session_t *session = 0;
3319   svm_fifo_t *tx_fifo;
3320   svm_queue_t *q;
3321   session_fifo_event_t evt;
3322   int rv, n_write;
3323   char *fifo_str;
3324   u32 poll_et;
3325   u8 is_server;
3326   u8 is_nonblocking;
3327   session_state_t state;
3328   u64 vpp_handle;
3329
3330   ASSERT (buf);
3331
3332   VCL_LOCK_AND_GET_SESSION (session_index, &session);
3333
3334   if (PREDICT_FALSE (session->is_vep))
3335     {
3336       clib_spinlock_unlock (&vcm->sessions_lockp);
3337       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
3338                     "cannot write to an epoll session!",
3339                     getpid (), session->vpp_handle, session_index);
3340
3341       rv = VPPCOM_EBADFD;
3342       goto done;
3343     }
3344
3345   is_server = session->is_server;
3346   is_nonblocking = session->is_nonblocking;
3347   vpp_handle = session->vpp_handle;
3348   state = session->state;
3349   if (!(state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
3350     {
3351       rv = ((state == STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
3352             VPPCOM_ENOTCONN);
3353
3354       clib_spinlock_unlock (&vcm->sessions_lockp);
3355       if (VPPCOM_DEBUG > 1)
3356         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
3357                       "%s session is not open! state 0x%x (%s)",
3358                       getpid (), vpp_handle, session_index,
3359                       is_server ? "server" : "client", state,
3360                       vppcom_session_state_str (state));
3361       goto done;
3362     }
3363
3364   tx_fifo = ((!session->is_cut_thru || is_server) ?
3365              session->server_tx_fifo : session->server_rx_fifo);
3366   fifo_str = ((!session->is_cut_thru || is_server) ?
3367               "server_tx_fifo" : "server_rx_fifo");
3368   clib_spinlock_unlock (&vcm->sessions_lockp);
3369
3370   do
3371     {
3372       n_write = svm_fifo_enqueue_nowait (tx_fifo, n, (void *) buf);
3373     }
3374   while (!is_nonblocking && (n_write <= 0));
3375
3376   /* If event wasn't set, add one */
3377   if (!session->is_cut_thru && (n_write > 0) && svm_fifo_set_event (tx_fifo))
3378     {
3379       /* Fabricate TX event, send to vpp */
3380       evt.fifo = tx_fifo;
3381       evt.event_type = FIFO_EVENT_APP_TX;
3382
3383       VCL_LOCK_AND_GET_SESSION (session_index, &session);
3384       q = session->vpp_event_queue;
3385       ASSERT (q);
3386       svm_queue_add (q, (u8 *) & evt, 0 /* do wait for mutex */ );
3387       clib_spinlock_unlock (&vcm->sessions_lockp);
3388       if (VPPCOM_DEBUG > 1)
3389         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
3390                       "added FIFO_EVENT_APP_TX to "
3391                       "vpp_event_q %p, n_write %d", getpid (),
3392                       vpp_handle, session_index, q, n_write);
3393     }
3394
3395   if (n_write <= 0)
3396     {
3397       VCL_LOCK_AND_GET_SESSION (session_index, &session);
3398
3399       poll_et = (((EPOLLET | EPOLLOUT) & session->vep.ev.events) ==
3400                  (EPOLLET | EPOLLOUT));
3401       if (poll_et)
3402         session->vep.et_mask |= EPOLLOUT;
3403
3404       if (state == STATE_CLOSE_ON_EMPTY)
3405         {
3406           session_state_t new_state = STATE_DISCONNECT;
3407           rv = VPPCOM_ECONNRESET;
3408
3409           if (VPPCOM_DEBUG > 1)
3410             {
3411               clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
3412                             "Empty fifo with %s session state 0x%x (%s)!"
3413                             "  Setting state to 0x%x (%s), returning %d (%s)",
3414                             getpid (), vpp_handle, session_index,
3415                             is_server ? "server" : "client",
3416                             state, vppcom_session_state_str (state),
3417                             new_state, vppcom_session_state_str (new_state),
3418                             rv, vppcom_retval_str (rv));
3419             }
3420
3421           session->state = new_state;
3422         }
3423       else
3424         rv = VPPCOM_EAGAIN;
3425
3426       clib_spinlock_unlock (&vcm->sessions_lockp);
3427     }
3428   else
3429     rv = n_write;
3430
3431   if (VPPCOM_DEBUG > 2)
3432     {
3433       if (n_write <= 0)
3434         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
3435                       "FIFO-FULL %s (%p)", getpid (), vpp_handle,
3436                       session_index, fifo_str, tx_fifo);
3437       else
3438         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
3439                       "wrote %d bytes to %s (%p)", getpid (), vpp_handle,
3440                       session_index, n_write, fifo_str, tx_fifo);
3441     }
3442 done:
3443   return rv;
3444 }
3445
3446 static inline int
3447 vppcom_session_write_ready (session_t * session, u32 session_index)
3448 {
3449   svm_fifo_t *tx_fifo;
3450   char *fifo_str;
3451   int ready;
3452   u32 poll_et;
3453   int rv;
3454   u8 is_server = session->is_server;
3455   session_state_t state = session->state;
3456
3457   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
3458   if (PREDICT_FALSE (session->is_vep))
3459     {
3460       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
3461                     "cannot write to an epoll session!",
3462                     getpid (), session->vpp_handle, session_index);
3463       rv = VPPCOM_EBADFD;
3464       goto done;
3465     }
3466
3467   if (PREDICT_FALSE (session->is_listen))
3468     {
3469       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
3470                     "cannot write to a listen session!",
3471                     getpid (), session->vpp_handle, session_index);
3472       rv = VPPCOM_EBADFD;
3473       goto done;
3474     }
3475
3476   if (!(state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
3477     {
3478       session_state_t state = session->state;
3479
3480       rv = ((state == STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
3481             VPPCOM_ENOTCONN);
3482
3483       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
3484                     "%s session is not open! state 0x%x (%s), "
3485                     "returning %d (%s)", getpid (), session->vpp_handle,
3486                     session_index, is_server ? "server" : "client",
3487                     state, vppcom_session_state_str (state),
3488                     rv, vppcom_retval_str (rv));
3489       goto done;
3490     }
3491
3492   tx_fifo = ((!session->is_cut_thru || session->is_server) ?
3493              session->server_tx_fifo : session->server_rx_fifo);
3494   fifo_str = ((!session->is_cut_thru || session->is_server) ?
3495               "server_tx_fifo" : "server_rx_fifo");
3496
3497   ready = svm_fifo_max_enqueue (tx_fifo);
3498
3499   if (VPPCOM_DEBUG > 3)
3500     clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
3501                   "peek %s (%p), ready = %d", getpid (),
3502                   session->vpp_handle, session_index,
3503                   fifo_str, tx_fifo, ready);
3504
3505   if (ready == 0)
3506     {
3507       poll_et = (((EPOLLET | EPOLLOUT) & session->vep.ev.events) ==
3508                  (EPOLLET | EPOLLOUT));
3509       if (poll_et)
3510         session->vep.et_mask |= EPOLLOUT;
3511
3512       if (state == STATE_CLOSE_ON_EMPTY)
3513         {
3514           rv = VPPCOM_ECONNRESET;
3515           session_state_t new_state = STATE_DISCONNECT;
3516
3517           if (VPPCOM_DEBUG > 1)
3518             {
3519               clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
3520                             "Empty fifo with %s session "
3521                             "state 0x%x (%s)! Setting state to 0x%x (%s), "
3522                             "returning %d (%s)", getpid (),
3523                             session->vpp_handle, session_index,
3524                             is_server ? "server" : "client",
3525                             state, vppcom_session_state_str (state),
3526                             new_state, vppcom_session_state_str (new_state),
3527                             rv, vppcom_retval_str (rv));
3528             }
3529           session->state = new_state;
3530           goto done;
3531         }
3532     }
3533   rv = ready;
3534 done:
3535   return rv;
3536 }
3537
3538 int
3539 vppcom_select (unsigned long n_bits, unsigned long *read_map,
3540                unsigned long *write_map, unsigned long *except_map,
3541                double time_to_wait)
3542 {
3543   u32 session_index;
3544   session_t *session = 0;
3545   int rv, bits_set = 0;
3546   f64 timeout = clib_time_now (&vcm->clib_time) + time_to_wait;
3547   u32 minbits = clib_max (n_bits, BITS (uword));
3548
3549   ASSERT (sizeof (clib_bitmap_t) == sizeof (long int));
3550
3551   if (n_bits && read_map)
3552     {
3553       clib_bitmap_validate (vcm->rd_bitmap, minbits);
3554       clib_memcpy (vcm->rd_bitmap, read_map,
3555                    vec_len (vcm->rd_bitmap) * sizeof (clib_bitmap_t));
3556       memset (read_map, 0, vec_len (vcm->rd_bitmap) * sizeof (clib_bitmap_t));
3557     }
3558   if (n_bits && write_map)
3559     {
3560       clib_bitmap_validate (vcm->wr_bitmap, minbits);
3561       clib_memcpy (vcm->wr_bitmap, write_map,
3562                    vec_len (vcm->wr_bitmap) * sizeof (clib_bitmap_t));
3563       memset (write_map, 0,
3564               vec_len (vcm->wr_bitmap) * sizeof (clib_bitmap_t));
3565     }
3566   if (n_bits && except_map)
3567     {
3568       clib_bitmap_validate (vcm->ex_bitmap, minbits);
3569       clib_memcpy (vcm->ex_bitmap, except_map,
3570                    vec_len (vcm->ex_bitmap) * sizeof (clib_bitmap_t));
3571       memset (except_map, 0,
3572               vec_len (vcm->ex_bitmap) * sizeof (clib_bitmap_t));
3573     }
3574
3575   do
3576     {
3577       /* *INDENT-OFF* */
3578       if (n_bits)
3579         {
3580           if (read_map)
3581             {
3582               clib_bitmap_foreach (session_index, vcm->rd_bitmap,
3583                 ({
3584                   clib_spinlock_lock (&vcm->sessions_lockp);
3585                   rv = vppcom_session_at_index (session_index, &session);
3586                   if (rv < 0)
3587                     {
3588                       clib_spinlock_unlock (&vcm->sessions_lockp);
3589                       if (VPPCOM_DEBUG > 1)
3590                         clib_warning ("VCL<%d>: session %d specified in "
3591                                       "read_map is closed.", getpid (),
3592                                       session_index);
3593                       bits_set = VPPCOM_EBADFD;
3594                       goto select_done;
3595                     }
3596
3597                   rv = vppcom_session_read_ready (session, session_index);
3598                   clib_spinlock_unlock (&vcm->sessions_lockp);
3599                   if (except_map && vcm->ex_bitmap &&
3600                       clib_bitmap_get (vcm->ex_bitmap, session_index) &&
3601                       (rv < 0))
3602                     {
3603                       clib_bitmap_set_no_check (except_map, session_index, 1);
3604                       bits_set++;
3605                     }
3606                   else if (rv > 0)
3607                     {
3608                       clib_bitmap_set_no_check (read_map, session_index, 1);
3609                       bits_set++;
3610                     }
3611                 }));
3612             }
3613
3614           if (write_map)
3615             {
3616               clib_bitmap_foreach (session_index, vcm->wr_bitmap,
3617                 ({
3618                   clib_spinlock_lock (&vcm->sessions_lockp);
3619                   rv = vppcom_session_at_index (session_index, &session);
3620                   if (rv < 0)
3621                     {
3622                       clib_spinlock_unlock (&vcm->sessions_lockp);
3623                       if (VPPCOM_DEBUG > 0)
3624                         clib_warning ("VCL<%d>: session %d specified in "
3625                                       "write_map is closed.", getpid (),
3626                                       session_index);
3627                       bits_set = VPPCOM_EBADFD;
3628                       goto select_done;
3629                     }
3630
3631                   rv = vppcom_session_write_ready (session, session_index);
3632                   clib_spinlock_unlock (&vcm->sessions_lockp);
3633                   if (write_map && (rv > 0))
3634                     {
3635                       clib_bitmap_set_no_check (write_map, session_index, 1);
3636                       bits_set++;
3637                     }
3638                 }));
3639             }
3640
3641           if (except_map)
3642             {
3643               clib_bitmap_foreach (session_index, vcm->ex_bitmap,
3644                 ({
3645                   clib_spinlock_lock (&vcm->sessions_lockp);
3646                   rv = vppcom_session_at_index (session_index, &session);
3647                   if (rv < 0)
3648                     {
3649                       clib_spinlock_unlock (&vcm->sessions_lockp);
3650                       if (VPPCOM_DEBUG > 1)
3651                         clib_warning ("VCL<%d>: session %d specified in "
3652                                       "except_map is closed.", getpid (),
3653                                       session_index);
3654                       bits_set = VPPCOM_EBADFD;
3655                       goto select_done;
3656                     }
3657
3658                   rv = vppcom_session_read_ready (session, session_index);
3659                   clib_spinlock_unlock (&vcm->sessions_lockp);
3660                   if (rv < 0)
3661                     {
3662                       clib_bitmap_set_no_check (except_map, session_index, 1);
3663                       bits_set++;
3664                     }
3665                 }));
3666             }
3667         }
3668       /* *INDENT-ON* */
3669     }
3670   while ((time_to_wait == -1) || (clib_time_now (&vcm->clib_time) < timeout));
3671
3672 select_done:
3673   return (bits_set);
3674 }
3675
3676 static inline void
3677 vep_verify_epoll_chain (u32 vep_idx)
3678 {
3679   session_t *session;
3680   vppcom_epoll_t *vep;
3681   int rv;
3682   u32 sid = vep_idx;
3683
3684   if (VPPCOM_DEBUG <= 1)
3685     return;
3686
3687   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
3688   rv = vppcom_session_at_index (vep_idx, &session);
3689   if (PREDICT_FALSE (rv))
3690     {
3691       clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!",
3692                     getpid (), vep_idx);
3693       goto done;
3694     }
3695   if (PREDICT_FALSE (!session->is_vep))
3696     {
3697       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
3698                     getpid (), vep_idx);
3699       goto done;
3700     }
3701   vep = &session->vep;
3702   clib_warning ("VCL<%d>: vep_idx (%u): Dumping epoll chain\n"
3703                 "{\n"
3704                 "   is_vep         = %u\n"
3705                 "   is_vep_session = %u\n"
3706                 "   next_sid       = 0x%x (%u)\n"
3707                 "   wait_cont_idx  = 0x%x (%u)\n"
3708                 "}\n", getpid (), vep_idx,
3709                 session->is_vep, session->is_vep_session,
3710                 vep->next_sid, vep->next_sid,
3711                 session->wait_cont_idx, session->wait_cont_idx);
3712
3713   for (sid = vep->next_sid; sid != ~0; sid = vep->next_sid)
3714     {
3715       rv = vppcom_session_at_index (sid, &session);
3716       if (PREDICT_FALSE (rv))
3717         {
3718           clib_warning ("VCL<%d>: ERROR: Invalid sid (%u)!", getpid (), sid);
3719           goto done;
3720         }
3721       if (PREDICT_FALSE (session->is_vep))
3722         clib_warning ("VCL<%d>: ERROR: sid (%u) is a vep!",
3723                       getpid (), vep_idx);
3724       else if (PREDICT_FALSE (!session->is_vep_session))
3725         {
3726           clib_warning ("VCL<%d>: ERROR: session (%u) "
3727                         "is not a vep session!", getpid (), sid);
3728           goto done;
3729         }
3730       vep = &session->vep;
3731       if (PREDICT_FALSE (vep->vep_idx != vep_idx))
3732         clib_warning ("VCL<%d>: ERROR: session (%u) vep_idx (%u) != "
3733                       "vep_idx (%u)!", getpid (),
3734                       sid, session->vep.vep_idx, vep_idx);
3735       if (session->is_vep_session)
3736         {
3737           clib_warning ("vep_idx[%u]: sid 0x%x (%u)\n"
3738                         "{\n"
3739                         "   next_sid       = 0x%x (%u)\n"
3740                         "   prev_sid       = 0x%x (%u)\n"
3741                         "   vep_idx        = 0x%x (%u)\n"
3742                         "   ev.events      = 0x%x\n"
3743                         "   ev.data.u64    = 0x%llx\n"
3744                         "   et_mask        = 0x%x\n"
3745                         "}\n",
3746                         vep_idx, sid, sid,
3747                         vep->next_sid, vep->next_sid,
3748                         vep->prev_sid, vep->prev_sid,
3749                         vep->vep_idx, vep->vep_idx,
3750                         vep->ev.events, vep->ev.data.u64, vep->et_mask);
3751         }
3752     }
3753
3754 done:
3755   clib_warning ("VCL<%d>: vep_idx (%u): Dump complete!\n",
3756                 getpid (), vep_idx);
3757 }
3758
3759 int
3760 vppcom_epoll_create (void)
3761 {
3762   session_t *vep_session;
3763   u32 vep_idx;
3764
3765   clib_spinlock_lock (&vcm->sessions_lockp);
3766   pool_get (vcm->sessions, vep_session);
3767   memset (vep_session, 0, sizeof (*vep_session));
3768   vep_idx = vep_session - vcm->sessions;
3769
3770   vep_session->is_vep = 1;
3771   vep_session->vep.vep_idx = ~0;
3772   vep_session->vep.next_sid = ~0;
3773   vep_session->vep.prev_sid = ~0;
3774   vep_session->wait_cont_idx = ~0;
3775   vep_session->vpp_handle = ~0;
3776   clib_spinlock_unlock (&vcm->sessions_lockp);
3777
3778   if (VPPCOM_DEBUG > 0)
3779     clib_warning ("VCL<%d>: Created vep_idx %u / sid %u!",
3780                   getpid (), vep_idx, vep_idx);
3781
3782   if (VPPCOM_DEBUG > 0)
3783     {
3784       vep_session->elog_track.name =
3785         (char *) format (0, "C:%d:VEP:%d%c", vcm->my_client_index,
3786                          vep_idx, 0);
3787       elog_track_register (&vcm->elog_main, &vep_session->elog_track);
3788
3789       /* *INDENT-OFF* */
3790       ELOG_TYPE_DECLARE (e) =
3791       {
3792         .format = "created epoll session:%d",
3793         .format_args = "i4",
3794       };
3795
3796       struct
3797       {
3798         u32 data;
3799       } *ed;
3800
3801       ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vep_session->elog_track);
3802       ed->data = vep_idx;
3803       /* *INDENT-ON* */
3804     }
3805
3806   return (vep_idx);
3807 }
3808
3809 int
3810 vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
3811                   struct epoll_event *event)
3812 {
3813   session_t *vep_session;
3814   session_t *session;
3815   int rv;
3816
3817   if (vep_idx == session_index)
3818     {
3819       clib_warning ("VCL<%d>: ERROR: vep_idx == session_index (%u)!",
3820                     getpid (), vep_idx);
3821       return VPPCOM_EINVAL;
3822     }
3823
3824   clib_spinlock_lock (&vcm->sessions_lockp);
3825   rv = vppcom_session_at_index (vep_idx, &vep_session);
3826   if (PREDICT_FALSE (rv))
3827     {
3828       clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!", vep_idx);
3829       goto done;
3830     }
3831   if (PREDICT_FALSE (!vep_session->is_vep))
3832     {
3833       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
3834                     getpid (), vep_idx);
3835       rv = VPPCOM_EINVAL;
3836       goto done;
3837     }
3838
3839   ASSERT (vep_session->vep.vep_idx == ~0);
3840   ASSERT (vep_session->vep.prev_sid == ~0);
3841
3842   rv = vppcom_session_at_index (session_index, &session);
3843   if (PREDICT_FALSE (rv))
3844     {
3845       if (VPPCOM_DEBUG > 0)
3846         clib_warning ("VCL<%d>: ERROR: Invalid session_index (%u)!",
3847                       getpid (), session_index);
3848       goto done;
3849     }
3850   if (PREDICT_FALSE (session->is_vep))
3851     {
3852       clib_warning ("ERROR: session_index (%u) is a vep!", vep_idx);
3853       rv = VPPCOM_EINVAL;
3854       goto done;
3855     }
3856
3857   switch (op)
3858     {
3859     case EPOLL_CTL_ADD:
3860       if (PREDICT_FALSE (!event))
3861         {
3862           clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: NULL pointer to "
3863                         "epoll_event structure!", getpid ());
3864           rv = VPPCOM_EINVAL;
3865           goto done;
3866         }
3867       if (vep_session->vep.next_sid != ~0)
3868         {
3869           session_t *next_session;
3870           rv = vppcom_session_at_index (vep_session->vep.next_sid,
3871                                         &next_session);
3872           if (PREDICT_FALSE (rv))
3873             {
3874               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: Invalid "
3875                             "vep.next_sid (%u) on vep_idx (%u)!",
3876                             getpid (), vep_session->vep.next_sid, vep_idx);
3877               goto done;
3878             }
3879           ASSERT (next_session->vep.prev_sid == vep_idx);
3880           next_session->vep.prev_sid = session_index;
3881         }
3882       session->vep.next_sid = vep_session->vep.next_sid;
3883       session->vep.prev_sid = vep_idx;
3884       session->vep.vep_idx = vep_idx;
3885       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
3886       session->vep.ev = *event;
3887       session->is_vep = 0;
3888       session->is_vep_session = 1;
3889       vep_session->vep.next_sid = session_index;
3890       if (VPPCOM_DEBUG > 1)
3891         clib_warning ("VCL<%d>: EPOLL_CTL_ADD: vep_idx %u, "
3892                       "sid %u, events 0x%x, data 0x%llx!",
3893                       getpid (), vep_idx, session_index,
3894                       event->events, event->data.u64);
3895       if (VPPCOM_DEBUG > 0)
3896         {
3897           /* *INDENT-OFF* */
3898           ELOG_TYPE_DECLARE (e) =
3899             {
3900               .format = "epoll_ctladd: events:%x data:%x",
3901               .format_args = "i4i4i8",
3902             };
3903           struct
3904           {
3905             u32 events;
3906             u64 event_data;
3907           } *ed;
3908
3909           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
3910
3911           ed->events = event->events;
3912           ed->event_data = event->data.u64;
3913           /* *INDENT-ON* */
3914         }
3915       break;
3916
3917     case EPOLL_CTL_MOD:
3918       if (PREDICT_FALSE (!event))
3919         {
3920           clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_MOD: NULL pointer to "
3921                         "epoll_event structure!", getpid ());
3922           rv = VPPCOM_EINVAL;
3923           goto done;
3924         }
3925       else if (PREDICT_FALSE (!session->is_vep_session))
3926         {
3927           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
3928                         "not a vep session!", getpid (), session_index);
3929           rv = VPPCOM_EINVAL;
3930           goto done;
3931         }
3932       else if (PREDICT_FALSE (session->vep.vep_idx != vep_idx))
3933         {
3934           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
3935                         "vep_idx (%u) != vep_idx (%u)!",
3936                         getpid (), session_index,
3937                         session->vep.vep_idx, vep_idx);
3938           rv = VPPCOM_EINVAL;
3939           goto done;
3940         }
3941       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
3942       session->vep.ev = *event;
3943       if (VPPCOM_DEBUG > 1)
3944         clib_warning
3945           ("VCL<%d>: EPOLL_CTL_MOD: vep_idx %u, sid %u, events 0x%x,"
3946            " data 0x%llx!", getpid (), vep_idx, session_index, event->events,
3947            event->data.u64);
3948       break;
3949
3950     case EPOLL_CTL_DEL:
3951       if (PREDICT_FALSE (!session->is_vep_session))
3952         {
3953           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
3954                         "not a vep session!", getpid (), session_index);
3955           rv = VPPCOM_EINVAL;
3956           goto done;
3957         }
3958       else if (PREDICT_FALSE (session->vep.vep_idx != vep_idx))
3959         {
3960           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
3961                         "vep_idx (%u) != vep_idx (%u)!",
3962                         getpid (), session_index,
3963                         session->vep.vep_idx, vep_idx);
3964           rv = VPPCOM_EINVAL;
3965           goto done;
3966         }
3967
3968       vep_session->wait_cont_idx =
3969         (vep_session->wait_cont_idx == session_index) ?
3970         session->vep.next_sid : vep_session->wait_cont_idx;
3971
3972       if (session->vep.prev_sid == vep_idx)
3973         vep_session->vep.next_sid = session->vep.next_sid;
3974       else
3975         {
3976           session_t *prev_session;
3977           rv = vppcom_session_at_index (session->vep.prev_sid, &prev_session);
3978           if (PREDICT_FALSE (rv))
3979             {
3980               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
3981                             "vep.prev_sid (%u) on sid (%u)!",
3982                             getpid (), session->vep.prev_sid, session_index);
3983               goto done;
3984             }
3985           ASSERT (prev_session->vep.next_sid == session_index);
3986           prev_session->vep.next_sid = session->vep.next_sid;
3987         }
3988       if (session->vep.next_sid != ~0)
3989         {
3990           session_t *next_session;
3991           rv = vppcom_session_at_index (session->vep.next_sid, &next_session);
3992           if (PREDICT_FALSE (rv))
3993             {
3994               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
3995                             "vep.next_sid (%u) on sid (%u)!",
3996                             getpid (), session->vep.next_sid, session_index);
3997               goto done;
3998             }
3999           ASSERT (next_session->vep.prev_sid == session_index);
4000           next_session->vep.prev_sid = session->vep.prev_sid;
4001         }
4002
4003       memset (&session->vep, 0, sizeof (session->vep));
4004       session->vep.next_sid = ~0;
4005       session->vep.prev_sid = ~0;
4006       session->vep.vep_idx = ~0;
4007       session->is_vep_session = 0;
4008       if (VPPCOM_DEBUG > 1)
4009         clib_warning ("VCL<%d>: EPOLL_CTL_DEL: vep_idx %u, sid %u!",
4010                       getpid (), vep_idx, session_index);
4011       if (VPPCOM_DEBUG > 0)
4012         {
4013           /* *INDENT-OFF* */
4014           ELOG_TYPE_DECLARE (e) =
4015             {
4016               .format = "epoll_ctldel: vep:%d",
4017               .format_args = "i4",
4018             };
4019           struct
4020           {
4021             u32 data;
4022           } *ed;
4023
4024           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4025
4026           ed->data = vep_idx;
4027           /* *INDENT-ON* */
4028         }
4029       break;
4030
4031     default:
4032       clib_warning ("VCL<%d>: ERROR: Invalid operation (%d)!", getpid (), op);
4033       rv = VPPCOM_EINVAL;
4034     }
4035
4036   vep_verify_epoll_chain (vep_idx);
4037
4038 done:
4039   clib_spinlock_unlock (&vcm->sessions_lockp);
4040   return rv;
4041 }
4042
4043 int
4044 vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
4045                    int maxevents, double wait_for_time)
4046 {
4047   session_t *vep_session;
4048   int rv;
4049   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
4050   u32 keep_trying = 1;
4051   int num_ev = 0;
4052   u32 vep_next_sid, wait_cont_idx;
4053   u8 is_vep;
4054
4055   if (PREDICT_FALSE (maxevents <= 0))
4056     {
4057       clib_warning ("VCL<%d>: ERROR: Invalid maxevents (%d)!",
4058                     getpid (), maxevents);
4059       return VPPCOM_EINVAL;
4060     }
4061   memset (events, 0, sizeof (*events) * maxevents);
4062
4063   VCL_LOCK_AND_GET_SESSION (vep_idx, &vep_session);
4064   vep_next_sid = vep_session->vep.next_sid;
4065   is_vep = vep_session->is_vep;
4066   wait_cont_idx = vep_session->wait_cont_idx;
4067   clib_spinlock_unlock (&vcm->sessions_lockp);
4068
4069   if (PREDICT_FALSE (!is_vep))
4070     {
4071       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
4072                     getpid (), vep_idx);
4073       rv = VPPCOM_EINVAL;
4074       goto done;
4075     }
4076   if (PREDICT_FALSE (vep_next_sid == ~0))
4077     {
4078       if (VPPCOM_DEBUG > 0)
4079         clib_warning ("VCL<%d>: WARNING: vep_idx (%u) is empty!",
4080                       getpid (), vep_idx);
4081       if (VPPCOM_DEBUG > 0)
4082         {
4083           /* *INDENT-OFF* */
4084           ELOG_TYPE_DECLARE (e) =
4085             {
4086               .format = "WRN: vep_idx:%d empty",
4087               .format_args = "i4",
4088             };
4089           struct
4090           {
4091             u32 data;
4092           } *ed;
4093
4094           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vep_session->elog_track);
4095
4096           ed->data = vep_idx;
4097           /* *INDENT-ON* */
4098         }
4099       goto done;
4100     }
4101
4102   do
4103     {
4104       u32 sid;
4105       u32 next_sid = ~0;
4106       session_t *session;
4107
4108       for (sid = (wait_cont_idx == ~0) ? vep_next_sid : wait_cont_idx;
4109            sid != ~0; sid = next_sid)
4110         {
4111           u32 session_events, et_mask, clear_et_mask, session_vep_idx;
4112           u8 add_event, is_vep_session;
4113           int ready;
4114           u64 session_ev_data;
4115
4116           VCL_LOCK_AND_GET_SESSION (sid, &session);
4117           next_sid = session->vep.next_sid;
4118           session_events = session->vep.ev.events;
4119           et_mask = session->vep.et_mask;
4120           is_vep = session->is_vep;
4121           is_vep_session = session->is_vep_session;
4122           session_vep_idx = session->vep.vep_idx;
4123           session_ev_data = session->vep.ev.data.u64;
4124           clib_spinlock_unlock (&vcm->sessions_lockp);
4125
4126           if (PREDICT_FALSE (is_vep))
4127             {
4128               if (VPPCOM_DEBUG > 0)
4129                 clib_warning ("VCL<%d>: ERROR: sid (%u) is a vep!",
4130                               getpid (), vep_idx);
4131               if (VPPCOM_DEBUG > 0)
4132                 {
4133                   /* *INDENT-OFF* */
4134                   ELOG_TYPE_DECLARE (e) =
4135                     {
4136                       .format = "ERR:vep_idx:%d is vep",
4137                       .format_args = "i4",
4138                     };
4139                   struct
4140                   {
4141                     u32 data;
4142                   } *ed;
4143
4144                   ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4145
4146                   ed->data = vep_idx;
4147                   /* *INDENT-ON* */
4148                 }
4149
4150               rv = VPPCOM_EINVAL;
4151               goto done;
4152             }
4153           if (PREDICT_FALSE (!is_vep_session))
4154             {
4155               if (VPPCOM_DEBUG > 0)
4156                 clib_warning ("VCL<%d>: ERROR: session (%u) is not "
4157                               "a vep session!", getpid (), sid);
4158               if (VPPCOM_DEBUG > 0)
4159                 {
4160                   /* *INDENT-OFF* */
4161                   ELOG_TYPE_DECLARE (e) =
4162                     {
4163                       .format = "ERR:SID:%d not vep",
4164                       .format_args = "i4",
4165                     };
4166                   struct
4167                   {
4168                     u32 data;
4169                   } *ed;
4170
4171                   ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4172
4173                   ed->data = sid;
4174                   /* *INDENT-ON* */
4175                 }
4176
4177               rv = VPPCOM_EINVAL;
4178               goto done;
4179             }
4180           if (PREDICT_FALSE (session_vep_idx != vep_idx))
4181             {
4182               clib_warning ("VCL<%d>: ERROR: session (%u) "
4183                             "vep_idx (%u) != vep_idx (%u)!",
4184                             getpid (), sid, session->vep.vep_idx, vep_idx);
4185               rv = VPPCOM_EINVAL;
4186               goto done;
4187             }
4188
4189           add_event = clear_et_mask = 0;
4190
4191           if (EPOLLIN & session_events)
4192             {
4193               VCL_LOCK_AND_GET_SESSION (sid, &session);
4194               ready = vppcom_session_read_ready (session, sid);
4195               clib_spinlock_unlock (&vcm->sessions_lockp);
4196               if ((ready > 0) && (EPOLLIN & et_mask))
4197                 {
4198                   add_event = 1;
4199                   events[num_ev].events |= EPOLLIN;
4200                   if (((EPOLLET | EPOLLIN) & session_events) ==
4201                       (EPOLLET | EPOLLIN))
4202                     clear_et_mask |= EPOLLIN;
4203                 }
4204               else if (ready < 0)
4205                 {
4206                   add_event = 1;
4207                   switch (ready)
4208                     {
4209                     case VPPCOM_ECONNRESET:
4210                       events[num_ev].events |= EPOLLHUP | EPOLLRDHUP;
4211                       break;
4212
4213                     default:
4214                       events[num_ev].events |= EPOLLERR;
4215                       break;
4216                     }
4217                 }
4218             }
4219
4220           if (EPOLLOUT & session_events)
4221             {
4222               VCL_LOCK_AND_GET_SESSION (sid, &session);
4223               ready = vppcom_session_write_ready (session, sid);
4224               clib_spinlock_unlock (&vcm->sessions_lockp);
4225               if ((ready > 0) && (EPOLLOUT & et_mask))
4226                 {
4227                   add_event = 1;
4228                   events[num_ev].events |= EPOLLOUT;
4229                   if (((EPOLLET | EPOLLOUT) & session_events) ==
4230                       (EPOLLET | EPOLLOUT))
4231                     clear_et_mask |= EPOLLOUT;
4232                 }
4233               else if (ready < 0)
4234                 {
4235                   add_event = 1;
4236                   switch (ready)
4237                     {
4238                     case VPPCOM_ECONNRESET:
4239                       events[num_ev].events |= EPOLLHUP;
4240                       break;
4241
4242                     default:
4243                       events[num_ev].events |= EPOLLERR;
4244                       break;
4245                     }
4246                 }
4247             }
4248
4249           if (add_event)
4250             {
4251               events[num_ev].data.u64 = session_ev_data;
4252               if (EPOLLONESHOT & session_events)
4253                 {
4254                   VCL_LOCK_AND_GET_SESSION (sid, &session);
4255                   session->vep.ev.events = 0;
4256                   clib_spinlock_unlock (&vcm->sessions_lockp);
4257                 }
4258               num_ev++;
4259               if (num_ev == maxevents)
4260                 {
4261                   VCL_LOCK_AND_GET_SESSION (vep_idx, &vep_session);
4262                   vep_session->wait_cont_idx = next_sid;
4263                   clib_spinlock_unlock (&vcm->sessions_lockp);
4264                   goto done;
4265                 }
4266             }
4267           if (wait_cont_idx != ~0)
4268             {
4269               if (next_sid == ~0)
4270                 next_sid = vep_next_sid;
4271               else if (next_sid == wait_cont_idx)
4272                 next_sid = ~0;
4273             }
4274         }
4275       if (wait_for_time != -1)
4276         keep_trying = (clib_time_now (&vcm->clib_time) <= timeout) ? 1 : 0;
4277     }
4278   while ((num_ev == 0) && keep_trying);
4279
4280   if (wait_cont_idx != ~0)
4281     {
4282       VCL_LOCK_AND_GET_SESSION (vep_idx, &vep_session);
4283       vep_session->wait_cont_idx = ~0;
4284       clib_spinlock_unlock (&vcm->sessions_lockp);
4285     }
4286 done:
4287   return (rv != VPPCOM_OK) ? rv : num_ev;
4288 }
4289
4290 int
4291 vppcom_session_attr (uint32_t session_index, uint32_t op,
4292                      void *buffer, uint32_t * buflen)
4293 {
4294   session_t *session;
4295   int rv = VPPCOM_OK;
4296   u32 *flags = buffer;
4297   vppcom_endpt_t *ep = buffer;
4298
4299   VCL_LOCK_AND_GET_SESSION (session_index, &session);
4300   switch (op)
4301     {
4302     case VPPCOM_ATTR_GET_NREAD:
4303       rv = vppcom_session_read_ready (session, session_index);
4304       if (VPPCOM_DEBUG > 2)
4305         clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_NREAD: sid %u, nread = %d",
4306                       getpid (), rv);
4307       if (VPPCOM_DEBUG > 0)
4308         {
4309           /* *INDENT-OFF* */
4310           ELOG_TYPE_DECLARE (e) =
4311             {
4312               .format = "VPPCOM_ATTR_GET_NREAD: nread=%d",
4313               .format_args = "i4",
4314             };
4315           struct
4316           {
4317             u32 data;
4318           } *ed;
4319
4320           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4321
4322           ed->data = rv;
4323           /* *INDENT-ON* */
4324         }
4325
4326       break;
4327
4328     case VPPCOM_ATTR_GET_NWRITE:
4329       rv = vppcom_session_write_ready (session, session_index);
4330       if (VPPCOM_DEBUG > 2)
4331         clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_NWRITE: sid %u, nwrite = %d",
4332                       getpid (), session_index, rv);
4333       if (VPPCOM_DEBUG > 0)
4334         {
4335           /* *INDENT-OFF* */
4336           ELOG_TYPE_DECLARE (e) =
4337             {
4338               .format = "VPPCOM_ATTR_GET_NWRITE: nwrite=%d",
4339               .format_args = "i4",
4340             };
4341           struct
4342           {
4343             u32 data;
4344           } *ed;
4345
4346           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4347
4348           ed->data = rv;
4349           /* *INDENT-ON* */
4350         }
4351       break;
4352
4353     case VPPCOM_ATTR_GET_FLAGS:
4354       if (PREDICT_TRUE (buffer && buflen && (*buflen >= sizeof (*flags))))
4355         {
4356           *flags = O_RDWR | ((session->is_nonblocking) ? O_NONBLOCK : 0);
4357           *buflen = sizeof (*flags);
4358           if (VPPCOM_DEBUG > 2)
4359             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_FLAGS: sid %u, "
4360                           "flags = 0x%08x, is_nonblocking = %u", getpid (),
4361                           session_index, *flags, session->is_nonblocking);
4362           if (VPPCOM_DEBUG > 0)
4363             {
4364               /* *INDENT-OFF* */
4365               ELOG_TYPE_DECLARE (e) =
4366                 {
4367                   .format = "VPPCOM_ATTR_GET_FLAGS: flags=%x is_nonblk=%d",
4368                   .format_args = "i4i4",
4369                 };
4370               struct
4371               {
4372                 u32 flags;
4373                 u32 is_nonblk;
4374               } *ed;
4375
4376               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4377
4378               ed->flags = *flags;
4379               ed->is_nonblk = session->is_nonblocking;
4380               /* *INDENT-ON* */
4381             }
4382
4383         }
4384       else
4385         rv = VPPCOM_EINVAL;
4386       break;
4387
4388     case VPPCOM_ATTR_SET_FLAGS:
4389       if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
4390         {
4391           session->is_nonblocking = (*flags & O_NONBLOCK) ? 1 : 0;
4392           if (VPPCOM_DEBUG > 2)
4393             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_FLAGS: sid %u, "
4394                           "flags = 0x%08x, is_nonblocking = %u",
4395                           getpid (), session_index, *flags,
4396                           session->is_nonblocking);
4397           if (VPPCOM_DEBUG > 0)
4398             {
4399               /* *INDENT-OFF* */
4400               ELOG_TYPE_DECLARE (e) =
4401                 {
4402                   .format = "VPPCOM_ATTR_SET_FLAGS: flags=%x is_nonblk=%d",
4403                   .format_args = "i4i4",
4404                 };
4405               struct
4406               {
4407                 u32 flags;
4408                 u32 is_nonblk;
4409               } *ed;
4410
4411               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4412
4413               ed->flags = *flags;
4414               ed->is_nonblk = session->is_nonblocking;
4415               /* *INDENT-ON* */
4416             }
4417         }
4418       else
4419         rv = VPPCOM_EINVAL;
4420       break;
4421
4422     case VPPCOM_ATTR_GET_PEER_ADDR:
4423       if (PREDICT_TRUE (buffer && buflen &&
4424                         (*buflen >= sizeof (*ep)) && ep->ip))
4425         {
4426           ep->vrf = session->vrf;
4427           ep->is_ip4 = session->peer_addr.is_ip4;
4428           ep->port = session->peer_port;
4429           if (session->peer_addr.is_ip4)
4430             clib_memcpy (ep->ip, &session->peer_addr.ip46.ip4,
4431                          sizeof (ip4_address_t));
4432           else
4433             clib_memcpy (ep->ip, &session->peer_addr.ip46.ip6,
4434                          sizeof (ip6_address_t));
4435           *buflen = sizeof (*ep);
4436           if (VPPCOM_DEBUG > 1)
4437             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_PEER_ADDR: sid %u, "
4438                           "is_ip4 = %u, addr = %U, port %u", getpid (),
4439                           session_index, ep->is_ip4, format_ip46_address,
4440                           &session->peer_addr.ip46, ep->is_ip4,
4441                           clib_net_to_host_u16 (ep->port));
4442           if (VPPCOM_DEBUG > 0)
4443             {
4444               if (ep->is_ip4)
4445                 {
4446                   /* *INDENT-OFF* */
4447                   ELOG_TYPE_DECLARE (e) =
4448                     {
4449                       .format = "VPPCOM_ATTR_GET_PEER_ADDR: addr:%d.%d.%d.%d:%d",
4450                       .format_args = "i1i1i1i1i2",
4451                     };
4452                   CLIB_PACKED (struct {
4453                     u8 addr[4]; //4
4454                     u16 port;   //2
4455                   }) * ed;
4456
4457                   ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4458
4459                   ed->addr[0] = session->peer_addr.ip46.ip4.as_u8[0];
4460                   ed->addr[1] = session->peer_addr.ip46.ip4.as_u8[1];
4461                   ed->addr[2] = session->peer_addr.ip46.ip4.as_u8[2];
4462                   ed->addr[3] = session->peer_addr.ip46.ip4.as_u8[3];
4463                   ed->port = clib_net_to_host_u16 (session->peer_port);
4464                   /* *INDENT-ON* */
4465                 }
4466               else
4467                 {
4468                   /* *INDENT-OFF* */
4469                   ELOG_TYPE_DECLARE (e) =
4470                     {
4471                       .format = "VPPCOM_ATTR_GET_PEER_ADDR: addr:IP6:%d",
4472                       .format_args = "i2",
4473                     };
4474                   CLIB_PACKED (struct {
4475                     u16 port;   //2
4476                   }) * ed;
4477
4478                   ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4479
4480                   ed->port = clib_net_to_host_u16 (session->peer_port);
4481                   /* *INDENT-ON* */
4482                 }
4483             }
4484         }
4485       else
4486         rv = VPPCOM_EINVAL;
4487       break;
4488
4489     case VPPCOM_ATTR_GET_LCL_ADDR:
4490       if (PREDICT_TRUE (buffer && buflen &&
4491                         (*buflen >= sizeof (*ep)) && ep->ip))
4492         {
4493           ep->vrf = session->vrf;
4494           ep->is_ip4 = session->lcl_addr.is_ip4;
4495           ep->port = session->lcl_port;
4496           if (session->lcl_addr.is_ip4)
4497             clib_memcpy (ep->ip, &session->lcl_addr.ip46.ip4,
4498                          sizeof (ip4_address_t));
4499           else
4500             clib_memcpy (ep->ip, &session->lcl_addr.ip46.ip6,
4501                          sizeof (ip6_address_t));
4502           *buflen = sizeof (*ep);
4503           if (VPPCOM_DEBUG > 1)
4504             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_LCL_ADDR: sid %u, "
4505                           "is_ip4 = %u, addr = %U port %d", getpid (),
4506                           session_index, ep->is_ip4, format_ip46_address,
4507                           &session->lcl_addr.ip46, ep->is_ip4,
4508                           clib_net_to_host_u16 (ep->port));
4509           if (VPPCOM_DEBUG > 0)
4510             {
4511               if (ep->is_ip4)
4512                 {
4513                   /* *INDENT-OFF* */
4514                   ELOG_TYPE_DECLARE (e) =
4515                     {
4516                       .format = "VPPCOM_ATTR_GET_LCL_ADDR: addr:%d.%d.%d.%d:%d",
4517                       .format_args = "i1i1i1i1i2",
4518                     };
4519                   CLIB_PACKED (struct {
4520                     u8 addr[4]; //4
4521                     u16 port;   //2
4522                   }) * ed;
4523
4524                   ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4525
4526                   ed->addr[0] = session->lcl_addr.ip46.ip4.as_u8[0];
4527                   ed->addr[1] = session->lcl_addr.ip46.ip4.as_u8[1];
4528                   ed->addr[2] = session->lcl_addr.ip46.ip4.as_u8[2];
4529                   ed->addr[3] = session->lcl_addr.ip46.ip4.as_u8[3];
4530                   ed->port = clib_net_to_host_u16 (session->peer_port);
4531                   /* *INDENT-ON* */
4532                 }
4533               else
4534                 {
4535                   /* *INDENT-OFF* */
4536                   ELOG_TYPE_DECLARE (e) =
4537                     {
4538                       .format = "VPPCOM_ATTR_GET_LCL_ADDR: addr:IP6:%d",
4539                       .format_args = "i2",
4540                     };
4541                   CLIB_PACKED (struct {
4542                     u16 port;   //2
4543                   }) * ed;
4544
4545                   ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4546
4547                   ed->port = clib_net_to_host_u16 (session->peer_port);
4548                   /* *INDENT-ON* */
4549                 }
4550             }
4551         }
4552       else
4553         rv = VPPCOM_EINVAL;
4554       break;
4555
4556     case VPPCOM_ATTR_GET_LIBC_EPFD:
4557       rv = session->libc_epfd;
4558       if (VPPCOM_DEBUG > 2)
4559         clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d",
4560                       getpid (), rv);
4561       if (VPPCOM_DEBUG > 0)
4562         {
4563           /* *INDENT-OFF* */
4564           ELOG_TYPE_DECLARE (e) =
4565             {
4566               .format = "VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd=%d",
4567               .format_args = "i4",
4568             };
4569           CLIB_PACKED (struct {
4570             i32 data;
4571           }) * ed;
4572
4573           ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4574           ed->data = session->libc_epfd;
4575           /* *INDENT-ON* */
4576         }
4577
4578       break;
4579
4580     case VPPCOM_ATTR_SET_LIBC_EPFD:
4581       if (PREDICT_TRUE (buffer && buflen &&
4582                         (*buflen == sizeof (session->libc_epfd))))
4583         {
4584           session->libc_epfd = *(int *) buffer;
4585           *buflen = sizeof (session->libc_epfd);
4586
4587           if (VPPCOM_DEBUG > 2)
4588             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, "
4589                           "buflen %d", getpid (), session->libc_epfd,
4590                           *buflen);
4591           if (VPPCOM_DEBUG > 0)
4592             {
4593               /* *INDENT-OFF* */
4594               ELOG_TYPE_DECLARE (e) =
4595                 {
4596                   .format = "VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd=%s%d buflen=%d",
4597                   .format_args = "t1i4i4",
4598                   .n_enum_strings = 2,
4599                   .enum_strings = {"", "-",},
4600                 };
4601               CLIB_PACKED (struct {
4602                 u8 sign;
4603                 u32 data[2];
4604               }) * ed;
4605
4606               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4607
4608               ed->sign = (session->libc_epfd < 0);
4609               ed->data[0] = abs(session->libc_epfd);
4610               ed->data[1] = *buflen;
4611               /* *INDENT-ON* */
4612             }
4613         }
4614       else
4615         rv = VPPCOM_EINVAL;
4616       break;
4617
4618     case VPPCOM_ATTR_GET_PROTOCOL:
4619       if (buffer && buflen && (*buflen >= sizeof (int)))
4620         {
4621           *(int *) buffer = session->proto;
4622           *buflen = sizeof (int);
4623
4624           if (VPPCOM_DEBUG > 2)
4625             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_PROTOCOL: %d (%s), "
4626                           "buflen %d", getpid (), *(int *) buffer,
4627                           *(int *) buffer ? "UDP" : "TCP", *buflen);
4628           if (VPPCOM_DEBUG > 0)
4629             {
4630               /* *INDENT-OFF* */
4631               ELOG_TYPE_DECLARE (e) =
4632                 {
4633                   .format = "VPPCOM_ATTR_GET_PROTOCOL: %s buflen=%d",
4634                   .format_args = "t1i4",
4635                   .n_enum_strings = 2,
4636                   .enum_strings = {"TCP", "UDP",},
4637                 };
4638
4639               CLIB_PACKED (struct {
4640                 u8 proto;
4641                 u32 buflen;
4642               }) * ed;
4643
4644               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4645               ed->proto = session->proto;
4646               ed->buflen = *(int *) buffer;
4647               /* *INDENT-ON* */
4648             }
4649         }
4650       else
4651         rv = VPPCOM_EINVAL;
4652       break;
4653
4654     case VPPCOM_ATTR_GET_LISTEN:
4655       if (buffer && buflen && (*buflen >= sizeof (int)))
4656         {
4657           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
4658                                                 VCL_SESS_ATTR_LISTEN);
4659           *buflen = sizeof (int);
4660
4661           if (VPPCOM_DEBUG > 2)
4662             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_LISTEN: %d, "
4663                           "buflen %d", getpid (), *(int *) buffer, *buflen);
4664           if (VPPCOM_DEBUG > 0)
4665             {
4666               /* *INDENT-OFF* */
4667               ELOG_TYPE_DECLARE (e) =
4668                 {
4669                   .format = "VPPCOM_ATTR_GET_LISTEN: %d buflen=%d",
4670                   .format_args = "i4i4",
4671                 };
4672
4673               struct {
4674                 u32 data[2];
4675               } * ed;
4676
4677               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4678               ed->data[0] = *(int *) buffer;
4679               ed->data[1] = *buflen;
4680               /* *INDENT-ON* */
4681             }
4682         }
4683       else
4684         rv = VPPCOM_EINVAL;
4685       break;
4686
4687     case VPPCOM_ATTR_GET_ERROR:
4688       if (buffer && buflen && (*buflen >= sizeof (int)))
4689         {
4690           *(int *) buffer = 0;
4691           *buflen = sizeof (int);
4692
4693           if (VPPCOM_DEBUG > 2)
4694             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_ERROR: %d, "
4695                           "buflen %d, #VPP-TBD#", getpid (),
4696                           *(int *) buffer, *buflen);
4697           if (VPPCOM_DEBUG > 0)
4698             {
4699               /* *INDENT-OFF* */
4700               ELOG_TYPE_DECLARE (e) =
4701                 {
4702                   .format = "VPPCOM_ATTR_GET_ERROR: %d buflen=%d",
4703                   .format_args = "i4i4",
4704                 };
4705
4706               struct {
4707                 u32 data[2];
4708               } * ed;
4709
4710               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4711               ed->data[0] = *(int *) buffer;
4712               ed->data[1] = *buflen;
4713               /* *INDENT-ON* */
4714             }
4715         }
4716       else
4717         rv = VPPCOM_EINVAL;
4718       break;
4719
4720     case VPPCOM_ATTR_GET_TX_FIFO_LEN:
4721       if (buffer && buflen && (*buflen >= sizeof (u32)))
4722         {
4723           svm_fifo_t *tx_fifo;
4724
4725           tx_fifo = ((!session->is_cut_thru || session->is_server) ?
4726                      session->server_tx_fifo : session->server_rx_fifo);
4727
4728           /* VPP-TBD */
4729           *(size_t *) buffer = (session->sndbuf_size ? session->sndbuf_size :
4730                                 tx_fifo ? tx_fifo->nitems :
4731                                 vcm->cfg.tx_fifo_size);
4732           *buflen = sizeof (u32);
4733
4734           if (VPPCOM_DEBUG > 2)
4735             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), "
4736                           "buflen %d, #VPP-TBD#", getpid (),
4737                           *(size_t *) buffer, *(size_t *) buffer, *buflen);
4738           if (VPPCOM_DEBUG > 0)
4739             {
4740               /* *INDENT-OFF* */
4741               ELOG_TYPE_DECLARE (e) =
4742                 {
4743                   .format = "VPPCOM_ATTR_GET_TX_FIFO_LEN: 0x%x buflen=%d",
4744                   .format_args = "i4i4",
4745                 };
4746
4747               struct {
4748                 u32 data[2];
4749               } * ed;
4750
4751               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4752               ed->data[0] = *(size_t *) buffer;
4753               ed->data[1] = *buflen;
4754               /* *INDENT-ON* */
4755             }
4756         }
4757       else
4758         rv = VPPCOM_EINVAL;
4759       break;
4760
4761     case VPPCOM_ATTR_SET_TX_FIFO_LEN:
4762       if (buffer && buflen && (*buflen == sizeof (u32)))
4763         {
4764           /* VPP-TBD */
4765           session->sndbuf_size = *(u32 *) buffer;
4766           if (VPPCOM_DEBUG > 2)
4767             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), "
4768                           "buflen %d, #VPP-TBD#", getpid (),
4769                           session->sndbuf_size, session->sndbuf_size,
4770                           *buflen);
4771           if (VPPCOM_DEBUG > 0)
4772             {
4773               /* *INDENT-OFF* */
4774               ELOG_TYPE_DECLARE (e) =
4775                 {
4776                   .format = "VPPCOM_ATTR_SET_TX_FIFO_LEN: 0x%x buflen=%d",
4777                   .format_args = "i4i4",
4778                 };
4779
4780               struct {
4781                 u32 data[2];
4782               } * ed;
4783
4784               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4785               ed->data[0] = session->sndbuf_size;
4786               ed->data[1] = *buflen;
4787               /* *INDENT-ON* */
4788             }
4789         }
4790       else
4791         rv = VPPCOM_EINVAL;
4792       break;
4793
4794     case VPPCOM_ATTR_GET_RX_FIFO_LEN:
4795       if (buffer && buflen && (*buflen >= sizeof (u32)))
4796         {
4797           svm_fifo_t *rx_fifo;
4798
4799           rx_fifo = ((!session->is_cut_thru || session->is_server) ?
4800                      session->server_rx_fifo : session->server_tx_fifo);
4801
4802           /* VPP-TBD */
4803           *(size_t *) buffer = (session->rcvbuf_size ? session->rcvbuf_size :
4804                                 rx_fifo ? rx_fifo->nitems :
4805                                 vcm->cfg.rx_fifo_size);
4806           *buflen = sizeof (u32);
4807
4808           if (VPPCOM_DEBUG > 2)
4809             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), "
4810                           "buflen %d, #VPP-TBD#", getpid (),
4811                           *(size_t *) buffer, *(size_t *) buffer, *buflen);
4812           if (VPPCOM_DEBUG > 0)
4813             {
4814               /* *INDENT-OFF* */
4815               ELOG_TYPE_DECLARE (e) =
4816                 {
4817                   .format = "VPPCOM_ATTR_GET_RX_FIFO_LEN: 0x%x buflen=%d",
4818                   .format_args = "i4i4",
4819                 };
4820
4821               struct {
4822                 u32 data[2];
4823               } * ed;
4824
4825               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4826               ed->data[0] = *(size_t *) buffer;
4827               ed->data[1] = *buflen;
4828               /* *INDENT-ON* */
4829             }
4830         }
4831       else
4832         rv = VPPCOM_EINVAL;
4833       break;
4834
4835     case VPPCOM_ATTR_SET_RX_FIFO_LEN:
4836       if (buffer && buflen && (*buflen == sizeof (u32)))
4837         {
4838           /* VPP-TBD */
4839           session->rcvbuf_size = *(u32 *) buffer;
4840           if (VPPCOM_DEBUG > 2)
4841             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), "
4842                           "buflen %d, #VPP-TBD#", getpid (),
4843                           session->sndbuf_size, session->sndbuf_size,
4844                           *buflen);
4845           if (VPPCOM_DEBUG > 0)
4846             {
4847               /* *INDENT-OFF* */
4848               ELOG_TYPE_DECLARE (e) =
4849                 {
4850                   .format = "VPPCOM_ATTR_SET_RX_FIFO_LEN: 0x%x buflen=%d",
4851                   .format_args = "i4i4",
4852                 };
4853
4854               struct {
4855                 u32 data[2];
4856               } * ed;
4857
4858               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4859               ed->data[0] = session->sndbuf_size;
4860               ed->data[1] = *buflen;
4861               /* *INDENT-ON* */
4862             }
4863         }
4864       else
4865         rv = VPPCOM_EINVAL;
4866       break;
4867
4868     case VPPCOM_ATTR_GET_REUSEADDR:
4869       if (buffer && buflen && (*buflen >= sizeof (int)))
4870         {
4871           /* VPP-TBD */
4872           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
4873                                                 VCL_SESS_ATTR_REUSEADDR);
4874           *buflen = sizeof (int);
4875
4876           if (VPPCOM_DEBUG > 2)
4877             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_REUSEADDR: %d, "
4878                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
4879                           *buflen);
4880           if (VPPCOM_DEBUG > 0)
4881             {
4882               /* *INDENT-OFF* */
4883               ELOG_TYPE_DECLARE (e) =
4884                 {
4885                   .format = "VPPCOM_ATTR_GET_REUSEADDR: %d buflen=%d",
4886                   .format_args = "i4i4",
4887                 };
4888
4889               struct {
4890                 u32 data[2];
4891               } * ed;
4892
4893               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4894               ed->data[0] = *(int *) buffer;
4895               ed->data[1] = *buflen;
4896               /* *INDENT-ON* */
4897             }
4898         }
4899       else
4900         rv = VPPCOM_EINVAL;
4901       break;
4902
4903     case VPPCOM_ATTR_SET_REUSEADDR:
4904       if (buffer && buflen && (*buflen == sizeof (int)) &&
4905           !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
4906         {
4907           /* VPP-TBD */
4908           if (*(int *) buffer)
4909             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEADDR);
4910           else
4911             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEADDR);
4912
4913           if (VPPCOM_DEBUG > 2)
4914             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_REUSEADDR: %d, "
4915                           "buflen %d, #VPP-TBD#", getpid (),
4916                           VCL_SESS_ATTR_TEST (session->attr,
4917                                               VCL_SESS_ATTR_REUSEADDR),
4918                           *buflen);
4919           if (VPPCOM_DEBUG > 0)
4920             {
4921               /* *INDENT-OFF* */
4922               ELOG_TYPE_DECLARE (e) =
4923                 {
4924                   .format = "VPPCOM_ATTR_SET_REUSEADDR: %d buflen=%d",
4925                   .format_args = "i4i4",
4926                 };
4927
4928               struct {
4929                 u32 data[2];
4930               } * ed;
4931
4932               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4933               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
4934                                                 VCL_SESS_ATTR_REUSEADDR);
4935               ed->data[1] = *buflen;
4936               /* *INDENT-ON* */
4937             }
4938         }
4939       else
4940         rv = VPPCOM_EINVAL;
4941       break;
4942
4943     case VPPCOM_ATTR_GET_REUSEPORT:
4944       if (buffer && buflen && (*buflen >= sizeof (int)))
4945         {
4946           /* VPP-TBD */
4947           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
4948                                                 VCL_SESS_ATTR_REUSEPORT);
4949           *buflen = sizeof (int);
4950
4951           if (VPPCOM_DEBUG > 2)
4952             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_REUSEPORT: %d, "
4953                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
4954                           *buflen);
4955           if (VPPCOM_DEBUG > 0)
4956             {
4957               /* *INDENT-OFF* */
4958               ELOG_TYPE_DECLARE (e) =
4959                 {
4960                   .format = "VPPCOM_ATTR_GET_REUSEPORT: %d buflen=%d",
4961                   .format_args = "i4i4",
4962                 };
4963
4964               struct {
4965                 u32 data[2];
4966               } * ed;
4967
4968               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
4969               ed->data[0] = *(int *) buffer;
4970               ed->data[1] = *buflen;
4971               /* *INDENT-ON* */
4972             }
4973         }
4974       else
4975         rv = VPPCOM_EINVAL;
4976       break;
4977
4978     case VPPCOM_ATTR_SET_REUSEPORT:
4979       if (buffer && buflen && (*buflen == sizeof (int)) &&
4980           !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
4981         {
4982           /* VPP-TBD */
4983           if (*(int *) buffer)
4984             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEPORT);
4985           else
4986             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEPORT);
4987
4988           if (VPPCOM_DEBUG > 2)
4989             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_REUSEPORT: %d, "
4990                           "buflen %d, #VPP-TBD#", getpid (),
4991                           VCL_SESS_ATTR_TEST (session->attr,
4992                                               VCL_SESS_ATTR_REUSEPORT),
4993                           *buflen);
4994           if (VPPCOM_DEBUG > 0)
4995             {
4996               /* *INDENT-OFF* */
4997               ELOG_TYPE_DECLARE (e) =
4998                 {
4999                   .format = "VPPCOM_ATTR_SET_REUSEPORT: %d buflen=%d",
5000                   .format_args = "i4i4",
5001                 };
5002
5003               struct {
5004                 u32 data[2];
5005               } * ed;
5006
5007               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5008               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
5009                                                 VCL_SESS_ATTR_REUSEPORT);
5010               ed->data[1] = *buflen;
5011               /* *INDENT-ON* */
5012             }
5013         }
5014       else
5015         rv = VPPCOM_EINVAL;
5016       break;
5017
5018     case VPPCOM_ATTR_GET_BROADCAST:
5019       if (buffer && buflen && (*buflen >= sizeof (int)))
5020         {
5021           /* VPP-TBD */
5022           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
5023                                                 VCL_SESS_ATTR_BROADCAST);
5024           *buflen = sizeof (int);
5025
5026           if (VPPCOM_DEBUG > 2)
5027             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_BROADCAST: %d, "
5028                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
5029                           *buflen);
5030           if (VPPCOM_DEBUG > 0)
5031             {
5032               /* *INDENT-OFF* */
5033               ELOG_TYPE_DECLARE (e) =
5034                 {
5035                   .format = "VPPCOM_ATTR_GET_BROADCAST: %d buflen=%d",
5036                   .format_args = "i4i4",
5037                 };
5038
5039               struct {
5040                 u32 data[2];
5041               } * ed;
5042
5043               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5044               ed->data[0] = *(int *) buffer;
5045               ed->data[1] = *buflen;
5046               /* *INDENT-ON* */
5047             }
5048         }
5049       else
5050         rv = VPPCOM_EINVAL;
5051       break;
5052
5053     case VPPCOM_ATTR_SET_BROADCAST:
5054       if (buffer && buflen && (*buflen == sizeof (int)))
5055         {
5056           /* VPP-TBD */
5057           if (*(int *) buffer)
5058             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_BROADCAST);
5059           else
5060             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_BROADCAST);
5061
5062           if (VPPCOM_DEBUG > 2)
5063             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_BROADCAST: %d, "
5064                           "buflen %d, #VPP-TBD#", getpid (),
5065                           VCL_SESS_ATTR_TEST (session->attr,
5066                                               VCL_SESS_ATTR_BROADCAST),
5067                           *buflen);
5068           if (VPPCOM_DEBUG > 0)
5069             {
5070               /* *INDENT-OFF* */
5071               ELOG_TYPE_DECLARE (e) =
5072                 {
5073                   .format = "VPPCOM_ATTR_SET_BROADCAST: %d buflen=%d",
5074                   .format_args = "i4i4",
5075                 };
5076
5077               struct {
5078                 u32 data[2];
5079               } * ed;
5080
5081               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5082               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
5083                                                 VCL_SESS_ATTR_BROADCAST);
5084               ed->data[1] = *buflen;
5085               /* *INDENT-ON* */
5086             }
5087         }
5088       else
5089         rv = VPPCOM_EINVAL;
5090       break;
5091
5092     case VPPCOM_ATTR_GET_V6ONLY:
5093       if (buffer && buflen && (*buflen >= sizeof (int)))
5094         {
5095           /* VPP-TBD */
5096           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
5097                                                 VCL_SESS_ATTR_V6ONLY);
5098           *buflen = sizeof (int);
5099
5100           if (VPPCOM_DEBUG > 2)
5101             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_V6ONLY: %d, "
5102                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
5103                           *buflen);
5104           if (VPPCOM_DEBUG > 0)
5105             {
5106               /* *INDENT-OFF* */
5107               ELOG_TYPE_DECLARE (e) =
5108                 {
5109                   .format = "VPPCOM_ATTR_GET_V6ONLY: %d buflen=%d",
5110                   .format_args = "i4i4",
5111                 };
5112
5113               struct {
5114                 u32 data[2];
5115               } * ed;
5116
5117               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5118               ed->data[0] = *(int *) buffer;
5119               ed->data[1] = *buflen;
5120               /* *INDENT-ON* */
5121             }
5122         }
5123       else
5124         rv = VPPCOM_EINVAL;
5125       break;
5126
5127     case VPPCOM_ATTR_SET_V6ONLY:
5128       if (buffer && buflen && (*buflen == sizeof (int)))
5129         {
5130           /* VPP-TBD */
5131           if (*(int *) buffer)
5132             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_V6ONLY);
5133           else
5134             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_V6ONLY);
5135
5136           if (VPPCOM_DEBUG > 2)
5137             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_V6ONLY: %d, "
5138                           "buflen %d, #VPP-TBD#", getpid (),
5139                           VCL_SESS_ATTR_TEST (session->attr,
5140                                               VCL_SESS_ATTR_V6ONLY), *buflen);
5141           if (VPPCOM_DEBUG > 0)
5142             {
5143               /* *INDENT-OFF* */
5144               ELOG_TYPE_DECLARE (e) =
5145                 {
5146                   .format = "VPPCOM_ATTR_SET_V6ONLY: %d buflen=%d",
5147                   .format_args = "i4i4",
5148                 };
5149
5150               struct {
5151                 u32 data[2];
5152               } * ed;
5153
5154               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5155               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
5156                                                 VCL_SESS_ATTR_V6ONLY);
5157               ed->data[1] = *buflen;
5158               /* *INDENT-ON* */
5159             }
5160         }
5161       else
5162         rv = VPPCOM_EINVAL;
5163       break;
5164
5165     case VPPCOM_ATTR_GET_KEEPALIVE:
5166       if (buffer && buflen && (*buflen >= sizeof (int)))
5167         {
5168           /* VPP-TBD */
5169           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
5170                                                 VCL_SESS_ATTR_KEEPALIVE);
5171           *buflen = sizeof (int);
5172
5173           if (VPPCOM_DEBUG > 2)
5174             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_KEEPALIVE: %d, "
5175                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
5176                           *buflen);
5177           if (VPPCOM_DEBUG > 0)
5178             {
5179               /* *INDENT-OFF* */
5180               ELOG_TYPE_DECLARE (e) =
5181                 {
5182                   .format = "VPPCOM_ATTR_GET_KEEPALIVE: %d buflen=%d",
5183                   .format_args = "i4i4",
5184                 };
5185
5186               struct {
5187                 u32 data[2];
5188               } * ed;
5189
5190               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5191               ed->data[0] = *(int *) buffer;
5192               ed->data[1] = *buflen;
5193               /* *INDENT-ON* */
5194             }
5195         }
5196       else
5197         rv = VPPCOM_EINVAL;
5198       break;
5199
5200     case VPPCOM_ATTR_SET_KEEPALIVE:
5201       if (buffer && buflen && (*buflen == sizeof (int)))
5202         {
5203           /* VPP-TBD */
5204           if (*(int *) buffer)
5205             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_KEEPALIVE);
5206           else
5207             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_KEEPALIVE);
5208
5209           if (VPPCOM_DEBUG > 2)
5210             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_KEEPALIVE: %d, "
5211                           "buflen %d, #VPP-TBD#", getpid (),
5212                           VCL_SESS_ATTR_TEST (session->attr,
5213                                               VCL_SESS_ATTR_KEEPALIVE),
5214                           *buflen);
5215           if (VPPCOM_DEBUG > 0)
5216             {
5217               /* *INDENT-OFF* */
5218               ELOG_TYPE_DECLARE (e) =
5219                 {
5220                   .format = "VPPCOM_ATTR_SET_KEEPALIVE: %d buflen=%d",
5221                   .format_args = "i4i4",
5222                 };
5223
5224               struct {
5225                 u32 data[2];
5226               } * ed;
5227
5228               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5229               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
5230                                                 VCL_SESS_ATTR_KEEPALIVE);
5231               ed->data[1] = *buflen;
5232               /* *INDENT-ON* */
5233             }
5234         }
5235       else
5236         rv = VPPCOM_EINVAL;
5237       break;
5238
5239     case VPPCOM_ATTR_GET_TCP_NODELAY:
5240       if (buffer && buflen && (*buflen >= sizeof (int)))
5241         {
5242           /* VPP-TBD */
5243           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
5244                                                 VCL_SESS_ATTR_TCP_NODELAY);
5245           *buflen = sizeof (int);
5246
5247           if (VPPCOM_DEBUG > 2)
5248             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_NODELAY: %d, "
5249                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
5250                           *buflen);
5251           if (VPPCOM_DEBUG > 0)
5252             {
5253               /* *INDENT-OFF* */
5254               ELOG_TYPE_DECLARE (e) =
5255                 {
5256                   .format = "VPPCOM_ATTR_GET_TCP_NODELAY: %d buflen=%d",
5257                   .format_args = "i4i4",
5258                 };
5259
5260               struct {
5261                 u32 data[2];
5262               } * ed;
5263
5264               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5265               ed->data[0] = *(int *) buffer;
5266               ed->data[1] = *buflen;
5267               /* *INDENT-ON* */
5268             }
5269         }
5270       else
5271         rv = VPPCOM_EINVAL;
5272       break;
5273
5274     case VPPCOM_ATTR_SET_TCP_NODELAY:
5275       if (buffer && buflen && (*buflen == sizeof (int)))
5276         {
5277           /* VPP-TBD */
5278           if (*(int *) buffer)
5279             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
5280           else
5281             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
5282
5283           if (VPPCOM_DEBUG > 2)
5284             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_NODELAY: %d, "
5285                           "buflen %d, #VPP-TBD#", getpid (),
5286                           VCL_SESS_ATTR_TEST (session->attr,
5287                                               VCL_SESS_ATTR_TCP_NODELAY),
5288                           *buflen);
5289           if (VPPCOM_DEBUG > 0)
5290             {
5291               /* *INDENT-OFF* */
5292               ELOG_TYPE_DECLARE (e) =
5293                 {
5294                   .format = "VPPCOM_ATTR_SET_TCP_NODELAY: %d buflen=%d",
5295                   .format_args = "i4i4",
5296                 };
5297
5298               struct {
5299                 u32 data[2];
5300               } * ed;
5301
5302               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5303               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
5304                                                 VCL_SESS_ATTR_TCP_NODELAY);
5305               ed->data[1] = *buflen;
5306               /* *INDENT-ON* */
5307             }
5308         }
5309       else
5310         rv = VPPCOM_EINVAL;
5311       break;
5312
5313     case VPPCOM_ATTR_GET_TCP_KEEPIDLE:
5314       if (buffer && buflen && (*buflen >= sizeof (int)))
5315         {
5316           /* VPP-TBD */
5317           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
5318                                                 VCL_SESS_ATTR_TCP_KEEPIDLE);
5319           *buflen = sizeof (int);
5320
5321           if (VPPCOM_DEBUG > 2)
5322             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, "
5323                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
5324                           *buflen);
5325           if (VPPCOM_DEBUG > 0)
5326             {
5327               /* *INDENT-OFF* */
5328               ELOG_TYPE_DECLARE (e) =
5329                 {
5330                   .format = "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d buflen=%d",
5331                   .format_args = "i4i4",
5332                 };
5333
5334               struct {
5335                 u32 data[2];
5336               } * ed;
5337
5338               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5339               ed->data[0] = *(int *) buffer;
5340               ed->data[1] = *buflen;
5341               /* *INDENT-ON* */
5342             }
5343         }
5344       else
5345         rv = VPPCOM_EINVAL;
5346       break;
5347
5348     case VPPCOM_ATTR_SET_TCP_KEEPIDLE:
5349       if (buffer && buflen && (*buflen == sizeof (int)))
5350         {
5351           /* VPP-TBD */
5352           if (*(int *) buffer)
5353             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
5354           else
5355             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
5356
5357           if (VPPCOM_DEBUG > 2)
5358             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, "
5359                           "buflen %d, #VPP-TBD#", getpid (),
5360                           VCL_SESS_ATTR_TEST (session->attr,
5361                                               VCL_SESS_ATTR_TCP_KEEPIDLE),
5362                           *buflen);
5363           if (VPPCOM_DEBUG > 0)
5364             {
5365               /* *INDENT-OFF* */
5366               ELOG_TYPE_DECLARE (e) =
5367                 {
5368                   .format = "VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d buflen=%d",
5369                   .format_args = "i4i4",
5370                 };
5371
5372               struct {
5373                 u32 data[2];
5374               } * ed;
5375
5376               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5377               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
5378                                                 VCL_SESS_ATTR_TCP_KEEPIDLE);
5379               ed->data[1] = *buflen;
5380               /* *INDENT-ON* */
5381             }
5382         }
5383       else
5384         rv = VPPCOM_EINVAL;
5385       break;
5386
5387     case VPPCOM_ATTR_GET_TCP_KEEPINTVL:
5388       if (buffer && buflen && (*buflen >= sizeof (int)))
5389         {
5390           /* VPP-TBD */
5391           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
5392                                                 VCL_SESS_ATTR_TCP_KEEPINTVL);
5393           *buflen = sizeof (int);
5394
5395           if (VPPCOM_DEBUG > 2)
5396             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, "
5397                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
5398                           *buflen);
5399           if (VPPCOM_DEBUG > 0)
5400             {
5401               /* *INDENT-OFF* */
5402               ELOG_TYPE_DECLARE (e) =
5403                 {
5404                   .format = "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d buflen=%d",
5405                   .format_args = "i4i4",
5406                 };
5407
5408               struct {
5409                 u32 data[2];
5410               } * ed;
5411
5412               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5413               ed->data[0] = *(int *) buffer;
5414               ed->data[1] = *buflen;
5415               /* *INDENT-ON* */
5416             }
5417         }
5418       else
5419         rv = VPPCOM_EINVAL;
5420       break;
5421
5422     case VPPCOM_ATTR_SET_TCP_KEEPINTVL:
5423       if (buffer && buflen && (*buflen == sizeof (int)))
5424         {
5425           /* VPP-TBD */
5426           if (*(int *) buffer)
5427             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
5428           else
5429             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
5430
5431           if (VPPCOM_DEBUG > 2)
5432             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, "
5433                           "buflen %d, #VPP-TBD#", getpid (),
5434                           VCL_SESS_ATTR_TEST (session->attr,
5435                                               VCL_SESS_ATTR_TCP_KEEPINTVL),
5436                           *buflen);
5437           if (VPPCOM_DEBUG > 0)
5438             {
5439               /* *INDENT-OFF* */
5440               ELOG_TYPE_DECLARE (e) =
5441                 {
5442                   .format = "VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d buflen=%d",
5443                   .format_args = "i4i4",
5444                 };
5445
5446               struct {
5447                 u32 data[2];
5448               } * ed;
5449
5450               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5451               ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
5452                                                 VCL_SESS_ATTR_TCP_KEEPINTVL);
5453               ed->data[1] = *buflen;
5454               /* *INDENT-ON* */
5455             }
5456         }
5457       else
5458         rv = VPPCOM_EINVAL;
5459       break;
5460
5461     case VPPCOM_ATTR_GET_TCP_USER_MSS:
5462       if (buffer && buflen && (*buflen >= sizeof (u32)))
5463         {
5464           /* VPP-TBD */
5465           *(u32 *) buffer = session->user_mss;
5466           *buflen = sizeof (int);
5467
5468           if (VPPCOM_DEBUG > 2)
5469             clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_USER_MSS: %d, "
5470                           "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
5471                           *buflen);
5472           if (VPPCOM_DEBUG > 0)
5473             {
5474               /* *INDENT-OFF* */
5475               ELOG_TYPE_DECLARE (e) =
5476                 {
5477                   .format = "VPPCOM_ATTR_GET_TCP_USER_MSS: %d buflen=%d",
5478                   .format_args = "i4i4",
5479                 };
5480
5481               struct {
5482                 u32 data[2];
5483               } * ed;
5484
5485               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5486               ed->data[0] = *(int *) buffer;
5487               ed->data[1] = *buflen;
5488               /* *INDENT-ON* */
5489             }
5490         }
5491       else
5492         rv = VPPCOM_EINVAL;
5493       break;
5494
5495     case VPPCOM_ATTR_SET_TCP_USER_MSS:
5496       if (buffer && buflen && (*buflen == sizeof (u32)))
5497         {
5498           /* VPP-TBD */
5499           session->user_mss = *(u32 *) buffer;
5500
5501           if (VPPCOM_DEBUG > 2)
5502             clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_USER_MSS: %u, "
5503                           "buflen %d, #VPP-TBD#", getpid (),
5504                           session->user_mss, *buflen);
5505           if (VPPCOM_DEBUG > 0)
5506             {
5507               /* *INDENT-OFF* */
5508               ELOG_TYPE_DECLARE (e) =
5509                 {
5510                   .format = "VPPCOM_ATTR_SET_TCP_USER_MSS: %d buflen=%d",
5511                   .format_args = "i4i4",
5512                 };
5513
5514               struct {
5515                 u32 data[2];
5516               } * ed;
5517
5518               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
5519               ed->data[0] = session->user_mss;
5520               ed->data[1] = *buflen;
5521               /* *INDENT-ON* */
5522             }
5523         }
5524       else
5525         rv = VPPCOM_EINVAL;
5526       break;
5527
5528     default:
5529       rv = VPPCOM_EINVAL;
5530       break;
5531     }
5532
5533 done:
5534   clib_spinlock_unlock (&vcm->sessions_lockp);
5535   return rv;
5536 }
5537
5538 int
5539 vppcom_session_recvfrom (uint32_t session_index, void *buffer,
5540                          uint32_t buflen, int flags, vppcom_endpt_t * ep)
5541 {
5542   int rv = VPPCOM_OK;
5543   session_t *session = 0;
5544
5545   if (ep)
5546     {
5547       clib_spinlock_lock (&vcm->sessions_lockp);
5548       rv = vppcom_session_at_index (session_index, &session);
5549       if (PREDICT_FALSE (rv))
5550         {
5551           clib_spinlock_unlock (&vcm->sessions_lockp);
5552           if (VPPCOM_DEBUG > 0)
5553             clib_warning ("VCL<%d>: invalid session, "
5554                           "sid (%u) has been closed!",
5555                           getpid (), session_index);
5556           if (VPPCOM_DEBUG > 0)
5557             {
5558               /* *INDENT-OFF* */
5559               ELOG_TYPE_DECLARE (e) =
5560                 {
5561                   .format = "invalid session: %d closed",
5562                   .format_args = "i4",
5563                 };
5564
5565               struct {
5566                 u32 data;
5567               } * ed;
5568
5569               ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
5570               ed->data = session_index;
5571               /* *INDENT-ON* */
5572             }
5573           rv = VPPCOM_EBADFD;
5574           clib_spinlock_unlock (&vcm->sessions_lockp);
5575           goto done;
5576         }
5577       ep->vrf = session->vrf;
5578       ep->is_ip4 = session->peer_addr.is_ip4;
5579       ep->port = session->peer_port;
5580       if (session->peer_addr.is_ip4)
5581         clib_memcpy (ep->ip, &session->peer_addr.ip46.ip4,
5582                      sizeof (ip4_address_t));
5583       else
5584         clib_memcpy (ep->ip, &session->peer_addr.ip46.ip6,
5585                      sizeof (ip6_address_t));
5586       clib_spinlock_unlock (&vcm->sessions_lockp);
5587     }
5588
5589   if (flags == 0)
5590     rv = vppcom_session_read (session_index, buffer, buflen);
5591   else if (flags & MSG_PEEK)
5592     rv = vppcom_session_peek (session_index, buffer, buflen);
5593   else
5594     {
5595       clib_warning ("VCL<%d>: Unsupport flags for recvfrom %d",
5596                     getpid (), flags);
5597       rv = VPPCOM_EAFNOSUPPORT;
5598     }
5599
5600 done:
5601   return rv;
5602 }
5603
5604 int
5605 vppcom_session_sendto (uint32_t session_index, void *buffer,
5606                        uint32_t buflen, int flags, vppcom_endpt_t * ep)
5607 {
5608   if (!buffer)
5609     return VPPCOM_EINVAL;
5610
5611   if (ep)
5612     {
5613       // TBD
5614       return VPPCOM_EINVAL;
5615     }
5616
5617   if (flags)
5618     {
5619       // TBD check the flags and do the right thing
5620       if (VPPCOM_DEBUG > 2)
5621         clib_warning ("VCL<%d>: handling flags 0x%u (%d) "
5622                       "not implemented yet.", getpid (), flags, flags);
5623     }
5624
5625   return (vppcom_session_write (session_index, buffer, buflen));
5626 }
5627
5628 int
5629 vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
5630 {
5631   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
5632   u32 i, keep_trying = 1;
5633   int rv, num_ev = 0;
5634
5635   if (VPPCOM_DEBUG > 3)
5636     clib_warning ("VCL<%d>: vp %p, nsids %u, wait_for_time %f",
5637                   getpid (), vp, n_sids, wait_for_time);
5638
5639   if (!vp)
5640     return VPPCOM_EFAULT;
5641
5642   do
5643     {
5644       session_t *session;
5645
5646       for (i = 0; i < n_sids; i++)
5647         {
5648           ASSERT (vp[i].revents);
5649
5650           VCL_LOCK_AND_GET_SESSION (vp[i].sid, &session);
5651           clib_spinlock_unlock (&vcm->sessions_lockp);
5652
5653           if (*vp[i].revents)
5654             *vp[i].revents = 0;
5655
5656           if (POLLIN & vp[i].events)
5657             {
5658               VCL_LOCK_AND_GET_SESSION (vp[i].sid, &session);
5659               rv = vppcom_session_read_ready (session, vp[i].sid);
5660               clib_spinlock_unlock (&vcm->sessions_lockp);
5661               if (rv > 0)
5662                 {
5663                   *vp[i].revents |= POLLIN;
5664                   num_ev++;
5665                 }
5666               else if (rv < 0)
5667                 {
5668                   switch (rv)
5669                     {
5670                     case VPPCOM_ECONNRESET:
5671                       *vp[i].revents = POLLHUP;
5672                       break;
5673
5674                     default:
5675                       *vp[i].revents = POLLERR;
5676                       break;
5677                     }
5678                   num_ev++;
5679                 }
5680             }
5681
5682           if (POLLOUT & vp[i].events)
5683             {
5684               VCL_LOCK_AND_GET_SESSION (vp[i].sid, &session);
5685               rv = vppcom_session_write_ready (session, vp[i].sid);
5686               clib_spinlock_unlock (&vcm->sessions_lockp);
5687               if (rv > 0)
5688                 {
5689                   *vp[i].revents |= POLLOUT;
5690                   num_ev++;
5691                 }
5692               else if (rv < 0)
5693                 {
5694                   switch (rv)
5695                     {
5696                     case VPPCOM_ECONNRESET:
5697                       *vp[i].revents = POLLHUP;
5698                       break;
5699
5700                     default:
5701                       *vp[i].revents = POLLERR;
5702                       break;
5703                     }
5704                   num_ev++;
5705                 }
5706             }
5707
5708           if (0)
5709             {
5710             done:
5711               *vp[i].revents = POLLNVAL;
5712               num_ev++;
5713             }
5714         }
5715       if (wait_for_time != -1)
5716         keep_trying = (clib_time_now (&vcm->clib_time) <= timeout) ? 1 : 0;
5717     }
5718   while ((num_ev == 0) && keep_trying);
5719
5720   if (VPPCOM_DEBUG > 3)
5721     {
5722       clib_warning ("VCL<%d>: returning %d", getpid (), num_ev);
5723       for (i = 0; i < n_sids; i++)
5724         {
5725           clib_warning ("VCL<%d>: vp[%d].sid %d (0x%x), .events 0x%x, "
5726                         ".revents 0x%x", getpid (), i, vp[i].sid, vp[i].sid,
5727                         vp[i].events, *vp[i].revents);
5728         }
5729     }
5730   return num_ev;
5731 }
5732
5733 /*
5734  * fd.io coding-style-patch-verification: ON
5735  *
5736  * Local Variables:
5737  * eval: (c-set-style "gnu")
5738  * End:
5739  */