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