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
  27 #define vl_typedefs             /* define message structures */
  28 #include <vpp/api/vpe_all_api_h.h>
  29 #undef vl_typedefs
  30
  31 /* declare message handlers for each api */
  32
  33 #define vl_endianfun            /* define message structures */
  34 #include <vpp/api/vpe_all_api_h.h>
  35 #undef vl_endianfun
  36
  37 /* instantiate all the print functions we know about */
  38 #define vl_print(handle, ...)
  39 #define vl_printfun
  40 #include <vpp/api/vpe_all_api_h.h>
  41 #undef vl_printfun
  42
  43 #if (CLIB_DEBUG > 0)
  44 /* Set VPPCOM_DEBUG_INIT 2 for connection debug,
  45  *                       3 for read/write debug output
  46  * or
  47  *    export VCL_DEBUG=<#> to set dynamically.
  48  */
  49 #define VPPCOM_DEBUG_INIT 1
  50 #else
  51 #define VPPCOM_DEBUG_INIT 0
  52 #endif
  53
  54 #define VPPCOM_DEBUG vcm->debug
  55
  56 /*
  57  * VPPCOM Private definitions and functions.
  58  */
  59 typedef enum
  60 {
  61   STATE_APP_START,
  62   STATE_APP_CONN_VPP,
  63   STATE_APP_ENABLED,
  64   STATE_APP_ATTACHED,
  65 } app_state_t;
  66
  67 typedef enum
  68 {
  69   STATE_START,
  70   STATE_CONNECT,
  71   STATE_LISTEN,
  72   STATE_ACCEPT,
  73   STATE_DISCONNECT,
  74   STATE_FAILED
  75 } session_state_t;
  76
  77 typedef struct epoll_event vppcom_epoll_event_t;
  78
  79 typedef struct
  80 {
  81   u32 next_sid;
  82   u32 prev_sid;
  83   u32 vep_idx;
  84   vppcom_epoll_event_t ev;
  85 #define VEP_DEFAULT_ET_MASK  (EPOLLIN|EPOLLOUT)
  86 #define VEP_UNSUPPORTED_EVENTS (EPOLLONESHOT|EPOLLEXCLUSIVE)
  87   u32 et_mask;
  88 } vppcom_epoll_t;
  89
  90 typedef struct
  91 {
  92   u8 is_ip4;
  93   ip46_address_t ip46;
  94 } vppcom_ip46_t;
  95
  96 typedef struct
  97 {
  98   volatile session_state_t state;
  99
 100   svm_fifo_t *server_rx_fifo;
 101   svm_fifo_t *server_tx_fifo;
 102   u8 *segment_name;
 103   u32 sm_seg_index;
 104   u32 client_context;
 105   u64 vpp_handle;
 106   unix_shared_memory_queue_t *vpp_event_queue;
 107
 108   /* Socket configuration state */
 109   /* TBD: covert 'is_*' vars to bit in u8 flags; */
 110   u8 is_server;
 111   u8 is_listen;
 112   u8 is_cut_thru;
 113   u8 is_nonblocking;
 114   u8 is_vep;
 115   u8 is_vep_session;
 116   u32 wait_cont_idx;
 117   vppcom_epoll_t vep;
 118   u32 vrf;
 119   vppcom_ip46_t lcl_addr;
 120   vppcom_ip46_t peer_addr;
 121   u16 lcl_port;                 // network order
 122   u16 peer_port;                // network order
 123   u8 proto;
 124   u64 client_queue_address;
 125   u64 options[16];
 126 } session_t;
 127
 128 typedef struct vppcom_cfg_t_
 129 {
 130   u64 heapsize;
 131   u64 segment_baseva;
 132   u32 segment_size;
 133   u32 add_segment_size;
 134   u32 preallocated_fifo_pairs;
 135   u32 rx_fifo_size;
 136   u32 tx_fifo_size;
 137   u32 event_queue_size;
 138   u32 listen_queue_size;
 139   u8 app_proxy_transport_tcp;
 140   u8 app_proxy_transport_udp;
 141   u8 app_scope_local;
 142   u8 app_scope_global;
 143   u8 *namespace_id;
 144   u64 namespace_secret;
 145   f64 app_timeout;
 146   f64 session_timeout;
 147   f64 accept_timeout;
 148 } vppcom_cfg_t;
 149
 150 typedef struct vppcom_main_t_
 151 {
 152   u8 init;
 153   u32 debug;
 154   u32 *client_session_index_fifo;
 155   volatile u32 bind_session_index;
 156   int main_cpu;
 157
 158   /* vpe input queue */
 159   unix_shared_memory_queue_t *vl_input_queue;
 160
 161   /* API client handle */
 162   u32 my_client_index;
 163
 164   /* Session pool */
 165   clib_spinlock_t sessions_lockp;
 166   session_t *sessions;
 167
 168   /* Hash table for disconnect processing */
 169   uword *session_index_by_vpp_handles;
 170
 171   /* Select bitmaps */
 172   clib_bitmap_t *rd_bitmap;
 173   clib_bitmap_t *wr_bitmap;
 174   clib_bitmap_t *ex_bitmap;
 175
 176   /* Our event queue */
 177   unix_shared_memory_queue_t *app_event_queue;
 178
 179   /* unique segment name counter */
 180   u32 unique_segment_index;
 181
 182   /* For deadman timers */
 183   clib_time_t clib_time;
 184
 185   /* State of the connection, shared between msg RX thread and main thread */
 186   volatile app_state_t app_state;
 187
 188   vppcom_cfg_t cfg;
 189
 190   /* VNET_API_ERROR_FOO -> "Foo" hash table */
 191   uword *error_string_by_error_number;
 192 } vppcom_main_t;
 193
 194 /* NOTE: _vppcom_main is only used until the heap is allocated.
 195  *       Do not access it directly -- use vcm which will point to
 196  *       the heap allocated copy after init.
 197  */
 198 static vppcom_main_t _vppcom_main = {
 199   .debug = VPPCOM_DEBUG_INIT,
 200   .my_client_index = ~0
 201 };
 202
 203 static vppcom_main_t *vcm = &_vppcom_main;
 204
 205 #define VCL_LOCK_AND_GET_SESSION(I, S)                  \
 206 do {                                                    \
 207   clib_spinlock_lock (&vcm->sessions_lockp);            \
 208   rv = vppcom_session_at_index (I, S);                  \
 209   if (PREDICT_FALSE (rv))                               \
 210     {                                                   \
 211       clib_spinlock_unlock (&vcm->sessions_lockp);      \
 212                                                         \
 213       if (VPPCOM_DEBUG > 0)                             \
 214         clib_warning ("[%s] ERROR: Invalid ##I (%u)!",  \
 215                       getpid (), I);                  \
 216                                                         \
 217       goto done;                                        \
 218     }                                                   \
 219 } while (0)
 220
 221 static const char *
 222 vppcom_app_state_str (app_state_t state)
 223 {
 224   char *st;
 225
 226   switch (state)
 227     {
 228     case STATE_APP_START:
 229       st = "STATE_APP_START";
 230       break;
 231
 232     case STATE_APP_CONN_VPP:
 233       st = "STATE_APP_CONN_VPP";
 234       break;
 235
 236     case STATE_APP_ENABLED:
 237       st = "STATE_APP_ENABLED";
 238       break;
 239
 240     case STATE_APP_ATTACHED:
 241       st = "STATE_APP_ATTACHED";
 242       break;
 243
 244     default:
 245       st = "UNKNOWN_APP_STATE";
 246       break;
 247     }
 248
 249   return st;
 250 }
 251
 252 static const char *
 253 vppcom_session_state_str (session_state_t state)
 254 {
 255   char *st;
 256
 257   switch (state)
 258     {
 259     case STATE_START:
 260       st = "STATE_START";
 261       break;
 262
 263     case STATE_CONNECT:
 264       st = "STATE_CONNECT";
 265       break;
 266
 267     case STATE_LISTEN:
 268       st = "STATE_LISTEN";
 269       break;
 270
 271     case STATE_ACCEPT:
 272       st = "STATE_ACCEPT";
 273       break;
 274
 275     case STATE_DISCONNECT:
 276       st = "STATE_DISCONNECT";
 277       break;
 278
 279     case STATE_FAILED:
 280       st = "STATE_FAILED";
 281       break;
 282
 283     default:
 284       st = "UNKNOWN_STATE";
 285       break;
 286     }
 287
 288   return st;
 289 }
 290
 291 /*
 292  * VPPCOM Utility Functions
 293  */
 294 static inline int
 295 vppcom_session_at_index (u32 session_index, session_t * volatile *sess)
 296 {
 297   /* Assumes that caller has acquired spinlock: vcm->sessions_lockp */
 298   if (PREDICT_FALSE ((session_index == ~0) ||
 299                      pool_is_free_index (vcm->sessions, session_index)))
 300     {
 301       clib_warning ("[%d] invalid session, sid (%u) has been closed!",
 302                     getpid (), session_index);
 303       return VPPCOM_EBADFD;
 304     }
 305   *sess = pool_elt_at_index (vcm->sessions, session_index);
 306   return VPPCOM_OK;
 307 }
 308
 309 static int
 310 vppcom_connect_to_vpp (char *app_name)
 311 {
 312   api_main_t *am = &api_main;
 313
 314   if (VPPCOM_DEBUG > 0)
 315     printf ("\nConnecting to VPP api...");
 316   if (vl_client_connect_to_vlib ("/vpe-api", app_name, 32) < 0)
 317     {
 318       clib_warning ("[%d] connect to vpp (%s) failed!", getpid (), app_name);
 319       return VPPCOM_ECONNREFUSED;
 320     }
 321
 322   vcm->vl_input_queue = am->shmem_hdr->vl_input_queue;
 323   vcm->my_client_index = am->my_client_index;
 324   if (VPPCOM_DEBUG > 0)
 325     printf (" connected!\n");
 326
 327   vcm->app_state = STATE_APP_CONN_VPP;
 328   return VPPCOM_OK;
 329 }
 330
 331 static u8 *
 332 format_api_error (u8 * s, va_list * args)
 333 {
 334   i32 error = va_arg (*args, u32);
 335   uword *p;
 336
 337   p = hash_get (vcm->error_string_by_error_number, -error);
 338
 339   if (p)
 340     s = format (s, "%s (%d)", p[0], error);
 341   else
 342     s = format (s, "%d", error);
 343   return s;
 344 }
 345
 346 static void
 347 vppcom_init_error_string_table (void)
 348 {
 349   vcm->error_string_by_error_number = hash_create (0, sizeof (uword));
 350
 351 #define _(n,v,s) hash_set (vcm->error_string_by_error_number, -v, s);
 352   foreach_vnet_api_error;
 353 #undef _
 354
 355   hash_set (vcm->error_string_by_error_number, 99, "Misc");
 356 }
 357
 358 static inline int
 359 vppcom_wait_for_app_state_change (app_state_t app_state)
 360 {
 361   f64 timeout = clib_time_now (&vcm->clib_time) + vcm->cfg.app_timeout;
 362
 363   while (clib_time_now (&vcm->clib_time) < timeout)
 364     {
 365       if (vcm->app_state == app_state)
 366         return VPPCOM_OK;
 367     }
 368   if (VPPCOM_DEBUG > 0)
 369     clib_warning ("[%d] timeout waiting for state %s (%d)", getpid (),
 370                   vppcom_app_state_str (app_state), app_state);
 371   return VPPCOM_ETIMEDOUT;
 372 }
 373
 374 static inline int
 375 vppcom_wait_for_session_state_change (u32 session_index,
 376                                       session_state_t state,
 377                                       f64 wait_for_time)
 378 {
 379   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
 380   session_t *volatile session;
 381   int rv;
 382
 383   do
 384     {
 385       clib_spinlock_lock (&vcm->sessions_lockp);
 386       rv = vppcom_session_at_index (session_index, &session);
 387       if (PREDICT_FALSE (rv))
 388         {
 389           clib_spinlock_unlock (&vcm->sessions_lockp);
 390           return rv;
 391         }
 392       if (session->state == state)
 393         {
 394           clib_spinlock_unlock (&vcm->sessions_lockp);
 395           return VPPCOM_OK;
 396         }
 397       clib_spinlock_unlock (&vcm->sessions_lockp);
 398     }
 399   while (clib_time_now (&vcm->clib_time) < timeout);
 400
 401   if (VPPCOM_DEBUG > 0)
 402     clib_warning ("[%d] timeout waiting for state %s (%d)", getpid (),
 403                   vppcom_session_state_str (state), state);
 404   return VPPCOM_ETIMEDOUT;
 405 }
 406
 407 static inline int
 408 vppcom_wait_for_client_session_index (f64 wait_for_time)
 409 {
 410   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
 411
 412   do
 413     {
 414       if (clib_fifo_elts (vcm->client_session_index_fifo))
 415         return VPPCOM_OK;
 416     }
 417   while (clib_time_now (&vcm->clib_time) < timeout);
 418
 419   if (wait_for_time == 0)
 420     return VPPCOM_EAGAIN;
 421
 422   if (VPPCOM_DEBUG > 0)
 423     clib_warning ("[%d] timeout waiting for client_session_index", getpid ());
 424   return VPPCOM_ETIMEDOUT;
 425 }
 426
 427 /*
 428  * VPP-API message functions
 429  */
 430 static void
 431 vppcom_send_session_enable_disable (u8 is_enable)
 432 {
 433   vl_api_session_enable_disable_t *bmp;
 434   bmp = vl_msg_api_alloc (sizeof (*bmp));
 435   memset (bmp, 0, sizeof (*bmp));
 436
 437   bmp->_vl_msg_id = ntohs (VL_API_SESSION_ENABLE_DISABLE);
 438   bmp->client_index = vcm->my_client_index;
 439   bmp->context = htonl (0xfeedface);
 440   bmp->is_enable = is_enable;
 441   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
 442 }
 443
 444 static int
 445 vppcom_app_session_enable (void)
 446 {
 447   int rv;
 448
 449   if (vcm->app_state != STATE_APP_ENABLED)
 450     {
 451       vppcom_send_session_enable_disable (1 /* is_enabled == TRUE */ );
 452       rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
 453       if (PREDICT_FALSE (rv))
 454         {
 455           if (VPPCOM_DEBUG > 0)
 456             clib_warning ("[%d] Session enable timed out, rv = %s (%d)",
 457                           getpid (), vppcom_retval_str (rv), rv);
 458           return rv;
 459         }
 460     }
 461   return VPPCOM_OK;
 462 }
 463
 464 static void
 465   vl_api_session_enable_disable_reply_t_handler
 466   (vl_api_session_enable_disable_reply_t * mp)
 467 {
 468   if (mp->retval)
 469     {
 470       clib_warning ("[%d] session_enable_disable failed: %U", getpid (),
 471                     format_api_error, ntohl (mp->retval));
 472     }
 473   else
 474     vcm->app_state = STATE_APP_ENABLED;
 475 }
 476
 477 static void
 478 vppcom_app_send_attach (void)
 479 {
 480   vl_api_application_attach_t *bmp;
 481   u8 nsid_len = vec_len (vcm->cfg.namespace_id);
 482   u8 app_is_proxy = (vcm->cfg.app_proxy_transport_tcp ||
 483                      vcm->cfg.app_proxy_transport_udp);
 484
 485   bmp = vl_msg_api_alloc (sizeof (*bmp));
 486   memset (bmp, 0, sizeof (*bmp));
 487
 488   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
 489   bmp->client_index = vcm->my_client_index;
 490   bmp->context = htonl (0xfeedface);
 491   bmp->options[APP_OPTIONS_FLAGS] =
 492     APP_OPTIONS_FLAGS_ACCEPT_REDIRECT | APP_OPTIONS_FLAGS_ADD_SEGMENT |
 493     (vcm->cfg.app_scope_local ? APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE : 0) |
 494     (vcm->cfg.app_scope_global ? APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE : 0) |
 495     (app_is_proxy ? APP_OPTIONS_FLAGS_IS_PROXY : 0);
 496   bmp->options[APP_OPTIONS_PROXY_TRANSPORT] =
 497     (vcm->cfg.app_proxy_transport_tcp ? 1 << TRANSPORT_PROTO_TCP : 0) |
 498     (vcm->cfg.app_proxy_transport_udp ? 1 << TRANSPORT_PROTO_UDP : 0);
 499   bmp->options[SESSION_OPTIONS_SEGMENT_SIZE] = vcm->cfg.segment_size;
 500   bmp->options[SESSION_OPTIONS_ADD_SEGMENT_SIZE] = vcm->cfg.add_segment_size;
 501   bmp->options[SESSION_OPTIONS_RX_FIFO_SIZE] = vcm->cfg.rx_fifo_size;
 502   bmp->options[SESSION_OPTIONS_TX_FIFO_SIZE] = vcm->cfg.tx_fifo_size;
 503   if (nsid_len)
 504     {
 505       bmp->namespace_id_len = nsid_len;
 506       clib_memcpy (bmp->namespace_id, vcm->cfg.namespace_id, nsid_len);
 507       bmp->options[APP_OPTIONS_NAMESPACE_SECRET] = vcm->cfg.namespace_secret;
 508     }
 509   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
 510 }
 511
 512 static int
 513 vppcom_app_attach (void)
 514 {
 515   int rv;
 516
 517   vppcom_app_send_attach ();
 518   rv = vppcom_wait_for_app_state_change (STATE_APP_ATTACHED);
 519   if (PREDICT_FALSE (rv))
 520     {
 521       if (VPPCOM_DEBUG > 0)
 522         clib_warning ("[%d] application attach timed out, rv = %s (%d)",
 523                       getpid (), vppcom_retval_str (rv), rv);
 524       return rv;
 525     }
 526   return VPPCOM_OK;
 527 }
 528
 529 static void
 530 vppcom_app_detach (void)
 531 {
 532   vl_api_application_detach_t *bmp;
 533   bmp = vl_msg_api_alloc (sizeof (*bmp));
 534   memset (bmp, 0, sizeof (*bmp));
 535
 536   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
 537   bmp->client_index = vcm->my_client_index;
 538   bmp->context = htonl (0xfeedface);
 539   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
 540 }
 541
 542 static void
 543 vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
 544                                            mp)
 545 {
 546   static svm_fifo_segment_create_args_t _a;
 547   svm_fifo_segment_create_args_t *a = &_a;
 548   int rv;
 549
 550   memset (a, 0, sizeof (*a));
 551   if (mp->retval)
 552     {
 553       clib_warning ("[%d] attach failed: %U", getpid (),
 554                     format_api_error, ntohl (mp->retval));
 555       return;
 556     }
 557
 558   if (mp->segment_name_length == 0)
 559     {
 560       clib_warning ("[%d] segment_name_length zero", getpid ());
 561       return;
 562     }
 563
 564   a->segment_name = (char *) mp->segment_name;
 565   a->segment_size = mp->segment_size;
 566
 567   ASSERT (mp->app_event_queue_address);
 568
 569   /* Attach to the segment vpp created */
 570   rv = svm_fifo_segment_attach (a);
 571   vec_reset_length (a->new_segment_indices);
 572   if (PREDICT_FALSE (rv))
 573     {
 574       clib_warning ("[%d] svm_fifo_segment_attach ('%s') failed", getpid (),
 575                     mp->segment_name);
 576       return;
 577     }
 578
 579   vcm->app_event_queue =
 580     uword_to_pointer (mp->app_event_queue_address,
 581                       unix_shared_memory_queue_t *);
 582
 583   vcm->app_state = STATE_APP_ATTACHED;
 584 }
 585
 586 static void
 587 vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
 588                                            mp)
 589 {
 590   if (mp->retval)
 591     clib_warning ("[%d] detach failed: %U", getpid (), format_api_error,
 592                   ntohl (mp->retval));
 593
 594   vcm->app_state = STATE_APP_ENABLED;
 595 }
 596
 597 static void
 598 vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
 599                                            mp)
 600 {
 601   uword *p;
 602   u32 session_index = ~0;
 603
 604   p = hash_get (vcm->session_index_by_vpp_handles, mp->handle);
 605   if (p)
 606     {
 607       session_t *session = 0;
 608       int rv;
 609
 610       session_index = p[0];
 611       hash_unset (vcm->session_index_by_vpp_handles, mp->handle);
 612       clib_spinlock_lock (&vcm->sessions_lockp);
 613       rv = vppcom_session_at_index (session_index, &session);
 614       if (PREDICT_FALSE (rv))
 615         {
 616           if (VPPCOM_DEBUG > 1)
 617             clib_warning ("[%d] invalid session, sid %u has been closed!",
 618                           getpid (), session_index);
 619         }
 620       else
 621         {
 622           if (VPPCOM_DEBUG > 1)
 623             clib_warning ("[%d] vpp handle 0x%llx, sid %u disconnected!",
 624                           getpid (), mp->handle, session_index);
 625
 626           session->state = STATE_DISCONNECT;
 627         }
 628       clib_spinlock_unlock (&vcm->sessions_lockp);
 629     }
 630   else
 631     {
 632       if (VPPCOM_DEBUG > 1)
 633         clib_warning ("[%d] couldn't find session: unknown vpp handle 0x%llx",
 634                       getpid (), mp->handle);
 635     }
 636
 637   if (mp->retval)
 638     clib_warning ("[%d] disconnect_session vpp handle 0x%llx, sid %u "
 639                   "failed: %U", getpid (), mp->handle, session_index,
 640                   format_api_error, ntohl (mp->retval));
 641 }
 642
 643 static void
 644 vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
 645 {
 646   static svm_fifo_segment_create_args_t _a;
 647   svm_fifo_segment_create_args_t *a = &_a;
 648   int rv;
 649
 650   memset (a, 0, sizeof (*a));
 651   a->segment_name = (char *) mp->segment_name;
 652   a->segment_size = mp->segment_size;
 653   /* Attach to the segment vpp created */
 654   rv = svm_fifo_segment_attach (a);
 655   vec_reset_length (a->new_segment_indices);
 656   if (PREDICT_FALSE (rv))
 657     {
 658       clib_warning ("[%d] svm_fifo_segment_attach ('%s') failed",
 659                     getpid (), mp->segment_name);
 660       return;
 661     }
 662   if (VPPCOM_DEBUG > 1)
 663     clib_warning ("[%d] mapped new segment '%s' size %d", getpid (),
 664                   mp->segment_name, mp->segment_size);
 665 }
 666
 667 static void
 668 vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
 669 {
 670   session_t *session = 0;
 671   vl_api_disconnect_session_reply_t *rmp;
 672   uword *p;
 673   int rv = 0;
 674
 675   p = hash_get (vcm->session_index_by_vpp_handles, mp->handle);
 676   if (p)
 677     {
 678       int rval;
 679       clib_spinlock_lock (&vcm->sessions_lockp);
 680       rval = vppcom_session_at_index (p[0], &session);
 681       if (PREDICT_FALSE (rval))
 682         {
 683           if (VPPCOM_DEBUG > 1)
 684             clib_warning ("[%d] invalid session, sid (%u) has been closed!",
 685                           getpid (), p[0]);
 686         }
 687       else
 688         pool_put (vcm->sessions, session);
 689       clib_spinlock_unlock (&vcm->sessions_lockp);
 690       hash_unset (vcm->session_index_by_vpp_handles, mp->handle);
 691     }
 692   else
 693     {
 694       clib_warning ("[%d] couldn't find session: unknown vpp handle 0x%llx",
 695                     getpid (), mp->handle);
 696       rv = -11;
 697     }
 698
 699   rmp = vl_msg_api_alloc (sizeof (*rmp));
 700   memset (rmp, 0, sizeof (*rmp));
 701
 702   rmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION_REPLY);
 703   rmp->retval = htonl (rv);
 704   rmp->handle = mp->handle;
 705   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
 706 }
 707
 708 static void
 709 vl_api_reset_session_t_handler (vl_api_reset_session_t * mp)
 710 {
 711   session_t *session = 0;
 712   vl_api_reset_session_reply_t *rmp;
 713   uword *p;
 714   int rv = 0;
 715
 716   p = hash_get (vcm->session_index_by_vpp_handles, mp->handle);
 717   if (p)
 718     {
 719       int rval;
 720       clib_spinlock_lock (&vcm->sessions_lockp);
 721       rval = vppcom_session_at_index (p[0], &session);
 722       if (PREDICT_FALSE (rval))
 723         {
 724           if (VPPCOM_DEBUG > 1)
 725             clib_warning ("[%d] invalid session, sid (%u) has been closed!",
 726                           getpid (), p[0]);
 727         }
 728       else
 729         pool_put (vcm->sessions, session);
 730       clib_spinlock_unlock (&vcm->sessions_lockp);
 731       hash_unset (vcm->session_index_by_vpp_handles, mp->handle);
 732     }
 733   else
 734     {
 735       clib_warning ("[%d] couldn't find session: unknown vpp handle 0x%llx",
 736                     getpid (), mp->handle);
 737       rv = -11;
 738     }
 739
 740   rmp = vl_msg_api_alloc (sizeof (*rmp));
 741   memset (rmp, 0, sizeof (*rmp));
 742   rmp->_vl_msg_id = ntohs (VL_API_RESET_SESSION_REPLY);
 743   rmp->retval = htonl (rv);
 744   rmp->handle = mp->handle;
 745   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
 746 }
 747
 748 static void
 749 vl_api_connect_session_reply_t_handler (vl_api_connect_session_reply_t * mp)
 750 {
 751   session_t *session;
 752   u32 session_index;
 753   svm_fifo_t *rx_fifo, *tx_fifo;
 754   u8 is_cut_thru = 0;
 755   int rv;
 756
 757   if (mp->retval)
 758     {
 759       clib_warning ("[%d] connect failed: %U", getpid (), format_api_error,
 760                     ntohl (mp->retval));
 761       return;
 762     }
 763
 764   session_index = mp->context;
 765   if (VPPCOM_DEBUG > 1)
 766     clib_warning ("[%d] session_index = %d 0x%08x", getpid (),
 767                   session_index, session_index);
 768
 769   clib_spinlock_lock (&vcm->sessions_lockp);
 770   if (pool_is_free_index (vcm->sessions, session_index))
 771     {
 772       clib_spinlock_unlock (&vcm->sessions_lockp);
 773       if (VPPCOM_DEBUG > 1)
 774         clib_warning ("[%d] invalid session, sid %d is closed!",
 775                       getpid (), session_index);
 776       return;
 777     }
 778
 779   /* We've been redirected */
 780   if (mp->segment_name_length > 0)
 781     {
 782       static svm_fifo_segment_create_args_t _a;
 783       svm_fifo_segment_create_args_t *a = &_a;
 784
 785       is_cut_thru = 1;
 786       memset (a, 0, sizeof (*a));
 787       a->segment_name = (char *) mp->segment_name;
 788       if (VPPCOM_DEBUG > 1)
 789         clib_warning ("[%d] cut-thru segment: %s\n",
 790                       getpid (), a->segment_name);
 791
 792       rv = svm_fifo_segment_attach (a);
 793       vec_reset_length (a->new_segment_indices);
 794       if (PREDICT_FALSE (rv))
 795         {
 796           clib_spinlock_unlock (&vcm->sessions_lockp);
 797           clib_warning ("[%d] sm_fifo_segment_attach ('%s') failed",
 798                         getpid (), a->segment_name);
 799           return;
 800         }
 801     }
 802
 803   /*
 804    * Setup session
 805    */
 806   session = pool_elt_at_index (vcm->sessions, session_index);
 807   session->is_cut_thru = is_cut_thru;
 808   session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
 809                                                unix_shared_memory_queue_t *);
 810
 811   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
 812   rx_fifo->client_session_index = session_index;
 813   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
 814   tx_fifo->client_session_index = session_index;
 815
 816   session->server_rx_fifo = rx_fifo;
 817   session->server_tx_fifo = tx_fifo;
 818   session->vpp_handle = mp->handle;
 819   session->state = STATE_CONNECT;
 820
 821   /* Add it to lookup table */
 822   hash_set (vcm->session_index_by_vpp_handles, mp->handle, session_index);
 823
 824   if (VPPCOM_DEBUG > 1)
 825     clib_warning ("[%d] client sid %d, vpp handle 0x%llx\n"
 826                   "  session_rx_fifo %p, refcnt %d\n"
 827                   "  session_tx_fifo %p, refcnt %d",
 828                   getpid (), session_index, mp->handle,
 829                   session->server_rx_fifo,
 830                   session->server_rx_fifo->refcnt,
 831                   session->server_tx_fifo, session->server_tx_fifo->refcnt);
 832
 833   clib_spinlock_unlock (&vcm->sessions_lockp);
 834 }
 835
 836 static void
 837 vppcom_send_connect_sock (session_t * session, u32 session_index)
 838 {
 839   vl_api_connect_sock_t *cmp;
 840
 841   /* Assumes caller as acquired the spinlock: vcm->sessions_lockp */
 842   session->is_server = 0;
 843   cmp = vl_msg_api_alloc (sizeof (*cmp));
 844   memset (cmp, 0, sizeof (*cmp));
 845   cmp->_vl_msg_id = ntohs (VL_API_CONNECT_SOCK);
 846   cmp->client_index = vcm->my_client_index;
 847   cmp->context = session_index;
 848
 849   if (VPPCOM_DEBUG > 1)
 850     clib_warning ("[%d] session_index = %d 0x%08x",
 851                   getpid (), session_index, session_index);
 852
 853   cmp->vrf = session->vrf;
 854   cmp->is_ip4 = session->peer_addr.is_ip4;
 855   clib_memcpy (cmp->ip, &session->peer_addr.ip46, sizeof (cmp->ip));
 856   cmp->port = session->peer_port;
 857   cmp->proto = session->proto;
 858   clib_memcpy (cmp->options, session->options, sizeof (cmp->options));
 859   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & cmp);
 860 }
 861
 862 static inline void
 863 vppcom_send_disconnect (session_t * session)
 864 {
 865   vl_api_disconnect_session_t *dmp;
 866
 867   /* Assumes caller as acquired the spinlock: vcm->sessions_lockp */
 868   dmp = vl_msg_api_alloc (sizeof (*dmp));
 869   memset (dmp, 0, sizeof (*dmp));
 870   dmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION);
 871   dmp->client_index = vcm->my_client_index;
 872   dmp->handle = session->vpp_handle;
 873   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & dmp);
 874 }
 875
 876 static void
 877 vl_api_bind_sock_reply_t_handler (vl_api_bind_sock_reply_t * mp)
 878 {
 879   session_t *session = 0;
 880   int rv;
 881
 882   if (mp->retval)
 883     clib_warning ("[%d] bind failed: %U", getpid (), format_api_error,
 884                   ntohl (mp->retval));
 885
 886   ASSERT (vcm->bind_session_index != ~0);
 887
 888   clib_spinlock_lock (&vcm->sessions_lockp);
 889   rv = vppcom_session_at_index (vcm->bind_session_index, &session);
 890   if (rv == VPPCOM_OK)
 891     {
 892       session->vpp_handle = mp->handle;
 893       hash_set (vcm->session_index_by_vpp_handles, mp->handle,
 894                 vcm->bind_session_index);
 895       session->state = mp->retval ? STATE_FAILED : STATE_LISTEN;
 896       vcm->bind_session_index = ~0;
 897     }
 898   clib_spinlock_unlock (&vcm->sessions_lockp);
 899 }
 900
 901 static void
 902 vl_api_unbind_sock_reply_t_handler (vl_api_unbind_sock_reply_t * mp)
 903 {
 904   session_t *session = 0;
 905   int rv;
 906
 907   clib_spinlock_lock (&vcm->sessions_lockp);
 908   rv = vppcom_session_at_index (vcm->bind_session_index, &session);
 909   if (rv == VPPCOM_OK)
 910     {
 911       if ((VPPCOM_DEBUG > 1) && (mp->retval))
 912         clib_warning ("[%d] unbind failed: %U", getpid (), format_api_error,
 913                       ntohl (mp->retval));
 914
 915       vcm->bind_session_index = ~0;
 916       session->state = STATE_START;
 917     }
 918   clib_spinlock_unlock (&vcm->sessions_lockp);
 919 }
 920
 921 u8 *
 922 format_ip4_address (u8 * s, va_list * args)
 923 {
 924   u8 *a = va_arg (*args, u8 *);
 925   return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
 926 }
 927
 928 u8 *
 929 format_ip6_address (u8 * s, va_list * args)
 930 {
 931   ip6_address_t *a = va_arg (*args, ip6_address_t *);
 932   u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
 933
 934   i_max_n_zero = ARRAY_LEN (a->as_u16);
 935   max_n_zeros = 0;
 936   i_first_zero = i_max_n_zero;
 937   n_zeros = 0;
 938   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 939     {
 940       u32 is_zero = a->as_u16[i] == 0;
 941       if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
 942         {
 943           i_first_zero = i;
 944           n_zeros = 0;
 945         }
 946       n_zeros += is_zero;
 947       if ((!is_zero && n_zeros > max_n_zeros)
 948           || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
 949         {
 950           i_max_n_zero = i_first_zero;
 951           max_n_zeros = n_zeros;
 952           i_first_zero = ARRAY_LEN (a->as_u16);
 953           n_zeros = 0;
 954         }
 955     }
 956
 957   last_double_colon = 0;
 958   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 959     {
 960       if (i == i_max_n_zero && max_n_zeros > 1)
 961         {
 962           s = format (s, "::");
 963           i += max_n_zeros - 1;
 964           last_double_colon = 1;
 965         }
 966       else
 967         {
 968           s = format (s, "%s%x",
 969                       (last_double_colon || i == 0) ? "" : ":",
 970                       clib_net_to_host_u16 (a->as_u16[i]));
 971           last_double_colon = 0;
 972         }
 973     }
 974
 975   return s;
 976 }
 977
 978 /* Format an IP46 address. */
 979 u8 *
 980 format_ip46_address (u8 * s, va_list * args)
 981 {
 982   ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
 983   ip46_type_t type = va_arg (*args, ip46_type_t);
 984   int is_ip4 = 1;
 985
 986   switch (type)
 987     {
 988     case IP46_TYPE_ANY:
 989       is_ip4 = ip46_address_is_ip4 (ip46);
 990       break;
 991     case IP46_TYPE_IP4:
 992       is_ip4 = 1;
 993       break;
 994     case IP46_TYPE_IP6:
 995       is_ip4 = 0;
 996       break;
 997     }
 998
 999   return is_ip4 ?
1000     format (s, "%U", format_ip4_address, &ip46->ip4) :
1001     format (s, "%U", format_ip6_address, &ip46->ip6);
1002 }
1003
1004 static inline void
1005 vppcom_send_accept_session_reply (u32 handle, int retval)
1006 {
1007   vl_api_accept_session_reply_t *rmp;
1008
1009   rmp = vl_msg_api_alloc (sizeof (*rmp));
1010   memset (rmp, 0, sizeof (*rmp));
1011   rmp->_vl_msg_id = ntohs (VL_API_ACCEPT_SESSION_REPLY);
1012   rmp->retval = htonl (retval);
1013   rmp->handle = handle;
1014   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
1015 }
1016
1017 static void
1018 vl_api_accept_session_t_handler (vl_api_accept_session_t * mp)
1019 {
1020   svm_fifo_t *rx_fifo, *tx_fifo;
1021   session_t *session;
1022   u32 session_index;
1023   uword *p;
1024
1025   clib_spinlock_lock (&vcm->sessions_lockp);
1026   if (!clib_fifo_free_elts (vcm->client_session_index_fifo))
1027     {
1028       clib_warning ("[%d] client session queue is full!", getpid ());
1029       vppcom_send_accept_session_reply (VNET_API_ERROR_QUEUE_FULL,
1030                                         mp->handle);
1031       clib_spinlock_unlock (&vcm->sessions_lockp);
1032       return;
1033     }
1034
1035   /* Allocate local session and set it up */
1036   pool_get (vcm->sessions, session);
1037   memset (session, 0, sizeof (*session));
1038   session_index = session - vcm->sessions;
1039
1040   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
1041   rx_fifo->client_session_index = session_index;
1042   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
1043   tx_fifo->client_session_index = session_index;
1044
1045   session->vpp_handle = mp->handle;
1046   session->server_rx_fifo = rx_fifo;
1047   session->server_tx_fifo = tx_fifo;
1048   session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
1049                                                unix_shared_memory_queue_t *);
1050   session->state = STATE_ACCEPT;
1051   session->is_cut_thru = 0;
1052   session->is_server = 1;
1053   session->peer_port = mp->port;
1054   session->peer_addr.is_ip4 = mp->is_ip4;
1055   clib_memcpy (&session->peer_addr.ip46, mp->ip,
1056                sizeof (session->peer_addr.ip46));
1057
1058   /* Add it to lookup table */
1059   hash_set (vcm->session_index_by_vpp_handles, mp->handle, session_index);
1060
1061   p = hash_get (vcm->session_index_by_vpp_handles, mp->listener_handle);
1062   if (p)
1063     {
1064       int rval;
1065       session_t *listen_session;
1066
1067       rval = vppcom_session_at_index (p[0], &listen_session);
1068       if (PREDICT_FALSE (rval))
1069         {
1070           if (VPPCOM_DEBUG > 1)
1071             clib_warning ("[%d] invalid listen session, sid (%u) "
1072                           "has been closed!", getpid (), p[0]);
1073         }
1074       else
1075         {
1076           session->lcl_port = listen_session->lcl_port;
1077           session->lcl_addr = listen_session->lcl_addr;
1078         }
1079       clib_spinlock_unlock (&vcm->sessions_lockp);
1080       hash_unset (vcm->session_index_by_vpp_handles, mp->handle);
1081     }
1082   else
1083     {
1084       clib_warning ("[%d] couldn't find listen session: unknown vpp "
1085                     "listener handle %llx", getpid (), mp->listener_handle);
1086     }
1087
1088   /* TBD: move client_session_index_fifo into listener session */
1089   clib_fifo_add1 (vcm->client_session_index_fifo, session_index);
1090   clib_spinlock_unlock (&vcm->sessions_lockp);
1091
1092   if (VPPCOM_DEBUG > 1)
1093     {
1094       u8 *ip_str = format (0, "%U", format_ip46_address, &mp->ip, mp->is_ip4);
1095       clib_warning ("[%d] received request to accept session (sid %d) "
1096                     "from %s:%d", getpid (), session_index, ip_str,
1097                     clib_net_to_host_u16 (mp->port));
1098       vec_free (ip_str);
1099     }
1100 }
1101
1102 static void
1103 vppcom_send_connect_session_reply (session_t * session, int retval)
1104 {
1105   vl_api_connect_session_reply_t *rmp;
1106   u32 len;
1107   unix_shared_memory_queue_t *client_q;
1108
1109   rmp = vl_msg_api_alloc (sizeof (*rmp));
1110   memset (rmp, 0, sizeof (*rmp));
1111
1112   rmp->_vl_msg_id = ntohs (VL_API_CONNECT_SESSION_REPLY);
1113   rmp->context = session->client_context;
1114   rmp->retval = htonl (retval);
1115   rmp->handle = session->vpp_handle;
1116   rmp->server_rx_fifo = pointer_to_uword (session->server_rx_fifo);
1117   rmp->server_tx_fifo = pointer_to_uword (session->server_tx_fifo);
1118   rmp->vpp_event_queue_address = pointer_to_uword (session->vpp_event_queue);
1119   rmp->segment_size = vcm->cfg.segment_size;
1120   len = vec_len (session->segment_name);
1121   rmp->segment_name_length = clib_min (len, sizeof (rmp->segment_name));
1122   clib_memcpy (rmp->segment_name, session->segment_name,
1123                rmp->segment_name_length - 1);
1124   clib_memcpy (rmp->lcl_ip, session->lcl_addr.ip46.as_u8,
1125                sizeof (rmp->lcl_ip));
1126   rmp->is_ip4 = session->lcl_addr.is_ip4;
1127   client_q = uword_to_pointer (session->client_queue_address,
1128                                unix_shared_memory_queue_t *);
1129   ASSERT (client_q);
1130   vl_msg_api_send_shmem (client_q, (u8 *) & rmp);
1131 }
1132
1133 /*
1134  * Acting as server for redirected connect requests
1135  */
1136 static void
1137 vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp)
1138 {
1139   u32 session_index;
1140   session_t *session = 0;
1141
1142   clib_spinlock_lock (&vcm->sessions_lockp);
1143   if (!clib_fifo_free_elts (vcm->client_session_index_fifo))
1144     {
1145       if (VPPCOM_DEBUG > 1)
1146         clib_warning ("[%d] client session queue is full!", getpid ());
1147       clib_spinlock_unlock (&vcm->sessions_lockp);
1148       vppcom_send_accept_session_reply (VNET_API_ERROR_QUEUE_FULL, 0);
1149       return;
1150     }
1151
1152   pool_get (vcm->sessions, session);
1153   memset (session, 0, sizeof (*session));
1154   session_index = session - vcm->sessions;
1155
1156   session->client_context = mp->context;
1157   session->vpp_handle = session_index;
1158   session->client_queue_address = mp->client_queue_address;
1159   session->is_cut_thru = 1;
1160   session->is_server = 1;
1161   session->peer_port = mp->port;
1162   session->peer_addr.is_ip4 = mp->is_ip4;
1163   clib_memcpy (&session->peer_addr.ip46, mp->ip,
1164                sizeof (session->peer_addr.ip46));
1165
1166   session->state = STATE_ACCEPT;
1167   clib_fifo_add1 (vcm->client_session_index_fifo, session_index);
1168   if (VPPCOM_DEBUG > 1)
1169     clib_warning
1170       ("[%d] Got a cut-thru connect request to client: "
1171        "sid %d, clib_fifo_elts %u!\n", getpid (), session_index,
1172        clib_fifo_elts (vcm->client_session_index_fifo));
1173   clib_spinlock_unlock (&vcm->sessions_lockp);
1174 }
1175
1176 static void
1177 vppcom_send_bind_sock (session_t * session)
1178 {
1179   vl_api_bind_sock_t *bmp;
1180
1181   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
1182   session->is_server = 1;
1183   bmp = vl_msg_api_alloc (sizeof (*bmp));
1184   memset (bmp, 0, sizeof (*bmp));
1185
1186   bmp->_vl_msg_id = ntohs (VL_API_BIND_SOCK);
1187   bmp->client_index = vcm->my_client_index;
1188   bmp->context = htonl (0xfeedface);
1189   bmp->vrf = session->vrf;
1190   bmp->is_ip4 = session->lcl_addr.is_ip4;
1191   clib_memcpy (bmp->ip, &session->lcl_addr.ip46, sizeof (bmp->ip));
1192   bmp->port = session->lcl_port;
1193   bmp->proto = session->proto;
1194   clib_memcpy (bmp->options, session->options, sizeof (bmp->options));
1195   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
1196 }
1197
1198 static void
1199 vppcom_send_unbind_sock (u32 session_index)
1200 {
1201   vl_api_unbind_sock_t *ump;
1202   session_t *session = 0;
1203   int rv;
1204
1205   clib_spinlock_lock (&vcm->sessions_lockp);
1206   rv = vppcom_session_at_index (session_index, &session);
1207   if (PREDICT_FALSE (rv))
1208     {
1209       clib_spinlock_unlock (&vcm->sessions_lockp);
1210       if (VPPCOM_DEBUG > 0)
1211         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
1212                       getpid (), session_index);
1213       return;
1214     }
1215
1216   ump = vl_msg_api_alloc (sizeof (*ump));
1217   memset (ump, 0, sizeof (*ump));
1218
1219   ump->_vl_msg_id = ntohs (VL_API_UNBIND_SOCK);
1220   ump->client_index = vcm->my_client_index;
1221   ump->handle = session->vpp_handle;
1222   clib_spinlock_unlock (&vcm->sessions_lockp);
1223   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & ump);
1224 }
1225
1226 static int
1227 vppcom_session_unbind_cut_thru (session_t * session, u32 session_index)
1228 {
1229   svm_fifo_segment_main_t *sm = &svm_fifo_segment_main;
1230   svm_fifo_segment_private_t *seg;
1231   int rv = VPPCOM_OK;
1232
1233   if (VPPCOM_DEBUG > 1)
1234     clib_warning ("[%d] sid %d, seg_nxd %d:\n"
1235                   "  server_rx_fifo %p, refcnt = %d\n"
1236                   "  server_tx_fifo %p, refcnt = %d",
1237                   getpid (), session_index, session->sm_seg_index,
1238                   session->server_rx_fifo, session->server_rx_fifo->refcnt,
1239                   session->server_tx_fifo, session->server_tx_fifo->refcnt);
1240
1241   seg = vec_elt_at_index (sm->segments, session->sm_seg_index);
1242   svm_fifo_segment_free_fifo (seg, session->server_rx_fifo,
1243                               FIFO_SEGMENT_RX_FREELIST);
1244   svm_fifo_segment_free_fifo (seg, session->server_tx_fifo,
1245                               FIFO_SEGMENT_TX_FREELIST);
1246   svm_fifo_segment_delete (seg);
1247
1248   return rv;
1249 }
1250
1251 static int
1252 vppcom_session_unbind (u32 session_index)
1253 {
1254   int rv;
1255
1256   clib_spinlock_lock (&vcm->sessions_lockp);
1257   if (PREDICT_FALSE (pool_is_free_index (vcm->sessions, session_index)))
1258     {
1259       clib_spinlock_unlock (&vcm->sessions_lockp);
1260       if (VPPCOM_DEBUG > 1)
1261         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
1262                       getpid (), session_index);
1263       return VPPCOM_EBADFD;
1264     }
1265   clib_spinlock_unlock (&vcm->sessions_lockp);
1266
1267   vcm->bind_session_index = session_index;
1268   vppcom_send_unbind_sock (session_index);
1269   rv = vppcom_wait_for_session_state_change (session_index, STATE_START,
1270                                              vcm->cfg.session_timeout);
1271   if (PREDICT_FALSE (rv))
1272     {
1273       vcm->bind_session_index = ~0;
1274       if (VPPCOM_DEBUG > 0)
1275         clib_warning ("[%d] server unbind timed out, rv = %s (%d)",
1276                       getpid (), vppcom_retval_str (rv), rv);
1277       return rv;
1278     }
1279   return VPPCOM_OK;
1280 }
1281
1282 static inline int
1283 vppcom_session_disconnect (u32 session_index)
1284 {
1285   int rv;
1286   session_t *session;
1287
1288   clib_spinlock_lock (&vcm->sessions_lockp);
1289   rv = vppcom_session_at_index (session_index, &session);
1290   if (PREDICT_FALSE (rv))
1291     {
1292       clib_spinlock_unlock (&vcm->sessions_lockp);
1293       if (VPPCOM_DEBUG > 1)
1294         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
1295                       getpid (), session_index);
1296       return rv;
1297     }
1298
1299   if (!session->is_cut_thru)
1300     {
1301       vppcom_send_disconnect (session);
1302       clib_spinlock_unlock (&vcm->sessions_lockp);
1303
1304       rv = vppcom_wait_for_session_state_change (session_index,
1305                                                  STATE_DISCONNECT, 1.0);
1306       /* TBD: Force clean up on error/timeout since there is no other
1307        *      way to recover from a failed disconnect.
1308        */
1309       if ((VPPCOM_DEBUG > 0) && (rv < 0))
1310         clib_warning ("[%d] disconnect (session %d) failed, rv = %s (%d)",
1311                       getpid (), session_index, vppcom_retval_str (rv), rv);
1312     }
1313   else
1314     {
1315       /* TBD: Handle cut-thru disconnect */
1316       clib_spinlock_unlock (&vcm->sessions_lockp);
1317     }
1318
1319   return VPPCOM_OK;
1320 }
1321
1322 #define foreach_sock_msg                                        \
1323 _(SESSION_ENABLE_DISABLE_REPLY, session_enable_disable_reply)   \
1324 _(BIND_SOCK_REPLY, bind_sock_reply)                             \
1325 _(UNBIND_SOCK_REPLY, unbind_sock_reply)                         \
1326 _(ACCEPT_SESSION, accept_session)                               \
1327 _(CONNECT_SOCK, connect_sock)                                   \
1328 _(CONNECT_SESSION_REPLY, connect_session_reply)                 \
1329 _(DISCONNECT_SESSION, disconnect_session)                       \
1330 _(DISCONNECT_SESSION_REPLY, disconnect_session_reply)           \
1331 _(RESET_SESSION, reset_session)                                 \
1332 _(APPLICATION_ATTACH_REPLY, application_attach_reply)           \
1333 _(APPLICATION_DETACH_REPLY, application_detach_reply)           \
1334 _(MAP_ANOTHER_SEGMENT, map_another_segment)
1335
1336 static void
1337 vppcom_api_hookup (void)
1338 {
1339 #define _(N,n)                                                  \
1340     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1341                            vl_api_##n##_t_handler,              \
1342                            vl_noop_handler,                     \
1343                            vl_api_##n##_t_endian,               \
1344                            vl_api_##n##_t_print,                \
1345                            sizeof(vl_api_##n##_t), 1);
1346   foreach_sock_msg;
1347 #undef _
1348 }
1349
1350 static void
1351 vppcom_cfg_init (vppcom_cfg_t * vcl_cfg)
1352 {
1353   ASSERT (vcl_cfg);
1354
1355   vcl_cfg->heapsize = (256ULL << 20);
1356   vcl_cfg->segment_baseva = 0x200000000ULL;
1357   vcl_cfg->segment_size = (256 << 20);
1358   vcl_cfg->add_segment_size = (128 << 20);
1359   vcl_cfg->preallocated_fifo_pairs = 8;
1360   vcl_cfg->rx_fifo_size = (1 << 20);
1361   vcl_cfg->tx_fifo_size = (1 << 20);
1362   vcl_cfg->event_queue_size = 2048;
1363   vcl_cfg->listen_queue_size = CLIB_CACHE_LINE_BYTES / sizeof (u32);
1364   vcl_cfg->app_timeout = 10 * 60.0;
1365   vcl_cfg->session_timeout = 10 * 60.0;
1366   vcl_cfg->accept_timeout = 60.0;
1367 }
1368
1369 static void
1370 vppcom_cfg_heapsize (char *conf_fname)
1371 {
1372   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
1373   FILE *fp;
1374   char inbuf[4096];
1375   int argc = 1;
1376   char **argv = NULL;
1377   char *arg = NULL;
1378   char *p;
1379   int i;
1380   u8 *sizep;
1381   u32 size;
1382   void *vcl_mem;
1383   void *heap;
1384
1385   fp = fopen (conf_fname, "r");
1386   if (fp == NULL)
1387     {
1388       if (VPPCOM_DEBUG > 0)
1389         fprintf (stderr, "open configuration file '%s' failed\n", conf_fname);
1390       goto defaulted;
1391     }
1392   argv = calloc (1, sizeof (char *));
1393   if (argv == NULL)
1394     goto defaulted;
1395
1396   while (1)
1397     {
1398       if (fgets (inbuf, 4096, fp) == 0)
1399         break;
1400       p = strtok (inbuf, " \t\n");
1401       while (p != NULL)
1402         {
1403           if (*p == '#')
1404             break;
1405           argc++;
1406           char **tmp = realloc (argv, argc * sizeof (char *));
1407           if (tmp == NULL)
1408             goto defaulted;
1409           argv = tmp;
1410           arg = strndup (p, 1024);
1411           if (arg == NULL)
1412             goto defaulted;
1413           argv[argc - 1] = arg;
1414           p = strtok (NULL, " \t\n");
1415         }
1416     }
1417
1418   fclose (fp);
1419   fp = NULL;
1420
1421   char **tmp = realloc (argv, (argc + 1) * sizeof (char *));
1422   if (tmp == NULL)
1423     goto defaulted;
1424   argv = tmp;
1425   argv[argc] = NULL;
1426
1427   /*
1428    * Look for and parse the "heapsize" config parameter.
1429    * Manual since none of the clib infra has been bootstrapped yet.
1430    *
1431    * Format: heapsize <nn>[mM][gG]
1432    */
1433
1434   for (i = 1; i < (argc - 1); i++)
1435     {
1436       if (!strncmp (argv[i], "heapsize", 8))
1437         {
1438           sizep = (u8 *) argv[i + 1];
1439           size = 0;
1440           while (*sizep >= '0' && *sizep <= '9')
1441             {
1442               size *= 10;
1443               size += *sizep++ - '0';
1444             }
1445           if (size == 0)
1446             {
1447               if (VPPCOM_DEBUG > 0)
1448                 clib_warning ("[%d] parse error '%s %s', "
1449                               "using default heapsize %lld (0x%llx)",
1450                               getpid (), argv[i], argv[i + 1],
1451                               vcl_cfg->heapsize, vcl_cfg->heapsize);
1452               goto defaulted;
1453             }
1454
1455           if (*sizep == 'g' || *sizep == 'G')
1456             vcl_cfg->heapsize = size << 30;
1457           else if (*sizep == 'm' || *sizep == 'M')
1458             vcl_cfg->heapsize = size << 20;
1459           else
1460             {
1461               if (VPPCOM_DEBUG > 0)
1462                 clib_warning ("[%d] parse error '%s %s', "
1463                               "using default heapsize %lld (0x%llx)",
1464                               getpid (), argv[i], argv[i + 1],
1465                               vcl_cfg->heapsize, vcl_cfg->heapsize);
1466               goto defaulted;
1467             }
1468         }
1469     }
1470
1471 defaulted:
1472   if (fp != NULL)
1473     fclose (fp);
1474   if (argv != NULL)
1475     free (argv);
1476
1477   vcl_mem = mmap (0, vcl_cfg->heapsize, PROT_READ | PROT_WRITE,
1478                   MAP_SHARED | MAP_ANONYMOUS, -1, 0);
1479   if (vcl_mem == MAP_FAILED)
1480     {
1481       clib_unix_error ("[%d] ERROR: mmap(0, %lld == 0x%llx, "
1482                        "PROT_READ | PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS, "
1483                        "-1, 0) failed!",
1484                        getpid (), vcl_cfg->heapsize, vcl_cfg->heapsize);
1485       return;
1486     }
1487   heap = clib_mem_init (vcl_mem, vcl_cfg->heapsize);
1488   if (!heap)
1489     {
1490       clib_warning ("[%d] ERROR: clib_mem_init() failed!", getpid ());
1491       return;
1492     }
1493   vcl_mem = clib_mem_alloc (sizeof (_vppcom_main));
1494   if (!vcl_mem)
1495     {
1496       clib_warning ("[%d] ERROR: clib_mem_alloc() failed!", getpid ());
1497       return;
1498     }
1499
1500   clib_memcpy (vcl_mem, &_vppcom_main, sizeof (_vppcom_main));
1501   vcm = vcl_mem;
1502
1503   if (VPPCOM_DEBUG > 0)
1504     clib_warning ("[%d] allocated VCL heap = %p, size %lld (0x%llx)",
1505                   getpid (), heap, vcl_cfg->heapsize, vcl_cfg->heapsize);
1506 }
1507
1508 static void
1509 vppcom_cfg_read (char *conf_fname)
1510 {
1511   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
1512   int fd;
1513   unformat_input_t _input, *input = &_input;
1514   unformat_input_t _line_input, *line_input = &_line_input;
1515   u8 vc_cfg_input = 0;
1516   u8 *chroot_path;
1517   struct stat s;
1518   u32 uid, gid;
1519
1520   fd = open (conf_fname, O_RDONLY);
1521   if (fd < 0)
1522     {
1523       if (VPPCOM_DEBUG > 0)
1524         clib_warning ("[%d] open configuration file '%s' failed!",
1525                       getpid (), conf_fname);
1526       goto file_done;
1527     }
1528
1529   if (fstat (fd, &s) < 0)
1530     {
1531       if (VPPCOM_DEBUG > 0)
1532         clib_warning ("[%d] failed to stat `%s'", getpid (), conf_fname);
1533       goto file_done;
1534     }
1535
1536   if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
1537     {
1538       if (VPPCOM_DEBUG > 0)
1539         clib_warning ("[%d] not a regular file `%s'", getpid (), conf_fname);
1540       goto file_done;
1541     }
1542
1543   unformat_init_clib_file (input, fd);
1544
1545   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1546     {
1547       (void) unformat_user (input, unformat_line_input, line_input);
1548       unformat_skip_white_space (line_input);
1549
1550       if (unformat (line_input, "vcl {"))
1551         {
1552           vc_cfg_input = 1;
1553           continue;
1554         }
1555
1556       if (vc_cfg_input)
1557         {
1558           if (unformat (line_input, "heapsize %s", &chroot_path))
1559             {
1560               vec_terminate_c_string (chroot_path);
1561               if (VPPCOM_DEBUG > 0)
1562                 clib_warning ("[%d] configured heapsize %s, "
1563                               "actual heapsize %lld (0x%llx)",
1564                               getpid (), chroot_path, vcl_cfg->heapsize,
1565                               vcl_cfg->heapsize);
1566               vec_free (chroot_path);
1567             }
1568           else if (unformat (line_input, "api-prefix %s", &chroot_path))
1569             {
1570               vec_terminate_c_string (chroot_path);
1571               vl_set_memory_root_path ((char *) chroot_path);
1572               if (VPPCOM_DEBUG > 0)
1573                 clib_warning ("[%d] configured api-prefix %s",
1574                               getpid (), chroot_path);
1575               chroot_path = 0;  /* Don't vec_free() it! */
1576             }
1577           else if (unformat (line_input, "uid %d", &uid))
1578             {
1579               vl_set_memory_uid (uid);
1580               if (VPPCOM_DEBUG > 0)
1581                 clib_warning ("[%d] configured uid %d", getpid (), uid);
1582             }
1583           else if (unformat (line_input, "gid %d", &gid))
1584             {
1585               vl_set_memory_gid (gid);
1586               if (VPPCOM_DEBUG > 0)
1587                 clib_warning ("[%d] configured gid %d", getpid (), gid);
1588             }
1589           else if (unformat (line_input, "segment-baseva 0x%lx",
1590                              &vcl_cfg->segment_baseva))
1591             {
1592               if (VPPCOM_DEBUG > 0)
1593                 clib_warning ("[%d] configured segment_baseva 0x%lx",
1594                               getpid (), vcl_cfg->segment_baseva);
1595             }
1596           else if (unformat (line_input, "segment-size 0x%lx",
1597                              &vcl_cfg->segment_size))
1598             {
1599               if (VPPCOM_DEBUG > 0)
1600                 clib_warning ("[%d] configured segment_size 0x%lx (%ld)",
1601                               getpid (), vcl_cfg->segment_size,
1602                               vcl_cfg->segment_size);
1603             }
1604           else if (unformat (line_input, "segment-size %ld",
1605                              &vcl_cfg->segment_size))
1606             {
1607               if (VPPCOM_DEBUG > 0)
1608                 clib_warning ("[%d] configured segment_size %ld (0x%lx)",
1609                               getpid (), vcl_cfg->segment_size,
1610                               vcl_cfg->segment_size);
1611             }
1612           else if (unformat (line_input, "add-segment-size 0x%lx",
1613                              &vcl_cfg->add_segment_size))
1614             {
1615               if (VPPCOM_DEBUG > 0)
1616                 clib_warning
1617                   ("[%d] configured add_segment_size 0x%lx (%ld)",
1618                    getpid (), vcl_cfg->add_segment_size,
1619                    vcl_cfg->add_segment_size);
1620             }
1621           else if (unformat (line_input, "add-segment-size %ld",
1622                              &vcl_cfg->add_segment_size))
1623             {
1624               if (VPPCOM_DEBUG > 0)
1625                 clib_warning
1626                   ("[%d] configured add_segment_size %ld (0x%lx)",
1627                    getpid (), vcl_cfg->add_segment_size,
1628                    vcl_cfg->add_segment_size);
1629             }
1630           else if (unformat (line_input, "preallocated-fifo-pairs %d",
1631                              &vcl_cfg->preallocated_fifo_pairs))
1632             {
1633               if (VPPCOM_DEBUG > 0)
1634                 clib_warning ("[%d] configured preallocated_fifo_pairs "
1635                               "%d (0x%x)", getpid (),
1636                               vcl_cfg->preallocated_fifo_pairs,
1637                               vcl_cfg->preallocated_fifo_pairs);
1638             }
1639           else if (unformat (line_input, "rx-fifo-size 0x%lx",
1640                              &vcl_cfg->rx_fifo_size))
1641             {
1642               if (VPPCOM_DEBUG > 0)
1643                 clib_warning ("[%d] configured rx_fifo_size 0x%lx (%ld)",
1644                               getpid (), vcl_cfg->rx_fifo_size,
1645                               vcl_cfg->rx_fifo_size);
1646             }
1647           else if (unformat (line_input, "rx-fifo-size %ld",
1648                              &vcl_cfg->rx_fifo_size))
1649             {
1650               if (VPPCOM_DEBUG > 0)
1651                 clib_warning ("[%d] configured rx_fifo_size %ld (0x%lx)",
1652                               getpid (), vcl_cfg->rx_fifo_size,
1653                               vcl_cfg->rx_fifo_size);
1654             }
1655           else if (unformat (line_input, "tx-fifo-size 0x%lx",
1656                              &vcl_cfg->tx_fifo_size))
1657             {
1658               if (VPPCOM_DEBUG > 0)
1659                 clib_warning ("[%d] configured tx_fifo_size 0x%lx (%ld)",
1660                               getpid (), vcl_cfg->tx_fifo_size,
1661                               vcl_cfg->tx_fifo_size);
1662             }
1663           else if (unformat (line_input, "tx-fifo-size %ld",
1664                              &vcl_cfg->tx_fifo_size))
1665             {
1666               if (VPPCOM_DEBUG > 0)
1667                 clib_warning ("[%d] configured tx_fifo_size %ld (0x%lx)",
1668                               getpid (), vcl_cfg->tx_fifo_size,
1669                               vcl_cfg->tx_fifo_size);
1670             }
1671           else if (unformat (line_input, "event-queue-size 0x%lx",
1672                              &vcl_cfg->event_queue_size))
1673             {
1674               if (VPPCOM_DEBUG > 0)
1675                 clib_warning ("[%d] configured event_queue_size 0x%lx (%ld)",
1676                               getpid (), vcl_cfg->event_queue_size,
1677                               vcl_cfg->event_queue_size);
1678             }
1679           else if (unformat (line_input, "event-queue-size %ld",
1680                              &vcl_cfg->event_queue_size))
1681             {
1682               if (VPPCOM_DEBUG > 0)
1683                 clib_warning ("[%d] configured event_queue_size %ld (0x%lx)",
1684                               getpid (), vcl_cfg->event_queue_size,
1685                               vcl_cfg->event_queue_size);
1686             }
1687           else if (unformat (line_input, "listen-queue-size 0x%lx",
1688                              &vcl_cfg->listen_queue_size))
1689             {
1690               if (VPPCOM_DEBUG > 0)
1691                 clib_warning ("[%d] configured listen_queue_size 0x%lx (%ld)",
1692                               getpid (), vcl_cfg->listen_queue_size,
1693                               vcl_cfg->listen_queue_size);
1694             }
1695           else if (unformat (line_input, "listen-queue-size %ld",
1696                              &vcl_cfg->listen_queue_size))
1697             {
1698               if (VPPCOM_DEBUG > 0)
1699                 clib_warning ("[%d] configured listen_queue_size %ld (0x%lx)",
1700                               getpid (), vcl_cfg->listen_queue_size,
1701                               vcl_cfg->listen_queue_size);
1702             }
1703           else if (unformat (line_input, "app-timeout %f",
1704                              &vcl_cfg->app_timeout))
1705             {
1706               if (VPPCOM_DEBUG > 0)
1707                 clib_warning ("[%d] configured app_timeout %f",
1708                               getpid (), vcl_cfg->app_timeout);
1709             }
1710           else if (unformat (line_input, "session-timeout %f",
1711                              &vcl_cfg->session_timeout))
1712             {
1713               if (VPPCOM_DEBUG > 0)
1714                 clib_warning ("[%d] configured session_timeout %f",
1715                               getpid (), vcl_cfg->session_timeout);
1716             }
1717           else if (unformat (line_input, "accept-timeout %f",
1718                              &vcl_cfg->accept_timeout))
1719             {
1720               if (VPPCOM_DEBUG > 0)
1721                 clib_warning ("[%d] configured accept_timeout %f",
1722                               getpid (), vcl_cfg->accept_timeout);
1723             }
1724           else if (unformat (line_input, "app-proxy-transport-tcp"))
1725             {
1726               vcl_cfg->app_proxy_transport_tcp = 1;
1727               if (VPPCOM_DEBUG > 0)
1728                 clib_warning ("[%d] configured app_proxy_transport_tcp (%d)",
1729                               getpid (), vcl_cfg->app_proxy_transport_tcp);
1730             }
1731           else if (unformat (line_input, "app-proxy-transport-udp"))
1732             {
1733               vcl_cfg->app_proxy_transport_udp = 1;
1734               if (VPPCOM_DEBUG > 0)
1735                 clib_warning ("[%d] configured app_proxy_transport_udp (%d)",
1736                               getpid (), vcl_cfg->app_proxy_transport_udp);
1737             }
1738           else if (unformat (line_input, "app-scope-local"))
1739             {
1740               vcl_cfg->app_scope_local = 1;
1741               if (VPPCOM_DEBUG > 0)
1742                 clib_warning ("[%d] configured app_scope_local (%d)",
1743                               getpid (), vcl_cfg->app_scope_local);
1744             }
1745           else if (unformat (line_input, "app-scope-global"))
1746             {
1747               vcl_cfg->app_scope_global = 1;
1748               if (VPPCOM_DEBUG > 0)
1749                 clib_warning ("[%d] configured app_scope_global (%d)",
1750                               getpid (), vcl_cfg->app_scope_global);
1751             }
1752           else if (unformat (line_input, "namespace-secret %lu",
1753                              &vcl_cfg->namespace_secret))
1754             {
1755               if (VPPCOM_DEBUG > 0)
1756                 clib_warning
1757                   ("[%d] configured namespace_secret %lu (0x%lx)",
1758                    getpid (), vcl_cfg->namespace_secret,
1759                    vcl_cfg->namespace_secret);
1760             }
1761           else if (unformat (line_input, "namespace-id %v",
1762                              &vcl_cfg->namespace_id))
1763             {
1764               vl_api_application_attach_t *mp;
1765               u32 max_nsid_vec_len = sizeof (mp->namespace_id) - 1;
1766               u32 nsid_vec_len = vec_len (vcl_cfg->namespace_id);
1767               if (nsid_vec_len > max_nsid_vec_len)
1768                 {
1769                   _vec_len (vcl_cfg->namespace_id) = max_nsid_vec_len;
1770                   if (VPPCOM_DEBUG > 0)
1771                     clib_warning ("[%d] configured namespace_id is too long,"
1772                                   " truncated to %d characters!", getpid (),
1773                                   max_nsid_vec_len);
1774                 }
1775
1776               if (VPPCOM_DEBUG > 0)
1777                 clib_warning ("[%d] configured namespace_id %v",
1778                               getpid (), vcl_cfg->namespace_id);
1779             }
1780           else if (unformat (line_input, "}"))
1781             {
1782               vc_cfg_input = 0;
1783               if (VPPCOM_DEBUG > 0)
1784                 clib_warning ("[%d] completed parsing vppcom config!",
1785                               getpid ());
1786               goto input_done;
1787             }
1788           else
1789             {
1790               if (line_input->buffer[line_input->index] != '#')
1791                 {
1792                   clib_warning ("[%d] Unknown vppcom config option: '%s'",
1793                                 getpid (), (char *)
1794                                 &line_input->buffer[line_input->index]);
1795                 }
1796             }
1797         }
1798     }
1799
1800 input_done:
1801   unformat_free (input);
1802
1803 file_done:
1804   if (fd >= 0)
1805     close (fd);
1806 }
1807
1808 /*
1809  * VPPCOM Public API functions
1810  */
1811 int
1812 vppcom_app_create (char *app_name)
1813 {
1814   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
1815   u8 *heap;
1816   mheap_t *h;
1817   int rv;
1818
1819   if (!vcm->init)
1820     {
1821       char *conf_fname;
1822       char *env_var_str;
1823
1824       vcm->init = 1;
1825       vppcom_cfg_init (vcl_cfg);
1826       env_var_str = getenv (VPPCOM_ENV_DEBUG);
1827       if (env_var_str)
1828         {
1829           u32 tmp;
1830           if (sscanf (env_var_str, "%u", &tmp) != 1)
1831             clib_warning ("[%d] Invalid debug level specified in "
1832                           "the environment variable "
1833                           VPPCOM_ENV_DEBUG
1834                           " (%s)!\n", getpid (), env_var_str);
1835           else
1836             {
1837               vcm->debug = tmp;
1838               clib_warning ("[%d] configured debug level (%u) from "
1839                             VPPCOM_ENV_DEBUG "!", getpid (), vcm->debug);
1840             }
1841         }
1842       conf_fname = getenv (VPPCOM_ENV_CONF);
1843       if (!conf_fname)
1844         {
1845           conf_fname = VPPCOM_CONF_DEFAULT;
1846           if (VPPCOM_DEBUG > 0)
1847             clib_warning ("[%d] getenv '%s' failed!", getpid (),
1848                           VPPCOM_ENV_CONF);
1849         }
1850       vppcom_cfg_heapsize (conf_fname);
1851       clib_fifo_validate (vcm->client_session_index_fifo,
1852                           vcm->cfg.listen_queue_size);
1853       vppcom_cfg_read (conf_fname);
1854       env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_ID);
1855       if (env_var_str)
1856         {
1857           u32 ns_id_vec_len = strlen (env_var_str);
1858
1859           vec_reset_length (vcm->cfg.namespace_id);
1860           vec_validate (vcm->cfg.namespace_id, ns_id_vec_len - 1);
1861           clib_memcpy (vcm->cfg.namespace_id, env_var_str, ns_id_vec_len);
1862
1863           if (VPPCOM_DEBUG > 0)
1864             clib_warning ("[%d] configured namespace_id (%v) from "
1865                           VPPCOM_ENV_APP_NAMESPACE_ID "!", getpid (),
1866                           vcm->cfg.namespace_id);
1867         }
1868       env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_SECRET);
1869       if (env_var_str)
1870         {
1871           u64 tmp;
1872           if (sscanf (env_var_str, "%lu", &tmp) != 1)
1873             clib_warning ("[%d] Invalid namespace secret specified in "
1874                           "the environment variable "
1875                           VPPCOM_ENV_APP_NAMESPACE_SECRET
1876                           " (%s)!\n", getpid (), env_var_str);
1877           else
1878             {
1879               vcm->cfg.namespace_secret = tmp;
1880               if (VPPCOM_DEBUG > 0)
1881                 clib_warning ("[%d] configured namespace secret (%lu) from "
1882                               VPPCOM_ENV_APP_NAMESPACE_ID "!", getpid (),
1883                               vcm->cfg.namespace_secret);
1884             }
1885         }
1886       if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP))
1887         {
1888           vcm->cfg.app_proxy_transport_tcp = 1;
1889           if (VPPCOM_DEBUG > 0)
1890             clib_warning ("[%d] configured app_proxy_transport_tcp (%u) from "
1891                           VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP "!", getpid (),
1892                           vcm->cfg.app_proxy_transport_tcp);
1893         }
1894       if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP))
1895         {
1896           vcm->cfg.app_proxy_transport_udp = 1;
1897           if (VPPCOM_DEBUG > 0)
1898             clib_warning ("[%d] configured app_proxy_transport_udp (%u) from "
1899                           VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP "!", getpid (),
1900                           vcm->cfg.app_proxy_transport_udp);
1901         }
1902       if (getenv (VPPCOM_ENV_APP_SCOPE_LOCAL))
1903         {
1904           vcm->cfg.app_scope_local = 1;
1905           if (VPPCOM_DEBUG > 0)
1906             clib_warning ("[%d] configured app_scope_local (%u) from "
1907                           VPPCOM_ENV_APP_SCOPE_LOCAL "!", getpid (),
1908                           vcm->cfg.app_scope_local);
1909         }
1910       if (getenv (VPPCOM_ENV_APP_SCOPE_GLOBAL))
1911         {
1912           vcm->cfg.app_scope_global = 1;
1913           if (VPPCOM_DEBUG > 0)
1914             clib_warning ("[%d] configured app_scope_global (%u) from "
1915                           VPPCOM_ENV_APP_SCOPE_GLOBAL "!", getpid (),
1916                           vcm->cfg.app_scope_global);
1917         }
1918
1919       vcm->bind_session_index = ~0;
1920       vcm->main_cpu = os_get_thread_index ();
1921       heap = clib_mem_get_per_cpu_heap ();
1922       h = mheap_header (heap);
1923
1924       /* make the main heap thread-safe */
1925       h->flags |= MHEAP_FLAG_THREAD_SAFE;
1926
1927       vcm->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
1928
1929       clib_time_init (&vcm->clib_time);
1930       vppcom_init_error_string_table ();
1931       svm_fifo_segment_init (vcl_cfg->segment_baseva,
1932                              20 /* timeout in secs */ );
1933       clib_spinlock_init (&vcm->sessions_lockp);
1934       vppcom_api_hookup ();
1935     }
1936
1937   if (vcm->my_client_index == ~0)
1938     {
1939       vcm->app_state = STATE_APP_START;
1940       rv = vppcom_connect_to_vpp (app_name);
1941       if (rv)
1942         {
1943           clib_warning ("[%d] couldn't connect to VPP.", getpid ());
1944           return rv;
1945         }
1946
1947       if (VPPCOM_DEBUG > 0)
1948         clib_warning ("[%d] sending session enable", getpid ());
1949
1950       rv = vppcom_app_session_enable ();
1951       if (rv)
1952         {
1953           clib_warning ("[%d] vppcom_app_session_enable() failed!",
1954                         getpid ());
1955           return rv;
1956         }
1957
1958       if (VPPCOM_DEBUG > 0)
1959         clib_warning ("[%d] sending app attach", getpid ());
1960
1961       rv = vppcom_app_attach ();
1962       if (rv)
1963         {
1964           clib_warning ("[%d] vppcom_app_attach() failed!", getpid ());
1965           return rv;
1966         }
1967
1968       if (VPPCOM_DEBUG > 0)
1969         clib_warning ("[%d] app_name '%s', my_client_index %d (0x%x)",
1970                       getpid (), app_name, vcm->my_client_index,
1971                       vcm->my_client_index);
1972     }
1973
1974   return VPPCOM_OK;
1975 }
1976
1977 void
1978 vppcom_app_destroy (void)
1979 {
1980   int rv;
1981
1982   if (vcm->my_client_index == ~0)
1983     return;
1984
1985   if (VPPCOM_DEBUG > 0)
1986     clib_warning ("[%d] detaching from VPP, my_client_index %d (0x%x)",
1987                   getpid (), vcm->my_client_index, vcm->my_client_index);
1988
1989   vppcom_app_detach ();
1990   rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
1991   if (PREDICT_FALSE (rv))
1992     {
1993       if (VPPCOM_DEBUG > 0)
1994         clib_warning ("[%d] application detach timed out, rv = %s (%d)",
1995                       getpid (), vppcom_retval_str (rv), rv);
1996     }
1997   vl_client_disconnect_from_vlib ();
1998   vcm->my_client_index = ~0;
1999   vcm->app_state = STATE_APP_START;
2000 }
2001
2002 int
2003 vppcom_session_create (u32 vrf, u8 proto, u8 is_nonblocking)
2004 {
2005   session_t *session;
2006   u32 session_index;
2007
2008   clib_spinlock_lock (&vcm->sessions_lockp);
2009   pool_get (vcm->sessions, session);
2010   memset (session, 0, sizeof (*session));
2011   session_index = session - vcm->sessions;
2012
2013   session->vrf = vrf;
2014   session->proto = proto;
2015   session->state = STATE_START;
2016   session->is_nonblocking = is_nonblocking ? 1 : 0;
2017   clib_spinlock_unlock (&vcm->sessions_lockp);
2018
2019   if (VPPCOM_DEBUG > 0)
2020     clib_warning ("[%d] sid %d", getpid (), session_index);
2021
2022   return (int) session_index;
2023 }
2024
2025 int
2026 vppcom_session_close (uint32_t session_index)
2027 {
2028   session_t *session = 0;
2029   int rv;
2030   u8 is_server;
2031   u8 is_listen;
2032   u8 is_cut_thru;
2033   u8 is_vep;
2034   u8 is_vep_session;
2035   u32 next_sid;
2036   u32 vep_idx;
2037   session_state_t state;
2038
2039   clib_spinlock_lock (&vcm->sessions_lockp);
2040   rv = vppcom_session_at_index (session_index, &session);
2041   if (PREDICT_FALSE (rv))
2042     {
2043       if (VPPCOM_DEBUG > 0)
2044         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2045                       getpid (), session_index);
2046       clib_spinlock_unlock (&vcm->sessions_lockp);
2047       goto done;
2048     }
2049   is_server = session->is_server;
2050   is_listen = session->is_listen;
2051   is_cut_thru = session->is_cut_thru;
2052   is_vep = session->is_vep;
2053   is_vep_session = session->is_vep_session;
2054   next_sid = session->vep.next_sid;
2055   vep_idx = session->vep.vep_idx;
2056   state = session->state;
2057   clib_spinlock_unlock (&vcm->sessions_lockp);
2058
2059   if (VPPCOM_DEBUG > 0)
2060     clib_warning ("[%d] sid %d", getpid (), session_index);
2061
2062   if (is_vep)
2063     {
2064       while (next_sid != ~0)
2065         {
2066           rv = vppcom_epoll_ctl (session_index, EPOLL_CTL_DEL, next_sid, 0);
2067           if ((VPPCOM_DEBUG > 0) && (rv < 0))
2068             clib_warning ("[%d] EPOLL_CTL_DEL vep_idx %u, sid %u failed, "
2069                           "rv = %s (%d)", getpid (), vep_idx, next_sid,
2070                           vppcom_retval_str (rv), rv);
2071
2072           clib_spinlock_lock (&vcm->sessions_lockp);
2073           rv = vppcom_session_at_index (session_index, &session);
2074           if (PREDICT_FALSE (rv))
2075             {
2076               if (VPPCOM_DEBUG > 0)
2077                 clib_warning
2078                   ("[%d] invalid session, sid (%u) has been closed!",
2079                    getpid (), session_index);
2080               clib_spinlock_unlock (&vcm->sessions_lockp);
2081               goto done;
2082             }
2083           next_sid = session->vep.next_sid;
2084           clib_spinlock_unlock (&vcm->sessions_lockp);
2085         }
2086     }
2087   else
2088     {
2089       if (is_vep_session)
2090         {
2091           rv = vppcom_epoll_ctl (vep_idx, EPOLL_CTL_DEL, session_index, 0);
2092           if ((VPPCOM_DEBUG > 0) && (rv < 0))
2093             clib_warning ("[%d] EPOLL_CTL_DEL vep_idx %u, sid %u failed, "
2094                           "rv = %s (%d)", getpid (), vep_idx, session_index,
2095                           vppcom_retval_str (rv), rv);
2096         }
2097
2098       if (is_cut_thru && is_server && (state == STATE_ACCEPT))
2099         {
2100           rv = vppcom_session_unbind_cut_thru (session, session_index);
2101           if ((VPPCOM_DEBUG > 0) && (rv < 0))
2102             clib_warning ("[%d] unbind cut-thru (session %d) failed, "
2103                           "rv = %s (%d)",
2104                           getpid (), session_index,
2105                           vppcom_retval_str (rv), rv);
2106         }
2107       else if (is_server && is_listen)
2108         {
2109           rv = vppcom_session_unbind (session_index);
2110           if ((VPPCOM_DEBUG > 0) && (rv < 0))
2111             clib_warning ("[%d] unbind (session %d) failed, rv = %s (%d)",
2112                           getpid (), session_index,
2113                           vppcom_retval_str (rv), rv);
2114         }
2115       else if (state == STATE_CONNECT)
2116         if (vppcom_session_disconnect (session_index))
2117           goto done;
2118     }
2119   clib_spinlock_lock (&vcm->sessions_lockp);
2120   pool_put_index (vcm->sessions, session_index);
2121   clib_spinlock_unlock (&vcm->sessions_lockp);
2122 done:
2123   return rv;
2124 }
2125
2126 int
2127 vppcom_session_bind (uint32_t session_index, vppcom_endpt_t * ep)
2128 {
2129   session_t *session = 0;
2130   int rv;
2131
2132   if (!ep || !ep->ip)
2133     return VPPCOM_EINVAL;
2134
2135   clib_spinlock_lock (&vcm->sessions_lockp);
2136   rv = vppcom_session_at_index (session_index, &session);
2137   if (PREDICT_FALSE (rv))
2138     {
2139       clib_spinlock_unlock (&vcm->sessions_lockp);
2140       if (VPPCOM_DEBUG > 0)
2141         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2142                       getpid (), session_index);
2143       return rv;
2144     }
2145
2146   if (session->is_vep)
2147     {
2148       clib_spinlock_unlock (&vcm->sessions_lockp);
2149       if (VPPCOM_DEBUG > 0)
2150         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2151                       getpid (), session_index);
2152       return VPPCOM_EBADFD;
2153     }
2154
2155   session->vrf = ep->vrf;
2156   session->lcl_addr.is_ip4 = ep->is_ip4;
2157   session->lcl_addr.ip46 = to_ip46 (!ep->is_ip4, ep->ip);
2158   session->lcl_port = ep->port;
2159
2160   if (VPPCOM_DEBUG > 0)
2161     clib_warning ("[%d] sid %d, bound to lcl address %U lcl port %u",
2162                   getpid (), session_index, format_ip46_address,
2163                   &session->lcl_addr.ip46, session->lcl_addr.is_ip4,
2164                   clib_net_to_host_u16 (session->lcl_port));
2165
2166   clib_spinlock_unlock (&vcm->sessions_lockp);
2167   return VPPCOM_OK;
2168 }
2169
2170 int
2171 vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len)
2172 {
2173   session_t *listen_session = 0;
2174   int rv;
2175
2176   clib_spinlock_lock (&vcm->sessions_lockp);
2177   rv = vppcom_session_at_index (listen_session_index, &listen_session);
2178   if (PREDICT_FALSE (rv))
2179     {
2180       clib_spinlock_unlock (&vcm->sessions_lockp);
2181       if (VPPCOM_DEBUG > 0)
2182         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2183                       getpid (), listen_session_index);
2184       return rv;
2185     }
2186
2187   if (listen_session->is_vep)
2188     {
2189       clib_spinlock_unlock (&vcm->sessions_lockp);
2190       if (VPPCOM_DEBUG > 0)
2191         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2192                       getpid (), listen_session_index);
2193       return VPPCOM_EBADFD;
2194     }
2195
2196   if (listen_session->is_listen)
2197     {
2198       clib_spinlock_unlock (&vcm->sessions_lockp);
2199       if (VPPCOM_DEBUG > 0)
2200         clib_warning ("[%d] sid (%u) is already in listen state!",
2201                       getpid (), listen_session_index);
2202       return VPPCOM_OK;
2203     }
2204
2205   if (VPPCOM_DEBUG > 0)
2206     clib_warning ("[%d] sid %d", getpid (), listen_session_index);
2207
2208   ASSERT (vcm->bind_session_index == ~0);
2209   vcm->bind_session_index = listen_session_index;
2210   vppcom_send_bind_sock (listen_session);
2211   clib_spinlock_unlock (&vcm->sessions_lockp);
2212   rv =
2213     vppcom_wait_for_session_state_change (listen_session_index, STATE_LISTEN,
2214                                           vcm->cfg.session_timeout);
2215   if (PREDICT_FALSE (rv))
2216     {
2217       vcm->bind_session_index = ~0;
2218       if (VPPCOM_DEBUG > 0)
2219         clib_warning ("[%d] server listen timed out, rv = %d (%d)",
2220                       getpid (), vppcom_retval_str (rv), rv);
2221       return rv;
2222     }
2223
2224   clib_spinlock_lock (&vcm->sessions_lockp);
2225   rv = vppcom_session_at_index (listen_session_index, &listen_session);
2226   if (PREDICT_FALSE (rv))
2227     {
2228       clib_spinlock_unlock (&vcm->sessions_lockp);
2229       if (VPPCOM_DEBUG > 0)
2230         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2231                       getpid (), listen_session_index);
2232       return rv;
2233     }
2234   listen_session->is_listen = 1;
2235   clib_fifo_validate (vcm->client_session_index_fifo, q_len);
2236   clib_spinlock_unlock (&vcm->sessions_lockp);
2237
2238   return VPPCOM_OK;
2239 }
2240
2241 int
2242 vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep,
2243                        uint32_t flags, double wait_for_time)
2244 {
2245   session_t *listen_session = 0;
2246   session_t *client_session = 0;
2247   u32 client_session_index = ~0;
2248   int rv;
2249   f64 wait_for;
2250   char *cut_thru_str;
2251
2252   clib_spinlock_lock (&vcm->sessions_lockp);
2253   rv = vppcom_session_at_index (listen_session_index, &listen_session);
2254   if (PREDICT_FALSE (rv))
2255     {
2256       clib_spinlock_unlock (&vcm->sessions_lockp);
2257       if (VPPCOM_DEBUG > 0)
2258         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2259                       getpid (), listen_session_index);
2260       return rv;
2261     }
2262
2263   if (listen_session->is_vep)
2264     {
2265       clib_spinlock_unlock (&vcm->sessions_lockp);
2266       if (VPPCOM_DEBUG > 0)
2267         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2268                       getpid (), listen_session_index);
2269       return VPPCOM_EBADFD;
2270     }
2271
2272   if (listen_session->state != STATE_LISTEN)
2273     {
2274       clib_spinlock_unlock (&vcm->sessions_lockp);
2275       if (VPPCOM_DEBUG > 0)
2276         clib_warning ("[%d] session not in listen state, state = %s",
2277                       getpid (),
2278                       vppcom_session_state_str (listen_session->state));
2279       return VPPCOM_EBADFD;
2280     }
2281   wait_for = listen_session->is_nonblocking ? 0 :
2282     (wait_for_time < 0) ? vcm->cfg.accept_timeout : wait_for_time;
2283
2284   if (VPPCOM_DEBUG > 0)
2285     clib_warning ("[%d] sid %d: %s (%d)", getpid (),
2286                   listen_session_index,
2287                   vppcom_session_state_str (listen_session->state),
2288                   listen_session->state);
2289   clib_spinlock_unlock (&vcm->sessions_lockp);
2290
2291   while (1)
2292     {
2293       rv = vppcom_wait_for_client_session_index (wait_for);
2294       if (rv)
2295         {
2296           if ((VPPCOM_DEBUG > 0))
2297             clib_warning ("[%d] sid %d, accept timed out, rv = %s (%d)",
2298                           getpid (), listen_session_index,
2299                           vppcom_retval_str (rv), rv);
2300           if ((wait_for == 0) || (wait_for_time > 0))
2301             return rv;
2302         }
2303       else
2304         break;
2305     }
2306
2307   clib_spinlock_lock (&vcm->sessions_lockp);
2308   clib_fifo_sub1 (vcm->client_session_index_fifo, client_session_index);
2309   rv = vppcom_session_at_index (client_session_index, &client_session);
2310   ASSERT (rv == VPPCOM_OK);
2311   ASSERT (client_session->peer_addr.is_ip4 ==
2312           listen_session->lcl_addr.is_ip4);
2313
2314   client_session->is_nonblocking = (flags & O_NONBLOCK) ? 1 : 0;
2315   if (VPPCOM_DEBUG > 0)
2316     clib_warning ("[%d] Got a request: client sid %d, flags %d, "
2317                   " is_nonblocking %u", getpid (), client_session_index,
2318                   flags, client_session->is_nonblocking);
2319
2320   ep->vrf = client_session->vrf;
2321   ep->is_cut_thru = client_session->is_cut_thru;
2322   ep->is_ip4 = client_session->peer_addr.is_ip4;
2323   ep->port = client_session->peer_port;
2324   if (client_session->peer_addr.is_ip4)
2325     clib_memcpy (ep->ip, &client_session->peer_addr.ip46.ip4,
2326                  sizeof (ip4_address_t));
2327   else
2328     clib_memcpy (ep->ip, &client_session->peer_addr.ip46.ip6,
2329                  sizeof (ip6_address_t));
2330
2331   if (client_session->is_server && client_session->is_cut_thru)
2332     {
2333       static svm_fifo_segment_create_args_t _a;
2334       svm_fifo_segment_create_args_t *a = &_a;
2335       svm_fifo_segment_private_t *seg;
2336
2337       cut_thru_str = "cut-thru ";
2338
2339       /* Create the segment */
2340       memset (a, 0, sizeof (*a));
2341       a->segment_name = (char *)
2342         format ((u8 *) a->segment_name, "%d:segment%d%c",
2343                 getpid (), vcm->unique_segment_index++, 0);
2344       a->segment_size = vcm->cfg.segment_size;
2345       a->preallocated_fifo_pairs = vcm->cfg.preallocated_fifo_pairs;
2346       a->rx_fifo_size = vcm->cfg.rx_fifo_size;
2347       a->tx_fifo_size = vcm->cfg.tx_fifo_size;
2348
2349       rv = svm_fifo_segment_create (a);
2350       if (PREDICT_FALSE (rv))
2351         {
2352           if (VPPCOM_DEBUG > 1)
2353             clib_warning ("[%d] svm_fifo_segment_create ('%s') failed",
2354                           getpid (), a->segment_name);
2355           vec_reset_length (a->new_segment_indices);
2356           rv = VNET_API_ERROR_URI_FIFO_CREATE_FAILED;
2357           vppcom_send_connect_session_reply (client_session, rv);
2358           clib_spinlock_unlock (&vcm->sessions_lockp);
2359           return VPPCOM_ENOMEM;
2360         }
2361
2362       client_session->segment_name = vec_dup ((u8 *) a->segment_name);
2363       client_session->sm_seg_index = a->new_segment_indices[0];
2364       vec_free (a->new_segment_indices);
2365
2366       seg = svm_fifo_segment_get_segment (client_session->sm_seg_index);
2367       client_session->server_rx_fifo =
2368         svm_fifo_segment_alloc_fifo (seg, vcm->cfg.rx_fifo_size,
2369                                      FIFO_SEGMENT_RX_FREELIST);
2370       if (PREDICT_FALSE (!client_session->server_rx_fifo))
2371         {
2372           svm_fifo_segment_delete (seg);
2373           clib_warning ("[%d] rx fifo alloc failed, size %ld (0x%lx)",
2374                         getpid (), vcm->cfg.rx_fifo_size,
2375                         vcm->cfg.rx_fifo_size);
2376           rv = VNET_API_ERROR_URI_FIFO_CREATE_FAILED;
2377           vppcom_send_connect_session_reply (client_session, rv);
2378           clib_spinlock_unlock (&vcm->sessions_lockp);
2379           return VPPCOM_ENOMEM;
2380         }
2381       client_session->server_rx_fifo->master_session_index =
2382         client_session_index;
2383
2384       client_session->server_tx_fifo =
2385         svm_fifo_segment_alloc_fifo (seg, vcm->cfg.tx_fifo_size,
2386                                      FIFO_SEGMENT_TX_FREELIST);
2387       if (PREDICT_FALSE (!client_session->server_tx_fifo))
2388         {
2389           svm_fifo_segment_delete (seg);
2390           if (VPPCOM_DEBUG > 1)
2391             clib_warning ("[%d] tx fifo alloc failed, size %ld (0x%lx)",
2392                           getpid (), vcm->cfg.tx_fifo_size,
2393                           vcm->cfg.tx_fifo_size);
2394           rv = VNET_API_ERROR_URI_FIFO_CREATE_FAILED;
2395           vppcom_send_connect_session_reply (client_session, rv);
2396           clib_spinlock_unlock (&vcm->sessions_lockp);
2397           return VPPCOM_ENOMEM;
2398         }
2399       client_session->server_tx_fifo->master_session_index =
2400         client_session_index;
2401
2402       if (VPPCOM_DEBUG > 1)
2403         clib_warning ("[%d] created segment '%s': rx_fifo %p, tx_fifo %p",
2404                       getpid (), client_session->segment_name,
2405                       client_session->server_rx_fifo,
2406                       client_session->server_tx_fifo);
2407
2408 #ifdef CUT_THRU_EVENT_QUEUE     /* TBD */
2409       {
2410         void *oldheap;
2411         ssvm_shared_header_t *sh = seg->ssvm.sh;
2412
2413         ssvm_lock_non_recursive (sh, 1);
2414         oldheap = ssvm_push_heap (sh);
2415         event_q = client_session->vpp_event_queue =
2416           unix_shared_memory_queue_init (vcm->cfg.event_queue_size,
2417                                          sizeof (session_fifo_event_t),
2418                                          getpid (), 0 /* signal not sent */ );
2419         ssvm_pop_heap (oldheap);
2420         ssvm_unlock_non_recursive (sh);
2421       }
2422 #endif
2423       vppcom_send_connect_session_reply (client_session, 0);
2424     }
2425   else
2426     {
2427       cut_thru_str = " ";
2428       vppcom_send_accept_session_reply (0, client_session->vpp_handle);
2429     }
2430
2431   if (VPPCOM_DEBUG > 0)
2432     clib_warning ("[%d] sid %d, accepted %sconnection to peer address "
2433                   "%U peer port %u",
2434                   getpid (), client_session_index, cut_thru_str,
2435                   format_ip46_address, &client_session->peer_addr.ip46,
2436                   client_session->peer_addr.is_ip4,
2437                   clib_net_to_host_u16 (client_session->peer_port));
2438
2439   clib_spinlock_unlock (&vcm->sessions_lockp);
2440   return (int) client_session_index;
2441 }
2442
2443 int
2444 vppcom_session_connect (uint32_t session_index, vppcom_endpt_t * server_ep)
2445 {
2446   session_t *session = 0;
2447   int rv;
2448
2449   clib_spinlock_lock (&vcm->sessions_lockp);
2450   rv = vppcom_session_at_index (session_index, &session);
2451   if (PREDICT_FALSE (rv))
2452     {
2453       clib_spinlock_unlock (&vcm->sessions_lockp);
2454       if (VPPCOM_DEBUG > 0)
2455         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2456                       getpid (), session_index);
2457       return rv;
2458     }
2459
2460   if (session->is_vep)
2461     {
2462       clib_spinlock_unlock (&vcm->sessions_lockp);
2463       if (VPPCOM_DEBUG > 0)
2464         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2465                       getpid (), session_index);
2466       return VPPCOM_EBADFD;
2467     }
2468
2469   if (session->state == STATE_CONNECT)
2470     {
2471       clib_spinlock_unlock (&vcm->sessions_lockp);
2472       if (VPPCOM_DEBUG > 0)
2473         clib_warning ("[%d] session, sid (%u) already connected!",
2474                       getpid (), session_index);
2475       return VPPCOM_OK;
2476     }
2477
2478   session->vrf = server_ep->vrf;
2479   session->peer_addr.is_ip4 = server_ep->is_ip4;
2480   session->peer_addr.ip46 = to_ip46 (!server_ep->is_ip4, server_ep->ip);
2481   session->peer_port = server_ep->port;
2482
2483   if (VPPCOM_DEBUG > 0)
2484     {
2485       u8 *ip_str = format (0, "%U", format_ip46_address,
2486                            &session->peer_addr.ip46,
2487                            session->peer_addr.is_ip4);
2488       clib_warning ("[%d] connect sid %d to %s server port %d proto %s",
2489                     getpid (), session_index, ip_str,
2490                     clib_net_to_host_u16 (session->peer_port),
2491                     session->proto ? "UDP" : "TCP");
2492       vec_free (ip_str);
2493     }
2494
2495   vppcom_send_connect_sock (session, session_index);
2496   clib_spinlock_unlock (&vcm->sessions_lockp);
2497   rv = vppcom_wait_for_session_state_change (session_index, STATE_CONNECT,
2498                                              vcm->cfg.session_timeout);
2499   if (PREDICT_FALSE (rv))
2500     {
2501       if (VPPCOM_DEBUG > 0)
2502         clib_warning ("[%d] connect timed out, rv = %s (%d)",
2503                       getpid (), vppcom_retval_str (rv), rv);
2504       return rv;
2505     }
2506   if (VPPCOM_DEBUG > 0)
2507     clib_warning ("[%d] sid %d connected!", getpid (), session_index);
2508
2509   return VPPCOM_OK;
2510 }
2511
2512 static inline int
2513 vppcom_session_read_internal (uint32_t session_index, void *buf, int n,
2514                               u8 peek)
2515 {
2516   session_t *session = 0;
2517   svm_fifo_t *rx_fifo;
2518   int n_read = 0;
2519   int rv;
2520   char *fifo_str;
2521   u32 poll_et;
2522
2523   ASSERT (buf);
2524
2525   clib_spinlock_lock (&vcm->sessions_lockp);
2526   rv = vppcom_session_at_index (session_index, &session);
2527   if (PREDICT_FALSE (rv))
2528     {
2529       clib_spinlock_unlock (&vcm->sessions_lockp);
2530       if (VPPCOM_DEBUG > 0)
2531         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2532                       getpid (), session_index);
2533       return rv;
2534     }
2535
2536   if (session->is_vep)
2537     {
2538       clib_spinlock_unlock (&vcm->sessions_lockp);
2539       if (VPPCOM_DEBUG > 0)
2540         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2541                       getpid (), session_index);
2542       return VPPCOM_EBADFD;
2543     }
2544
2545   if (session->state == STATE_DISCONNECT)
2546     {
2547       clib_spinlock_unlock (&vcm->sessions_lockp);
2548       if (VPPCOM_DEBUG > 0)
2549         clib_warning ("[%d] sid (%u) has been closed by remote peer!",
2550                       getpid (), session_index);
2551       return VPPCOM_ECONNRESET;
2552     }
2553
2554   rx_fifo = ((!session->is_cut_thru || session->is_server) ?
2555              session->server_rx_fifo : session->server_tx_fifo);
2556   fifo_str = ((!session->is_cut_thru || session->is_server) ?
2557               "server_rx_fifo" : "server_tx_fifo");
2558   poll_et =
2559     ((EPOLLET | EPOLLIN) & session->vep.ev.events) == (EPOLLET | EPOLLIN);
2560   clib_spinlock_unlock (&vcm->sessions_lockp);
2561
2562   do
2563     {
2564       if (peek)
2565         n_read = svm_fifo_peek (rx_fifo, 0, n, buf);
2566       else
2567         n_read = svm_fifo_dequeue_nowait (rx_fifo, n, buf);
2568     }
2569   while (!session->is_nonblocking && (n_read <= 0));
2570
2571   if (poll_et && (n_read <= 0))
2572     {
2573       clib_spinlock_lock (&vcm->sessions_lockp);
2574       session->vep.et_mask |= EPOLLIN;
2575       clib_spinlock_unlock (&vcm->sessions_lockp);
2576     }
2577
2578   if ((VPPCOM_DEBUG > 2) && (n_read > 0))
2579     clib_warning ("[%d] sid %d, read %d bytes from %s (%p)", getpid (),
2580                   session_index, n_read, fifo_str, rx_fifo);
2581
2582   return (n_read <= 0) ? VPPCOM_EAGAIN : n_read;
2583 }
2584
2585 int
2586 vppcom_session_read (uint32_t session_index, void *buf, int n)
2587 {
2588   return (vppcom_session_read_internal (session_index, buf, n, 0));
2589 }
2590
2591 static int
2592 vppcom_session_peek (uint32_t session_index, void *buf, int n)
2593 {
2594   return (vppcom_session_read_internal (session_index, buf, n, 1));
2595 }
2596
2597 static inline int
2598 vppcom_session_read_ready (session_t * session, u32 session_index)
2599 {
2600   svm_fifo_t *rx_fifo = 0;
2601   int ready = 0;
2602   u32 poll_et;
2603
2604   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
2605   if (session->is_vep)
2606     {
2607       clib_spinlock_unlock (&vcm->sessions_lockp);
2608       if (VPPCOM_DEBUG > 0)
2609         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2610                       getpid (), session_index);
2611       return VPPCOM_EBADFD;
2612     }
2613
2614   if (session->state == STATE_DISCONNECT)
2615     {
2616       if (VPPCOM_DEBUG > 0)
2617         clib_warning ("[%d] sid (%u) has been closed by remote peer!",
2618                       getpid (), session_index);
2619       return VPPCOM_ECONNRESET;
2620     }
2621
2622   if (session->is_listen)
2623     ready = clib_fifo_elts (vcm->client_session_index_fifo);
2624   else
2625     {
2626       rx_fifo = ((!session->is_cut_thru || session->is_server) ?
2627                  session->server_rx_fifo : session->server_tx_fifo);
2628
2629       ready = svm_fifo_max_dequeue (rx_fifo);
2630     }
2631
2632   poll_et =
2633     ((EPOLLET | EPOLLIN) & session->vep.ev.events) == (EPOLLET | EPOLLIN);
2634   if (poll_et && (ready == 0))
2635     {
2636       if (VPPCOM_DEBUG > 11)
2637         clib_warning ("[%d] sid %d: current vep.et_mask = 0x%x", getpid (),
2638                       session_index, session->vep.et_mask);
2639       session->vep.et_mask |= EPOLLIN;
2640       if (VPPCOM_DEBUG > 11)
2641         clib_warning ("[%d] sid %d: updated vep.et_mask = 0x%x", getpid (),
2642                       session_index, session->vep.et_mask);
2643     }
2644
2645   if (session->vep.et_mask && (VPPCOM_DEBUG > 11))
2646     clib_warning ("[%d] sid %d, is_listen %u, peek %s (%p), ready = %d, "
2647                   "et_mask 0x%x",
2648                   getpid (), session_index, session->is_listen,
2649                   session->is_server ? "server_rx_fifo" : "server_tx_fifo",
2650                   rx_fifo, ready, session->vep.et_mask);
2651   return ready;
2652 }
2653
2654 int
2655 vppcom_session_write (uint32_t session_index, void *buf, int n)
2656 {
2657   session_t *session = 0;
2658   svm_fifo_t *tx_fifo;
2659   unix_shared_memory_queue_t *q;
2660   session_fifo_event_t evt;
2661   int rv, n_write;
2662   char *fifo_str;
2663   u32 poll_et;
2664
2665   ASSERT (buf);
2666
2667   clib_spinlock_lock (&vcm->sessions_lockp);
2668   rv = vppcom_session_at_index (session_index, &session);
2669   if (PREDICT_FALSE (rv))
2670     {
2671       clib_spinlock_unlock (&vcm->sessions_lockp);
2672       if (VPPCOM_DEBUG > 0)
2673         clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2674                       getpid (), session_index);
2675       return rv;
2676     }
2677
2678   if (session->is_vep)
2679     {
2680       clib_spinlock_unlock (&vcm->sessions_lockp);
2681       if (VPPCOM_DEBUG > 0)
2682         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2683                       getpid (), session_index);
2684       return VPPCOM_EBADFD;
2685     }
2686
2687   if (session->state == STATE_DISCONNECT)
2688     {
2689       clib_spinlock_unlock (&vcm->sessions_lockp);
2690       if (VPPCOM_DEBUG > 0)
2691         clib_warning ("[%d] sid (%u) has been closed by remote peer!",
2692                       getpid (), session_index);
2693       return VPPCOM_ECONNRESET;
2694     }
2695
2696   tx_fifo = ((!session->is_cut_thru || session->is_server) ?
2697              session->server_tx_fifo : session->server_rx_fifo);
2698   fifo_str = ((!session->is_cut_thru || session->is_server) ?
2699               "server_tx_fifo" : "server_rx_fifo");
2700   q = session->vpp_event_queue;
2701   poll_et = (((EPOLLET | EPOLLOUT) & session->vep.ev.events) ==
2702              (EPOLLET | EPOLLOUT));
2703   clib_spinlock_unlock (&vcm->sessions_lockp);
2704
2705   do
2706     {
2707       n_write = svm_fifo_enqueue_nowait (tx_fifo, n, buf);
2708     }
2709   while (!session->is_nonblocking && (n_write <= 0));
2710
2711   /* If event wasn't set, add one */
2712   if (!session->is_cut_thru && (n_write > 0) && svm_fifo_set_event (tx_fifo))
2713     {
2714       int rval;
2715
2716       /* Fabricate TX event, send to vpp */
2717       evt.fifo = tx_fifo;
2718       evt.event_type = FIFO_EVENT_APP_TX;
2719
2720       rval = vppcom_session_at_index (session_index, &session);
2721       if (PREDICT_FALSE (rval))
2722         {
2723           if (VPPCOM_DEBUG > 1)
2724             clib_warning ("[%d] invalid session, sid (%u) has been closed!",
2725                           getpid (), session_index);
2726           return rval;
2727         }
2728       ASSERT (q);
2729       unix_shared_memory_queue_add (q, (u8 *) & evt,
2730                                     0 /* do wait for mutex */ );
2731     }
2732
2733   if (poll_et && (n_write <= 0))
2734     {
2735       clib_spinlock_lock (&vcm->sessions_lockp);
2736       session->vep.et_mask |= EPOLLOUT;
2737       clib_spinlock_unlock (&vcm->sessions_lockp);
2738     }
2739
2740   if (VPPCOM_DEBUG > 2)
2741     {
2742       if (n_write == -2)
2743         clib_warning ("[%d] sid %d, FIFO-FULL %s (%p)", getpid (),
2744                       session_index, fifo_str, tx_fifo);
2745       else
2746         clib_warning ("[%d] sid %d, wrote %d bytes to %s (%p)", getpid (),
2747                       session_index, n_write, fifo_str, tx_fifo);
2748     }
2749   return (n_write < 0) ? VPPCOM_EAGAIN : n_write;
2750 }
2751
2752 static inline int
2753 vppcom_session_write_ready (session_t * session, u32 session_index)
2754 {
2755   svm_fifo_t *tx_fifo;
2756   char *fifo_str;
2757   int ready;
2758   u32 poll_et;
2759
2760   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
2761   if (session->is_vep)
2762     {
2763       clib_spinlock_unlock (&vcm->sessions_lockp);
2764       if (VPPCOM_DEBUG > 0)
2765         clib_warning ("[%d] invalid session, sid (%u) is an epoll session!",
2766                       getpid (), session_index);
2767       return VPPCOM_EBADFD;
2768     }
2769
2770   if (session->state == STATE_DISCONNECT)
2771     {
2772       if (VPPCOM_DEBUG > 0)
2773         clib_warning ("[%d] sid (%u) has been closed by remote peer!",
2774                       getpid (), session_index);
2775       return VPPCOM_ECONNRESET;
2776     }
2777
2778   tx_fifo = ((!session->is_cut_thru || session->is_server) ?
2779              session->server_tx_fifo : session->server_rx_fifo);
2780   fifo_str = ((!session->is_cut_thru || session->is_server) ?
2781               "server_tx_fifo" : "server_rx_fifo");
2782
2783   ready = svm_fifo_max_enqueue (tx_fifo);
2784
2785   if (VPPCOM_DEBUG > 3)
2786     clib_warning ("[%d] sid %d, peek %s (%p), ready = %d", getpid (),
2787                   session_index, fifo_str, tx_fifo, ready);
2788   poll_et = (((EPOLLET | EPOLLOUT) & session->vep.ev.events) ==
2789              (EPOLLET | EPOLLOUT));
2790   if (poll_et && (ready == 0))
2791     session->vep.et_mask |= EPOLLOUT;
2792
2793   return ready;
2794 }
2795
2796 int
2797 vppcom_select (unsigned long n_bits, unsigned long *read_map,
2798                unsigned long *write_map, unsigned long *except_map,
2799                double time_to_wait)
2800 {
2801   u32 session_index;
2802   session_t *session = 0;
2803   int rv, bits_set = 0;
2804   f64 timeout = clib_time_now (&vcm->clib_time) + time_to_wait;
2805   u32 minbits = clib_max (n_bits, BITS (uword));
2806
2807   ASSERT (sizeof (clib_bitmap_t) == sizeof (long int));
2808
2809   if (n_bits && read_map)
2810     {
2811       clib_bitmap_validate (vcm->rd_bitmap, minbits);
2812       clib_memcpy (vcm->rd_bitmap, read_map, vec_len (vcm->rd_bitmap));
2813       memset (read_map, 0, vec_len (vcm->rd_bitmap));
2814     }
2815   if (n_bits && write_map)
2816     {
2817       clib_bitmap_validate (vcm->wr_bitmap, minbits);
2818       clib_memcpy (vcm->wr_bitmap, write_map, vec_len (vcm->wr_bitmap));
2819       memset (write_map, 0, vec_len (vcm->wr_bitmap));
2820     }
2821   if (n_bits && except_map)
2822     {
2823       clib_bitmap_validate (vcm->ex_bitmap, minbits);
2824       clib_memcpy (vcm->ex_bitmap, except_map, vec_len (vcm->ex_bitmap));
2825       memset (except_map, 0, vec_len (vcm->ex_bitmap));
2826     }
2827
2828   do
2829     {
2830       /* *INDENT-OFF* */
2831       if (n_bits)
2832         {
2833           if (read_map)
2834             {
2835               clib_bitmap_foreach (session_index, vcm->rd_bitmap,
2836                 ({
2837                   clib_spinlock_lock (&vcm->sessions_lockp);
2838                   rv = vppcom_session_at_index (session_index, &session);
2839                   if (rv < 0)
2840                     {
2841                       clib_spinlock_unlock (&vcm->sessions_lockp);
2842                       if (VPPCOM_DEBUG > 1)
2843                         clib_warning ("[%d] session %d specified in "
2844                                       "read_map is closed.", getpid (),
2845                                       session_index);
2846                       bits_set = VPPCOM_EBADFD;
2847                       goto select_done;
2848                     }
2849
2850                   rv = vppcom_session_read_ready (session, session_index);
2851                   clib_spinlock_unlock (&vcm->sessions_lockp);
2852                   if (except_map && vcm->ex_bitmap &&
2853                       clib_bitmap_get (vcm->ex_bitmap, session_index) &&
2854                       (rv < 0))
2855                     {
2856                       // TBD: clib_warning
2857                       clib_bitmap_set_no_check (except_map, session_index, 1);
2858                       bits_set++;
2859                     }
2860                   else if (rv > 0)
2861                     {
2862                       // TBD: clib_warning
2863                       clib_bitmap_set_no_check (read_map, session_index, 1);
2864                       bits_set++;
2865                     }
2866                 }));
2867             }
2868
2869           if (write_map)
2870             {
2871               clib_bitmap_foreach (session_index, vcm->wr_bitmap,
2872                 ({
2873                   clib_spinlock_lock (&vcm->sessions_lockp);
2874                   rv = vppcom_session_at_index (session_index, &session);
2875                   if (rv < 0)
2876                     {
2877                       clib_spinlock_unlock (&vcm->sessions_lockp);
2878                       if (VPPCOM_DEBUG > 0)
2879                         clib_warning ("[%d] session %d specified in "
2880                                       "write_map is closed.", getpid (),
2881                                       session_index);
2882                       bits_set = VPPCOM_EBADFD;
2883                       goto select_done;
2884                     }
2885
2886                   rv = vppcom_session_write_ready (session, session_index);
2887                   clib_spinlock_unlock (&vcm->sessions_lockp);
2888                   if (write_map && (rv > 0))
2889                     {
2890                       // TBD: clib_warning
2891                       clib_bitmap_set_no_check (write_map, session_index, 1);
2892                       bits_set++;
2893                     }
2894                 }));
2895             }
2896
2897           if (except_map)
2898             {
2899               clib_bitmap_foreach (session_index, vcm->ex_bitmap,
2900                 ({
2901                   clib_spinlock_lock (&vcm->sessions_lockp);
2902                   rv = vppcom_session_at_index (session_index, &session);
2903                   if (rv < 0)
2904                     {
2905                       clib_spinlock_unlock (&vcm->sessions_lockp);
2906                       if (VPPCOM_DEBUG > 1)
2907                         clib_warning ("[%d] session %d specified in "
2908                                       "except_map is closed.", getpid (),
2909                                       session_index);
2910                       bits_set = VPPCOM_EBADFD;
2911                       goto select_done;
2912                     }
2913
2914                   rv = vppcom_session_read_ready (session, session_index);
2915                   clib_spinlock_unlock (&vcm->sessions_lockp);
2916                   if (rv < 0)
2917                     {
2918                       // TBD: clib_warning
2919                       clib_bitmap_set_no_check (except_map, session_index, 1);
2920                       bits_set++;
2921                     }
2922                 }));
2923             }
2924         }
2925       /* *INDENT-ON* */
2926     }
2927   while (clib_time_now (&vcm->clib_time) < timeout);
2928
2929 select_done:
2930   return (bits_set);
2931 }
2932
2933 static inline void
2934 vep_verify_epoll_chain (u32 vep_idx)
2935 {
2936   session_t *session;
2937   vppcom_epoll_t *vep;
2938   int rv;
2939   u32 sid = vep_idx;
2940
2941   if (VPPCOM_DEBUG <= 1)
2942     return;
2943
2944   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
2945   rv = vppcom_session_at_index (vep_idx, &session);
2946   if (PREDICT_FALSE (rv))
2947     {
2948       clib_warning ("[%d] ERROR: Invalid vep_idx (%u)!", getpid (), vep_idx);
2949       goto done;
2950     }
2951   if (PREDICT_FALSE (!session->is_vep))
2952     {
2953       clib_warning ("[%d] ERROR: vep_idx (%u) is not a vep!", getpid (),
2954                     vep_idx);
2955       goto done;
2956     }
2957   clib_warning ("[%d] vep_idx (%u): Dumping epoll chain\n"
2958                 "{\n"
2959                 "   is_vep         = %u\n"
2960                 "   is_vep_session = %u\n"
2961                 "   wait_cont_idx  = 0x%x (%u)\n"
2962                 "}\n", getpid (),
2963                 vep_idx, session->is_vep, session->is_vep_session,
2964                 session->wait_cont_idx, session->wait_cont_idx);
2965   do
2966     {
2967       vep = &session->vep;
2968       sid = vep->next_sid;
2969       if (sid != ~0)
2970         {
2971           rv = vppcom_session_at_index (sid, &session);
2972           if (PREDICT_FALSE (rv))
2973             {
2974               clib_warning ("[%d] ERROR: Invalid sid (%u)!", getpid (), sid);
2975               goto done;
2976             }
2977           if (PREDICT_FALSE (session->is_vep))
2978             clib_warning ("[%d] ERROR: sid (%u) is a vep!",
2979                           getpid (), vep_idx);
2980           else if (PREDICT_FALSE (!session->is_vep_session))
2981             {
2982               clib_warning ("[%d] ERROR: session (%u) is not a vep session!",
2983                             getpid (), sid);
2984               goto done;
2985             }
2986           if (PREDICT_FALSE (session->vep.vep_idx != vep_idx))
2987             clib_warning ("[%d] ERROR: session (%u) vep_idx (%u) != "
2988                           "vep_idx (%u)!", getpid (),
2989                           sid, session->vep.vep_idx, vep_idx);
2990           if (session->is_vep_session)
2991             {
2992               clib_warning ("vep_idx[%u]: sid 0x%x (%u)\n"
2993                             "{\n"
2994                             "   next_sid       = 0x%x (%u)\n"
2995                             "   prev_sid       = 0x%x (%u)\n"
2996                             "   vep_idx        = 0x%x (%u)\n"
2997                             "   ev.events      = 0x%x\n"
2998                             "   ev.data.u64    = 0x%llx\n"
2999                             "   et_mask        = 0x%x\n"
3000                             "}\n",
3001                             vep_idx, sid, sid,
3002                             vep->next_sid, vep->next_sid,
3003                             vep->prev_sid, vep->prev_sid,
3004                             vep->vep_idx, vep->vep_idx,
3005                             vep->ev.events, vep->ev.data.u64, vep->et_mask);
3006             }
3007         }
3008     }
3009   while (sid != ~0);
3010
3011 done:
3012   clib_warning ("[%d] vep_idx (%u): Dump complete!\n", getpid (), vep_idx);
3013 }
3014
3015 int
3016 vppcom_epoll_create (void)
3017 {
3018   session_t *vep_session;
3019   u32 vep_idx;
3020
3021   clib_spinlock_lock (&vcm->sessions_lockp);
3022   pool_get (vcm->sessions, vep_session);
3023   memset (vep_session, 0, sizeof (*vep_session));
3024   vep_idx = vep_session - vcm->sessions;
3025
3026   vep_session->is_vep = 1;
3027   vep_session->vep.vep_idx = ~0;
3028   vep_session->vep.next_sid = ~0;
3029   vep_session->vep.prev_sid = ~0;
3030   vep_session->wait_cont_idx = ~0;
3031   clib_spinlock_unlock (&vcm->sessions_lockp);
3032
3033   if (VPPCOM_DEBUG > 0)
3034     clib_warning ("[%d] Created vep_idx %u!", getpid (), vep_idx);
3035
3036   return (vep_idx);
3037 }
3038
3039 int
3040 vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
3041                   struct epoll_event *event)
3042 {
3043   session_t *vep_session;
3044   session_t *session;
3045   int rv;
3046
3047   if (vep_idx == session_index)
3048     {
3049       if (VPPCOM_DEBUG > 0)
3050         clib_warning ("[%d] ERROR: vep_idx == session_index (%u)!",
3051                       getpid (), vep_idx);
3052       return VPPCOM_EINVAL;
3053     }
3054
3055   clib_spinlock_lock (&vcm->sessions_lockp);
3056   rv = vppcom_session_at_index (vep_idx, &vep_session);
3057   if (PREDICT_FALSE (rv))
3058     {
3059       if (VPPCOM_DEBUG > 0)
3060         clib_warning ("[%d] ERROR: Invalid vep_idx (%u)!", vep_idx);
3061       goto done;
3062     }
3063   if (PREDICT_FALSE (!vep_session->is_vep))
3064     {
3065       if (VPPCOM_DEBUG > 0)
3066         clib_warning ("[%d] ERROR: vep_idx (%u) is not a vep!",
3067                       getpid (), vep_idx);
3068       rv = VPPCOM_EINVAL;
3069       goto done;
3070     }
3071
3072   ASSERT (vep_session->vep.vep_idx == ~0);
3073   ASSERT (vep_session->vep.prev_sid == ~0);
3074
3075   rv = vppcom_session_at_index (session_index, &session);
3076   if (PREDICT_FALSE (rv))
3077     {
3078       if (VPPCOM_DEBUG > 0)
3079         clib_warning ("[%d] ERROR: Invalid session_index (%u)!",
3080                       getpid (), session_index);
3081       goto done;
3082     }
3083   if (PREDICT_FALSE (session->is_vep))
3084     {
3085       if (VPPCOM_DEBUG > 0)
3086         clib_warning ("ERROR: session_index (%u) is a vep!", vep_idx);
3087       rv = VPPCOM_EINVAL;
3088       goto done;
3089     }
3090
3091   switch (op)
3092     {
3093     case EPOLL_CTL_ADD:
3094       if (PREDICT_FALSE (!event))
3095         {
3096           clib_warning ("[%d] ERROR: EPOLL_CTL_ADD: NULL pointer to "
3097                         "epoll_event structure!", getpid ());
3098           rv = VPPCOM_EINVAL;
3099           goto done;
3100         }
3101       if (vep_session->vep.next_sid != ~0)
3102         {
3103           session_t *next_session;
3104           rv = vppcom_session_at_index (vep_session->vep.next_sid,
3105                                         &next_session);
3106           if (PREDICT_FALSE (rv))
3107             {
3108               if (VPPCOM_DEBUG > 0)
3109                 clib_warning ("[%d] ERROR: EPOLL_CTL_ADD: Invalid "
3110                               "vep.next_sid (%u) on vep_idx (%u)!",
3111                               getpid (), vep_session->vep.next_sid, vep_idx);
3112               goto done;
3113             }
3114           ASSERT (next_session->vep.prev_sid == vep_idx);
3115           next_session->vep.prev_sid = session_index;
3116         }
3117       session->vep.next_sid = vep_session->vep.next_sid;
3118       session->vep.prev_sid = vep_idx;
3119       session->vep.vep_idx = vep_idx;
3120       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
3121       session->vep.ev = *event;
3122       session->is_vep_session = 1;
3123       vep_session->vep.next_sid = session_index;
3124       if (VPPCOM_DEBUG > 1)
3125         clib_warning ("[%d] EPOLL_CTL_ADD: vep_idx %u, sid %u, events 0x%x,"
3126                       " data 0x%llx!", getpid (), vep_idx, session_index,
3127                       event->events, event->data.u64);
3128       break;
3129
3130     case EPOLL_CTL_MOD:
3131       if (PREDICT_FALSE (!event))
3132         {
3133           clib_warning ("[%d] ERROR: EPOLL_CTL_MOD: NULL pointer to "
3134                         "epoll_event structure!", getpid ());
3135           rv = VPPCOM_EINVAL;
3136           goto done;
3137         }
3138       if (PREDICT_FALSE (!session->is_vep_session &&
3139                          (session->vep.vep_idx != vep_idx)))
3140         {
3141           if (VPPCOM_DEBUG > 0)
3142             {
3143               if (!session->is_vep_session)
3144                 clib_warning ("[%d] ERROR: EPOLL_CTL_MOD: session (%u) "
3145                               "is not a vep session!",
3146                               getpid (), session_index);
3147               else
3148                 clib_warning ("[%d] ERROR: EPOLL_CTL_MOD: session (%u) "
3149                               "vep_idx (%u) != vep_idx (%u)!",
3150                               getpid (), session_index,
3151                               session->vep.vep_idx, vep_idx);
3152             }
3153           rv = VPPCOM_EINVAL;
3154           goto done;
3155         }
3156       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
3157       session->vep.ev = *event;
3158       if (VPPCOM_DEBUG > 1)
3159         clib_warning ("[%d] EPOLL_CTL_MOD: vep_idx %u, sid %u, events 0x%x,"
3160                       " data 0x%llx!", getpid (), vep_idx, session_index,
3161                       event->events, event->data.u64);
3162       break;
3163
3164     case EPOLL_CTL_DEL:
3165       if (PREDICT_FALSE (!session->is_vep_session &&
3166                          (session->vep.vep_idx != vep_idx)))
3167         {
3168           if (VPPCOM_DEBUG > 0)
3169             {
3170               if (!session->is_vep_session)
3171                 clib_warning ("[%d] ERROR: EPOLL_CTL_DEL: session (%u) "
3172                               "is not a vep session!",
3173                               getpid (), session_index);
3174               else
3175                 clib_warning ("[%d] ERROR: EPOLL_CTL_DEL: session (%u) "
3176                               "vep_idx (%u) != vep_idx (%u)!",
3177                               getpid (), session_index,
3178                               session->vep.vep_idx, vep_idx);
3179             }
3180           rv = VPPCOM_EINVAL;
3181           goto done;
3182         }
3183
3184       vep_session->wait_cont_idx =
3185         (vep_session->wait_cont_idx == session_index) ?
3186         session->vep.next_sid : vep_session->wait_cont_idx;
3187
3188       if (session->vep.prev_sid == vep_idx)
3189         vep_session->vep.next_sid = session->vep.next_sid;
3190       else
3191         {
3192           session_t *prev_session;
3193           rv = vppcom_session_at_index (session->vep.prev_sid, &prev_session);
3194           if (PREDICT_FALSE (rv))
3195             {
3196               if (VPPCOM_DEBUG > 0)
3197                 clib_warning ("[%d] ERROR: EPOLL_CTL_DEL: Invalid "
3198                               "vep.prev_sid (%u) on sid (%u)!",
3199                               getpid (), session->vep.prev_sid,
3200                               session_index);
3201               goto done;
3202             }
3203           ASSERT (prev_session->vep.next_sid == session_index);
3204           prev_session->vep.next_sid = session->vep.next_sid;
3205         }
3206       if (session->vep.next_sid != ~0)
3207         {
3208           session_t *next_session;
3209           rv = vppcom_session_at_index (session->vep.next_sid, &next_session);
3210           if (PREDICT_FALSE (rv))
3211             {
3212               if (VPPCOM_DEBUG > 0)
3213                 clib_warning ("[%d] ERROR: EPOLL_CTL_DEL: Invalid "
3214                               "vep.next_sid (%u) on sid (%u)!",
3215                               getpid (), session->vep.next_sid,
3216                               session_index);
3217               goto done;
3218             }
3219           ASSERT (next_session->vep.prev_sid == session_index);
3220           next_session->vep.prev_sid = session->vep.prev_sid;
3221         }
3222
3223       memset (&session->vep, 0, sizeof (session->vep));
3224       session->vep.next_sid = ~0;
3225       session->vep.prev_sid = ~0;
3226       session->vep.vep_idx = ~0;
3227       session->is_vep_session = 0;
3228       if (VPPCOM_DEBUG > 1)
3229         clib_warning ("[%d] EPOLL_CTL_DEL: vep_idx %u, sid %u!",
3230                       getpid (), vep_idx, session_index);
3231       break;
3232
3233     default:
3234       clib_warning ("[%d] ERROR: Invalid operation (%d)!", getpid (), op);
3235       rv = VPPCOM_EINVAL;
3236     }
3237
3238   vep_verify_epoll_chain (vep_idx);
3239
3240 done:
3241   clib_spinlock_unlock (&vcm->sessions_lockp);
3242   return rv;
3243 }
3244
3245 int
3246 vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
3247                    int maxevents, double wait_for_time)
3248 {
3249   session_t *vep_session;
3250   int rv;
3251   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
3252   u32 keep_trying = 1;
3253   int num_ev = 0;
3254   u32 vep_next_sid, wait_cont_idx;
3255   u8 is_vep;
3256
3257   if (PREDICT_FALSE (maxevents <= 0))
3258     {
3259       if (VPPCOM_DEBUG > 0)
3260         clib_warning ("[%d] ERROR: Invalid maxevents (%d)!",
3261                       getpid (), maxevents);
3262       return VPPCOM_EINVAL;
3263     }
3264   memset (events, 0, sizeof (*events) * maxevents);
3265
3266   VCL_LOCK_AND_GET_SESSION (vep_idx, &vep_session);
3267   vep_next_sid = vep_session->vep.next_sid;
3268   is_vep = vep_session->is_vep;
3269   wait_cont_idx = vep_session->wait_cont_idx;
3270   clib_spinlock_unlock (&vcm->sessions_lockp);
3271
3272   if (PREDICT_FALSE (!is_vep))
3273     {
3274       if (VPPCOM_DEBUG > 0)
3275         clib_warning ("[%d] ERROR: vep_idx (%u) is not a vep!",
3276                       getpid (), vep_idx);
3277       rv = VPPCOM_EINVAL;
3278       goto done;
3279     }
3280   if (PREDICT_FALSE (vep_next_sid == ~0))
3281     {
3282       if (VPPCOM_DEBUG > 0)
3283         clib_warning ("[%d] WARNING: vep_idx (%u) is empty!",
3284                       getpid (), vep_idx);
3285       goto done;
3286     }
3287
3288   do
3289     {
3290       u32 sid;
3291       u32 next_sid = ~0;
3292       session_t *session;
3293
3294       for (sid = (wait_cont_idx == ~0) ? vep_next_sid : wait_cont_idx;
3295            sid != ~0; sid = next_sid)
3296         {
3297           u32 session_events, et_mask, clear_et_mask, session_vep_idx;
3298           u8 add_event, is_vep_session;
3299           int ready;
3300           u64 session_ev_data;
3301
3302           VCL_LOCK_AND_GET_SESSION (sid, &session);
3303           next_sid = session->vep.next_sid;
3304           session_events = session->vep.ev.events;
3305           et_mask = session->vep.et_mask;
3306           is_vep = session->is_vep;
3307           is_vep_session = session->is_vep_session;
3308           session_vep_idx = session->vep.vep_idx;
3309           session_ev_data = session->vep.ev.data.u64;
3310           clib_spinlock_unlock (&vcm->sessions_lockp);
3311
3312           if (PREDICT_FALSE (is_vep))
3313             {
3314               if (VPPCOM_DEBUG > 0)
3315                 clib_warning ("[%d] ERROR: sid (%u) is a vep!",
3316                               getpid (), vep_idx);
3317               rv = VPPCOM_EINVAL;
3318               goto done;
3319             }
3320           if (PREDICT_FALSE (!is_vep_session))
3321             {
3322               if (VPPCOM_DEBUG > 0)
3323                 clib_warning ("[%d] ERROR: session (%u) is not "
3324                               "a vep session!", getpid (), sid);
3325               rv = VPPCOM_EINVAL;
3326               goto done;
3327             }
3328           if (PREDICT_FALSE (session_vep_idx != vep_idx))
3329             {
3330               clib_warning ("[%d] ERROR: session (%u) "
3331                             "vep_idx (%u) != vep_idx (%u)!",
3332                             getpid (), sid, session->vep.vep_idx, vep_idx);
3333               rv = VPPCOM_EINVAL;
3334               goto done;
3335             }
3336
3337           add_event = clear_et_mask = 0;
3338
3339           if (EPOLLIN & session_events)
3340             {
3341               VCL_LOCK_AND_GET_SESSION (sid, &session);
3342               ready = vppcom_session_read_ready (session, sid);
3343               clib_spinlock_unlock (&vcm->sessions_lockp);
3344               if ((ready > 0) && (EPOLLIN & et_mask))
3345                 {
3346                   add_event = 1;
3347                   events[num_ev].events |= EPOLLIN;
3348                   if (((EPOLLET | EPOLLIN) & session_events) ==
3349                       (EPOLLET | EPOLLIN))
3350                     clear_et_mask |= EPOLLIN;
3351                 }
3352               else if (ready < 0)
3353                 {
3354                   add_event = 1;
3355                   switch (ready)
3356                     {
3357                     case VPPCOM_ECONNRESET:
3358                       events[num_ev].events |= EPOLLHUP | EPOLLRDHUP;
3359                       break;
3360
3361                     default:
3362                       events[num_ev].events |= EPOLLERR;
3363                       break;
3364                     }
3365                 }
3366             }
3367
3368           if (EPOLLOUT & session_events)
3369             {
3370               VCL_LOCK_AND_GET_SESSION (sid, &session);
3371               ready = vppcom_session_write_ready (session, sid);
3372               clib_spinlock_unlock (&vcm->sessions_lockp);
3373               if ((ready > 0) && (EPOLLOUT & et_mask))
3374                 {
3375                   add_event = 1;
3376                   events[num_ev].events |= EPOLLOUT;
3377                   if (((EPOLLET | EPOLLOUT) & session_events) ==
3378                       (EPOLLET | EPOLLOUT))
3379                     clear_et_mask |= EPOLLOUT;
3380                 }
3381               else if (ready < 0)
3382                 {
3383                   add_event = 1;
3384                   switch (ready)
3385                     {
3386                     case VPPCOM_ECONNRESET:
3387                       events[num_ev].events |= EPOLLHUP;
3388                       break;
3389
3390                     default:
3391                       events[num_ev].events |= EPOLLERR;
3392                       break;
3393                     }
3394                 }
3395             }
3396
3397           if (add_event)
3398             {
3399               events[num_ev].data.u64 = session_ev_data;
3400               if (EPOLLONESHOT & session_events)
3401                 {
3402                   VCL_LOCK_AND_GET_SESSION (sid, &session);
3403                   session->vep.ev.events = 0;
3404                   clib_spinlock_unlock (&vcm->sessions_lockp);
3405                 }
3406               num_ev++;
3407               if (num_ev == maxevents)
3408                 {
3409                   VCL_LOCK_AND_GET_SESSION (vep_idx, &vep_session);
3410                   vep_session->wait_cont_idx = next_sid;
3411                   clib_spinlock_unlock (&vcm->sessions_lockp);
3412                   goto done;
3413                 }
3414             }
3415           if (wait_cont_idx != ~0)
3416             {
3417               if (next_sid == ~0)
3418                 next_sid = vep_next_sid;
3419               else if (next_sid == wait_cont_idx)
3420                 next_sid = ~0;
3421             }
3422         }
3423       if (wait_for_time != -1)
3424         keep_trying = (clib_time_now (&vcm->clib_time) <= timeout) ? 1 : 0;
3425     }
3426   while ((num_ev == 0) && keep_trying);
3427
3428   if (wait_cont_idx != ~0)
3429     {
3430       VCL_LOCK_AND_GET_SESSION (vep_idx, &vep_session);
3431       vep_session->wait_cont_idx = ~0;
3432       clib_spinlock_unlock (&vcm->sessions_lockp);
3433     }
3434 done:
3435   return (rv != VPPCOM_OK) ? rv : num_ev;
3436 }
3437
3438 int
3439 vppcom_session_attr (uint32_t session_index, uint32_t op,
3440                      void *buffer, uint32_t * buflen)
3441 {
3442   session_t *session;
3443   int rv = VPPCOM_OK;
3444   u32 *flags = buffer;
3445   vppcom_endpt_t *ep = buffer;
3446
3447   VCL_LOCK_AND_GET_SESSION (session_index, &session);
3448   switch (op)
3449     {
3450     case VPPCOM_ATTR_GET_NREAD:
3451       rv = vppcom_session_read_ready (session, session_index);
3452       if (VPPCOM_DEBUG > 2)
3453         clib_warning ("[%d] VPPCOM_ATTR_GET_NREAD: sid %u, nread = %d",
3454                       getpid (), rv);
3455
3456       break;
3457
3458     case VPPCOM_ATTR_GET_NWRITE:
3459       rv = vppcom_session_write_ready (session, session_index);
3460       if (VPPCOM_DEBUG > 2)
3461         clib_warning ("[%d] VPPCOM_ATTR_GET_NWRITE: sid %u, nwrite = %d",
3462                       getpid (), session_index, rv);
3463
3464       break;
3465
3466     case VPPCOM_ATTR_GET_FLAGS:
3467       if (buffer && buflen && (*buflen >= sizeof (*flags)))
3468         {
3469           *flags = O_RDWR | ((session->is_nonblocking) ? O_NONBLOCK : 0);
3470           *buflen = sizeof (*flags);
3471           if (VPPCOM_DEBUG > 2)
3472             clib_warning ("[%d] VPPCOM_ATTR_GET_FLAGS: sid %u, "
3473                           "flags = 0x%08x, is_nonblocking = %u", getpid (),
3474                           session_index, *flags, session->is_nonblocking);
3475         }
3476       else
3477         rv = VPPCOM_EINVAL;
3478       break;
3479
3480     case VPPCOM_ATTR_SET_FLAGS:
3481       if (buffer && buflen && (*buflen >= sizeof (*flags)))
3482         {
3483           session->is_nonblocking = (*flags & O_NONBLOCK) ? 1 : 0;
3484           if (VPPCOM_DEBUG > 2)
3485             clib_warning ("[%d] VPPCOM_ATTR_SET_FLAGS: sid %u, "
3486                           "flags = 0x%08x, is_nonblocking = %u",
3487                           getpid (), *flags, session->is_nonblocking);
3488         }
3489       else
3490         rv = VPPCOM_EINVAL;
3491       break;
3492
3493     case VPPCOM_ATTR_GET_PEER_ADDR:
3494       if (buffer && buflen && (*buflen >= sizeof (*ep)))
3495         {
3496           ep->vrf = session->vrf;
3497           ep->is_ip4 = session->peer_addr.is_ip4;
3498           ep->port = session->peer_port;
3499           if (session->peer_addr.is_ip4)
3500             clib_memcpy (ep->ip, &session->peer_addr.ip46.ip4,
3501                          sizeof (ip4_address_t));
3502           else
3503             clib_memcpy (ep->ip, &session->peer_addr.ip46.ip6,
3504                          sizeof (ip6_address_t));
3505           *buflen = sizeof (*ep);
3506           if (VPPCOM_DEBUG > 1)
3507             clib_warning ("[%d] VPPCOM_ATTR_GET_PEER_ADDR: sid %u, is_ip4 = "
3508                           "%u, addr = %U, port %u", getpid (),
3509                           session_index, ep->is_ip4, format_ip46_address,
3510                           &session->peer_addr.ip46, ep->is_ip4,
3511                           clib_net_to_host_u16 (ep->port));
3512         }
3513       else
3514         rv = VPPCOM_EINVAL;
3515       break;
3516
3517     case VPPCOM_ATTR_GET_LCL_ADDR:
3518       if (buffer && buflen && (*buflen >= sizeof (*ep)))
3519         {
3520           ep->vrf = session->vrf;
3521           ep->is_ip4 = session->lcl_addr.is_ip4;
3522           ep->port = session->lcl_port;
3523           if (session->lcl_addr.is_ip4)
3524             clib_memcpy (ep->ip, &session->lcl_addr.ip46.ip4,
3525                          sizeof (ip4_address_t));
3526           else
3527             clib_memcpy (ep->ip, &session->lcl_addr.ip46.ip6,
3528                          sizeof (ip6_address_t));
3529           *buflen = sizeof (*ep);
3530           if (VPPCOM_DEBUG > 1)
3531             clib_warning ("[%d] VPPCOM_ATTR_GET_LCL_ADDR: sid %u, is_ip4 = "
3532                           "%u, addr = %U port %d", getpid (),
3533                           session_index, ep->is_ip4, format_ip46_address,
3534                           &session->lcl_addr.ip46, ep->is_ip4,
3535                           clib_net_to_host_u16 (ep->port));
3536         }
3537       else
3538         rv = VPPCOM_EINVAL;
3539       break;
3540
3541     case VPPCOM_ATTR_SET_REUSEADDR:
3542       break;
3543
3544     case VPPCOM_ATTR_SET_BROADCAST:
3545       break;
3546
3547     case VPPCOM_ATTR_SET_V6ONLY:
3548       break;
3549
3550     case VPPCOM_ATTR_SET_KEEPALIVE:
3551       break;
3552
3553     case VPPCOM_ATTR_SET_TCP_KEEPIDLE:
3554       break;
3555
3556     case VPPCOM_ATTR_SET_TCP_KEEPINTVL:
3557       break;
3558
3559     default:
3560       rv = VPPCOM_EINVAL;
3561       break;
3562     }
3563
3564 done:
3565   clib_spinlock_unlock (&vcm->sessions_lockp);
3566   return rv;
3567 }
3568
3569 int
3570 vppcom_session_recvfrom (uint32_t session_index, void *buffer,
3571                          uint32_t buflen, int flags, vppcom_endpt_t * ep)
3572 {
3573   int rv = VPPCOM_OK;
3574   session_t *session = 0;
3575
3576   if (ep)
3577     {
3578       clib_spinlock_lock (&vcm->sessions_lockp);
3579       rv = vppcom_session_at_index (session_index, &session);
3580       if (PREDICT_FALSE (rv))
3581         {
3582           clib_spinlock_unlock (&vcm->sessions_lockp);
3583           if (VPPCOM_DEBUG > 0)
3584             clib_warning ("[%d] invalid session, sid (%u) has been closed!",
3585                           getpid (), session_index);
3586           rv = VPPCOM_EBADFD;
3587           clib_spinlock_unlock (&vcm->sessions_lockp);
3588           goto done;
3589         }
3590       ep->vrf = session->vrf;
3591       ep->is_ip4 = session->peer_addr.is_ip4;
3592       ep->port = session->peer_port;
3593       if (session->peer_addr.is_ip4)
3594         clib_memcpy (ep->ip, &session->peer_addr.ip46.ip4,
3595                      sizeof (ip4_address_t));
3596       else
3597         clib_memcpy (ep->ip, &session->peer_addr.ip46.ip6,
3598                      sizeof (ip6_address_t));
3599       clib_spinlock_unlock (&vcm->sessions_lockp);
3600     }
3601
3602   if (flags == 0)
3603     rv = vppcom_session_read (session_index, buffer, buflen);
3604   else if (flags & MSG_PEEK)
3605     rv = vppcom_session_peek (session_index, buffer, buflen);
3606   else
3607     {
3608       clib_warning ("[%d] Unsupport flags for recvfrom %d", getpid (), flags);
3609       rv = VPPCOM_EAFNOSUPPORT;
3610     }
3611
3612 done:
3613   return rv;
3614 }
3615
3616 int
3617 vppcom_session_sendto (uint32_t session_index, void *buffer,
3618                        uint32_t buflen, int flags, vppcom_endpt_t * ep)
3619 {
3620   if (!buffer)
3621     return VPPCOM_EINVAL;
3622
3623   if (ep)
3624     {
3625       // TBD
3626       return VPPCOM_EINVAL;
3627     }
3628
3629   if (flags)
3630     {
3631       // TBD check the flags and do the right thing
3632       if (VPPCOM_DEBUG > 2)
3633         clib_warning ("[%d] handling flags 0x%u (%d) not implemented yet.",
3634                       getpid (), flags, flags);
3635     }
3636
3637   return (vppcom_session_write (session_index, buffer, buflen));
3638 }
3639
3640 /*
3641  * fd.io coding-style-patch-verification: ON
3642  *
3643  * Local Variables:
3644  * eval: (c-set-style "gnu")
3645  * End:
3646  */