src/vnet/session/application.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 file except in compliance with the License.
   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 <vnet/session/application.h>
  17 #include <vnet/session/application_interface.h>
  18 #include <vnet/session/application_namespace.h>
  19 #include <vnet/session/session.h>
  20
  21 /**
  22  * Pool from which we allocate all applications
  23  */
  24 static application_t *app_pool;
  25
  26 /**
  27  * Hash table of apps by api client index
  28  */
  29 static uword *app_by_api_client_index;
  30
  31 /**
  32  * Hash table of builtin apps by name
  33  */
  34 static uword *app_by_name;
  35
  36 static u8 *
  37 app_get_name_from_reg_index (application_t * app)
  38 {
  39   u8 *app_name;
  40
  41   vl_api_registration_t *regp;
  42   regp = vl_api_client_index_to_registration (app->api_client_index);
  43   if (!regp)
  44     app_name = format (0, "builtin-%d%c", app->index, 0);
  45   else
  46     app_name = format (0, "%s%c", regp->name, 0);
  47
  48   return app_name;
  49 }
  50
  51 static u8 *
  52 app_get_name (application_t * app)
  53 {
  54   if (!app->name)
  55     return app_get_name_from_reg_index (app);
  56   return app->name;
  57 }
  58
  59 u32
  60 application_session_table (application_t * app, u8 fib_proto)
  61 {
  62   app_namespace_t *app_ns;
  63   app_ns = app_namespace_get (app->ns_index);
  64   if (!application_has_global_scope (app))
  65     return APP_INVALID_INDEX;
  66   if (fib_proto == FIB_PROTOCOL_IP4)
  67     return session_lookup_get_index_for_fib (fib_proto,
  68                                              app_ns->ip4_fib_index);
  69   else
  70     return session_lookup_get_index_for_fib (fib_proto,
  71                                              app_ns->ip6_fib_index);
  72 }
  73
  74 u32
  75 application_local_session_table (application_t * app)
  76 {
  77   app_namespace_t *app_ns;
  78   if (!application_has_local_scope (app))
  79     return APP_INVALID_INDEX;
  80   app_ns = app_namespace_get (app->ns_index);
  81   return app_ns->local_table_index;
  82 }
  83
  84 int
  85 application_api_queue_is_full (application_t * app)
  86 {
  87   svm_queue_t *q;
  88
  89   /* builtin servers are always OK */
  90   if (app->api_client_index == ~0)
  91     return 0;
  92
  93   q = vl_api_client_index_to_input_queue (app->api_client_index);
  94   if (!q)
  95     return 1;
  96
  97   if (q->cursize == q->maxsize)
  98     return 1;
  99   return 0;
 100 }
 101
 102 /**
 103  * Returns app name
 104  *
 105  * Since the name is not stored per app, we generate it on the fly. It is
 106  * the caller's responsibility to free the vector
 107  */
 108 u8 *
 109 application_name_from_index (u32 app_index)
 110 {
 111   application_t *app = application_get (app_index);
 112   if (!app)
 113     return 0;
 114   return app_get_name_from_reg_index (app);
 115 }
 116
 117 static void
 118 application_table_add (application_t * app)
 119 {
 120   if (app->api_client_index != APP_INVALID_INDEX)
 121     hash_set (app_by_api_client_index, app->api_client_index, app->index);
 122   else if (app->name)
 123     hash_set_mem (app_by_name, app->name, app->index);
 124 }
 125
 126 static void
 127 application_table_del (application_t * app)
 128 {
 129   if (app->api_client_index != APP_INVALID_INDEX)
 130     hash_unset (app_by_api_client_index, app->api_client_index);
 131   else if (app->name)
 132     hash_unset_mem (app_by_name, app->name);
 133 }
 134
 135 application_t *
 136 application_lookup (u32 api_client_index)
 137 {
 138   uword *p;
 139   p = hash_get (app_by_api_client_index, api_client_index);
 140   if (p)
 141     return application_get (p[0]);
 142
 143   return 0;
 144 }
 145
 146 application_t *
 147 application_lookup_name (const u8 * name)
 148 {
 149   uword *p;
 150   p = hash_get_mem (app_by_name, name);
 151   if (p)
 152     return application_get (p[0]);
 153
 154   return 0;
 155 }
 156
 157 application_t *
 158 application_new ()
 159 {
 160   application_t *app;
 161   pool_get (app_pool, app);
 162   memset (app, 0, sizeof (*app));
 163   app->index = application_get_index (app);
 164   app->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 165   app->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 166   app->local_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 167   if (CLIB_DEBUG > 1)
 168     clib_warning ("[%d] New app (%d)", getpid (), app->index);
 169   return app;
 170 }
 171
 172 void
 173 application_del (application_t * app)
 174 {
 175   vnet_unbind_args_t _a, *a = &_a;
 176   u64 handle, *handles = 0;
 177   segment_manager_t *sm;
 178   u32 index;
 179   int i;
 180
 181   /*
 182    * The app event queue allocated in first segment is cleared with
 183    * the segment manager. No need to explicitly free it.
 184    */
 185   if (CLIB_DEBUG > 1)
 186     clib_warning ("[%d] Delete app (%d)", getpid (), app->index);
 187
 188   if (application_is_proxy (app))
 189     application_remove_proxy (app);
 190
 191   /*
 192    *  Listener cleanup
 193    */
 194
 195   /* *INDENT-OFF* */
 196   hash_foreach (handle, index, app->listeners_table,
 197   ({
 198     vec_add1 (handles, handle);
 199     sm = segment_manager_get (index);
 200     sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 201   }));
 202   /* *INDENT-ON* */
 203
 204   for (i = 0; i < vec_len (handles); i++)
 205     {
 206       a->app_index = app->index;
 207       a->handle = handles[i];
 208       /* seg manager is removed when unbind completes */
 209       vnet_unbind (a);
 210     }
 211
 212   /*
 213    * Connects segment manager cleanup
 214    */
 215
 216   if (app->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
 217     {
 218       sm = segment_manager_get (app->connects_seg_manager);
 219       sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 220       segment_manager_init_del (sm);
 221     }
 222
 223   /* If first segment manager is used by a listener */
 224   if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 225       && app->first_segment_manager != app->connects_seg_manager)
 226     {
 227       sm = segment_manager_get (app->first_segment_manager);
 228       /* .. and has no fifos, e.g. it might be used for redirected sessions,
 229        * remove it */
 230       if (!segment_manager_has_fifos (sm))
 231         {
 232           sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 233           segment_manager_del (sm);
 234         }
 235     }
 236
 237   /*
 238    * Local connections cleanup
 239    */
 240   application_local_sessions_del (app);
 241
 242   vec_free (app->tls_cert);
 243   vec_free (app->tls_key);
 244
 245   application_table_del (app);
 246   vec_free (app->name);
 247   pool_put (app_pool, app);
 248 }
 249
 250 static void
 251 application_verify_cb_fns (session_cb_vft_t * cb_fns)
 252 {
 253   if (cb_fns->session_accept_callback == 0)
 254     clib_warning ("No accept callback function provided");
 255   if (cb_fns->session_connected_callback == 0)
 256     clib_warning ("No session connected callback function provided");
 257   if (cb_fns->session_disconnect_callback == 0)
 258     clib_warning ("No session disconnect callback function provided");
 259   if (cb_fns->session_reset_callback == 0)
 260     clib_warning ("No session reset callback function provided");
 261 }
 262
 263 /**
 264  * Check app config for given segment type
 265  *
 266  * Returns 1 on success and 0 otherwise
 267  */
 268 static u8
 269 application_verify_cfg (ssvm_segment_type_t st)
 270 {
 271   u8 is_valid;
 272   if (st == SSVM_SEGMENT_MEMFD)
 273     {
 274       is_valid = (session_manager_get_evt_q_segment () != 0);
 275       if (!is_valid)
 276         clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
 277       return is_valid;
 278     }
 279   else if (st == SSVM_SEGMENT_SHM)
 280     {
 281       is_valid = (session_manager_get_evt_q_segment () == 0);
 282       if (!is_valid)
 283         clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
 284       return is_valid;
 285     }
 286   else
 287     return 1;
 288 }
 289
 290 int
 291 application_init (application_t * app, u32 api_client_index, u8 * app_name,
 292                   u64 * options, session_cb_vft_t * cb_fns)
 293 {
 294   ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
 295   u32 first_seg_size, prealloc_fifo_pairs;
 296   segment_manager_properties_t *props;
 297   vl_api_registration_t *reg;
 298   segment_manager_t *sm;
 299   int rv;
 300
 301   /*
 302    * Make sure we support the requested configuration
 303    */
 304
 305   if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
 306     {
 307       reg = vl_api_client_index_to_registration (api_client_index);
 308       if (!reg)
 309         return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 310       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 311         seg_type = SSVM_SEGMENT_SHM;
 312     }
 313   else
 314     {
 315       seg_type = SSVM_SEGMENT_PRIVATE;
 316     }
 317
 318   if (!application_verify_cfg (seg_type))
 319     return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 320
 321   /*
 322    * Setup segment manager
 323    */
 324   sm = segment_manager_new ();
 325   sm->app_index = app->index;
 326   props = application_segment_manager_properties (app);
 327   segment_manager_properties_init (props);
 328   if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
 329     {
 330       props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
 331       props->add_segment = 1;
 332     }
 333   if (options[APP_OPTIONS_RX_FIFO_SIZE])
 334     props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
 335   if (options[APP_OPTIONS_TX_FIFO_SIZE])
 336     props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
 337   if (options[APP_OPTIONS_EVT_QUEUE_SIZE])
 338     props->evt_q_size = options[APP_OPTIONS_EVT_QUEUE_SIZE];
 339   if (options[APP_OPTIONS_TLS_ENGINE])
 340     app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
 341   props->segment_type = seg_type;
 342
 343   first_seg_size = options[APP_OPTIONS_SEGMENT_SIZE];
 344   prealloc_fifo_pairs = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
 345
 346   if ((rv = segment_manager_init (sm, first_seg_size, prealloc_fifo_pairs)))
 347     return rv;
 348   sm->first_is_protected = 1;
 349
 350   /*
 351    * Setup application
 352    */
 353   app->first_segment_manager = segment_manager_index (sm);
 354   app->api_client_index = api_client_index;
 355   app->flags = options[APP_OPTIONS_FLAGS];
 356   app->cb_fns = *cb_fns;
 357   app->ns_index = options[APP_OPTIONS_NAMESPACE];
 358   app->listeners_table = hash_create (0, sizeof (u64));
 359   app->local_connects = hash_create (0, sizeof (u64));
 360   app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT];
 361   app->event_queue = segment_manager_event_queue (sm);
 362   app->name = vec_dup (app_name);
 363
 364   /* If no scope enabled, default to global */
 365   if (!application_has_global_scope (app)
 366       && !application_has_local_scope (app))
 367     app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 368
 369   /* Check that the obvious things are properly set up */
 370   application_verify_cb_fns (cb_fns);
 371
 372   /* Add app to lookup by api_client_index table */
 373   application_table_add (app);
 374
 375   /*
 376    * Segment manager for local sessions
 377    */
 378   sm = segment_manager_new ();
 379   sm->app_index = app->index;
 380   app->local_segment_manager = segment_manager_index (sm);
 381
 382   return 0;
 383 }
 384
 385 application_t *
 386 application_get (u32 index)
 387 {
 388   if (index == APP_INVALID_INDEX)
 389     return 0;
 390   return pool_elt_at_index (app_pool, index);
 391 }
 392
 393 application_t *
 394 application_get_if_valid (u32 index)
 395 {
 396   if (pool_is_free_index (app_pool, index))
 397     return 0;
 398
 399   return pool_elt_at_index (app_pool, index);
 400 }
 401
 402 u32
 403 application_get_index (application_t * app)
 404 {
 405   return app - app_pool;
 406 }
 407
 408 static segment_manager_t *
 409 application_alloc_segment_manager (application_t * app)
 410 {
 411   segment_manager_t *sm = 0;
 412
 413   /* If the first segment manager is not in use, don't allocate a new one */
 414   if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 415       && app->first_segment_manager_in_use == 0)
 416     {
 417       sm = segment_manager_get (app->first_segment_manager);
 418       app->first_segment_manager_in_use = 1;
 419       return sm;
 420     }
 421
 422   sm = segment_manager_new ();
 423   sm->app_index = app->index;
 424
 425   return sm;
 426 }
 427
 428 /**
 429  * Start listening local transport endpoint for requested transport.
 430  *
 431  * Creates a 'dummy' stream session with state LISTENING to be used in session
 432  * lookups, prior to establishing connection. Requests transport to build
 433  * it's own specific listening connection.
 434  */
 435 int
 436 application_start_listen (application_t * srv, session_endpoint_t * sep,
 437                           session_handle_t * res)
 438 {
 439   segment_manager_t *sm;
 440   stream_session_t *s;
 441   session_handle_t handle;
 442   session_type_t sst;
 443
 444   sst = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
 445   s = listen_session_new (0, sst);
 446   s->app_index = srv->index;
 447
 448   /* Allocate segment manager. All sessions derived out of a listen session
 449    * have fifos allocated by the same segment manager. */
 450   if (!(sm = application_alloc_segment_manager (srv)))
 451     goto err;
 452
 453   /* Add to app's listener table. Useful to find all child listeners
 454    * when app goes down, although, just for unbinding this is not needed */
 455   handle = listen_session_get_handle (s);
 456   hash_set (srv->listeners_table, handle, segment_manager_index (sm));
 457
 458   if (stream_session_listen (s, sep))
 459     {
 460       segment_manager_del (sm);
 461       hash_unset (srv->listeners_table, handle);
 462       goto err;
 463     }
 464
 465   *res = handle;
 466   return 0;
 467
 468 err:
 469   listen_session_del (s);
 470   return -1;
 471 }
 472
 473 /**
 474  * Stop listening on session associated to handle
 475  */
 476 int
 477 application_stop_listen (application_t * srv, session_handle_t handle)
 478 {
 479   stream_session_t *listener;
 480   uword *indexp;
 481   segment_manager_t *sm;
 482
 483   if (srv && hash_get (srv->listeners_table, handle) == 0)
 484     {
 485       clib_warning ("app doesn't own handle %llu!", handle);
 486       return -1;
 487     }
 488
 489   listener = listen_session_get_from_handle (handle);
 490   stream_session_stop_listen (listener);
 491
 492   indexp = hash_get (srv->listeners_table, handle);
 493   ASSERT (indexp);
 494
 495   sm = segment_manager_get (*indexp);
 496   if (srv->first_segment_manager == *indexp)
 497     {
 498       /* Delete sessions but don't remove segment manager */
 499       srv->first_segment_manager_in_use = 0;
 500       segment_manager_del_sessions (sm);
 501     }
 502   else
 503     {
 504       segment_manager_init_del (sm);
 505     }
 506   hash_unset (srv->listeners_table, handle);
 507   listen_session_del (listener);
 508
 509   return 0;
 510 }
 511
 512 int
 513 application_open_session (application_t * app, session_endpoint_t * sep,
 514                           u32 api_context)
 515 {
 516   int rv;
 517
 518   /* Make sure we have a segment manager for connects */
 519   application_alloc_connects_segment_manager (app);
 520
 521   if ((rv = session_open (app->index, sep, api_context)))
 522     return rv;
 523
 524   return 0;
 525 }
 526
 527 int
 528 application_alloc_connects_segment_manager (application_t * app)
 529 {
 530   segment_manager_t *sm;
 531
 532   if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
 533     {
 534       sm = application_alloc_segment_manager (app);
 535       if (sm == 0)
 536         return -1;
 537       app->connects_seg_manager = segment_manager_index (sm);
 538     }
 539   return 0;
 540 }
 541
 542 segment_manager_t *
 543 application_get_connect_segment_manager (application_t * app)
 544 {
 545   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 546   return segment_manager_get (app->connects_seg_manager);
 547 }
 548
 549 segment_manager_t *
 550 application_get_listen_segment_manager (application_t * app,
 551                                         stream_session_t * s)
 552 {
 553   uword *smp;
 554   smp = hash_get (app->listeners_table, listen_session_get_handle (s));
 555   ASSERT (smp != 0);
 556   return segment_manager_get (*smp);
 557 }
 558
 559 segment_manager_t *
 560 application_get_local_segment_manager (application_t * app)
 561 {
 562   return segment_manager_get (app->local_segment_manager);
 563 }
 564
 565 segment_manager_t *
 566 application_get_local_segment_manager_w_session (application_t * app,
 567                                                  local_session_t * ls)
 568 {
 569   stream_session_t *listener;
 570   if (application_local_session_listener_has_transport (ls))
 571     {
 572       listener = listen_session_get (ls->listener_index);
 573       return application_get_listen_segment_manager (app, listener);
 574     }
 575   return segment_manager_get (app->local_segment_manager);
 576 }
 577
 578 int
 579 application_is_proxy (application_t * app)
 580 {
 581   return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
 582 }
 583
 584 int
 585 application_is_builtin (application_t * app)
 586 {
 587   return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
 588 }
 589
 590 int
 591 application_is_builtin_proxy (application_t * app)
 592 {
 593   return (application_is_proxy (app) && application_is_builtin (app));
 594 }
 595
 596 /**
 597  * Send an API message to the external app, to map new segment
 598  */
 599 int
 600 application_add_segment_notify (u32 app_index, ssvm_private_t * fs)
 601 {
 602   application_t *app = application_get (app_index);
 603   return app->cb_fns.add_segment_callback (app->api_client_index, fs);
 604 }
 605
 606 u8
 607 application_has_local_scope (application_t * app)
 608 {
 609   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
 610 }
 611
 612 u8
 613 application_has_global_scope (application_t * app)
 614 {
 615   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 616 }
 617
 618 u32
 619 application_n_listeners (application_t * app)
 620 {
 621   return hash_elts (app->listeners_table);
 622 }
 623
 624 stream_session_t *
 625 application_first_listener (application_t * app, u8 fib_proto,
 626                             u8 transport_proto)
 627 {
 628   stream_session_t *listener;
 629   u64 handle;
 630   u32 sm_index;
 631   u8 sst;
 632
 633   sst = session_type_from_proto_and_ip (transport_proto,
 634                                         fib_proto == FIB_PROTOCOL_IP4);
 635
 636   /* *INDENT-OFF* */
 637    hash_foreach (handle, sm_index, app->listeners_table, ({
 638      listener = listen_session_get_from_handle (handle);
 639      if (listener->session_type == sst
 640          && listener->listener_index != SESSION_PROXY_LISTENER_INDEX)
 641        return listener;
 642    }));
 643   /* *INDENT-ON* */
 644
 645   return 0;
 646 }
 647
 648 stream_session_t *
 649 application_proxy_listener (application_t * app, u8 fib_proto,
 650                             u8 transport_proto)
 651 {
 652   stream_session_t *listener;
 653   u64 handle;
 654   u32 sm_index;
 655   u8 sst;
 656
 657   sst = session_type_from_proto_and_ip (transport_proto,
 658                                         fib_proto == FIB_PROTOCOL_IP4);
 659
 660   /* *INDENT-OFF* */
 661    hash_foreach (handle, sm_index, app->listeners_table, ({
 662      listener = listen_session_get_from_handle (handle);
 663      if (listener->session_type == sst
 664          && listener->listener_index == SESSION_PROXY_LISTENER_INDEX)
 665        return listener;
 666    }));
 667   /* *INDENT-ON* */
 668
 669   return 0;
 670 }
 671
 672 static clib_error_t *
 673 application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
 674                                         u8 transport_proto, u8 is_start)
 675 {
 676   app_namespace_t *app_ns = app_namespace_get (app->ns_index);
 677   u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
 678   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
 679   transport_connection_t *tc;
 680   stream_session_t *s;
 681   u64 handle;
 682
 683   if (is_start)
 684     {
 685       s = application_first_listener (app, fib_proto, transport_proto);
 686       if (!s)
 687         {
 688           sep.is_ip4 = is_ip4;
 689           sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
 690           sep.sw_if_index = app_ns->sw_if_index;
 691           sep.transport_proto = transport_proto;
 692           application_start_listen (app, &sep, &handle);
 693           s = listen_session_get_from_handle (handle);
 694           s->listener_index = SESSION_PROXY_LISTENER_INDEX;
 695         }
 696     }
 697   else
 698     {
 699       s = application_proxy_listener (app, fib_proto, transport_proto);
 700       ASSERT (s);
 701     }
 702
 703   tc = listen_session_get_transport (s);
 704
 705   if (!ip_is_zero (&tc->lcl_ip, 1))
 706     {
 707       u32 sti;
 708       sep.is_ip4 = is_ip4;
 709       sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
 710       sep.transport_proto = transport_proto;
 711       sep.port = 0;
 712       sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
 713       if (is_start)
 714         session_lookup_add_session_endpoint (sti, &sep, s->session_index);
 715       else
 716         session_lookup_del_session_endpoint (sti, &sep);
 717     }
 718
 719   return 0;
 720 }
 721
 722 static void
 723 application_start_stop_proxy_local_scope (application_t * app,
 724                                           u8 transport_proto, u8 is_start)
 725 {
 726   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
 727   app_namespace_t *app_ns;
 728   app_ns = app_namespace_get (app->ns_index);
 729   sep.is_ip4 = 1;
 730   sep.transport_proto = transport_proto;
 731   sep.port = 0;
 732
 733   if (is_start)
 734     {
 735       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
 736                                            app->index);
 737       sep.is_ip4 = 0;
 738       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
 739                                            app->index);
 740     }
 741   else
 742     {
 743       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
 744       sep.is_ip4 = 0;
 745       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
 746     }
 747 }
 748
 749 void
 750 application_start_stop_proxy (application_t * app,
 751                               transport_proto_t transport_proto, u8 is_start)
 752 {
 753   if (application_has_local_scope (app))
 754     application_start_stop_proxy_local_scope (app, transport_proto, is_start);
 755
 756   if (application_has_global_scope (app))
 757     {
 758       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4,
 759                                               transport_proto, is_start);
 760       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6,
 761                                               transport_proto, is_start);
 762     }
 763 }
 764
 765 void
 766 application_setup_proxy (application_t * app)
 767 {
 768   u16 transports = app->proxied_transports;
 769   transport_proto_t tp;
 770
 771   ASSERT (application_is_proxy (app));
 772
 773   /* *INDENT-OFF* */
 774   transport_proto_foreach (tp, ({
 775     if (transports & (1 << tp))
 776       application_start_stop_proxy (app, tp, 1);
 777   }));
 778   /* *INDENT-ON* */
 779 }
 780
 781 void
 782 application_remove_proxy (application_t * app)
 783 {
 784   u16 transports = app->proxied_transports;
 785   transport_proto_t tp;
 786
 787   ASSERT (application_is_proxy (app));
 788
 789   /* *INDENT-OFF* */
 790   transport_proto_foreach (tp, ({
 791     if (transports & (1 << tp))
 792       application_start_stop_proxy (app, tp, 0);
 793   }));
 794   /* *INDENT-ON* */
 795 }
 796
 797 segment_manager_properties_t *
 798 application_segment_manager_properties (application_t * app)
 799 {
 800   return &app->sm_properties;
 801 }
 802
 803 segment_manager_properties_t *
 804 application_get_segment_manager_properties (u32 app_index)
 805 {
 806   application_t *app = application_get (app_index);
 807   return &app->sm_properties;
 808 }
 809
 810 static inline int
 811 app_enqueue_evt (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, u8 lock)
 812 {
 813   if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
 814     {
 815       clib_warning ("evt q full");
 816       svm_msg_q_free_msg (mq, msg);
 817       if (lock)
 818         svm_msg_q_unlock (mq);
 819       return -1;
 820     }
 821
 822   if (lock)
 823     {
 824       svm_msg_q_add_and_unlock (mq, msg);
 825       return 0;
 826     }
 827
 828   /* Even when not locking the ring, we must wait for queue mutex */
 829   if (svm_msg_q_add (mq, msg, SVM_Q_WAIT))
 830     {
 831       clib_warning ("msg q add returned");
 832       return -1;
 833     }
 834   return 0;
 835 }
 836
 837 static inline int
 838 app_send_io_evt_rx (application_t * app, stream_session_t * s, u8 lock)
 839 {
 840   session_event_t *evt;
 841   svm_msg_q_msg_t msg;
 842   svm_msg_q_t *mq;
 843
 844   if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY
 845                      && s->session_state != SESSION_STATE_LISTENING))
 846     {
 847       /* Session is closed so app will never clean up. Flush rx fifo */
 848       if (s->session_state == SESSION_STATE_CLOSED)
 849         svm_fifo_dequeue_drop_all (s->server_rx_fifo);
 850       return 0;
 851     }
 852
 853   if (app->cb_fns.builtin_app_rx_callback)
 854     return app->cb_fns.builtin_app_rx_callback (s);
 855
 856   if (svm_fifo_has_event (s->server_rx_fifo)
 857       || svm_fifo_is_empty (s->server_rx_fifo))
 858     return 0;
 859
 860   mq = app->event_queue;
 861   if (lock)
 862     svm_msg_q_lock (mq);
 863
 864   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
 865     {
 866       clib_warning ("evt q rings full");
 867       if (lock)
 868         svm_msg_q_unlock (mq);
 869       return -1;
 870     }
 871
 872   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
 873   ASSERT (!svm_msg_q_msg_is_invalid (&msg));
 874
 875   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
 876   evt->fifo = s->server_rx_fifo;
 877   evt->event_type = FIFO_EVENT_APP_RX;
 878
 879   if (app_enqueue_evt (mq, &msg, lock))
 880     return -1;
 881   (void) svm_fifo_set_event (s->server_rx_fifo);
 882   return 0;
 883 }
 884
 885 static inline int
 886 app_send_io_evt_tx (application_t * app, stream_session_t * s, u8 lock)
 887 {
 888   svm_msg_q_t *mq;
 889   session_event_t *evt;
 890   svm_msg_q_msg_t msg;
 891
 892   if (application_is_builtin (app))
 893     return 0;
 894
 895   mq = app->event_queue;
 896   if (lock)
 897     svm_msg_q_lock (mq);
 898
 899   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
 900     {
 901       clib_warning ("evt q rings full");
 902       if (lock)
 903         svm_msg_q_unlock (mq);
 904       return -1;
 905     }
 906
 907   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
 908   ASSERT (!svm_msg_q_msg_is_invalid (&msg));
 909
 910   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
 911   evt->event_type = FIFO_EVENT_APP_TX;
 912   evt->fifo = s->server_tx_fifo;
 913
 914   return app_enqueue_evt (mq, &msg, lock);
 915 }
 916
 917 /* *INDENT-OFF* */
 918 typedef int (app_send_evt_handler_fn) (application_t *app,
 919                                        stream_session_t *s,
 920                                        u8 lock);
 921 static app_send_evt_handler_fn * const app_send_evt_handler_fns[3] = {
 922     app_send_io_evt_rx,
 923     0,
 924     app_send_io_evt_tx,
 925 };
 926 /* *INDENT-ON* */
 927
 928 /**
 929  * Send event to application
 930  *
 931  * Logic from queue perspective is non-blocking. That is, if there's
 932  * not enough space to enqueue a message, we return. However, if the lock
 933  * flag is set, we do wait for queue mutex.
 934  */
 935 int
 936 application_send_event (application_t * app, stream_session_t * s,
 937                         u8 evt_type)
 938 {
 939   ASSERT (app && evt_type <= FIFO_EVENT_APP_TX);
 940   return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ );
 941 }
 942
 943 int
 944 application_lock_and_send_event (application_t * app, stream_session_t * s,
 945                                  u8 evt_type)
 946 {
 947   return app_send_evt_handler_fns[evt_type] (app, s, 1 /* lock */ );
 948 }
 949
 950 local_session_t *
 951 application_alloc_local_session (application_t * app)
 952 {
 953   local_session_t *s;
 954   pool_get (app->local_sessions, s);
 955   memset (s, 0, sizeof (*s));
 956   s->app_index = app->index;
 957   s->session_index = s - app->local_sessions;
 958   s->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
 959   return s;
 960 }
 961
 962 void
 963 application_free_local_session (application_t * app, local_session_t * s)
 964 {
 965   pool_put (app->local_sessions, s);
 966   if (CLIB_DEBUG)
 967     memset (s, 0xfc, sizeof (*s));
 968 }
 969
 970 local_session_t *
 971 application_get_local_session (application_t * app, u32 session_index)
 972 {
 973   return pool_elt_at_index (app->local_sessions, session_index);
 974 }
 975
 976 local_session_t *
 977 application_get_local_session_from_handle (session_handle_t handle)
 978 {
 979   application_t *server;
 980   u32 session_index, server_index;
 981   local_session_parse_handle (handle, &server_index, &session_index);
 982   server = application_get (server_index);
 983   return application_get_local_session (server, session_index);
 984 }
 985
 986 always_inline void
 987 application_local_listener_session_endpoint (local_session_t * ll,
 988                                              session_endpoint_t * sep)
 989 {
 990   sep->transport_proto =
 991     session_type_transport_proto (ll->listener_session_type);
 992   sep->port = ll->port;
 993   sep->is_ip4 = ll->listener_session_type & 1;
 994 }
 995
 996 int
 997 application_start_local_listen (application_t * server,
 998                                 session_endpoint_t * sep,
 999                                 session_handle_t * handle)
