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