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 static app_main_t app_main;
  22
  23 static app_listener_t *
  24 app_listener_alloc (application_t * app)
  25 {
  26   app_listener_t *app_listener;
  27   pool_get (app->listeners, app_listener);
  28   memset (app_listener, 0, sizeof (*app_listener));
  29   app_listener->al_index = app_listener - app->listeners;
  30   return app_listener;
  31 }
  32
  33 static app_listener_t *
  34 app_listener_get (application_t * app, u32 app_listener_index)
  35 {
  36   return pool_elt_at_index (app->listeners, app_listener_index);
  37 }
  38
  39 static void
  40 app_listener_free (application_t * app, app_listener_t * app_listener)
  41 {
  42   clib_bitmap_free (app_listener->workers);
  43   pool_put (app->listeners, app_listener);
  44   if (CLIB_DEBUG)
  45     memset (app_listener, 0xfa, sizeof (*app_listener));
  46 }
  47
  48 static app_listener_t *
  49 app_local_listener_alloc (application_t * app)
  50 {
  51   app_listener_t *app_listener;
  52   pool_get (app->local_listeners, app_listener);
  53   memset (app_listener, 0, sizeof (*app_listener));
  54   app_listener->al_index = app_listener - app->local_listeners;
  55   return app_listener;
  56 }
  57
  58 static app_listener_t *
  59 app_local_listener_get (application_t * app, u32 app_listener_index)
  60 {
  61   return pool_elt_at_index (app->local_listeners, app_listener_index);
  62 }
  63
  64 static void
  65 app_local_listener_free (application_t * app, app_listener_t * app_listener)
  66 {
  67   clib_bitmap_free (app_listener->workers);
  68   pool_put (app->local_listeners, app_listener);
  69   if (CLIB_DEBUG)
  70     memset (app_listener, 0xfa, sizeof (*app_listener));
  71 }
  72
  73 static app_worker_map_t *
  74 app_worker_map_alloc (application_t * app)
  75 {
  76   app_worker_map_t *map;
  77   pool_get (app->worker_maps, map);
  78   memset (map, 0, sizeof (*map));
  79   return map;
  80 }
  81
  82 static u32
  83 app_worker_map_index (application_t * app, app_worker_map_t * map)
  84 {
  85   return (map - app->worker_maps);
  86 }
  87
  88 static void
  89 app_worker_map_free (application_t * app, app_worker_map_t * map)
  90 {
  91   pool_put (app->worker_maps, map);
  92 }
  93
  94 static app_worker_map_t *
  95 app_worker_map_get (application_t * app, u32 map_index)
  96 {
  97   return pool_elt_at_index (app->worker_maps, map_index);
  98 }
  99
 100 static u8 *
 101 app_get_name_from_reg_index (application_t * app)
 102 {
 103   u8 *app_name;
 104
 105   vl_api_registration_t *regp;
 106   regp = vl_api_client_index_to_registration (app->api_client_index);
 107   if (!regp)
 108     app_name = format (0, "builtin-%d%c", app->app_index, 0);
 109   else
 110     app_name = format (0, "%s%c", regp->name, 0);
 111
 112   return app_name;
 113 }
 114
 115 static u8 *
 116 app_get_name (application_t * app)
 117 {
 118   if (!app->name)
 119     return app_get_name_from_reg_index (app);
 120   return app->name;
 121 }
 122
 123 u32
 124 application_session_table (application_t * app, u8 fib_proto)
 125 {
 126   app_namespace_t *app_ns;
 127   app_ns = app_namespace_get (app->ns_index);
 128   if (!application_has_global_scope (app))
 129     return APP_INVALID_INDEX;
 130   if (fib_proto == FIB_PROTOCOL_IP4)
 131     return session_lookup_get_index_for_fib (fib_proto,
 132                                              app_ns->ip4_fib_index);
 133   else
 134     return session_lookup_get_index_for_fib (fib_proto,
 135                                              app_ns->ip6_fib_index);
 136 }
 137
 138 u32
 139 application_local_session_table (application_t * app)
 140 {
 141   app_namespace_t *app_ns;
 142   if (!application_has_local_scope (app))
 143     return APP_INVALID_INDEX;
 144   app_ns = app_namespace_get (app->ns_index);
 145   return app_ns->local_table_index;
 146 }
 147
 148 static void
 149 application_local_listener_session_endpoint (local_session_t * ll,
 150                                              session_endpoint_t * sep)
 151 {
 152   sep->transport_proto =
 153     session_type_transport_proto (ll->listener_session_type);
 154   sep->port = ll->port;
 155   sep->is_ip4 = ll->listener_session_type & 1;
 156 }
 157
 158 int
 159 application_api_queue_is_full (application_t * app)
 160 {
 161   svm_queue_t *q;
 162
 163   /* builtin servers are always OK */
 164   if (app->api_client_index == ~0)
 165     return 0;
 166
 167   q = vl_api_client_index_to_input_queue (app->api_client_index);
 168   if (!q)
 169     return 1;
 170
 171   if (q->cursize == q->maxsize)
 172     return 1;
 173   return 0;
 174 }
 175
 176 /**
 177  * Returns app name
 178  *
 179  * Since the name is not stored per app, we generate it on the fly. It is
 180  * the caller's responsibility to free the vector
 181  */
 182 u8 *
 183 application_name_from_index (u32 app_index)
 184 {
 185   application_t *app = application_get (app_index);
 186   if (!app)
 187     return 0;
 188   return app_get_name_from_reg_index (app);
 189 }
 190
 191 static void
 192 application_table_add (application_t * app)
 193 {
 194   if (app->api_client_index != APP_INVALID_INDEX)
 195     hash_set (app_main.app_by_api_client_index, app->api_client_index,
 196               app->app_index);
 197   else if (app->name)
 198     hash_set_mem (app_main.app_by_name, app->name, app->app_index);
 199 }
 200
 201 static void
 202 application_table_del (application_t * app)
 203 {
 204   if (app->api_client_index != APP_INVALID_INDEX)
 205     hash_unset (app_main.app_by_api_client_index, app->api_client_index);
 206   else if (app->name)
 207     hash_unset_mem (app_main.app_by_name, app->name);
 208 }
 209
 210 application_t *
 211 application_lookup (u32 api_client_index)
 212 {
 213   uword *p;
 214   p = hash_get (app_main.app_by_api_client_index, api_client_index);
 215   if (p)
 216     return application_get (p[0]);
 217
 218   return 0;
 219 }
 220
 221 application_t *
 222 application_lookup_name (const u8 * name)
 223 {
 224   uword *p;
 225   p = hash_get_mem (app_main.app_by_name, name);
 226   if (p)
 227     return application_get (p[0]);
 228
 229   return 0;
 230 }
 231
 232 application_t *
 233 application_alloc (void)
 234 {
 235   application_t *app;
 236   pool_get (app_main.app_pool, app);
 237   memset (app, 0, sizeof (*app));
 238   app->app_index = app - app_main.app_pool;
 239   return app;
 240 }
 241
 242 application_t *
 243 application_get (u32 app_index)
 244 {
 245   if (app_index == APP_INVALID_INDEX)
 246     return 0;
 247   return pool_elt_at_index (app_main.app_pool, app_index);
 248 }
 249
 250 application_t *
 251 application_get_if_valid (u32 app_index)
 252 {
 253   if (pool_is_free_index (app_main.app_pool, app_index))
 254     return 0;
 255
 256   return pool_elt_at_index (app_main.app_pool, app_index);
 257 }
 258
 259 u32
 260 application_index (application_t * app)
 261 {
 262   return app - app_main.app_pool;
 263 }
 264
 265 static void
 266 application_verify_cb_fns (session_cb_vft_t * cb_fns)
 267 {
 268   if (cb_fns->session_accept_callback == 0)
 269     clib_warning ("No accept callback function provided");
 270   if (cb_fns->session_connected_callback == 0)
 271     clib_warning ("No session connected callback function provided");
 272   if (cb_fns->session_disconnect_callback == 0)
 273     clib_warning ("No session disconnect callback function provided");
 274   if (cb_fns->session_reset_callback == 0)
 275     clib_warning ("No session reset callback function provided");
 276 }
 277
 278 /**
 279  * Check app config for given segment type
 280  *
 281  * Returns 1 on success and 0 otherwise
 282  */
 283 static u8
 284 application_verify_cfg (ssvm_segment_type_t st)
 285 {
 286   u8 is_valid;
 287   if (st == SSVM_SEGMENT_MEMFD)
 288     {
 289       is_valid = (session_manager_get_evt_q_segment () != 0);
 290       if (!is_valid)
 291         clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
 292       return is_valid;
 293     }
 294   else if (st == SSVM_SEGMENT_SHM)
 295     {
 296       is_valid = (session_manager_get_evt_q_segment () == 0);
 297       if (!is_valid)
 298         clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
 299       return is_valid;
 300     }
 301   else
 302     return 1;
 303 }
 304
 305 int
 306 application_alloc_and_init (app_init_args_t * a)
 307 {
 308   ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
 309   segment_manager_properties_t *props;
 310   vl_api_registration_t *reg;
 311   application_t *app;
 312   u64 *options;
 313
 314   app = application_alloc ();
 315   options = a->options;
 316   /*
 317    * Make sure we support the requested configuration
 318    */
 319   if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
 320     {
 321       reg = vl_api_client_index_to_registration (a->api_client_index);
 322       if (!reg)
 323         return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 324       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 325         seg_type = SSVM_SEGMENT_SHM;
 326     }
 327   else
 328     {
 329       if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 330         {
 331           clib_warning ("mq eventfds can only be used if socket transport is "
 332                         "used for api");
 333           return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 334         }
 335       seg_type = SSVM_SEGMENT_PRIVATE;
 336     }
 337
 338   if (!application_verify_cfg (seg_type))
 339     return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 340
 341   /* Check that the obvious things are properly set up */
 342   application_verify_cb_fns (a->session_cb_vft);
 343
 344   app->api_client_index = a->api_client_index;
 345   app->flags = options[APP_OPTIONS_FLAGS];
 346   app->cb_fns = *a->session_cb_vft;
 347   app->ns_index = options[APP_OPTIONS_NAMESPACE];
 348   app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT];
 349   app->name = vec_dup (a->name);
 350
 351   /* If no scope enabled, default to global */
 352   if (!application_has_global_scope (app)
 353       && !application_has_local_scope (app))
 354     app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 355
 356   props = application_segment_manager_properties (app);
 357   segment_manager_properties_init (props);
 358   props->segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
 359   props->prealloc_fifos = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
 360   if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
 361     {
 362       props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
 363       props->add_segment = 1;
 364     }
 365   if (options[APP_OPTIONS_RX_FIFO_SIZE])
 366     props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
 367   if (options[APP_OPTIONS_TX_FIFO_SIZE])
 368     props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
 369   if (options[APP_OPTIONS_EVT_QUEUE_SIZE])
 370     props->evt_q_size = options[APP_OPTIONS_EVT_QUEUE_SIZE];
 371   if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 372     props->use_mq_eventfd = 1;
 373   if (options[APP_OPTIONS_TLS_ENGINE])
 374     app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
 375   props->segment_type = seg_type;
 376
 377   /* Add app to lookup by api_client_index table */
 378   application_table_add (app);
 379   a->app_index = application_index (app);
 380
 381   APP_DBG ("New app name: %v api index: %u index %u", app->name,
 382            app->api_client_index, app->app_index);
 383
 384   return 0;
 385 }
 386
 387 void
 388 application_free (application_t * app)
 389 {
 390   app_worker_map_t *wrk_map;
 391   app_worker_t *app_wrk;
 392   u32 table_index;
 393   local_session_t *ll;
 394   session_endpoint_t sep;
 395
 396   /*
 397    * The app event queue allocated in first segment is cleared with
 398    * the segment manager. No need to explicitly free it.
 399    */
 400   APP_DBG ("Delete app name %v api index: %d index: %d", app->name,
 401            app->api_client_index, app->app_index);
 402
 403   if (application_is_proxy (app))
 404     application_remove_proxy (app);
 405
 406   /*
 407    * Free workers
 408    */
 409
 410   /* *INDENT-OFF* */
 411   pool_flush (wrk_map, app->worker_maps, ({
 412     app_wrk = app_worker_get (wrk_map->wrk_index);
 413     app_worker_free (app_wrk);
 414   }));
 415   /* *INDENT-ON* */
 416   pool_free (app->worker_maps);
 417
 418   /*
 419    * Free local listeners. Global table unbinds stop local listeners
 420    * as well, but if we have only local binds, these won't be cleaned up.
 421    * Don't bother with local accepted sessions, we clean them when
 422    * cleaning up the worker.
 423    */
 424   table_index = application_local_session_table (app);
 425   /* *INDENT-OFF* */
 426   pool_foreach (ll, app->local_listen_sessions, ({
 427     application_local_listener_session_endpoint (ll, &sep);
 428     session_lookup_del_session_endpoint (table_index, &sep);
 429   }));
 430   /* *INDENT-ON* */
 431   pool_free (app->local_listen_sessions);
 432
 433   /*
 434    * Cleanup remaining state
 435    */
 436   application_table_del (app);
 437   vec_free (app->name);
 438   vec_free (app->tls_cert);
 439   vec_free (app->tls_key);
 440   pool_put (app_main.app_pool, app);
 441 }
 442
 443 app_worker_t *
 444 application_get_worker (application_t * app, u32 wrk_map_index)
 445 {
 446   app_worker_map_t *map;
 447   map = app_worker_map_get (app, wrk_map_index);
 448   if (!map)
 449     return 0;
 450   return app_worker_get (map->wrk_index);
 451 }
 452
 453 app_worker_t *
 454 application_get_default_worker (application_t * app)
 455 {
 456   return application_get_worker (app, 0);
 457 }
 458
 459 app_worker_t *
 460 application_listener_select_worker (stream_session_t * ls, u8 is_local)
 461 {
 462   app_listener_t *app_listener;
 463   application_t *app;
 464   u32 wrk_index;
 465
 466   app = application_get (ls->app_index);
 467   if (!is_local)
 468     app_listener = app_listener_get (app, ls->listener_db_index);
 469   else
 470     app_listener = app_local_listener_get (app, ls->listener_db_index);
 471
 472   wrk_index = clib_bitmap_next_set (app_listener->workers,
 473                                     app_listener->accept_rotor + 1);
 474   if (wrk_index == ~0)
 475     wrk_index = clib_bitmap_first_set (app_listener->workers);
 476
 477   ASSERT (wrk_index != ~0);
 478   app_listener->accept_rotor = wrk_index;
 479   return application_get_worker (app, wrk_index);
 480 }
 481
 482 app_worker_t *
 483 app_worker_alloc (application_t * app)
 484 {
 485   app_worker_t *app_wrk;
 486   pool_get (app_main.workers, app_wrk);
 487   memset (app_wrk, 0, sizeof (*app_wrk));
 488   app_wrk->wrk_index = app_wrk - app_main.workers;
 489   app_wrk->app_index = app->app_index;
 490   app_wrk->wrk_map_index = ~0;
 491   app_wrk->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 492   app_wrk->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 493   app_wrk->local_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
 494   APP_DBG ("New app %v worker %u", app_get_name (app), app_wrk->wrk_index);
 495   return app_wrk;
 496 }
 497
 498 app_worker_t *
 499 app_worker_get (u32 wrk_index)
 500 {
 501   return pool_elt_at_index (app_main.workers, wrk_index);
 502 }
 503
 504 app_worker_t *
 505 app_worker_get_if_valid (u32 wrk_index)
 506 {
 507   if (pool_is_free_index (app_main.workers, wrk_index))
 508     return 0;
 509   return pool_elt_at_index (app_main.workers, wrk_index);
 510 }
 511
 512 void
 513 app_worker_free (app_worker_t * app_wrk)
 514 {
 515   application_t *app = application_get (app_wrk->app_index);
 516   vnet_unbind_args_t _a, *a = &_a;
 517   u64 handle, *handles = 0;
 518   segment_manager_t *sm;
 519   u32 sm_index;
 520   int i;
 521
 522   /*
 523    *  Listener cleanup
 524    */
 525
 526   /* *INDENT-OFF* */
 527   hash_foreach (handle, sm_index, app_wrk->listeners_table,
 528   ({
 529     vec_add1 (handles, handle);
 530     sm = segment_manager_get (sm_index);
 531     sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 532   }));
 533   /* *INDENT-ON* */
 534
 535   for (i = 0; i < vec_len (handles); i++)
 536     {
 537       a->app_index = app->app_index;
 538       a->wrk_map_index = app_wrk->wrk_map_index;
 539       a->handle = handles[i];
 540       /* seg manager is removed when unbind completes */
 541       vnet_unbind (a);
 542     }
 543
 544   /*
 545    * Connects segment manager cleanup
 546    */
 547
 548   if (app_wrk->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
 549     {
 550       sm = segment_manager_get (app_wrk->connects_seg_manager);
 551       sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 552       segment_manager_init_del (sm);
 553     }
 554
 555   /* If first segment manager is used by a listener */
 556   if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 557       && app_wrk->first_segment_manager != app_wrk->connects_seg_manager)
 558     {
 559       sm = segment_manager_get (app_wrk->first_segment_manager);
 560       /* .. and has no fifos, e.g. it might be used for redirected sessions,
 561        * remove it */
 562       if (!segment_manager_has_fifos (sm))
 563         {
 564           sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 565           segment_manager_del (sm);
 566         }
 567     }
 568
 569   /*
 570    * Local sessions
 571    */
 572   app_worker_local_sessions_free (app_wrk);
 573
 574   pool_put (app_main.workers, app_wrk);
 575   if (CLIB_DEBUG)
 576     memset (app_wrk, 0xfe, sizeof (*app_wrk));
 577 }
 578
 579 int
 580 app_worker_alloc_and_init (application_t * app, app_worker_t ** wrk)
 581 {
 582   app_worker_map_t *wrk_map;
 583   app_worker_t *app_wrk;
 584   segment_manager_t *sm;
 585   int rv;
 586
 587   app_wrk = app_worker_alloc (app);
 588   wrk_map = app_worker_map_alloc (app);
 589   wrk_map->wrk_index = app_wrk->wrk_index;
 590   app_wrk->wrk_map_index = app_worker_map_index (app, wrk_map);
 591
 592   /*
 593    * Setup first segment manager
 594    */
 595   sm = segment_manager_new ();
 596   sm->app_wrk_index = app_wrk->wrk_index;
 597
 598   if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
 599                                   app->sm_properties.prealloc_fifos)))
 600     {
 601       app_worker_free (app_wrk);
 602       return rv;
 603     }
 604   sm->first_is_protected = 1;
 605
 606   /*
 607    * Setup app worker
 608    */
 609   app_wrk->first_segment_manager = segment_manager_index (sm);
 610   app_wrk->listeners_table = hash_create (0, sizeof (u64));
 611   app_wrk->event_queue = segment_manager_event_queue (sm);
 612   app_wrk->app_is_builtin = application_is_builtin (app);
 613
 614   /*
 615    * Segment manager for local sessions
 616    */
 617   sm = segment_manager_new ();
 618   sm->app_wrk_index = app_wrk->wrk_index;
 619   app_wrk->local_segment_manager = segment_manager_index (sm);
 620   app_wrk->local_connects = hash_create (0, sizeof (u64));
 621
 622   *wrk = app_wrk;
 623
 624   return 0;
 625 }
 626
 627 application_t *
 628 app_worker_get_app (u32 wrk_index)
 629 {
 630   app_worker_t *app_wrk;
 631   app_wrk = app_worker_get_if_valid (wrk_index);
 632   if (!app_wrk)
 633     return 0;
 634   return application_get_if_valid (app_wrk->app_index);
 635 }
 636
 637 static segment_manager_t *
 638 app_worker_alloc_segment_manager (app_worker_t * app_wrk)
 639 {
 640   segment_manager_t *sm = 0;
 641
 642   /* If the first segment manager is not in use, don't allocate a new one */
 643   if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 644       && app_wrk->first_segment_manager_in_use == 0)
 645     {
 646       sm = segment_manager_get (app_wrk->first_segment_manager);
 647       app_wrk->first_segment_manager_in_use = 1;
 648       return sm;
 649     }
 650
 651   sm = segment_manager_new ();
 652   sm->app_wrk_index = app_wrk->wrk_index;
 653
 654   return sm;
 655 }
 656
 657 int
 658 app_worker_start_listen (app_worker_t * app_wrk, stream_session_t * ls)
 659 {
 660   segment_manager_t *sm;
 661
 662   /* Allocate segment manager. All sessions derived out of a listen session
 663    * have fifos allocated by the same segment manager. */
 664   if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
 665     return -1;
 666
 667   /* Add to app's listener table. Useful to find all child listeners
 668    * when app goes down, although, just for unbinding this is not needed */
 669   hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
 670             segment_manager_index (sm));
 671
 672   if (!ls->server_rx_fifo
 673       && session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
 674     {
 675       if (session_alloc_fifos (sm, ls))
 676         return -1;
 677     }
 678   return 0;
 679 }
 680
 681 int
 682 app_worker_stop_listen (app_worker_t * app_wrk, session_handle_t handle)
 683 {
 684   segment_manager_t *sm;
 685   uword *sm_indexp;
 686
 687   sm_indexp = hash_get (app_wrk->listeners_table, handle);
 688   if (PREDICT_FALSE (!sm_indexp))
 689     {
 690       clib_warning ("listener handle was removed %llu!", handle);
 691       return -1;
 692     }
 693
 694   sm = segment_manager_get (*sm_indexp);
 695   if (app_wrk->first_segment_manager == *sm_indexp)
 696     {
 697       /* Delete sessions but don't remove segment manager */
 698       app_wrk->first_segment_manager_in_use = 0;
 699       segment_manager_del_sessions (sm);
 700     }
 701   else
 702     {
 703       segment_manager_init_del (sm);
 704     }
 705   hash_unset (app_wrk->listeners_table, handle);
 706
 707   return 0;
 708 }
 709
 710 /**
 711  * Start listening local transport endpoint for requested transport.
 712  *
 713  * Creates a 'dummy' stream session with state LISTENING to be used in session
 714  * lookups, prior to establishing connection. Requests transport to build
 715  * it's own specific listening connection.
 716  */
 717 int
 718 application_start_listen (application_t * app,
 719                           session_endpoint_extended_t * sep_ext,
 720                           session_handle_t * res)
 721 {
 722   app_listener_t *app_listener;
 723   u32 table_index, fib_proto;
 724   session_endpoint_t *sep;
 725   app_worker_t *app_wrk;
 726   stream_session_t *ls;
 727   session_handle_t lh;
 728   session_type_t sst;
 729
 730   /*
 731    * Check if sep is already listened on
 732    */
 733   sep = (session_endpoint_t *) sep_ext;
 734   fib_proto = session_endpoint_fib_proto (sep);
 735   table_index = application_session_table (app, fib_proto);
 736   lh = session_lookup_endpoint_listener (table_index, sep, 1);
 737   if (lh != SESSION_INVALID_HANDLE)
 738     {
 739       ls = listen_session_get_from_handle (lh);
 740       if (ls->app_index != app->app_index)
 741         return VNET_API_ERROR_ADDRESS_IN_USE;
 742
 743       app_wrk = app_worker_get (sep_ext->app_wrk_index);
 744       if (ls->app_wrk_index == app_wrk->wrk_index)
 745         return VNET_API_ERROR_ADDRESS_IN_USE;
 746
 747       if (app_worker_start_listen (app_wrk, ls))
 748         return -1;
 749
 750       app_listener = app_listener_get (app, ls->listener_db_index);
 751       app_listener->workers = clib_bitmap_set (app_listener->workers,
 752                                                app_wrk->wrk_map_index, 1);
 753
 754       *res = listen_session_get_handle (ls);
 755       return 0;
 756     }
 757
 758   /*
 759    * Allocate new listener for application
 760    */
 761   sst = session_type_from_proto_and_ip (sep_ext->transport_proto,
 762                                         sep_ext->is_ip4);
 763   ls = listen_session_new (0, sst);
 764   ls->app_index = app->app_index;
 765   lh = listen_session_get_handle (ls);
 766   if (session_listen (ls, sep_ext))
 767     goto err;
 768
 769
 770   ls = listen_session_get_from_handle (lh);
 771   app_listener = app_listener_alloc (app);
 772   ls->listener_db_index = app_listener->al_index;
 773
 774   /*
 775    * Setup app worker as a listener
 776    */
 777   app_wrk = app_worker_get (sep_ext->app_wrk_index);
 778   ls->app_wrk_index = app_wrk->wrk_index;
 779   if (app_worker_start_listen (app_wrk, ls))
 780     goto err;
 781   app_listener->workers = clib_bitmap_set (app_listener->workers,
 782                                            app_wrk->wrk_map_index, 1);
 783
 784   *res = lh;
 785   return 0;
 786
 787 err:
 788   listen_session_del (ls);
 789   return -1;
 790 }
 791
 792 /**
 793  * Stop listening on session associated to handle
 794  *
 795  * @param handle        listener handle
 796  * @param app_index     index of the app owning the handle.
 797  * @param app_wrk_index index of the worker requesting the stop
 798  */
 799 int
 800 application_stop_listen (u32 app_index, u32 app_wrk_index,
 801                          session_handle_t handle)
 802 {
 803   app_listener_t *app_listener;
 804   stream_session_t *listener;
 805   app_worker_t *app_wrk;
 806   application_t *app;
 807
 808   listener = listen_session_get_from_handle (handle);
 809   app = application_get (app_index);
 810   if (PREDICT_FALSE (!app || app->app_index != listener->app_index))
 811     {
 812       clib_warning ("app doesn't own handle %llu!", handle);
 813       return -1;
 814     }
 815
 816   app_listener = app_listener_get (app, listener->listener_db_index);
 817   if (!clib_bitmap_get (app_listener->workers, app_wrk_index))
 818     {
 819       clib_warning ("worker not listening on handle %lu", handle);
 820       return 0;
 821     }
 822
 823   app_wrk = application_get_worker (app, app_wrk_index);
 824   app_worker_stop_listen (app_wrk, handle);
 825   clib_bitmap_set_no_check (app_listener->workers, app_wrk_index, 0);
 826
 827   if (clib_bitmap_is_zero (app_listener->workers))
 828     {
 829       session_stop_listen (listener);
 830       app_listener_free (app, app_listener);
 831       listen_session_del (listener);
 832     }
 833
 834   return 0;
 835 }
 836
 837 int
 838 app_worker_open_session (app_worker_t * app, session_endpoint_t * sep,
 839                          u32 api_context)
 840 {
 841   int rv;
 842
 843   /* Make sure we have a segment manager for connects */
 844   app_worker_alloc_connects_segment_manager (app);
 845
 846   if ((rv = session_open (app->wrk_index, sep, api_context)))
 847     return rv;
 848
 849   return 0;
 850 }
 851
 852 int
 853 app_worker_alloc_connects_segment_manager (app_worker_t * app_wrk)
 854 {
 855   segment_manager_t *sm;
 856
 857   if (app_wrk->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
 858     {
 859       sm = app_worker_alloc_segment_manager (app_wrk);
 860       if (sm == 0)
 861         return -1;
 862       app_wrk->connects_seg_manager = segment_manager_index (sm);
 863     }
 864   return 0;
 865 }
 866
 867 segment_manager_t *
 868 app_worker_get_connect_segment_manager (app_worker_t * app)
 869 {
 870   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 871   return segment_manager_get (app->connects_seg_manager);
 872 }
 873
 874 segment_manager_t *
 875 app_worker_get_listen_segment_manager (app_worker_t * app,
 876                                        stream_session_t * s)
 877 {
 878   uword *smp;
 879   smp = hash_get (app->listeners_table, listen_session_get_handle (s));
 880   ASSERT (smp != 0);
 881   return segment_manager_get (*smp);
 882 }
 883
 884 clib_error_t *
 885 vnet_app_worker_add_del (vnet_app_worker_add_del_args_t * a)
 886 {
 887   svm_fifo_segment_private_t *fs;
 888   app_worker_map_t *wrk_map;
 889   app_worker_t *app_wrk;
 890   segment_manager_t *sm;
 891   application_t *app;
 892   int rv;
 893
 894   app = application_get (a->app_index);
 895   if (!app)
 896     return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
 897                                    "App %u does not exist", a->app_index);
 898
 899   if (a->is_add)
 900     {
 901       if ((rv = app_worker_alloc_and_init (app, &app_wrk)))
 902         return clib_error_return_code (0, rv, 0, "app wrk init: %d", rv);
 903       sm = segment_manager_get (app_wrk->first_segment_manager);
 904       fs = segment_manager_get_segment_w_lock (sm, 0);
 905       a->segment = &fs->ssvm;
 906       segment_manager_segment_reader_unlock (sm);
 907       a->evt_q = app_wrk->event_queue;
 908       a->wrk_index = app_wrk->wrk_map_index;
 909     }
 910   else
 911     {
 912       wrk_map = app_worker_map_get (app, a->wrk_index);
 913       if (!wrk_map)
 914         return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
 915                                        "App %u does not have worker %u",
 916                                        app->app_index, a->wrk_index);
 917       app_wrk = app_worker_get (wrk_map->wrk_index);
 918       app_worker_map_free (app, wrk_map);
 919       if (!app_wrk)
 920         return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
 921                                        "No worker %u", a->wrk_index);
 922       app_worker_free (app_wrk);
 923     }
 924   return 0;
 925 }
 926
 927 segment_manager_t *
 928 application_get_local_segment_manager (app_worker_t * app)
 929 {
 930   return segment_manager_get (app->local_segment_manager);
 931 }
 932
 933 segment_manager_t *
 934 application_get_local_segment_manager_w_session (app_worker_t * app,
 935                                                  local_session_t * ls)
 936 {
 937   stream_session_t *listener;
 938   if (application_local_session_listener_has_transport (ls))
 939     {
 940       listener = listen_session_get (ls->listener_index);
 941       return app_worker_get_listen_segment_manager (app, listener);
 942     }
 943   return segment_manager_get (app->local_segment_manager);
 944 }
 945
 946 int
 947 application_is_proxy (application_t * app)
 948 {
 949   return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
 950 }
 951
 952 int
 953 application_is_builtin (application_t * app)
 954 {
 955   return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
 956 }
 957
 958 int
 959 application_is_builtin_proxy (application_t * app)
 960 {
 961   return (application_is_proxy (app) && application_is_builtin (app));
 962 }
 963
 964 u8
 965 application_has_local_scope (application_t * app)
 966 {
 967   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
 968 }
 969
 970 u8
 971 application_has_global_scope (application_t * app)
 972 {
 973   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 974 }
 975
 976 u8
 977 application_use_mq_for_ctrl (application_t * app)
 978 {
 979   return app->flags & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
 980 }
 981
 982 /**
 983  * Send an API message to the external app, to map new segment
 984  */
 985 int
 986 app_worker_add_segment_notify (u32 app_wrk_index, ssvm_private_t * fs)
 987 {
 988   app_worker_t *app_wrk = app_worker_get (app_wrk_index);
 989   application_t *app = application_get (app_wrk->app_index);
 990   return app->cb_fns.add_segment_callback (app->api_client_index, fs);
 991 }
 992
 993 u32
 994 application_n_listeners (app_worker_t * app)
 995 {
 996   return hash_elts (app->listeners_table);
 997 }
 998
 999 stream_session_t *