1000 {
1001   session_handle_t lh;
1002   local_session_t *ll;
1003   u32 table_index;
1004
1005   table_index = application_local_session_table (server);
1006
1007   /* An exact sep match, as opposed to session_lookup_local_listener */
1008   lh = session_lookup_endpoint_listener (table_index, sep, 1);
1009   if (lh != SESSION_INVALID_HANDLE)
1010     return VNET_API_ERROR_ADDRESS_IN_USE;
1011
1012   pool_get (server->local_listen_sessions, ll);
1013   memset (ll, 0, sizeof (*ll));
1014   ll->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
1015   ll->app_index = server->index;
1016   ll->session_index = ll - server->local_listen_sessions;
1017   ll->port = sep->port;
1018   /* Store the original session type for the unbind */
1019   ll->listener_session_type =
1020     session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
1021   ll->transport_listener_index = ~0;
1022
1023   *handle = application_local_session_handle (ll);
1024   session_lookup_add_session_endpoint (table_index, sep, *handle);
1025
1026   return 0;
1027 }
1028
1029 /**
1030  * Clean up local session table. If we have a listener session use it to
1031  * find the port and proto. If not, the handle must be a local table handle
1032  * so parse it.
1033  */
1034 int
1035 application_stop_local_listen (application_t * server, session_handle_t lh)
1036 {
1037   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
1038   u32 table_index, ll_index, server_index;
1039   stream_session_t *sl = 0;
1040   local_session_t *ll, *ls;
1041
1042   table_index = application_local_session_table (server);
1043
1044   /* We have both local and global table binds. Figure from global what
1045    * the sep we should be cleaning up is.
1046    */
1047   if (!session_handle_is_local (lh))
1048     {
1049       sl = listen_session_get_from_handle (lh);
1050       if (!sl || listen_session_get_local_session_endpoint (sl, &sep))
1051         {
1052           clib_warning ("broken listener");
1053           return -1;
1054         }
1055       lh = session_lookup_endpoint_listener (table_index, &sep, 0);
1056       if (lh == SESSION_INVALID_HANDLE)
1057         return -1;
1058     }
1059
1060   local_session_parse_handle (lh, &server_index, &ll_index);
1061   ASSERT (server->index == server_index);
1062   if (!(ll = application_get_local_listen_session (server, ll_index)))
1063     {
1064       clib_warning ("no local listener");
1065       return -1;
1066     }
1067   application_local_listener_session_endpoint (ll, &sep);
1068   session_lookup_del_session_endpoint (table_index, &sep);
1069
1070   /* *INDENT-OFF* */
1071   pool_foreach (ls, server->local_sessions, ({
1072     if (ls->listener_index == ll->session_index)
1073       application_local_session_disconnect (server->index, ls);
1074   }));
1075   /* *INDENT-ON* */
1076   pool_put_index (server->local_listen_sessions, ll->session_index);
1077
1078   return 0;
1079 }
1080
1081 int
1082 application_local_session_connect (u32 table_index, application_t * client,
1083                                    application_t * server,
1084                                    local_session_t * ll, u32 opaque)
1085 {
1086   u32 seg_size, evt_q_sz, evt_q_elts, margin = 16 << 10;
1087   segment_manager_properties_t *props, *cprops;
1088   u32 round_rx_fifo_sz, round_tx_fifo_sz;
1089   int rv, has_transport, seg_index;
1090   svm_fifo_segment_private_t *seg;
1091   segment_manager_t *sm;
1092   local_session_t *ls;
1093   svm_msg_q_t *sq, *cq;
1094
1095   ls = application_alloc_local_session (server);
1096
1097   props = application_segment_manager_properties (server);
1098   cprops = application_segment_manager_properties (client);
1099   evt_q_elts = props->evt_q_size + cprops->evt_q_size;
1100   evt_q_sz = segment_manager_evt_q_expected_size (evt_q_elts);
1101   round_rx_fifo_sz = 1 << max_log2 (props->rx_fifo_size);
1102   round_tx_fifo_sz = 1 << max_log2 (props->tx_fifo_size);
1103   seg_size = round_rx_fifo_sz + round_tx_fifo_sz + evt_q_sz + margin;
1104
1105   has_transport = session_has_transport ((stream_session_t *) ll);
1106   if (!has_transport)
1107     {
1108       /* Local sessions don't have backing transport */
1109       ls->port = ll->port;
1110       sm = application_get_local_segment_manager (server);
1111     }
1112   else
1113     {
1114       stream_session_t *sl = (stream_session_t *) ll;
1115       transport_connection_t *tc;
1116       tc = listen_session_get_transport (sl);
1117       ls->port = tc->lcl_port;
1118       sm = application_get_listen_segment_manager (server, sl);
1119     }
1120
1121   seg_index = segment_manager_add_segment (sm, seg_size);
1122   if (seg_index < 0)
1123     {
1124       clib_warning ("failed to add new cut-through segment");
1125       return seg_index;
1126     }
1127   seg = segment_manager_get_segment_w_lock (sm, seg_index);
1128   sq = segment_manager_alloc_queue (seg, props->evt_q_size);
1129   cq = segment_manager_alloc_queue (seg, cprops->evt_q_size);
1130   ls->server_evt_q = pointer_to_uword (sq);
1131   ls->client_evt_q = pointer_to_uword (cq);
1132   rv = segment_manager_try_alloc_fifos (seg, props->rx_fifo_size,
1133                                         props->tx_fifo_size,
1134                                         &ls->server_rx_fifo,
1135                                         &ls->server_tx_fifo);
1136   if (rv)
1137     {
1138       clib_warning ("failed to add fifos in cut-through segment");
1139       segment_manager_segment_reader_unlock (sm);
1140       goto failed;
1141     }
1142   ls->server_rx_fifo->master_session_index = ls->session_index;
1143   ls->server_tx_fifo->master_session_index = ls->session_index;
1144   ls->server_rx_fifo->master_thread_index = ~0;
1145   ls->server_tx_fifo->master_thread_index = ~0;
1146   ls->svm_segment_index = seg_index;
1147   ls->listener_index = ll->session_index;
1148   ls->client_index = client->index;
1149   ls->client_opaque = opaque;
1150   ls->listener_session_type = ll->session_type;
1151
1152   if ((rv = server->cb_fns.add_segment_callback (server->api_client_index,
1153                                                  &seg->ssvm)))
1154     {
1155       clib_warning ("failed to notify server of new segment");
1156       segment_manager_segment_reader_unlock (sm);
1157       goto failed;
1158     }
1159   segment_manager_segment_reader_unlock (sm);
1160   if ((rv = server->cb_fns.session_accept_callback ((stream_session_t *) ls)))
1161     {
1162       clib_warning ("failed to send accept cut-through notify to server");
1163       goto failed;
1164     }
1165   if (server->flags & APP_OPTIONS_FLAGS_IS_BUILTIN)
1166     application_local_session_connect_notify (ls);
1167
1168   return 0;
1169
1170 failed:
1171   if (!has_transport)
1172     segment_manager_del_segment (sm, seg);
1173   return rv;
1174 }
1175
1176 static uword
1177 application_client_local_connect_key (local_session_t * ls)
1178 {
1179   return ((uword) ls->app_index << 32 | (uword) ls->session_index);
1180 }
1181
1182 static void
1183 application_client_local_connect_key_parse (uword key, u32 * app_index,
1184                                             u32 * session_index)
1185 {
1186   *app_index = key >> 32;
1187   *session_index = key & 0xFFFFFFFF;
1188 }
1189
1190 int
1191 application_local_session_connect_notify (local_session_t * ls)
1192 {
1193   svm_fifo_segment_private_t *seg;
1194   application_t *client, *server;
1195   segment_manager_t *sm;
1196   int rv, is_fail = 0;
1197   uword client_key;
1198
1199   client = application_get (ls->client_index);
1200   server = application_get (ls->app_index);
1201   sm = application_get_local_segment_manager_w_session (server, ls);
1202   seg = segment_manager_get_segment_w_lock (sm, ls->svm_segment_index);
1203   if ((rv = client->cb_fns.add_segment_callback (client->api_client_index,
1204                                                  &seg->ssvm)))
1205     {
1206       clib_warning ("failed to notify client %u of new segment",
1207                     ls->client_index);
1208       segment_manager_segment_reader_unlock (sm);
1209       application_local_session_disconnect (ls->client_index, ls);
1210       is_fail = 1;
1211     }
1212   else
1213     {
1214       segment_manager_segment_reader_unlock (sm);
1215     }
1216
1217   client->cb_fns.session_connected_callback (client->index, ls->client_opaque,
1218                                              (stream_session_t *) ls,
1219                                              is_fail);
1220
1221   client_key = application_client_local_connect_key (ls);
1222   hash_set (client->local_connects, client_key, client_key);
1223   return 0;
1224 }
1225
1226 int
1227 application_local_session_cleanup (application_t * client,
1228                                    application_t * server,
1229                                    local_session_t * ls)
1230 {
1231   svm_fifo_segment_private_t *seg;
1232   segment_manager_t *sm;
1233   uword client_key;
1234   u8 has_transport;
1235
1236   has_transport = session_has_transport ((stream_session_t *) ls);
1237   client_key = application_client_local_connect_key (ls);
1238   if (!has_transport)
1239     sm = application_get_local_segment_manager_w_session (server, ls);
1240   else
1241     sm = application_get_listen_segment_manager (server,
1242                                                  (stream_session_t *) ls);
1243
1244   seg = segment_manager_get_segment (sm, ls->svm_segment_index);
1245   if (client)
1246     hash_unset (client->local_connects, client_key);
1247
1248   if (!has_transport)
1249     {
1250       server->cb_fns.del_segment_callback (server->api_client_index,
1251                                            &seg->ssvm);
1252       if (client)
1253         client->cb_fns.del_segment_callback (client->api_client_index,
1254                                              &seg->ssvm);
1255       segment_manager_del_segment (sm, seg);
1256     }
1257
1258   application_free_local_session (server, ls);
1259
1260   return 0;
1261 }
1262
1263 int
1264 application_local_session_disconnect (u32 app_index, local_session_t * ls)
1265 {
1266   application_t *client, *server;
1267
1268   client = application_get_if_valid (ls->client_index);
1269   server = application_get (ls->app_index);
1270
1271   if (ls->session_state == SESSION_STATE_CLOSED)
1272     return application_local_session_cleanup (client, server, ls);
1273
1274   if (app_index == ls->client_index)
1275     {
1276       send_local_session_disconnect_callback (ls->app_index, ls);
1277     }
1278   else
1279     {
1280       if (!client)
1281         {
1282           return application_local_session_cleanup (client, server, ls);
1283         }
1284       else if (ls->session_state < SESSION_STATE_READY)
1285         {
1286           client->cb_fns.session_connected_callback (client->index,
1287                                                      ls->client_opaque,
1288                                                      (stream_session_t *) ls,
1289                                                      1 /* is_fail */ );
1290           ls->session_state = SESSION_STATE_CLOSED;
1291           return application_local_session_cleanup (client, server, ls);
1292         }
1293       else
1294         {
1295           send_local_session_disconnect_callback (client->index, ls);
1296         }
1297     }
1298
1299   ls->session_state = SESSION_STATE_CLOSED;
1300
1301   return 0;
1302 }
1303
1304 int
1305 application_local_session_disconnect_w_index (u32 app_index, u32 ls_index)
1306 {
1307   application_t *app;
1308   local_session_t *ls;
1309   app = application_get (app_index);
1310   ls = application_get_local_session (app, ls_index);
1311   return application_local_session_disconnect (app_index, ls);
1312 }
1313
1314 void
1315 application_local_sessions_del (application_t * app)
1316 {
1317   u32 index, server_index, session_index, table_index;
1318   segment_manager_t *sm;
1319   u64 handle, *handles = 0;
1320   local_session_t *ls, *ll;
1321   application_t *server;
1322   session_endpoint_t sep;
1323   int i;
1324
1325   /*
1326    * Local listens. Don't bother with local sessions, we clean them lower
1327    */
1328   table_index = application_local_session_table (app);
1329   /* *INDENT-OFF* */
1330   pool_foreach (ll, app->local_listen_sessions, ({
1331     application_local_listener_session_endpoint (ll, &sep);
1332     session_lookup_del_session_endpoint (table_index, &sep);
1333   }));
1334   /* *INDENT-ON* */
1335
1336   /*
1337    * Local sessions
1338    */
1339   if (app->local_sessions)
1340     {
1341       /* *INDENT-OFF* */
1342       pool_foreach (ls, app->local_sessions, ({
1343         application_local_session_disconnect (app->index, ls);
1344       }));
1345       /* *INDENT-ON* */
1346     }
1347
1348   /*
1349    * Local connects
1350    */
1351   vec_reset_length (handles);
1352   /* *INDENT-OFF* */
1353   hash_foreach (handle, index, app->local_connects, ({
1354     vec_add1 (handles, handle);
1355   }));
1356   /* *INDENT-ON* */
1357
1358   for (i = 0; i < vec_len (handles); i++)
1359     {
1360       application_client_local_connect_key_parse (handles[i], &server_index,
1361                                                   &session_index);
1362       server = application_get_if_valid (server_index);
1363       if (server)
1364         {
1365           ls = application_get_local_session (server, session_index);
1366           application_local_session_disconnect (app->index, ls);
1367         }
1368     }
1369
1370   sm = segment_manager_get (app->local_segment_manager);
1371   sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
1372   segment_manager_del (sm);
1373 }
1374
1375 clib_error_t *
1376 vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
1377 {
1378   application_t *app;
1379   app = application_get (a->app_index);
1380   if (!app)
1381     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1382                                    0, "app %u doesn't exist", a->app_index);
1383   app->tls_cert = vec_dup (a->cert);
1384   return 0;
1385 }
1386
1387 clib_error_t *
1388 vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
1389 {
1390   application_t *app;
1391   app = application_get (a->app_index);
1392   if (!app)
1393     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1394                                    0, "app %u doesn't exist", a->app_index);
1395   app->tls_key = vec_dup (a->key);
1396   return 0;
1397 }
1398
1399 u8 *
1400 format_application_listener (u8 * s, va_list * args)
1401 {
1402   application_t *app = va_arg (*args, application_t *);
1403   u64 handle = va_arg (*args, u64);
1404   u32 sm_index = va_arg (*args, u32);
1405   int verbose = va_arg (*args, int);
1406   stream_session_t *listener;
1407   u8 *app_name, *str;
1408
1409   if (app == 0)
1410     {
1411       if (verbose)
1412         s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App",
1413                     "API Client", "ListenerID", "SegManager");
1414       else
1415         s = format (s, "%-40s%-20s", "Connection", "App");
1416
1417       return s;
1418     }
1419
1420   app_name = app_get_name_from_reg_index (app);
1421   listener = listen_session_get_from_handle (handle);
1422   str = format (0, "%U", format_stream_session, listener, verbose);
1423
1424   if (verbose)
1425     {
1426       s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name,
1427                   app->api_client_index, handle, sm_index);
1428     }
1429   else
1430     s = format (s, "%-40s%-20s", str, app_name);
1431
1432   vec_free (app_name);
1433   return s;
1434 }
1435
1436 void
1437 application_format_connects (application_t * app, int verbose)
1438 {
1439   svm_fifo_segment_private_t *fifo_segment;
1440   vlib_main_t *vm = vlib_get_main ();
1441   segment_manager_t *sm;
1442   u8 *app_name, *s = 0;
1443
1444   /* Header */
1445   if (app == 0)
1446     {
1447       if (verbose)
1448         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
1449                          "API Client", "SegManager");
1450       else
1451         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
1452       return;
1453     }
1454
1455   /* make sure */
1456   if (app->connects_seg_manager == (u32) ~ 0)
1457     return;
1458
1459   app_name = app_get_name_from_reg_index (app);
1460
1461   /* Across all fifo segments */
1462   sm = segment_manager_get (app->connects_seg_manager);
1463
1464   /* *INDENT-OFF* */
1465   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
1466     svm_fifo_t *fifo;
1467     u8 *str;
1468
1469     fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
1470     while (fifo)
1471         {
1472           u32 session_index, thread_index;
1473           stream_session_t *session;
1474
1475           session_index = fifo->master_session_index;
1476           thread_index = fifo->master_thread_index;
1477
1478           session = session_get (session_index, thread_index);
1479           str = format (0, "%U", format_stream_session, session, verbose);
1480
1481           if (verbose)
1482             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
1483                         app->api_client_index, app->connects_seg_manager);
1484           else
1485             s = format (s, "%-40s%-20s", str, app_name);
1486
1487           vlib_cli_output (vm, "%v", s);
1488           vec_reset_length (s);
1489           vec_free (str);
1490
1491           fifo = fifo->next;
1492         }
1493     vec_free (s);
1494   }));
1495   /* *INDENT-ON* */
1496
1497   vec_free (app_name);
1498 }
1499
1500 void
1501 application_format_local_sessions (application_t * app, int verbose)
1502 {
1503   vlib_main_t *vm = vlib_get_main ();
1504   local_session_t *ls;
1505   transport_proto_t tp;
1506   u8 *conn = 0;
1507
1508   /* Header */
1509   if (app == 0)
1510     {
1511       vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "ServerApp",
1512                        "ClientApp");
1513       return;
1514     }
1515
1516   /* *INDENT-OFF* */
1517   pool_foreach (ls, app->local_listen_sessions, ({
1518     tp = session_type_transport_proto(ls->listener_session_type);
1519     conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
1520                    ls->port);
1521     vlib_cli_output (vm, "%-40v%-15u%-20s", conn, ls->app_index, "*");
1522     vec_reset_length (conn);
1523   }));
1524   pool_foreach (ls, app->local_sessions, ({
1525     tp = session_type_transport_proto(ls->listener_session_type);
1526     conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
1527                    ls->port);
1528     vlib_cli_output (vm, "%-40v%-15u%-20u", conn, ls->app_index,
1529                      ls->client_index);
1530     vec_reset_length (conn);
1531   }));
1532   /* *INDENT-ON* */
1533
1534   vec_free (conn);
1535 }
1536
1537 void
1538 application_format_local_connects (application_t * app, int verbose)
1539 {
1540   vlib_main_t *vm = vlib_get_main ();
1541   u32 app_index, session_index;
1542   application_t *server;
1543   local_session_t *ls;
1544   uword client_key;
1545   u64 value;
1546
1547   /* Header */
1548   if (app == 0)
1549     {
1550       if (verbose)
1551         vlib_cli_output (vm, "%-40s%-15s%-20s%-10s", "Connection", "App",
1552                          "Peer App", "SegManager");
1553       else
1554         vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "App",
1555                          "Peer App");
1556       return;
1557     }
1558
1559   /* *INDENT-OFF* */
1560   hash_foreach (client_key, value, app->local_connects, ({
1561     application_client_local_connect_key_parse (client_key, &app_index,
1562                                                 &session_index);
1563     server = application_get (app_index);
1564     ls = application_get_local_session (server, session_index);
1565     vlib_cli_output (vm, "%-40s%-15s%-20s", "TODO", ls->app_index, ls->client_index);
1566   }));
1567   /* *INDENT-ON* */
1568 }
1569
1570 u8 *
1571 format_application (u8 * s, va_list * args)
1572 {
1573   application_t *app = va_arg (*args, application_t *);
1574   CLIB_UNUSED (int verbose) = va_arg (*args, int);
1575   segment_manager_properties_t *props;
1576   const u8 *app_ns_name;
1577   u8 *app_name;
1578
1579   if (app == 0)
1580     {
1581       if (verbose)
1582         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
1583                     "API Client", "Namespace", "Add seg size", "Rx-f size",
1584                     "Tx-f size");
1585       else
1586         s = format (s, "%-10s%-20s%-15s%-40s", "Index", "Name", "API Client",
1587                     "Namespace");
1588       return s;
1589     }
1590
1591   app_name = app_get_name (app);
1592   app_ns_name = app_namespace_id_from_index (app->ns_index);
1593   props = application_segment_manager_properties (app);
1594   if (verbose)
1595     s = format (s, "%-10u%-20s%-15d%-15u%-15U%-15U%-15U", app->index,
1596                 app_name, app->api_client_index, app->ns_index,
1597                 format_memory_size, props->add_segment_size,
1598                 format_memory_size, props->rx_fifo_size, format_memory_size,
1599                 props->tx_fifo_size);
1600   else
1601     s = format (s, "%-10u%-20s%-15d%-40s", app->index, app_name,
1602                 app->api_client_index, app_ns_name);
1603   return s;
1604 }
1605
1606
1607 void
1608 application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
1609 {
1610   application_t *app;
1611   u32 sm_index;
1612   u64 handle;
1613
1614   if (!pool_elts (app_pool))
1615     {
1616       vlib_cli_output (vm, "No active server bindings");
1617       return;
1618     }
1619
1620   if (do_local)
1621     {
1622       application_format_local_sessions (0, verbose);
1623       /* *INDENT-OFF* */
1624       pool_foreach (app, app_pool, ({
1625         if (!pool_elts (app->local_sessions)
1626             && !pool_elts(app->local_connects))
1627           continue;
1628         application_format_local_sessions (app, verbose);
1629       }));
1630       /* *INDENT-ON* */
1631     }
1632   else
1633     {
1634       vlib_cli_output (vm, "%U", format_application_listener, 0 /* header */ ,
1635                        0, 0, verbose);
1636
1637       /* *INDENT-OFF* */
1638       pool_foreach (app, app_pool, ({
1639         if (hash_elts (app->listeners_table) == 0)
1640           continue;
1641         hash_foreach (handle, sm_index, app->listeners_table, ({
1642           vlib_cli_output (vm, "%U", format_application_listener, app,
1643                            handle, sm_index, verbose);
1644         }));
1645       }));
1646       /* *INDENT-ON* */
1647     }
1648 }
1649
1650 void
1651 application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
1652 {
1653   application_t *app;
1654
1655   if (!pool_elts (app_pool))
1656     {
1657       vlib_cli_output (vm, "No active apps");
1658       return;
1659     }
1660
1661   if (do_local)
1662     {
1663       application_format_local_connects (0, verbose);
1664
1665       /* *INDENT-OFF* */
1666       pool_foreach (app, app_pool, ({
1667         if (app->local_connects)
1668           application_format_local_connects (app, verbose);
1669       }));
1670       /* *INDENT-ON* */
1671     }
1672   else
1673     {
1674       application_format_connects (0, verbose);
1675
1676       /* *INDENT-OFF* */
1677       pool_foreach (app, app_pool, ({
1678         if (app->connects_seg_manager == (u32)~0)
1679           continue;
1680         application_format_connects (app, verbose);
1681       }));
1682       /* *INDENT-ON* */
1683     }
1684 }
1685
1686 static clib_error_t *
1687 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
1688                      vlib_cli_command_t * cmd)
1689 {
1690   int do_server = 0, do_client = 0, do_local = 0;
1691   application_t *app;
1692   int verbose = 0;
1693
1694   session_cli_return_if_not_enabled ();
1695
1696   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1697     {
1698       if (unformat (input, "server"))
1699         do_server = 1;
1700       else if (unformat (input, "client"))
1701         do_client = 1;
1702       else if (unformat (input, "local"))
1703         do_local = 1;
1704       else if (unformat (input, "verbose"))
1705         verbose = 1;
1706       else
1707         break;
1708     }
1709
1710   if (do_server)
1711     application_format_all_listeners (vm, do_local, verbose);
1712
1713   if (do_client)
1714     application_format_all_clients (vm, do_local, verbose);
1715
1716   /* Print app related info */
1717   if (!do_server && !do_client)
1718     {
1719       vlib_cli_output (vm, "%U", format_application, 0, verbose);
1720       /* *INDENT-OFF* */
1721       pool_foreach (app, app_pool, ({
1722         vlib_cli_output (vm, "%U", format_application, app, verbose);
1723       }));
1724       /* *INDENT-ON* */
1725     }
1726
1727   return 0;
1728 }
1729
1730 /* *INDENT-OFF* */
1731 VLIB_CLI_COMMAND (show_app_command, static) =
1732 {
1733   .path = "show app",
1734   .short_help = "show app [server|client] [verbose]",
1735   .function = show_app_command_fn,
1736 };
1737 /* *INDENT-ON* */
1738
1739 /*
1740  * fd.io coding-style-patch-verification: ON
1741  *
1742  * Local Variables:
1743  * eval: (c-set-style "gnu")
1744  * End:
1745  */