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   svm_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   vnet_unbind_args_t _a, *a = &_a;
 150   segment_manager_t *sm;
 151   u64 handle, *handles = 0;
 152   u32 index;
 153   int i;
 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   application_table_del (app);
 211   pool_put (app_pool, app);
 212 }
 213
 214 static void
 215 application_verify_cb_fns (session_cb_vft_t * cb_fns)
 216 {
 217   if (cb_fns->session_accept_callback == 0)
 218     clib_warning ("No accept callback function provided");
 219   if (cb_fns->session_connected_callback == 0)
 220     clib_warning ("No session connected callback function provided");
 221   if (cb_fns->session_disconnect_callback == 0)
 222     clib_warning ("No session disconnect callback function provided");
 223   if (cb_fns->session_reset_callback == 0)
 224     clib_warning ("No session reset callback function provided");
 225 }
 226
 227 /**
 228  * Check app config for given segment type
 229  *
 230  * Returns 1 on success and 0 otherwise
 231  */
 232 static u8
 233 application_verify_cfg (ssvm_segment_type_t st)
 234 {
 235   u8 is_valid;
 236   if (st == SSVM_SEGMENT_MEMFD)
 237     {
 238       is_valid = (session_manager_get_evt_q_segment () != 0);
 239       if (!is_valid)
 240         clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
 241       return is_valid;
 242     }
 243   else if (st == SSVM_SEGMENT_SHM)
 244     {
 245       is_valid = (session_manager_get_evt_q_segment () == 0);
 246       if (!is_valid)
 247         clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
 248       return is_valid;
 249     }
 250   else
 251     return 1;
 252 }
 253
 254 int
 255 application_init (application_t * app, u32 api_client_index, u64 * options,
 256                   session_cb_vft_t * cb_fns)
 257 {
 258   u32 app_evt_queue_size, first_seg_size, prealloc_fifo_pairs;
 259   ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
 260   segment_manager_properties_t *props;
 261   vl_api_registration_t *reg;
 262   segment_manager_t *sm;
 263   int rv;
 264
 265   /*
 266    * Make sure we support the requested configuration
 267    */
 268
 269   if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
 270     {
 271       reg = vl_api_client_index_to_registration (api_client_index);
 272       if (!reg)
 273         return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 274       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 275         seg_type = SSVM_SEGMENT_SHM;
 276     }
 277   else
 278     {
 279       seg_type = SSVM_SEGMENT_PRIVATE;
 280     }
 281
 282   if (!application_verify_cfg (seg_type))
 283     return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 284
 285   /*
 286    * Setup segment manager
 287    */
 288   sm = segment_manager_new ();
 289   sm->app_index = app->index;
 290   props = application_segment_manager_properties (app);
 291   segment_manager_properties_init (props);
 292   if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
 293     {
 294       props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
 295       props->add_segment = 1;
 296     }
 297   if (options[APP_OPTIONS_RX_FIFO_SIZE])
 298     props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
 299   if (options[APP_OPTIONS_TX_FIFO_SIZE])
 300     props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
 301   props->segment_type = seg_type;
 302
 303   app_evt_queue_size = options[APP_OPTIONS_EVT_QUEUE_SIZE] > 0 ?
 304     options[APP_OPTIONS_EVT_QUEUE_SIZE] : default_app_evt_queue_size;
 305   first_seg_size = options[APP_OPTIONS_SEGMENT_SIZE];
 306   prealloc_fifo_pairs = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
 307
 308   if ((rv = segment_manager_init (sm, first_seg_size, app_evt_queue_size,
 309                                   prealloc_fifo_pairs)))
 310     return rv;
 311   sm->first_is_protected = 1;
 312
 313   /*
 314    * Setup application
 315    */
 316   app->first_segment_manager = segment_manager_index (sm);
 317   app->api_client_index = api_client_index;
 318   app->flags = options[APP_OPTIONS_FLAGS];
 319   app->cb_fns = *cb_fns;
 320   app->ns_index = options[APP_OPTIONS_NAMESPACE];
 321   app->listeners_table = hash_create (0, sizeof (u64));
 322   app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT];
 323   app->event_queue = segment_manager_event_queue (sm);
 324
 325   /* If no scope enabled, default to global */
 326   if (!application_has_global_scope (app)
 327       && !application_has_local_scope (app))
 328     app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 329
 330   /* Check that the obvious things are properly set up */
 331   application_verify_cb_fns (cb_fns);
 332
 333   /* Add app to lookup by api_client_index table */
 334   application_table_add (app);
 335
 336   return 0;
 337 }
 338
 339 application_t *
 340 application_get (u32 index)
 341 {
 342   if (index == APP_INVALID_INDEX)
 343     return 0;
 344   return pool_elt_at_index (app_pool, index);
 345 }
 346
 347 application_t *
 348 application_get_if_valid (u32 index)
 349 {
 350   if (pool_is_free_index (app_pool, index))
 351     return 0;
 352
 353   return pool_elt_at_index (app_pool, index);
 354 }
 355
 356 u32
 357 application_get_index (application_t * app)
 358 {
 359   return app - app_pool;
 360 }
 361
 362 static segment_manager_t *
 363 application_alloc_segment_manager (application_t * app)
 364 {
 365   segment_manager_t *sm = 0;
 366
 367   /* If the first segment manager is not in use, don't allocate a new one */
 368   if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 369       && app->first_segment_manager_in_use == 0)
 370     {
 371       sm = segment_manager_get (app->first_segment_manager);
 372       app->first_segment_manager_in_use = 1;
 373       return sm;
 374     }
 375
 376   sm = segment_manager_new ();
 377   sm->app_index = app->index;
 378
 379   return sm;
 380 }
 381
 382 /**
 383  * Start listening local transport endpoint for requested transport.
 384  *
 385  * Creates a 'dummy' stream session with state LISTENING to be used in session
 386  * lookups, prior to establishing connection. Requests transport to build
 387  * it's own specific listening connection.
 388  */
 389 int
 390 application_start_listen (application_t * srv, session_endpoint_t * sep,
 391                           u64 * res)
 392 {
 393   segment_manager_t *sm;
 394   stream_session_t *s;
 395   u64 handle;
 396   session_type_t sst;
 397
 398   sst = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
 399   s = listen_session_new (sst);
 400   s->app_index = srv->index;
 401
 402   if (stream_session_listen (s, sep))
 403     goto err;
 404
 405   /* Allocate segment manager. All sessions derived out of a listen session
 406    * have fifos allocated by the same segment manager. */
 407   sm = application_alloc_segment_manager (srv);
 408   if (sm == 0)
 409     goto err;
 410
 411   /* Add to app's listener table. Useful to find all child listeners
 412    * when app goes down, although, just for unbinding this is not needed */
 413   handle = listen_session_get_handle (s);
 414   hash_set (srv->listeners_table, handle, segment_manager_index (sm));
 415
 416   *res = handle;
 417   return 0;
 418
 419 err:
 420   listen_session_del (s);
 421   return -1;
 422 }
 423
 424 /**
 425  * Stop listening on session associated to handle
 426  */
 427 int
 428 application_stop_listen (application_t * srv, u64 handle)
 429 {
 430   stream_session_t *listener;
 431   uword *indexp;
 432   segment_manager_t *sm;
 433
 434   if (srv && hash_get (srv->listeners_table, handle) == 0)
 435     {
 436       clib_warning ("app doesn't own handle %llu!", handle);
 437       return -1;
 438     }
 439
 440   listener = listen_session_get_from_handle (handle);
 441   stream_session_stop_listen (listener);
 442
 443   indexp = hash_get (srv->listeners_table, handle);
 444   ASSERT (indexp);
 445
 446   sm = segment_manager_get (*indexp);
 447   if (srv->first_segment_manager == *indexp)
 448     {
 449       /* Delete sessions but don't remove segment manager */
 450       srv->first_segment_manager_in_use = 0;
 451       segment_manager_del_sessions (sm);
 452     }
 453   else
 454     {
 455       segment_manager_init_del (sm);
 456     }
 457   hash_unset (srv->listeners_table, handle);
 458   listen_session_del (listener);
 459
 460   return 0;
 461 }
 462
 463 int
 464 application_open_session (application_t * app, session_endpoint_t * sep,
 465                           u32 api_context)
 466 {
 467   segment_manager_t *sm;
 468   int rv;
 469
 470   /* Make sure we have a segment manager for connects */
 471   if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
 472     {
 473       sm = application_alloc_segment_manager (app);
 474       if (sm == 0)
 475         return -1;
 476       app->connects_seg_manager = segment_manager_index (sm);
 477     }
 478
 479   if ((rv = session_open (app->index, sep, api_context)))
 480     return rv;
 481
 482   return 0;
 483 }
 484
 485 segment_manager_t *
 486 application_get_connect_segment_manager (application_t * app)
 487 {
 488   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 489   return segment_manager_get (app->connects_seg_manager);
 490 }
 491
 492 segment_manager_t *
 493 application_get_listen_segment_manager (application_t * app,
 494                                         stream_session_t * s)
 495 {
 496   uword *smp;
 497   smp = hash_get (app->listeners_table, listen_session_get_handle (s));
 498   ASSERT (smp != 0);
 499   return segment_manager_get (*smp);
 500 }
 501
 502 int
 503 application_is_proxy (application_t * app)
 504 {
 505   return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
 506 }
 507
 508 int
 509 application_is_builtin (application_t * app)
 510 {
 511   return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
 512 }
 513
 514 int
 515 application_is_builtin_proxy (application_t * app)
 516 {
 517   return (application_is_proxy (app) && application_is_builtin (app));
 518 }
 519
 520 /**
 521  * Send an API message to the external app, to map new segment
 522  */
 523 int
 524 application_add_segment_notify (u32 app_index, ssvm_private_t * fs)
 525 {
 526   application_t *app = application_get (app_index);
 527   return app->cb_fns.add_segment_callback (app->api_client_index, fs);
 528 }
 529
 530 u8
 531 application_has_local_scope (application_t * app)
 532 {
 533   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
 534 }
 535
 536 u8
 537 application_has_global_scope (application_t * app)
 538 {
 539   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 540 }
 541
 542 u32
 543 application_n_listeners (application_t * app)
 544 {
 545   return hash_elts (app->listeners_table);
 546 }
 547
 548 stream_session_t *
 549 application_first_listener (application_t * app, u8 fib_proto,
 550                             u8 transport_proto)
 551 {
 552   stream_session_t *listener;
 553   u64 handle;
 554   u32 sm_index;
 555   u8 sst;
 556
 557   sst = session_type_from_proto_and_ip (transport_proto,
 558                                         fib_proto == FIB_PROTOCOL_IP4);
 559
 560   /* *INDENT-OFF* */
 561    hash_foreach (handle, sm_index, app->listeners_table, ({
 562      listener = listen_session_get_from_handle (handle);
 563      if (listener->session_type == sst
 564          && listener->listener_index != SESSION_PROXY_LISTENER_INDEX)
 565        return listener;
 566    }));
 567   /* *INDENT-ON* */
 568
 569   return 0;
 570 }
 571
 572 stream_session_t *
 573 application_proxy_listener (application_t * app, u8 fib_proto,
 574                             u8 transport_proto)
 575 {
 576   stream_session_t *listener;
 577   u64 handle;
 578   u32 sm_index;
 579   u8 sst;
 580
 581   sst = session_type_from_proto_and_ip (transport_proto,
 582                                         fib_proto == FIB_PROTOCOL_IP4);
 583
 584   /* *INDENT-OFF* */
 585    hash_foreach (handle, sm_index, app->listeners_table, ({
 586      listener = listen_session_get_from_handle (handle);
 587      if (listener->session_type == sst
 588          && listener->listener_index == SESSION_PROXY_LISTENER_INDEX)
 589        return listener;
 590    }));
 591   /* *INDENT-ON* */
 592
 593   return 0;
 594 }
 595
 596 static clib_error_t *
 597 application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
 598                                         u8 transport_proto, u8 is_start)
 599 {
 600   app_namespace_t *app_ns = app_namespace_get (app->ns_index);
 601   u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
 602   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
 603   transport_connection_t *tc;
 604   stream_session_t *s;
 605   u64 handle;
 606
 607   if (is_start)
 608     {
 609       s = application_first_listener (app, fib_proto, transport_proto);
 610       if (!s)
 611         {
 612           sep.is_ip4 = is_ip4;
 613           sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
 614           sep.sw_if_index = app_ns->sw_if_index;
 615           sep.transport_proto = transport_proto;
 616           application_start_listen (app, &sep, &handle);
 617           s = listen_session_get_from_handle (handle);
 618           s->listener_index = SESSION_PROXY_LISTENER_INDEX;
 619         }
 620     }
 621   else
 622     {
 623       s = application_proxy_listener (app, fib_proto, transport_proto);
 624       ASSERT (s);
 625     }
 626
 627   tc = listen_session_get_transport (s);
 628
 629   if (!ip_is_zero (&tc->lcl_ip, 1))
 630     {
 631       u32 sti;
 632       sep.is_ip4 = is_ip4;
 633       sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
 634       sep.transport_proto = transport_proto;
 635       sep.port = 0;
 636       sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
 637       if (is_start)
 638         session_lookup_add_session_endpoint (sti, &sep, s->session_index);
 639       else
 640         session_lookup_del_session_endpoint (sti, &sep);
 641     }
 642
 643   return 0;
 644 }
 645
 646 static void
 647 application_start_stop_proxy_local_scope (application_t * app,
 648                                           u8 transport_proto, u8 is_start)
 649 {
 650   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
 651   app_namespace_t *app_ns;
 652   app_ns = app_namespace_get (app->ns_index);
 653   sep.is_ip4 = 1;
 654   sep.transport_proto = transport_proto;
 655   sep.port = 0;
 656
 657   if (is_start)
 658     {
 659       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
 660                                            app->index);
 661       sep.is_ip4 = 0;
 662       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
 663                                            app->index);
 664     }
 665   else
 666     {
 667       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
 668       sep.is_ip4 = 0;
 669       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
 670     }
 671 }
 672
 673 void
 674 application_start_stop_proxy (application_t * app,
 675                               transport_proto_t transport_proto, u8 is_start)
 676 {
 677   if (application_has_local_scope (app))
 678     application_start_stop_proxy_local_scope (app, transport_proto, is_start);
 679
 680   if (application_has_global_scope (app))
 681     {
 682       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4,
 683                                               transport_proto, is_start);
 684       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6,
 685                                               transport_proto, is_start);
 686     }
 687 }
 688
 689 void
 690 application_setup_proxy (application_t * app)
 691 {
 692   u16 transports = app->proxied_transports;
 693   transport_proto_t tp;
 694
 695   ASSERT (application_is_proxy (app));
 696
 697   /* *INDENT-OFF* */
 698   transport_proto_foreach (tp, ({
 699     if (transports & (1 << tp))
 700       application_start_stop_proxy (app, tp, 1);
 701   }));
 702   /* *INDENT-ON* */
 703 }
 704
 705 void
 706 application_remove_proxy (application_t * app)
 707 {
 708   u16 transports = app->proxied_transports;
 709   transport_proto_t tp;
 710
 711   ASSERT (application_is_proxy (app));
 712
 713   /* *INDENT-OFF* */
 714   transport_proto_foreach (tp, ({
 715     if (transports & (1 << tp))
 716       application_start_stop_proxy (app, tp, 0);
 717   }));
 718   /* *INDENT-ON* */
 719 }
 720
 721 segment_manager_properties_t *
 722 application_segment_manager_properties (application_t * app)
 723 {
 724   return &app->sm_properties;
 725 }
 726
 727 segment_manager_properties_t *
 728 application_get_segment_manager_properties (u32 app_index)
 729 {
 730   application_t *app = application_get (app_index);
 731   return &app->sm_properties;
 732 }
 733
 734 u8 *
 735 format_application_listener (u8 * s, va_list * args)
 736 {
 737   application_t *app = va_arg (*args, application_t *);
 738   u64 handle = va_arg (*args, u64);
 739   u32 index = va_arg (*args, u32);
 740   int verbose = va_arg (*args, int);
 741   stream_session_t *listener;
 742   u8 *app_name, *str;
 743
 744   if (app == 0)
 745     {
 746       if (verbose)
 747         s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App",
 748                     "API Client", "ListenerID", "SegManager");
 749       else
 750         s = format (s, "%-40s%-20s", "Connection", "App");
 751
 752       return s;
 753     }
 754
 755   app_name = app_get_name_from_reg_index (app);
 756   listener = listen_session_get_from_handle (handle);
 757   str = format (0, "%U", format_stream_session, listener, verbose);
 758
 759   if (verbose)
 760     {
 761       s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name,
 762                   app->api_client_index, handle, index);
 763     }
 764   else
 765     s = format (s, "%-40s%-20s", str, app_name);
 766
 767   vec_free (app_name);
 768   return s;
 769 }
 770
 771 void
 772 application_format_connects (application_t * app, int verbose)
 773 {
 774   svm_fifo_segment_private_t *fifo_segment;
 775   vlib_main_t *vm = vlib_get_main ();
 776   segment_manager_t *sm;
 777   u8 *app_name, *s = 0;
 778
 779   /* Header */
 780   if (app == 0)
 781     {
 782       if (verbose)
 783         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
 784                          "API Client", "SegManager");
 785       else
 786         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
 787       return;
 788     }
 789
 790   /* make sure */
 791   if (app->connects_seg_manager == (u32) ~ 0)
 792     return;
 793
 794   app_name = app_get_name_from_reg_index (app);
 795
 796   /* Across all fifo segments */
 797   sm = segment_manager_get (app->connects_seg_manager);
 798
 799   /* *INDENT-OFF* */
 800   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
 801     svm_fifo_t *fifo;
 802     u8 *str;
 803
 804     fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
 805     while (fifo)
 806         {
 807           u32 session_index, thread_index;
 808           stream_session_t *session;
 809
 810           session_index = fifo->master_session_index;
 811           thread_index = fifo->master_thread_index;
 812
 813           session = session_get (session_index, thread_index);
 814           str = format (0, "%U", format_stream_session, session, verbose);
 815
 816           if (verbose)
 817             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
 818                         app->api_client_index, app->connects_seg_manager);
 819           else
 820             s = format (s, "%-40s%-20s", str, app_name);
 821
 822           vlib_cli_output (vm, "%v", s);
 823           vec_reset_length (s);
 824           vec_free (str);
 825
 826           fifo = fifo->next;
 827         }
 828     vec_free (s);
 829   }));
 830   /* *INDENT-ON* */
 831
 832   vec_free (app_name);
 833 }
 834
 835 u8 *
 836 format_application (u8 * s, va_list * args)
 837 {
 838   application_t *app = va_arg (*args, application_t *);
 839   CLIB_UNUSED (int verbose) = va_arg (*args, int);
 840   segment_manager_properties_t *props;
 841   const u8 *app_ns_name;
 842   u8 *app_name;
 843
 844   if (app == 0)
 845     {
 846       if (verbose)
 847         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
 848                     "API Client", "Namespace", "Add seg size", "Rx fifo size",
 849                     "Tx fifo size");
 850       else
 851         s =
 852           format (s, "%-10s%-20s%-15s%-40s", "Index", "Name", "API Client",
 853                   "Namespace");
 854       return s;
 855     }
 856
 857   app_name = app_get_name_from_reg_index (app);
 858   app_ns_name = app_namespace_id_from_index (app->ns_index);
 859   props = application_segment_manager_properties (app);
 860   if (verbose)
 861     s =
 862       format (s, "%-10d%-20s%-15d%-15d%-15d%-15d%-15d", app->index, app_name,
 863               app->api_client_index, app->ns_index,
 864               props->add_segment_size,
 865               props->rx_fifo_size, props->tx_fifo_size);
 866   else
 867     s = format (s, "%-10d%-20s%-15d%-40s", app->index, app_name,
 868                 app->api_client_index, app_ns_name);
 869   return s;
 870 }
 871
 872 static clib_error_t *
 873 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 874                      vlib_cli_command_t * cmd)
 875 {
 876   application_t *app;
 877   int do_server = 0;
 878   int do_client = 0;
 879   int verbose = 0;
 880
 881   session_cli_return_if_not_enabled ();
 882
 883   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 884     {
 885       if (unformat (input, "server"))
 886         do_server = 1;
 887       else if (unformat (input, "client"))
 888         do_client = 1;
 889       else if (unformat (input, "verbose"))
 890         verbose = 1;
 891       else
 892         break;
 893     }
 894
 895   if (do_server)
 896     {
 897       u64 handle;
 898       u32 index;
 899       if (pool_elts (app_pool))
 900         {
 901           vlib_cli_output (vm, "%U", format_application_listener,
 902                            0 /* header */ , 0, 0, verbose);
 903
 904           /* *INDENT-OFF* */
 905           pool_foreach (app, app_pool, ({
 906             /* App's listener sessions */
 907             if (hash_elts (app->listeners_table) == 0)
 908               continue;
 909             hash_foreach (handle, index, app->listeners_table, ({
 910               vlib_cli_output (vm, "%U", format_application_listener, app,
 911                                        handle, index, verbose);
 912             }));
 913           }));
 914           /* *INDENT-ON* */
 915
 916         }
 917       else
 918         vlib_cli_output (vm, "No active server bindings");
 919     }
 920
 921   if (do_client)
 922     {
 923       if (pool_elts (app_pool))
 924         {
 925           application_format_connects (0, verbose);
 926
 927           /* *INDENT-OFF* */
 928           pool_foreach (app, app_pool,
 929           ({
 930             if (app->connects_seg_manager == (u32)~0)
 931               continue;
 932             application_format_connects (app, verbose);
 933           }));
 934           /* *INDENT-ON* */
 935         }
 936       else
 937         vlib_cli_output (vm, "No active client bindings");
 938     }
 939
 940   /* Print app related info */
 941   if (!do_server && !do_client)
 942     {
 943       vlib_cli_output (vm, "%U", format_application, 0, verbose);
 944       /* *INDENT-OFF* */
 945       pool_foreach (app, app_pool, ({
 946         vlib_cli_output (vm, "%U", format_application, app, verbose);
 947       }));
 948       /* *INDENT-ON* */
 949     }
 950
 951   return 0;
 952 }
 953
 954 /* *INDENT-OFF* */
 955 VLIB_CLI_COMMAND (show_app_command, static) =
 956 {
 957   .path = "show app",
 958   .short_help = "show app [server|client] [verbose]",
 959   .function = show_app_command_fn,
 960 };
 961 /* *INDENT-ON* */
 962
 963 /*
 964  * fd.io coding-style-patch-verification: ON
 965  *
 966  * Local Variables:
 967  * eval: (c-set-style "gnu")
 968  * End:
 969  */