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  * Default application event queue size
  33  */
  34 static u32 default_app_evt_queue_size = 128;
  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 u32
  52 application_session_table (application_t * app, u8 fib_proto)
  53 {
  54   app_namespace_t *app_ns;
  55   app_ns = app_namespace_get (app->ns_index);
  56   if (!application_has_global_scope (app))
  57     return APP_INVALID_INDEX;
  58   if (fib_proto == FIB_PROTOCOL_IP4)
  59     return session_lookup_get_index_for_fib (fib_proto,
  60                                              app_ns->ip4_fib_index);
  61   else
  62     return session_lookup_get_index_for_fib (fib_proto,
  63                                              app_ns->ip6_fib_index);
  64 }
  65
  66 u32
  67 application_local_session_table (application_t * app)
  68 {
  69   app_namespace_t *app_ns;
  70   if (!application_has_local_scope (app))
  71     return APP_INVALID_INDEX;
  72   app_ns = app_namespace_get (app->ns_index);
  73   return app_ns->local_table_index;
  74 }
  75
  76 int
  77 application_api_queue_is_full (application_t * app)
  78 {
  79   unix_shared_memory_queue_t *q;
  80
  81   /* builtin servers are always OK */
  82   if (app->api_client_index == ~0)
  83     return 0;
  84
  85   q = vl_api_client_index_to_input_queue (app->api_client_index);
  86   if (!q)
  87     return 1;
  88
  89   if (q->cursize == q->maxsize)
  90     return 1;
  91   return 0;
  92 }
  93
  94 /**
  95  * Returns app name
  96  *
  97  * Since the name is not stored per app, we generate it on the fly. It is
  98  * the caller's responsibility to free the vector
  99  */
 100 u8 *
 101 application_name_from_index (u32 app_index)
 102 {
 103   application_t *app = application_get (app_index);
 104   if (!app)
 105     return 0;
 106   return app_get_name_from_reg_index (app);
 107 }
 108
 109 static void
 110 application_table_add (application_t * app)
 111 {
 112   hash_set (app_by_api_client_index, app->api_client_index, app->index);
 113 }
 114
 115 static void
 116 application_table_del (application_t * app)
 117 {
 118   hash_unset (app_by_api_client_index, app->api_client_index);
 119 }
 120
 121 application_t *
 122 application_lookup (u32 api_client_index)
 123 {
 124   uword *p;
 125   p = hash_get (app_by_api_client_index, api_client_index);
 126   if (p)
 127     return application_get (p[0]);
 128
 129   return 0;
 130 }
 131
 132 application_t *
 133 application_new ()
 134 {
 135   application_t *app;
 136   pool_get (app_pool, app);
 137   memset (app, 0, sizeof (*app));
 138   app->index = application_get_index (app);
 139   app->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 140   app->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 141   if (CLIB_DEBUG > 1)
 142     clib_warning ("[%d] New app (%d)", getpid (), app->index);
 143   return app;
 144 }
 145
 146 void
 147 application_del (application_t * app)
 148 {
 149   segment_manager_t *sm;
 150   u64 handle, *handles = 0;
 151   u32 index;
 152   int i;
 153   vnet_unbind_args_t _a, *a = &_a;
 154
 155   /*
 156    * The app event queue allocated in first segment is cleared with
 157    * the segment manager. No need to explicitly free it.
 158    */
 159   if (CLIB_DEBUG > 1)
 160     clib_warning ("[%d] Delete app (%d)", getpid (), app->index);
 161
 162   if (application_is_proxy (app))
 163     application_remove_proxy (app);
 164
 165   /*
 166    *  Listener cleanup
 167    */
 168
 169   /* *INDENT-OFF* */
 170   hash_foreach (handle, index, app->listeners_table,
 171   ({
 172     vec_add1 (handles, handle);
 173     sm = segment_manager_get (index);
 174     sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 175   }));
 176   /* *INDENT-ON* */
 177
 178   for (i = 0; i < vec_len (handles); i++)
 179     {
 180       a->app_index = app->index;
 181       a->handle = handles[i];
 182       /* seg manager is removed when unbind completes */
 183       vnet_unbind (a);
 184     }
 185
 186   /*
 187    * Connects segment manager cleanup
 188    */
 189
 190   if (app->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
 191     {
 192       sm = segment_manager_get (app->connects_seg_manager);
 193       sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 194       segment_manager_init_del (sm);
 195     }
 196
 197   /* If first segment manager is used by a listener */
 198   if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 199       && app->first_segment_manager != app->connects_seg_manager)
 200     {
 201       sm = segment_manager_get (app->first_segment_manager);
 202       /* .. and has no fifos, e.g. it might be used for redirected sessions,
 203        * remove it */
 204       if (!segment_manager_has_fifos (sm))
 205         {
 206           sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 207           segment_manager_del (sm);
 208         }
 209     }
 210
 211   application_table_del (app);
 212   pool_put (app_pool, app);
 213 }
 214
 215 static void
 216 application_verify_cb_fns (session_cb_vft_t * cb_fns)
 217 {
 218   if (cb_fns->session_accept_callback == 0)
 219     clib_warning ("No accept callback function provided");
 220   if (cb_fns->session_connected_callback == 0)
 221     clib_warning ("No session connected callback function provided");
 222   if (cb_fns->session_disconnect_callback == 0)
 223     clib_warning ("No session disconnect callback function provided");
 224   if (cb_fns->session_reset_callback == 0)
 225     clib_warning ("No session reset callback function provided");
 226 }
 227
 228 int
 229 application_init (application_t * app, u32 api_client_index, u64 * options,
 230                   session_cb_vft_t * cb_fns)
 231 {
 232   segment_manager_t *sm;
 233   segment_manager_properties_t *props;
 234   u32 app_evt_queue_size, first_seg_size;
 235   u32 default_rx_fifo_size = 16 << 10, default_tx_fifo_size = 16 << 10;
 236   int rv;
 237
 238   app_evt_queue_size = options[APP_EVT_QUEUE_SIZE] > 0 ?
 239     options[APP_EVT_QUEUE_SIZE] : default_app_evt_queue_size;
 240
 241   /*
 242    * Setup segment manager
 243    */
 244   sm = segment_manager_new ();
 245   sm->app_index = app->index;
 246   props = &app->sm_properties;
 247   props->add_segment_size = options[SESSION_OPTIONS_ADD_SEGMENT_SIZE];
 248   props->rx_fifo_size = options[SESSION_OPTIONS_RX_FIFO_SIZE];
 249   props->rx_fifo_size =
 250     props->rx_fifo_size ? props->rx_fifo_size : default_rx_fifo_size;
 251   props->tx_fifo_size = options[SESSION_OPTIONS_TX_FIFO_SIZE];
 252   props->tx_fifo_size =
 253     props->tx_fifo_size ? props->tx_fifo_size : default_tx_fifo_size;
 254   props->add_segment = props->add_segment_size != 0;
 255   props->preallocated_fifo_pairs = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
 256   props->use_private_segment = options[APP_OPTIONS_FLAGS]
 257     & APP_OPTIONS_FLAGS_IS_BUILTIN;
 258   props->private_segment_count = options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT];
 259   props->private_segment_size = options[APP_OPTIONS_PRIVATE_SEGMENT_SIZE];
 260
 261   first_seg_size = options[SESSION_OPTIONS_SEGMENT_SIZE];
 262   if ((rv = segment_manager_init (sm, props, first_seg_size)))
 263     return rv;
 264   sm->first_is_protected = 1;
 265
 266   /*
 267    * Setup application
 268    */
 269   app->first_segment_manager = segment_manager_index (sm);
 270   app->api_client_index = api_client_index;
 271   app->flags = options[APP_OPTIONS_FLAGS];
 272   app->cb_fns = *cb_fns;
 273   app->ns_index = options[APP_OPTIONS_NAMESPACE];
 274   app->listeners_table = hash_create (0, sizeof (u64));
 275   app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT];
 276
 277   /* If no scope enabled, default to global */
 278   if (!application_has_global_scope (app)
 279       && !application_has_local_scope (app))
 280     app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 281
 282   /* Allocate app event queue in the first shared-memory segment */
 283   app->event_queue = segment_manager_alloc_queue (sm, app_evt_queue_size);
 284
 285   /* Check that the obvious things are properly set up */
 286   application_verify_cb_fns (cb_fns);
 287
 288   /* Add app to lookup by api_client_index table */
 289   application_table_add (app);
 290
 291   return 0;
 292 }
 293
 294 application_t *
 295 application_get (u32 index)
 296 {
 297   if (index == APP_INVALID_INDEX)
 298     return 0;
 299   return pool_elt_at_index (app_pool, index);
 300 }
 301
 302 application_t *
 303 application_get_if_valid (u32 index)
 304 {
 305   if (pool_is_free_index (app_pool, index))
 306     return 0;
 307
 308   return pool_elt_at_index (app_pool, index);
 309 }
 310
 311 u32
 312 application_get_index (application_t * app)
 313 {
 314   return app - app_pool;
 315 }
 316
 317 static segment_manager_t *
 318 application_alloc_segment_manager (application_t * app)
 319 {
 320   segment_manager_t *sm = 0;
 321
 322   /* If the first segment manager is not in use, don't allocate a new one */
 323   if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 324       && app->first_segment_manager_in_use == 0)
 325     {
 326       sm = segment_manager_get (app->first_segment_manager);
 327       app->first_segment_manager_in_use = 1;
 328       return sm;
 329     }
 330
 331   sm = segment_manager_new ();
 332   sm->properties = &app->sm_properties;
 333
 334   return sm;
 335 }
 336
 337 /**
 338  * Start listening local transport endpoint for requested transport.
 339  *
 340  * Creates a 'dummy' stream session with state LISTENING to be used in session
 341  * lookups, prior to establishing connection. Requests transport to build
 342  * it's own specific listening connection.
 343  */
 344 int
 345 application_start_listen (application_t * srv, session_endpoint_t * sep,
 346                           u64 * res)
 347 {
 348   segment_manager_t *sm;
 349   stream_session_t *s;
 350   u64 handle;
 351   session_type_t sst;
 352
 353   sst = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
 354   s = listen_session_new (sst);
 355   s->app_index = srv->index;
 356
 357   if (stream_session_listen (s, sep))
 358     goto err;
 359
 360   /* Allocate segment manager. All sessions derived out of a listen session
 361    * have fifos allocated by the same segment manager. */
 362   sm = application_alloc_segment_manager (srv);
 363   if (sm == 0)
 364     goto err;
 365
 366   /* Add to app's listener table. Useful to find all child listeners
 367    * when app goes down, although, just for unbinding this is not needed */
 368   handle = listen_session_get_handle (s);
 369   hash_set (srv->listeners_table, handle, segment_manager_index (sm));
 370
 371   *res = handle;
 372   return 0;
 373
 374 err:
 375   listen_session_del (s);
 376   return -1;
 377 }
 378
 379 /**
 380  * Stop listening on session associated to handle
 381  */
 382 int
 383 application_stop_listen (application_t * srv, u64 handle)
 384 {
 385   stream_session_t *listener;
 386   uword *indexp;
 387   segment_manager_t *sm;
 388
 389   if (srv && hash_get (srv->listeners_table, handle) == 0)
 390     {
 391       clib_warning ("app doesn't own handle %llu!", handle);
 392       return -1;
 393     }
 394
 395   listener = listen_session_get_from_handle (handle);
 396   stream_session_stop_listen (listener);
 397
 398   indexp = hash_get (srv->listeners_table, handle);
 399   ASSERT (indexp);
 400
 401   sm = segment_manager_get (*indexp);
 402   if (srv->first_segment_manager == *indexp)
 403     {
 404       /* Delete sessions but don't remove segment manager */
 405       srv->first_segment_manager_in_use = 0;
 406       segment_manager_del_sessions (sm);
 407     }
 408   else
 409     {
 410       segment_manager_init_del (sm);
 411     }
 412   hash_unset (srv->listeners_table, handle);
 413   listen_session_del (listener);
 414
 415   return 0;
 416 }
 417
 418 int
 419 application_open_session (application_t * app, session_endpoint_t * sep,
 420                           u32 api_context)
 421 {
 422   segment_manager_t *sm;
 423   int rv;
 424
 425   /* Make sure we have a segment manager for connects */
 426   if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
 427     {
 428       sm = application_alloc_segment_manager (app);
 429       if (sm == 0)
 430         return -1;
 431       app->connects_seg_manager = segment_manager_index (sm);
 432     }
 433
 434   if ((rv = session_open (app->index, sep, api_context)))
 435     return rv;
 436
 437   return 0;
 438 }
 439
 440 segment_manager_t *
 441 application_get_connect_segment_manager (application_t * app)
 442 {
 443   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 444   return segment_manager_get (app->connects_seg_manager);
 445 }
 446
 447 segment_manager_t *
 448 application_get_listen_segment_manager (application_t * app,
 449                                         stream_session_t * s)
 450 {
 451   uword *smp;
 452   smp = hash_get (app->listeners_table, listen_session_get_handle (s));
 453   ASSERT (smp != 0);
 454   return segment_manager_get (*smp);
 455 }
 456
 457 int
 458 application_is_proxy (application_t * app)
 459 {
 460   return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
 461 }
 462
 463 int
 464 application_is_builtin (application_t * app)
 465 {
 466   return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
 467 }
 468
 469 int
 470 application_is_builtin_proxy (application_t * app)
 471 {
 472   return (application_is_proxy (app) && application_is_builtin (app));
 473 }
 474
 475 int
 476 application_add_segment_notify (u32 app_index, u32 fifo_segment_index)
 477 {
 478   application_t *app = application_get (app_index);
 479   u32 seg_size = 0;
 480   u8 *seg_name;
 481
 482   /* Send an API message to the external app, to map new segment */
 483   ASSERT (app->cb_fns.add_segment_callback);
 484
 485   segment_manager_get_segment_info (fifo_segment_index, &seg_name, &seg_size);
 486   return app->cb_fns.add_segment_callback (app->api_client_index, seg_name,
 487                                            seg_size);
 488 }
 489
 490 u8
 491 application_has_local_scope (application_t * app)
 492 {
 493   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
 494 }
 495
 496 u8
 497 application_has_global_scope (application_t * app)
 498 {
 499   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 500 }
 501
 502 u32
 503 application_n_listeners (application_t * app)
 504 {
 505   return hash_elts (app->listeners_table);
 506 }
 507
 508 stream_session_t *
 509 application_first_listener (application_t * app, u8 fib_proto,
 510                             u8 transport_proto)
 511 {
 512   stream_session_t *listener;
 513   u64 handle;
 514   u32 sm_index;
 515   u8 sst;
 516
 517   sst = session_type_from_proto_and_ip (transport_proto,
 518                                         fib_proto == FIB_PROTOCOL_IP4);
 519
 520   /* *INDENT-OFF* */
 521    hash_foreach (handle, sm_index, app->listeners_table, ({
 522      listener = listen_session_get_from_handle (handle);
 523      if (listener->session_type == sst)
 524        return listener;
 525    }));
 526   /* *INDENT-ON* */
 527
 528   return 0;
 529 }
 530
 531 static clib_error_t *
 532 application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
 533                                         u8 transport_proto, u8 is_start)
 534 {
 535   session_rule_add_del_args_t args;
 536   fib_prefix_t lcl_pref, rmt_pref;
 537   app_namespace_t *app_ns = app_namespace_get (app->ns_index);
 538   u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
 539   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
 540   transport_connection_t *tc;
 541   stream_session_t *s;
 542   u64 handle;
 543
 544   if (is_start)
 545     {
 546       sep.is_ip4 = is_ip4;
 547       sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
 548       sep.sw_if_index = app_ns->sw_if_index;
 549       sep.transport_proto = transport_proto;
 550       application_start_listen (app, &sep, &handle);
 551       s = listen_session_get_from_handle (handle);
 552     }
 553   else
 554     {
 555       s = application_first_listener (app, fib_proto, transport_proto);
 556     }
 557   tc = listen_session_get_transport (s);
 558
 559   if (!ip_is_zero (&tc->lcl_ip, 1))
 560     {
 561       ip_copy (&lcl_pref.fp_addr, &tc->lcl_ip, is_ip4);
 562       lcl_pref.fp_len = is_ip4 ? 32 : 128;
 563       lcl_pref.fp_proto = fib_proto;
 564       memset (&rmt_pref.fp_addr, 0, sizeof (rmt_pref.fp_addr));
 565       rmt_pref.fp_len = 0;
 566       rmt_pref.fp_proto = fib_proto;
 567
 568       args.table_args.lcl = lcl_pref;
 569       args.table_args.rmt = rmt_pref;
 570       args.table_args.lcl_port = 0;
 571       args.table_args.rmt_port = 0;
 572       args.table_args.action_index = app->index;
 573       args.table_args.is_add = is_start;
 574       args.table_args.transport_proto = transport_proto;
 575       args.appns_index = app->ns_index;
 576       args.scope = SESSION_RULE_SCOPE_GLOBAL;
 577       return vnet_session_rule_add_del (&args);
 578     }
 579   return 0;
 580 }
 581
 582 void
 583 application_start_stop_proxy (application_t * app, u8 transport_proto,
 584                               u8 is_start)
 585 {
 586   session_rule_add_del_args_t args;
 587
 588   if (application_has_local_scope (app))
 589     {
 590       memset (&args, 0, sizeof (args));
 591       args.table_args.lcl.fp_proto = FIB_PROTOCOL_IP4;
 592       args.table_args.rmt.fp_proto = FIB_PROTOCOL_IP4;
 593       args.table_args.lcl_port = 0;
 594       args.table_args.rmt_port = 0;
 595       args.table_args.action_index = app->index;
 596       args.table_args.is_add = is_start;
 597       args.table_args.transport_proto = transport_proto;
 598       args.appns_index = app->ns_index;
 599       args.scope = SESSION_RULE_SCOPE_LOCAL;
 600       vnet_session_rule_add_del (&args);
 601
 602       args.table_args.lcl.fp_proto = FIB_PROTOCOL_IP6;
 603       args.table_args.rmt.fp_proto = FIB_PROTOCOL_IP6;
 604       vnet_session_rule_add_del (&args);
 605     }
 606
 607   if (application_has_global_scope (app))
 608     {
 609       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4,
 610                                               transport_proto, is_start);
 611       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6,
 612                                               transport_proto, is_start);
 613     }
 614 }
 615
 616 void
 617 application_setup_proxy (application_t * app)
 618 {
 619   u16 transports = app->proxied_transports;
 620   ASSERT (application_is_proxy (app));
 621   if (application_is_builtin (app))
 622     return;
 623   if (transports & (1 << TRANSPORT_PROTO_TCP))
 624     application_start_stop_proxy (app, TRANSPORT_PROTO_TCP, 1);
 625   if (transports & (1 << TRANSPORT_PROTO_UDP))
 626     application_start_stop_proxy (app, TRANSPORT_PROTO_UDP, 1);
 627 }
 628
 629 void
 630 application_remove_proxy (application_t * app)
 631 {
 632   u16 transports = app->proxied_transports;
 633   ASSERT (application_is_proxy (app));
 634   if (transports & (1 << TRANSPORT_PROTO_TCP))
 635     application_start_stop_proxy (app, TRANSPORT_PROTO_TCP, 0);
 636   if (transports & (1 << TRANSPORT_PROTO_UDP))
 637     application_start_stop_proxy (app, TRANSPORT_PROTO_UDP, 0);
 638 }
 639
 640 u8 *
 641 format_application_listener (u8 * s, va_list * args)
 642 {
 643   application_t *app = va_arg (*args, application_t *);
 644   u64 handle = va_arg (*args, u64);
 645   u32 index = va_arg (*args, u32);
 646   int verbose = va_arg (*args, int);
 647   stream_session_t *listener;
 648   u8 *app_name, *str;
 649
 650   if (app == 0)
 651     {
 652       if (verbose)
 653         s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App",
 654                     "API Client", "ListenerID", "SegManager");
 655       else
 656         s = format (s, "%-40s%-20s", "Connection", "App");
 657
 658       return s;
 659     }
 660
 661   app_name = app_get_name_from_reg_index (app);
 662   listener = listen_session_get_from_handle (handle);
 663   str = format (0, "%U", format_stream_session, listener, verbose);
 664
 665   if (verbose)
 666     {
 667       s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name,
 668                   app->api_client_index, handle, index);
 669     }
 670   else
 671     s = format (s, "%-40s%-20s", str, app_name);
 672
 673   vec_free (app_name);
 674   return s;
 675 }
 676
 677 void
 678 application_format_connects (application_t * app, int verbose)
 679 {
 680   vlib_main_t *vm = vlib_get_main ();
 681   segment_manager_t *sm;
 682   u8 *app_name, *s = 0;
 683   int j;
 684
 685   /* Header */
 686   if (app == 0)
 687     {
 688       if (verbose)
 689         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
 690                          "API Client", "SegManager");
 691       else
 692         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
 693       return;
 694     }
 695
 696   /* make sure */
 697   if (app->connects_seg_manager == (u32) ~ 0)
 698     return;
 699
 700   app_name = app_get_name_from_reg_index (app);
 701
 702   /* Across all fifo segments */
 703   sm = segment_manager_get (app->connects_seg_manager);
 704   for (j = 0; j < vec_len (sm->segment_indices); j++)
 705     {
 706       svm_fifo_segment_private_t *fifo_segment;
 707       svm_fifo_t *fifo;
 708       u8 *str;
 709
 710       fifo_segment = svm_fifo_segment_get_segment (sm->segment_indices[j]);
 711       fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
 712       while (fifo)
 713         {
 714           u32 session_index, thread_index;
 715           stream_session_t *session;
 716
 717           session_index = fifo->master_session_index;
 718           thread_index = fifo->master_thread_index;
 719
 720           session = session_get (session_index, thread_index);
 721           str = format (0, "%U", format_stream_session, session, verbose);
 722
 723           if (verbose)
 724             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
 725                         app->api_client_index, app->connects_seg_manager);
 726           else
 727             s = format (s, "%-40s%-20s", str, app_name);
 728
 729           vlib_cli_output (vm, "%v", s);
 730           vec_reset_length (s);
 731           vec_free (str);
 732
 733           fifo = fifo->next;
 734         }
 735       vec_free (s);
 736     }
 737
 738   vec_free (app_name);
 739 }
 740
 741 u8 *
 742 format_application (u8 * s, va_list * args)
 743 {
 744   application_t *app = va_arg (*args, application_t *);
 745   CLIB_UNUSED (int verbose) = va_arg (*args, int);
 746   const u8 *app_ns_name;
 747   u8 *app_name;
 748
 749   if (app == 0)
 750     {
 751       if (verbose)
 752         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
 753                     "Namespace", "API Client", "Add seg size", "Rx fifo size",
 754                     "Tx fifo size");
 755       else
 756         s =
 757           format (s, "%-10s%-20s%-15s%-20s", "Index", "Name", "Namespace",
 758                   "API Client");
 759       return s;
 760     }
 761
 762   app_name = app_get_name_from_reg_index (app);
 763   app_ns_name = app_namespace_id_from_index (app->ns_index);
 764   if (verbose)
 765     s =
 766       format (s, "%-10d%-20s%-15s%-15d%-15d%-15d%-15d", app->index, app_name,
 767               app_ns_name, app->api_client_index,
 768               app->sm_properties.add_segment_size,
 769               app->sm_properties.rx_fifo_size,
 770               app->sm_properties.tx_fifo_size);
 771   else
 772     s = format (s, "%-10d%-20s%-15s%-20d", app->index, app_name, app_ns_name,
 773                 app->api_client_index);
 774   return s;
 775 }
 776
 777 static clib_error_t *
 778 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 779                      vlib_cli_command_t * cmd)
 780 {
 781   application_t *app;
 782   int do_server = 0;
 783   int do_client = 0;
 784   int verbose = 0;
 785
 786   session_cli_return_if_not_enabled ();
 787
 788   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 789     {
 790       if (unformat (input, "server"))
 791         do_server = 1;
 792       else if (unformat (input, "client"))
 793         do_client = 1;
 794       else if (unformat (input, "verbose"))
 795         verbose = 1;
 796       else
 797         break;
 798     }
 799
 800   if (do_server)
 801     {
 802       u64 handle;
 803       u32 index;
 804       if (pool_elts (app_pool))
 805         {
 806           vlib_cli_output (vm, "%U", format_application_listener,
 807                            0 /* header */ , 0, 0,
 808                            verbose);
 809           /* *INDENT-OFF* */
 810           pool_foreach (app, app_pool,
 811           ({
 812             /* App's listener sessions */
 813             if (hash_elts (app->listeners_table) == 0)
 814               continue;
 815             hash_foreach (handle, index, app->listeners_table,
 816             ({
 817               vlib_cli_output (vm, "%U", format_application_listener, app,
 818                                        handle, index, verbose);
 819             }));
 820           }));
 821           /* *INDENT-ON* */
 822         }
 823       else
 824         vlib_cli_output (vm, "No active server bindings");
 825     }
 826
 827   if (do_client)
 828     {
 829       if (pool_elts (app_pool))
 830         {
 831           application_format_connects (0, verbose);
 832
 833           /* *INDENT-OFF* */
 834           pool_foreach (app, app_pool,
 835           ({
 836             if (app->connects_seg_manager == (u32)~0)
 837               continue;
 838             application_format_connects (app, verbose);
 839           }));
 840           /* *INDENT-ON* */
 841         }
 842       else
 843         vlib_cli_output (vm, "No active client bindings");
 844     }
 845
 846   /* Print app related info */
 847   if (!do_server && !do_client)
 848     {
 849       vlib_cli_output (vm, "%U", format_application, 0, verbose);
 850       /* *INDENT-OFF* */
 851       pool_foreach (app, app_pool, ({
 852         vlib_cli_output (vm, "%U", format_application, app, verbose);
 853       }));
 854       /* *INDENT-ON* */
 855     }
 856
 857   return 0;
 858 }
 859
 860 /* *INDENT-OFF* */
 861 VLIB_CLI_COMMAND (show_app_command, static) =
 862 {
 863   .path = "show app",
 864   .short_help = "show app [server|client] [verbose]",
 865   .function = show_app_command_fn,
 866 };
 867 /* *INDENT-ON* */
 868
 869 /*
 870  * fd.io coding-style-patch-verification: ON
 871  *
 872  * Local Variables:
 873  * eval: (c-set-style "gnu")
 874  * End:
 875  */