1000 app_worker_first_listener (app_worker_t * app, u8 fib_proto,
1001                            u8 transport_proto)
1002 {
1003   stream_session_t *listener;
1004   u64 handle;
1005   u32 sm_index;
1006   u8 sst;
1007
1008   sst = session_type_from_proto_and_ip (transport_proto,
1009                                         fib_proto == FIB_PROTOCOL_IP4);
1010
1011   /* *INDENT-OFF* */
1012    hash_foreach (handle, sm_index, app->listeners_table, ({
1013      listener = listen_session_get_from_handle (handle);
1014      if (listener->session_type == sst
1015          && listener->enqueue_epoch != SESSION_PROXY_LISTENER_INDEX)
1016        return listener;
1017    }));
1018   /* *INDENT-ON* */
1019
1020   return 0;
1021 }
1022
1023 u8
1024 app_worker_application_is_builtin (app_worker_t * app_wrk)
1025 {
1026   return app_wrk->app_is_builtin;
1027 }
1028
1029 stream_session_t *
1030 application_proxy_listener (app_worker_t * app, u8 fib_proto,
1031                             u8 transport_proto)
1032 {
1033   stream_session_t *listener;
1034   u64 handle;
1035   u32 sm_index;
1036   u8 sst;
1037
1038   sst = session_type_from_proto_and_ip (transport_proto,
1039                                         fib_proto == FIB_PROTOCOL_IP4);
1040
1041   /* *INDENT-OFF* */
1042    hash_foreach (handle, sm_index, app->listeners_table, ({
1043      listener = listen_session_get_from_handle (handle);
1044      if (listener->session_type == sst
1045          && listener->enqueue_epoch == SESSION_PROXY_LISTENER_INDEX)
1046        return listener;
1047    }));
1048   /* *INDENT-ON* */
1049
1050   return 0;
1051 }
1052
1053 static clib_error_t *
1054 application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
1055                                         u8 transport_proto, u8 is_start)
1056 {
1057   app_namespace_t *app_ns = app_namespace_get (app->ns_index);
1058   u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
1059   session_endpoint_extended_t sep = SESSION_ENDPOINT_EXT_NULL;
1060   transport_connection_t *tc;
1061   app_worker_t *app_wrk;
1062   stream_session_t *s;
1063   u64 handle;
1064
1065   /* TODO decide if we want proxy to be enabled for all workers */
1066   app_wrk = application_get_default_worker (app);
1067   if (is_start)
1068     {
1069       s = app_worker_first_listener (app_wrk, fib_proto, transport_proto);
1070       if (!s)
1071         {
1072           sep.is_ip4 = is_ip4;
1073           sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1074           sep.sw_if_index = app_ns->sw_if_index;
1075           sep.transport_proto = transport_proto;
1076           sep.app_wrk_index = app_wrk->wrk_index;       /* only default */
1077           application_start_listen (app, &sep, &handle);
1078           s = listen_session_get_from_handle (handle);
1079           s->enqueue_epoch = SESSION_PROXY_LISTENER_INDEX;
1080         }
1081     }
1082   else
1083     {
1084       s = application_proxy_listener (app_wrk, fib_proto, transport_proto);
1085       ASSERT (s);
1086     }
1087
1088   tc = listen_session_get_transport (s);
1089
1090   if (!ip_is_zero (&tc->lcl_ip, 1))
1091     {
1092       u32 sti;
1093       sep.is_ip4 = is_ip4;
1094       sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1095       sep.transport_proto = transport_proto;
1096       sep.port = 0;
1097       sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
1098       if (is_start)
1099         session_lookup_add_session_endpoint (sti,
1100                                              (session_endpoint_t *) & sep,
1101                                              s->session_index);
1102       else
1103         session_lookup_del_session_endpoint (sti,
1104                                              (session_endpoint_t *) & sep);
1105     }
1106
1107   return 0;
1108 }
1109
1110 static void
1111 application_start_stop_proxy_local_scope (application_t * app,
1112                                           u8 transport_proto, u8 is_start)
1113 {
1114   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
1115   app_namespace_t *app_ns;
1116   app_ns = app_namespace_get (app->ns_index);
1117   sep.is_ip4 = 1;
1118   sep.transport_proto = transport_proto;
1119   sep.port = 0;
1120
1121   if (is_start)
1122     {
1123       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1124                                            app->app_index);
1125       sep.is_ip4 = 0;
1126       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1127                                            app->app_index);
1128     }
1129   else
1130     {
1131       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1132       sep.is_ip4 = 0;
1133       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1134     }
1135 }
1136
1137 void
1138 application_start_stop_proxy (application_t * app,
1139                               transport_proto_t transport_proto, u8 is_start)
1140 {
1141   if (application_has_local_scope (app))
1142     application_start_stop_proxy_local_scope (app, transport_proto, is_start);
1143
1144   if (application_has_global_scope (app))
1145     {
1146       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4,
1147                                               transport_proto, is_start);
1148       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6,
1149                                               transport_proto, is_start);
1150     }
1151 }
1152
1153 void
1154 application_setup_proxy (application_t * app)
1155 {
1156   u16 transports = app->proxied_transports;
1157   transport_proto_t tp;
1158
1159   ASSERT (application_is_proxy (app));
1160
1161   /* *INDENT-OFF* */
1162   transport_proto_foreach (tp, ({
1163     if (transports & (1 << tp))
1164       application_start_stop_proxy (app, tp, 1);
1165   }));
1166   /* *INDENT-ON* */
1167 }
1168
1169 void
1170 application_remove_proxy (application_t * app)
1171 {
1172   u16 transports = app->proxied_transports;
1173   transport_proto_t tp;
1174
1175   ASSERT (application_is_proxy (app));
1176
1177   /* *INDENT-OFF* */
1178   transport_proto_foreach (tp, ({
1179     if (transports & (1 << tp))
1180       application_start_stop_proxy (app, tp, 0);
1181   }));
1182   /* *INDENT-ON* */
1183 }
1184
1185 segment_manager_properties_t *
1186 application_segment_manager_properties (application_t * app)
1187 {
1188   return &app->sm_properties;
1189 }
1190
1191 segment_manager_properties_t *
1192 application_get_segment_manager_properties (u32 app_index)
1193 {
1194   application_t *app = application_get (app_index);
1195   return &app->sm_properties;
1196 }
1197
1198 static inline int
1199 app_enqueue_evt (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, u8 lock)
1200 {
1201   if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
1202     {
1203       clib_warning ("evt q full");
1204       svm_msg_q_free_msg (mq, msg);
1205       if (lock)
1206         svm_msg_q_unlock (mq);
1207       return -1;
1208     }
1209
1210   if (lock)
1211     {
1212       svm_msg_q_add_and_unlock (mq, msg);
1213       return 0;
1214     }
1215
1216   /* Even when not locking the ring, we must wait for queue mutex */
1217   if (svm_msg_q_add (mq, msg, SVM_Q_WAIT))
1218     {
1219       clib_warning ("msg q add returned");
1220       return -1;
1221     }
1222   return 0;
1223 }
1224
1225 static inline int
1226 app_send_io_evt_rx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
1227 {
1228   session_event_t *evt;
1229   svm_msg_q_msg_t msg;
1230   svm_msg_q_t *mq;
1231
1232   if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY
1233                      && s->session_state != SESSION_STATE_LISTENING))
1234     {
1235       /* Session is closed so app will never clean up. Flush rx fifo */
1236       if (s->session_state == SESSION_STATE_CLOSED)
1237         svm_fifo_dequeue_drop_all (s->server_rx_fifo);
1238       return 0;
1239     }
1240
1241   if (app_worker_application_is_builtin (app_wrk))
1242     {
1243       application_t *app = application_get (app_wrk->app_index);
1244       return app->cb_fns.builtin_app_rx_callback (s);
1245     }
1246
1247   if (svm_fifo_has_event (s->server_rx_fifo)
1248       || svm_fifo_is_empty (s->server_rx_fifo))
1249     return 0;
1250
1251   mq = app_wrk->event_queue;
1252   if (lock)
1253     svm_msg_q_lock (mq);
1254
1255   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
1256     {
1257       clib_warning ("evt q rings full");
1258       if (lock)
1259         svm_msg_q_unlock (mq);
1260       return -1;
1261     }
1262
1263   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
1264   ASSERT (!svm_msg_q_msg_is_invalid (&msg));
1265
1266   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
1267   evt->fifo = s->server_rx_fifo;
1268   evt->event_type = FIFO_EVENT_APP_RX;
1269
1270   (void) svm_fifo_set_event (s->server_rx_fifo);
1271
1272   if (app_enqueue_evt (mq, &msg, lock))
1273     return -1;
1274   return 0;
1275 }
1276
1277 static inline int
1278 app_send_io_evt_tx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
1279 {
1280   svm_msg_q_t *mq;
1281   session_event_t *evt;
1282   svm_msg_q_msg_t msg;
1283
1284   if (app_worker_application_is_builtin (app_wrk))
1285     return 0;
1286
1287   mq = app_wrk->event_queue;
1288   if (lock)
1289     svm_msg_q_lock (mq);
1290
1291   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
1292     {
1293       clib_warning ("evt q rings full");
1294       if (lock)
1295         svm_msg_q_unlock (mq);
1296       return -1;
1297     }
1298
1299   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
1300   ASSERT (!svm_msg_q_msg_is_invalid (&msg));
1301
1302   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
1303   evt->event_type = FIFO_EVENT_APP_TX;
1304   evt->fifo = s->server_tx_fifo;
1305
1306   return app_enqueue_evt (mq, &msg, lock);
1307 }
1308
1309 /* *INDENT-OFF* */
1310 typedef int (app_send_evt_handler_fn) (app_worker_t *app,
1311                                        stream_session_t *s,
1312                                        u8 lock);
1313 static app_send_evt_handler_fn * const app_send_evt_handler_fns[3] = {
1314     app_send_io_evt_rx,
1315     0,
1316     app_send_io_evt_tx,
1317 };
1318 /* *INDENT-ON* */
1319
1320 /**
1321  * Send event to application
1322  *
1323  * Logic from queue perspective is non-blocking. If there's
1324  * not enough space to enqueue a message, we return.
1325  */
1326 int
1327 app_worker_send_event (app_worker_t * app, stream_session_t * s, u8 evt_type)
1328 {
1329   ASSERT (app && evt_type <= FIFO_EVENT_APP_TX);
1330   return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ );
1331 }
1332
1333 /**
1334  * Send event to application
1335  *
1336  * Logic from queue perspective is blocking. However, if queue is full,
1337  * we return.
1338  */
1339 int
1340 app_worker_lock_and_send_event (app_worker_t * app, stream_session_t * s,
1341                                 u8 evt_type)
1342 {
1343   return app_send_evt_handler_fns[evt_type] (app, s, 1 /* lock */ );
1344 }
1345
1346 local_session_t *
1347 application_local_session_alloc (app_worker_t * app_wrk)
1348 {
1349   local_session_t *s;
1350   pool_get (app_wrk->local_sessions, s);
1351   memset (s, 0, sizeof (*s));
1352   s->app_wrk_index = app_wrk->wrk_index;
1353   s->session_index = s - app_wrk->local_sessions;
1354   s->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
1355   return s;
1356 }
1357
1358 void
1359 application_local_session_free (app_worker_t * app, local_session_t * s)
1360 {
1361   pool_put (app->local_sessions, s);
1362   if (CLIB_DEBUG)
1363     memset (s, 0xfc, sizeof (*s));
1364 }
1365
1366 local_session_t *
1367 application_get_local_session (app_worker_t * app_wrk, u32 session_index)
1368 {
1369   if (pool_is_free_index (app_wrk->local_sessions, session_index))
1370     return 0;
1371   return pool_elt_at_index (app_wrk->local_sessions, session_index);
1372 }
1373
1374 local_session_t *
1375 application_get_local_session_from_handle (session_handle_t handle)
1376 {
1377   app_worker_t *server_wrk;
1378   u32 session_index, server_wrk_index;
1379   local_session_parse_handle (handle, &server_wrk_index, &session_index);
1380   server_wrk = app_worker_get_if_valid (server_wrk_index);
1381   if (!server_wrk)
1382     return 0;
1383   return application_get_local_session (server_wrk, session_index);
1384 }
1385
1386 local_session_t *
1387 application_local_listen_session_alloc (application_t * app)
1388 {
1389   local_session_t *ll;
1390   pool_get (app->local_listen_sessions, ll);
1391   memset (ll, 0, sizeof (*ll));
1392   return ll;
1393 }
1394
1395 u32
1396 application_local_listener_index (application_t * app, local_session_t * ll)
1397 {
1398   return (ll - app->local_listen_sessions);
1399 }
1400
1401 void
1402 application_local_listen_session_free (application_t * app,
1403                                        local_session_t * ll)
1404 {
1405   pool_put (app->local_listen_sessions, ll);
1406   if (CLIB_DEBUG)
1407     memset (ll, 0xfb, sizeof (*ll));
1408 }
1409
1410 int
1411 application_start_local_listen (application_t * app,
1412                                 session_endpoint_extended_t * sep_ext,
1413                                 session_handle_t * handle)
1414 {
1415   app_listener_t *app_listener;
1416   session_endpoint_t *sep;
1417   app_worker_t *app_wrk;
1418   session_handle_t lh;
1419   local_session_t *ll;
1420   u32 table_index;
1421
1422   sep = (session_endpoint_t *) sep_ext;
1423   table_index = application_local_session_table (app);
1424   app_wrk = app_worker_get (sep_ext->app_wrk_index);
1425
1426   /* An exact sep match, as opposed to session_lookup_local_listener */
1427   lh = session_lookup_endpoint_listener (table_index, sep, 1);
1428   if (lh != SESSION_INVALID_HANDLE)
1429     {
1430       ll = application_get_local_listener_w_handle (lh);
1431       if (ll->app_index != app->app_index)
1432         return VNET_API_ERROR_ADDRESS_IN_USE;
1433
1434       if (ll->app_wrk_index == app_wrk->wrk_index)
1435         return VNET_API_ERROR_ADDRESS_IN_USE;
1436
1437       app_listener = app_local_listener_get (app, ll->listener_db_index);
1438       app_listener->workers = clib_bitmap_set (app_listener->workers,
1439                                                app_wrk->wrk_map_index, 1);
1440       *handle = application_local_session_handle (ll);
1441       return 0;
1442     }
1443
1444   ll = application_local_listen_session_alloc (app);
1445   ll->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
1446   ll->app_wrk_index = app_wrk->app_index;
1447   ll->session_index = application_local_listener_index (app, ll);
1448   ll->port = sep_ext->port;
1449   /* Store the original session type for the unbind */
1450   ll->listener_session_type =
1451     session_type_from_proto_and_ip (sep_ext->transport_proto,
1452                                     sep_ext->is_ip4);
1453   ll->transport_listener_index = ~0;
1454   ll->app_index = app->app_index;
1455
1456   app_listener = app_local_listener_alloc (app);
1457   ll->listener_db_index = app_listener->al_index;
1458   app_listener->workers = clib_bitmap_set (app_listener->workers,
1459                                            app_wrk->wrk_map_index, 1);
1460
1461   *handle = application_local_session_handle (ll);
1462   session_lookup_add_session_endpoint (table_index, sep, *handle);
1463
1464   return 0;
1465 }
1466
1467 /**
1468  * Clean up local session table. If we have a listener session use it to
1469  * find the port and proto. If not, the handle must be a local table handle
1470  * so parse it.
1471  */
1472 int
1473 application_stop_local_listen (u32 app_index, u32 wrk_map_index,
1474                                session_handle_t lh)
1475 {
1476   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
1477   u32 table_index, ll_index, server_index;
1478   app_listener_t *app_listener;
1479   app_worker_t *server_wrk;
1480   stream_session_t *sl = 0;
1481   local_session_t *ll, *ls;
1482   application_t *server;
1483
1484   server = application_get (app_index);
1485   table_index = application_local_session_table (server);
1486
1487   /* We have both local and global table binds. Figure from global what
1488    * the sep we should be cleaning up is.
1489    */
1490   if (!session_handle_is_local (lh))
1491     {
1492       sl = listen_session_get_from_handle (lh);
1493       if (!sl || listen_session_get_local_session_endpoint (sl, &sep))
1494         {
1495           clib_warning ("broken listener");
1496           return -1;
1497         }
1498       lh = session_lookup_endpoint_listener (table_index, &sep, 0);
1499       if (lh == SESSION_INVALID_HANDLE)
1500         return -1;
1501     }
1502
1503   local_session_parse_handle (lh, &server_index, &ll_index);
1504   if (PREDICT_FALSE (server_index != app_index))
1505     {
1506       clib_warning ("app %u does not own local handle 0x%lx", app_index, lh);
1507       return -1;
1508     }
1509
1510   ll = application_get_local_listen_session (server, ll_index);
1511   if (PREDICT_FALSE (!ll))
1512     {
1513       clib_warning ("no local listener");
1514       return -1;
1515     }
1516
1517   app_listener = app_local_listener_get (server, ll->listener_db_index);
1518   if (!clib_bitmap_get (app_listener->workers, wrk_map_index))
1519     {
1520       clib_warning ("app wrk %u not listening on handle %lu", wrk_map_index,
1521                     lh);
1522       return -1;
1523     }
1524
1525   server_wrk = application_get_worker (server, wrk_map_index);
1526   /* *INDENT-OFF* */
1527   pool_foreach (ls, server_wrk->local_sessions, ({
1528     if (ls->listener_index == ll->session_index)
1529       application_local_session_disconnect (server_wrk->app_index, ls);
1530   }));
1531   /* *INDENT-ON* */
1532
1533   clib_bitmap_set_no_check (app_listener->workers, wrk_map_index, 0);
1534   if (clib_bitmap_is_zero (app_listener->workers))
1535     {
1536       app_local_listener_free (server, app_listener);
1537       application_local_listener_session_endpoint (ll, &sep);
1538       session_lookup_del_session_endpoint (table_index, &sep);
1539       application_local_listen_session_free (server, ll);
1540     }
1541
1542   return 0;
1543 }
1544
1545 static void
1546 application_local_session_fix_eventds (svm_msg_q_t * sq, svm_msg_q_t * cq)
1547 {
1548   int fd;
1549
1550   /*
1551    * segment manager initializes only the producer eventds, since vpp is
1552    * typically the producer. But for local sessions, we also pass to the
1553    * apps the mqs they listen on for events from peer apps, so they are also
1554    * consumer fds.
1555    */
1556   fd = svm_msg_q_get_producer_eventfd (sq);
1557   svm_msg_q_set_consumer_eventfd (sq, fd);
1558   fd = svm_msg_q_get_producer_eventfd (cq);
1559   svm_msg_q_set_consumer_eventfd (cq, fd);
1560 }
1561
1562 int
1563 application_local_session_connect (app_worker_t * client_wrk,
1564                                    app_worker_t * server_wrk,
1565                                    local_session_t * ll, u32 opaque)
1566 {
1567   u32 seg_size, evt_q_sz, evt_q_elts, margin = 16 << 10;
1568   segment_manager_properties_t *props, *cprops;
1569   u32 round_rx_fifo_sz, round_tx_fifo_sz;
1570   int rv, has_transport, seg_index;
1571   svm_fifo_segment_private_t *seg;
1572   application_t *server, *client;
1573   segment_manager_t *sm;
1574   local_session_t *ls;
1575   svm_msg_q_t *sq, *cq;
1576
1577   ls = application_local_session_alloc (server_wrk);
1578   server = application_get (server_wrk->app_index);
1579   client = application_get (client_wrk->app_index);
1580
1581   props = application_segment_manager_properties (server);
1582   cprops = application_segment_manager_properties (client);
1583   evt_q_elts = props->evt_q_size + cprops->evt_q_size;
1584   evt_q_sz = segment_manager_evt_q_expected_size (evt_q_elts);
1585   round_rx_fifo_sz = 1 << max_log2 (props->rx_fifo_size);
1586   round_tx_fifo_sz = 1 << max_log2 (props->tx_fifo_size);
1587   seg_size = round_rx_fifo_sz + round_tx_fifo_sz + evt_q_sz + margin;
1588
1589   has_transport = session_has_transport ((stream_session_t *) ll);
1590   if (!has_transport)
1591     {
1592       /* Local sessions don't have backing transport */
1593       ls->port = ll->port;
1594       sm = application_get_local_segment_manager (server_wrk);
1595     }
1596   else
1597     {
1598       stream_session_t *sl = (stream_session_t *) ll;
1599       transport_connection_t *tc;
1600       tc = listen_session_get_transport (sl);
1601       ls->port = tc->lcl_port;
1602       sm = app_worker_get_listen_segment_manager (server_wrk, sl);
1603     }
1604
1605   seg_index = segment_manager_add_segment (sm, seg_size);
1606   if (seg_index < 0)
1607     {
1608       clib_warning ("failed to add new cut-through segment");
1609       return seg_index;
1610     }
1611   seg = segment_manager_get_segment_w_lock (sm, seg_index);
1612   sq = segment_manager_alloc_queue (seg, props);
1613   cq = segment_manager_alloc_queue (seg, cprops);
1614
1615   if (props->use_mq_eventfd)
1616     application_local_session_fix_eventds (sq, cq);
1617
1618   ls->server_evt_q = pointer_to_uword (sq);
1619   ls->client_evt_q = pointer_to_uword (cq);
1620   rv = segment_manager_try_alloc_fifos (seg, props->rx_fifo_size,
1621                                         props->tx_fifo_size,
1622                                         &ls->server_rx_fifo,
1623                                         &ls->server_tx_fifo);
1624   if (rv)
1625     {
1626       clib_warning ("failed to add fifos in cut-through segment");
1627       segment_manager_segment_reader_unlock (sm);
1628       goto failed;
1629     }
1630   ls->server_rx_fifo->master_session_index = ls->session_index;
1631   ls->server_tx_fifo->master_session_index = ls->session_index;
1632   ls->server_rx_fifo->master_thread_index = ~0;
1633   ls->server_tx_fifo->master_thread_index = ~0;
1634   ls->svm_segment_index = seg_index;
1635   ls->listener_index = ll->session_index;
1636   ls->client_wrk_index = client_wrk->wrk_index;
1637   ls->client_opaque = opaque;
1638   ls->listener_session_type = ll->session_type;
1639   ls->session_state = SESSION_STATE_READY;
1640
1641   if ((rv = server->cb_fns.add_segment_callback (server->api_client_index,
1642                                                  &seg->ssvm)))
1643     {
1644       clib_warning ("failed to notify server of new segment");
1645       segment_manager_segment_reader_unlock (sm);
1646       goto failed;
1647     }
1648   segment_manager_segment_reader_unlock (sm);
1649   if ((rv = server->cb_fns.session_accept_callback ((stream_session_t *) ls)))
1650     {
1651       clib_warning ("failed to send accept cut-through notify to server");
1652       goto failed;
1653     }
1654   if (server->flags & APP_OPTIONS_FLAGS_IS_BUILTIN)
1655     application_local_session_connect_notify (ls);
1656
1657   return 0;
1658
1659 failed:
1660   if (!has_transport)
1661     segment_manager_del_segment (sm, seg);
1662   return rv;
1663 }
1664
1665 static uword
1666 application_client_local_connect_key (local_session_t * ls)
1667 {
1668   return ((uword) ls->app_wrk_index << 32 | (uword) ls->session_index);
1669 }
1670
1671 static void
1672 application_client_local_connect_key_parse (uword key, u32 * app_wrk_index,
1673                                             u32 * session_index)
1674 {
1675   *app_wrk_index = key >> 32;
1676   *session_index = key & 0xFFFFFFFF;
1677 }
1678
1679 int
1680 application_local_session_connect_notify (local_session_t * ls)
1681 {
1682   svm_fifo_segment_private_t *seg;
1683   app_worker_t *client_wrk, *server_wrk;
1684   segment_manager_t *sm;
1685   application_t *client;
1686   int rv, is_fail = 0;
1687   uword client_key;
1688
1689   client_wrk = app_worker_get (ls->client_wrk_index);
1690   server_wrk = app_worker_get (ls->app_wrk_index);
1691   client = application_get (client_wrk->app_index);
1692
1693   sm = application_get_local_segment_manager_w_session (server_wrk, ls);
1694   seg = segment_manager_get_segment_w_lock (sm, ls->svm_segment_index);
1695   if ((rv = client->cb_fns.add_segment_callback (client->api_client_index,
1696                                                  &seg->ssvm)))
1697     {
1698       clib_warning ("failed to notify client %u of new segment",
1699                     ls->client_wrk_index);
1700       segment_manager_segment_reader_unlock (sm);
1701       application_local_session_disconnect (ls->client_wrk_index, ls);
1702       is_fail = 1;
1703     }
1704   else
1705     {
1706       segment_manager_segment_reader_unlock (sm);
1707     }
1708
1709   client->cb_fns.session_connected_callback (client_wrk->wrk_index,
1710                                              ls->client_opaque,
1711                                              (stream_session_t *) ls,
1712                                              is_fail);
1713
1714   client_key = application_client_local_connect_key (ls);
1715   hash_set (client_wrk->local_connects, client_key, client_key);
1716   return 0;
1717 }
1718
1719 int
1720 application_local_session_cleanup (app_worker_t * client_wrk,
1721                                    app_worker_t * server_wrk,
1722                                    local_session_t * ls)
1723 {
1724   svm_fifo_segment_private_t *seg;
1725   segment_manager_t *sm;
1726   uword client_key;
1727   u8 has_transport;
1728
1729   has_transport = session_has_transport ((stream_session_t *) ls);
1730   client_key = application_client_local_connect_key (ls);
1731   if (!has_transport)
1732     sm = application_get_local_segment_manager_w_session (server_wrk, ls);
1733   else
1734     sm = app_worker_get_listen_segment_manager (server_wrk,
1735                                                 (stream_session_t *) ls);
1736
1737   seg = segment_manager_get_segment (sm, ls->svm_segment_index);
1738   if (client_wrk)
1739     hash_unset (client_wrk->local_connects, client_key);
1740
1741   if (!has_transport)
1742     {
1743       application_t *server = application_get (server_wrk->app_index);
1744       server->cb_fns.del_segment_callback (server->api_client_index,
1745                                            &seg->ssvm);
1746       if (client_wrk)
1747         {
1748           application_t *client = application_get (client_wrk->app_index);
1749           client->cb_fns.del_segment_callback (client->api_client_index,
1750                                                &seg->ssvm);
1751         }
1752       segment_manager_del_segment (sm, seg);
1753     }
1754
1755   application_local_session_free (server_wrk, ls);
1756
1757   return 0;
1758 }
1759
1760 int
1761 application_local_session_disconnect (u32 app_index, local_session_t * ls)
1762 {
1763   app_worker_t *client_wrk, *server_wrk;
1764   u8 is_server = 0, is_client = 0;
1765   application_t *app;
1766
1767   app = application_get_if_valid (app_index);
1768   if (!app)
1769     return 0;
1770
1771   client_wrk = app_worker_get_if_valid (ls->client_wrk_index);
1772   server_wrk = app_worker_get (ls->app_wrk_index);
1773
1774   if (server_wrk->app_index == app_index)
1775     is_server = 1;
1776   else if (client_wrk && client_wrk->app_index == app_index)
1777     is_client = 1;
1778
1779   if (!is_server && !is_client)
1780     {
1781       clib_warning ("app %u is neither client nor server for session 0x%lx",
1782                     app_index, application_local_session_handle (ls));
1783       return VNET_API_ERROR_INVALID_VALUE;
1784     }
1785
1786   if (ls->session_state == SESSION_STATE_CLOSED)
1787     return application_local_session_cleanup (client_wrk, server_wrk, ls);
1788
1789   if (app_index == ls->client_wrk_index)
1790     {
1791       mq_send_local_session_disconnected_cb (ls->app_wrk_index, ls);
1792     }
1793   else
1794     {
1795       if (!client_wrk)
1796         {
1797           return application_local_session_cleanup (client_wrk, server_wrk,
1798                                                     ls);
1799         }
1800       else if (ls->session_state < SESSION_STATE_READY)
1801         {
1802           application_t *client = application_get (client_wrk->app_index);
1803           client->cb_fns.session_connected_callback (client_wrk->wrk_index,
1804                                                      ls->client_opaque,
1805                                                      (stream_session_t *) ls,
1806                                                      1 /* is_fail */ );
1807           ls->session_state = SESSION_STATE_CLOSED;
1808           return application_local_session_cleanup (client_wrk, server_wrk,
1809                                                     ls);
1810         }
1811       else
1812         {
1813           mq_send_local_session_disconnected_cb (client_wrk->wrk_index, ls);
1814         }
1815     }
1816
1817   ls->session_state = SESSION_STATE_CLOSED;
1818
1819   return 0;
1820 }
1821
1822 int
1823 application_local_session_disconnect_w_index (u32 app_wrk_index, u32 ls_index)
1824 {
1825   app_worker_t *app_wrk;
1826   local_session_t *ls;
1827   app_wrk = app_worker_get (app_wrk_index);
1828   ls = application_get_local_session (app_wrk, ls_index);
1829   return application_local_session_disconnect (app_wrk_index, ls);
1830 }
1831
1832 void
1833 app_worker_local_sessions_free (app_worker_t * app_wrk)
1834 {
1835   u32 index, server_wrk_index, session_index;
1836   u64 handle, *handles = 0;
1837   app_worker_t *server_wrk;
1838   segment_manager_t *sm;
1839   local_session_t *ls;
1840   int i;
1841
1842   /*
1843    * Local sessions
1844    */
1845   if (app_wrk->local_sessions)
1846     {
1847       /* *INDENT-OFF* */
1848       pool_foreach (ls, app_wrk->local_sessions, ({
1849         application_local_session_disconnect (app_wrk->wrk_index, ls);
1850       }));
1851       /* *INDENT-ON* */
1852     }
1853
1854   /*
1855    * Local connects
1856    */
1857   vec_reset_length (handles);
1858   /* *INDENT-OFF* */
1859   hash_foreach (handle, index, app_wrk->local_connects, ({
1860     vec_add1 (handles, handle);
1861   }));
1862   /* *INDENT-ON* */
1863
1864   for (i = 0; i < vec_len (handles); i++)
1865     {
1866       application_client_local_connect_key_parse (handles[i],
1867                                                   &server_wrk_index,
1868                                                   &session_index);
1869       server_wrk = app_worker_get_if_valid (server_wrk_index);
1870       if (server_wrk)
1871         {
1872           ls = application_get_local_session (server_wrk, session_index);
1873           application_local_session_disconnect (app_wrk->wrk_index, ls);
1874         }
1875     }
1876
1877   sm = segment_manager_get (app_wrk->local_segment_manager);
1878   sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
1879   segment_manager_del (sm);
1880 }
1881
1882 clib_error_t *
1883 vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
1884 {
1885   application_t *app;
1886   app = application_get (a->app_index);
1887   if (!app)
1888     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1889                                    0, "app %u doesn't exist", a->app_index);
1890   app->tls_cert = vec_dup (a->cert);
1891   return 0;
1892 }
1893
1894 clib_error_t *
1895 vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
1896 {
1897   application_t *app;
1898   app = application_get (a->app_index);
1899   if (!app)
1900     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1901                                    0, "app %u doesn't exist", a->app_index);
1902   app->tls_key = vec_dup (a->key);
1903   return 0;
1904 }
1905
1906 u8 *
1907 format_app_worker_listener (u8 * s, va_list * args)
1908 {
1909   app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
1910   u64 handle = va_arg (*args, u64);
1911   u32 sm_index = va_arg (*args, u32);
1912   int verbose = va_arg (*args, int);
1913   stream_session_t *listener;
1914   application_t *app;
1915   u8 *app_name, *str;
1916
1917   if (!app_wrk)
1918     {
1919       if (verbose)
1920         s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
1921                     "Wrk", "API Client", "ListenerID", "SegManager");
1922       else
1923         s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
1924
1925       return s;
1926     }
1927
1928   app = application_get (app_wrk->app_index);
1929   app_name = app_get_name_from_reg_index (app);
1930   listener = listen_session_get_from_handle (handle);
1931   str = format (0, "%U", format_stream_session, listener, verbose);
1932
1933   if (verbose)
1934     {
1935       char buf[32];
1936       sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
1937       s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
1938                   buf, app->api_client_index, handle, sm_index);
1939     }
1940   else
1941     s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
1942
1943   vec_free (app_name);
1944   return s;
1945 }
1946
1947 static void
1948 application_format_listeners (application_t * app, int verbose)
1949 {
1950   vlib_main_t *vm = vlib_get_main ();
1951   app_worker_map_t *wrk_map;
1952   app_worker_t *app_wrk;
1953   u32 sm_index;
1954   u64 handle;
1955
1956   if (!app)
1957     {
1958       vlib_cli_output (vm, "%U", format_app_worker_listener, 0 /* header */ ,
1959                        0, 0, verbose);
1960       return;
1961     }
1962
1963   /* *INDENT-OFF* */
1964   pool_foreach (wrk_map, app->worker_maps, ({
1965     app_wrk = app_worker_get (wrk_map->wrk_index);
1966     if (hash_elts (app_wrk->listeners_table) == 0)
1967       continue;
1968     hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
1969       vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
1970                        handle, sm_index, verbose);
1971     }));
1972   }));
1973   /* *INDENT-ON* */
1974 }
1975
1976 static void
1977 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
1978 {
1979   svm_fifo_segment_private_t *fifo_segment;
1980   vlib_main_t *vm = vlib_get_main ();
1981   segment_manager_t *sm;
1982   u8 *app_name, *s = 0;
1983   application_t *app;
1984
1985   /* Header */
1986   if (!app_wrk)
1987     {
1988       if (verbose)
1989         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
1990                          "API Client", "SegManager");
1991       else
1992         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
1993       return;
1994     }
1995
1996   app = application_get (app_wrk->app_index);
1997   if (app_wrk->connects_seg_manager == (u32) ~ 0)
1998     return;
1999
2000   app_name = app_get_name_from_reg_index (app);
2001
2002   /* Across all fifo segments */
2003   sm = segment_manager_get (app_wrk->connects_seg_manager);
2004
2005   /* *INDENT-OFF* */
2006   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
2007     svm_fifo_t *fifo;
2008     u8 *str;
2009
2010     fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
2011     while (fifo)
2012         {
2013           u32 session_index, thread_index;
2014           stream_session_t *session;
2015
2016           session_index = fifo->master_session_index;
2017           thread_index = fifo->master_thread_index;
2018
2019           session = session_get (session_index, thread_index);
2020           str = format (0, "%U", format_stream_session, session, verbose);
2021
2022           if (verbose)
2023             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
2024                         app->api_client_index, app_wrk->connects_seg_manager);
2025           else
2026             s = format (s, "%-40s%-20s", str, app_name);
2027
2028           vlib_cli_output (vm, "%v", s);
2029           vec_reset_length (s);
2030           vec_free (str);
2031
2032           fifo = fifo->next;
2033         }
2034     vec_free (s);
2035   }));
2036   /* *INDENT-ON* */
2037
2038   vec_free (app_name);
2039 }
2040
2041 static void
2042 application_format_connects (application_t * app, int verbose)
2043 {
2044   app_worker_map_t *wrk_map;
2045   app_worker_t *app_wrk;
2046
2047   if (!app)
2048     {
2049       app_worker_format_connects (0, verbose);
2050       return;
2051     }
2052
2053   /* *INDENT-OFF* */
2054   pool_foreach (wrk_map, app->worker_maps, ({
2055     app_wrk = app_worker_get (wrk_map->wrk_index);
2056     app_worker_format_connects (app_wrk, verbose);
2057   }));
2058   /* *INDENT-ON* */
2059 }
2060
2061 static void
2062 app_worker_format_local_sessions (app_worker_t * app_wrk, int verbose)
2063 {
2064   vlib_main_t *vm = vlib_get_main ();
2065   local_session_t *ls;
2066   transport_proto_t tp;
2067   u8 *conn = 0;
2068
2069   /* Header */
2070   if (app_wrk == 0)
2071     {
2072       vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "ServerApp",
2073                        "ClientApp");
2074       return;
2075     }
2076
2077   if (!pool_elts (app_wrk->local_sessions)
2078       && !pool_elts (app_wrk->local_connects))
2079     return;
2080
2081   /* *INDENT-OFF* */
2082   pool_foreach (ls, app_wrk->local_sessions, ({
2083     tp = session_type_transport_proto(ls->listener_session_type);
2084     conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
2085                    ls->port);
2086     vlib_cli_output (vm, "%-40v%-15u%-20u", conn, ls->app_wrk_index,
2087                      ls->client_wrk_index);
2088     vec_reset_length (conn);
2089   }));
2090   /* *INDENT-ON* */
2091
2092   vec_free (conn);
2093 }
2094
2095 static void
2096 application_format_local_sessions (application_t * app, int verbose)
2097 {
2098   vlib_main_t *vm = vlib_get_main ();
2099   app_worker_map_t *wrk_map;
2100   app_worker_t *app_wrk;
2101   transport_proto_t tp;
2102   local_session_t *ls;
2103   u8 *conn = 0;
2104
2105   if (!app)
2106     {
2107       app_worker_format_local_sessions (0, verbose);
2108       return;
2109     }
2110
2111   /*
2112    * Format local listeners
2113    */
2114
2115   /* *INDENT-OFF* */
2116   pool_foreach (ls, app->local_listen_sessions, ({
2117     tp = session_type_transport_proto (ls->listener_session_type);
2118     conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
2119                    ls->port);
2120     vlib_cli_output (vm, "%-40v%-15u%-20s", conn, ls->app_wrk_index, "*");
2121     vec_reset_length (conn);
2122   }));
2123   /* *INDENT-ON* */
2124
2125   /*
2126    * Format local accepted/connected sessions
2127    */
2128   /* *INDENT-OFF* */
2129   pool_foreach (wrk_map, app->worker_maps, ({
2130     app_wrk = app_worker_get (wrk_map->wrk_index);
2131     app_worker_format_local_sessions (app_wrk, verbose);
2132   }));
2133   /* *INDENT-ON* */
2134 }
2135
2136 static void
2137 app_worker_format_local_connects (app_worker_t * app, int verbose)
2138 {
2139   vlib_main_t *vm = vlib_get_main ();
2140   u32 app_wrk_index, session_index;
2141   app_worker_t *server_wrk;
2142   local_session_t *ls;
2143   uword client_key;
2144   u64 value;
2145
2146   /* Header */
2147   if (app == 0)
2148     {
2149       if (verbose)
2150         vlib_cli_output (vm, "%-40s%-15s%-20s%-10s", "Connection", "App",
2151                          "Peer App", "SegManager");
2152       else
2153         vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "App",
2154                          "Peer App");
2155       return;
2156     }
2157
2158   if (!app->local_connects)
2159     return;
2160
2161   /* *INDENT-OFF* */
2162   hash_foreach (client_key, value, app->local_connects, ({
2163     application_client_local_connect_key_parse (client_key, &app_wrk_index,
2164                                                 &session_index);
2165     server_wrk = app_worker_get (app_wrk_index);
2166     ls = application_get_local_session (server_wrk, session_index);
2167     vlib_cli_output (vm, "%-40s%-15s%-20s", "TODO", ls->app_wrk_index,
2168                      ls->client_wrk_index);
2169   }));
2170   /* *INDENT-ON* */
2171 }
2172
2173 static void
2174 application_format_local_connects (application_t * app, int verbose)
2175 {
2176   app_worker_map_t *wrk_map;
2177   app_worker_t *app_wrk;
2178
2179   if (!app)
2180     {
2181       app_worker_format_local_connects (0, verbose);
2182       return;
2183     }
2184
2185   /* *INDENT-OFF* */
2186   pool_foreach (wrk_map, app->worker_maps, ({
2187     app_wrk = app_worker_get (wrk_map->wrk_index);
2188     app_worker_format_local_connects (app_wrk, verbose);
2189   }));
2190   /* *INDENT-ON* */
2191 }
2192
2193 u8 *
2194 format_application (u8 * s, va_list * args)
2195 {
2196   application_t *app = va_arg (*args, application_t *);
2197   CLIB_UNUSED (int verbose) = va_arg (*args, int);
2198   segment_manager_properties_t *props;
2199   const u8 *app_ns_name;
2200   u8 *app_name;
2201
2202   if (app == 0)
2203     {
2204       if (verbose)
2205         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
2206                     "API Client", "Namespace", "Add seg size", "Rx-f size",
2207                     "Tx-f size");
2208       else
2209         s = format (s, "%-10s%-20s%-15s%-40s", "Index", "Name", "API Client",
2210                     "Namespace");
2211       return s;
2212     }
2213
2214   app_name = app_get_name (app);
2215   app_ns_name = app_namespace_id_from_index (app->ns_index);
2216   props = application_segment_manager_properties (app);
2217   if (verbose)
2218     s = format (s, "%-10u%-20s%-15d%-15u%-15U%-15U%-15U", app->app_index,
2219                 app_name, app->api_client_index, app->ns_index,
2220                 format_memory_size, props->add_segment_size,
2221                 format_memory_size, props->rx_fifo_size, format_memory_size,
2222                 props->tx_fifo_size);
2223   else
2224     s = format (s, "%-10u%-20s%-15d%-40s", app->app_index, app_name,
2225                 app->api_client_index, app_ns_name);
2226   return s;
2227 }
2228
2229 void
2230 application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
2231 {
2232   application_t *app;
2233
2234   if (!pool_elts (app_main.app_pool))
2235     {
2236       vlib_cli_output (vm, "No active server bindings");
2237       return;
2238     }
2239
2240   if (do_local)
2241     {
2242       application_format_local_sessions (0, verbose);
2243       /* *INDENT-OFF* */
2244       pool_foreach (app, app_main.app_pool, ({
2245         application_format_local_sessions (app, verbose);
2246       }));
2247       /* *INDENT-ON* */
2248     }
2249   else
2250     {
2251       application_format_listeners (0, verbose);
2252
2253       /* *INDENT-OFF* */
2254       pool_foreach (app, app_main.app_pool, ({
2255         application_format_listeners (app, verbose);
2256       }));
2257       /* *INDENT-ON* */
2258     }
2259 }
2260
2261 void
2262 application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
2263 {
2264   application_t *app;
2265
2266   if (!pool_elts (app_main.app_pool))
2267     {
2268       vlib_cli_output (vm, "No active apps");
2269       return;
2270     }
2271
2272   if (do_local)
2273     {
2274       application_format_local_connects (0, verbose);
2275
2276       /* *INDENT-OFF* */
2277       pool_foreach (app, app_main.app_pool, ({
2278         application_format_local_connects (app, verbose);
2279       }));
2280       /* *INDENT-ON* */
2281     }
2282   else
2283     {
2284       application_format_connects (0, verbose);
2285
2286       /* *INDENT-OFF* */
2287       pool_foreach (app, app_main.app_pool, ({
2288         application_format_connects (app, verbose);
2289       }));
2290       /* *INDENT-ON* */
2291     }
2292 }
2293
2294 static clib_error_t *
2295 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
2296                      vlib_cli_command_t * cmd)
2297 {
2298   int do_server = 0, do_client = 0, do_local = 0;
2299   application_t *app;
2300   int verbose = 0;
2301
2302   session_cli_return_if_not_enabled ();
2303
2304   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2305     {
2306       if (unformat (input, "server"))
2307         do_server = 1;
2308       else if (unformat (input, "client"))
2309         do_client = 1;
2310       else if (unformat (input, "local"))
2311         do_local = 1;
2312       else if (unformat (input, "verbose"))
2313         verbose = 1;
2314       else
2315         break;
2316     }
2317
2318   if (do_server)
2319     application_format_all_listeners (vm, do_local, verbose);
2320
2321   if (do_client)
2322     application_format_all_clients (vm, do_local, verbose);
2323
2324   /* Print app related info */
2325   if (!do_server && !do_client)
2326     {
2327       vlib_cli_output (vm, "%U", format_application, 0, verbose);
2328       /* *INDENT-OFF* */
2329       pool_foreach (app, app_main.app_pool, ({
2330         vlib_cli_output (vm, "%U", format_application, app, verbose);
2331       }));
2332       /* *INDENT-ON* */
2333     }
2334
2335   return 0;
2336 }
2337
2338 /* *INDENT-OFF* */
2339 VLIB_CLI_COMMAND (show_app_command, static) =
2340 {
2341   .path = "show app",
2342   .short_help = "show app [server|client] [verbose]",
2343   .function = show_app_command_fn,
2344 };
2345 /* *INDENT-ON* */
2346
2347 /*
2348  * fd.io coding-style-patch-verification: ON
2349  *
2350  * Local Variables:
2351  * eval: (c-set-style "gnu")
2352  * End:
2353  */