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       sm->first_is_protected = 0;
 561       sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 562       /* .. and has no fifos, e.g. it might be used for redirected sessions,
 563        * remove it */
 564       if (!segment_manager_has_fifos (sm))
 565         segment_manager_del (sm);
 566     }
 567
 568   /*
 569    * Local sessions
 570    */
 571   app_worker_local_sessions_free (app_wrk);
 572
 573   pool_put (app_main.workers, app_wrk);
 574   if (CLIB_DEBUG)
 575     memset (app_wrk, 0xfe, sizeof (*app_wrk));
 576 }
 577
 578 int
 579 app_worker_alloc_and_init (application_t * app, app_worker_t ** wrk)
 580 {
 581   app_worker_map_t *wrk_map;
 582   app_worker_t *app_wrk;
 583   segment_manager_t *sm;
 584   int rv;
 585
 586   app_wrk = app_worker_alloc (app);
 587   wrk_map = app_worker_map_alloc (app);
 588   wrk_map->wrk_index = app_wrk->wrk_index;
 589   app_wrk->wrk_map_index = app_worker_map_index (app, wrk_map);
 590
 591   /*
 592    * Setup first segment manager
 593    */
 594   sm = segment_manager_new ();
 595   sm->app_wrk_index = app_wrk->wrk_index;
 596
 597   if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
 598                                   app->sm_properties.prealloc_fifos)))
 599     {
 600       app_worker_free (app_wrk);
 601       return rv;
 602     }
 603   sm->first_is_protected = 1;
 604
 605   /*
 606    * Setup app worker
 607    */
 608   app_wrk->first_segment_manager = segment_manager_index (sm);
 609   app_wrk->listeners_table = hash_create (0, sizeof (u64));
 610   app_wrk->event_queue = segment_manager_event_queue (sm);
 611   app_wrk->app_is_builtin = application_is_builtin (app);
 612
 613   /*
 614    * Segment manager for local sessions
 615    */
 616   sm = segment_manager_new ();
 617   sm->app_wrk_index = app_wrk->wrk_index;
 618   app_wrk->local_segment_manager = segment_manager_index (sm);
 619   app_wrk->local_connects = hash_create (0, sizeof (u64));
 620
 621   *wrk = app_wrk;
 622
 623   return 0;
 624 }
 625
 626 application_t *
 627 app_worker_get_app (u32 wrk_index)
 628 {
 629   app_worker_t *app_wrk;
 630   app_wrk = app_worker_get_if_valid (wrk_index);
 631   if (!app_wrk)
 632     return 0;
 633   return application_get_if_valid (app_wrk->app_index);
 634 }
 635
 636 static segment_manager_t *
 637 app_worker_alloc_segment_manager (app_worker_t * app_wrk)
 638 {
 639   segment_manager_t *sm = 0;
 640
 641   /* If the first segment manager is not in use, don't allocate a new one */
 642   if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
 643       && app_wrk->first_segment_manager_in_use == 0)
 644     {
 645       sm = segment_manager_get (app_wrk->first_segment_manager);
 646       app_wrk->first_segment_manager_in_use = 1;
 647       return sm;
 648     }
 649
 650   sm = segment_manager_new ();
 651   sm->app_wrk_index = app_wrk->wrk_index;
 652
 653   return sm;
 654 }
 655
 656 int
 657 app_worker_start_listen (app_worker_t * app_wrk, stream_session_t * ls)
 658 {
 659   segment_manager_t *sm;
 660
 661   /* Allocate segment manager. All sessions derived out of a listen session
 662    * have fifos allocated by the same segment manager. */
 663   if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
 664     return -1;
 665
 666   /* Add to app's listener table. Useful to find all child listeners
 667    * when app goes down, although, just for unbinding this is not needed */
 668   hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
 669             segment_manager_index (sm));
 670
 671   if (!ls->server_rx_fifo
 672       && session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
 673     {
 674       if (session_alloc_fifos (sm, ls))
 675         return -1;
 676     }
 677   return 0;
 678 }
 679
 680 int
 681 app_worker_stop_listen (app_worker_t * app_wrk, session_handle_t handle)
 682 {
 683   segment_manager_t *sm;
 684   uword *sm_indexp;
 685
 686   sm_indexp = hash_get (app_wrk->listeners_table, handle);
 687   if (PREDICT_FALSE (!sm_indexp))
 688     {
 689       clib_warning ("listener handle was removed %llu!", handle);
 690       return -1;
 691     }
 692
 693   sm = segment_manager_get (*sm_indexp);
 694   if (app_wrk->first_segment_manager == *sm_indexp)
 695     {
 696       /* Delete sessions but don't remove segment manager */
 697       app_wrk->first_segment_manager_in_use = 0;
 698       segment_manager_del_sessions (sm);
 699     }
 700   else
 701     {
 702       segment_manager_init_del (sm);
 703     }
 704   hash_unset (app_wrk->listeners_table, handle);
 705
 706   return 0;
 707 }
 708
 709 /**
 710  * Start listening local transport endpoint for requested transport.
 711  *
 712  * Creates a 'dummy' stream session with state LISTENING to be used in session
 713  * lookups, prior to establishing connection. Requests transport to build
 714  * it's own specific listening connection.
 715  */
 716 int
 717 application_start_listen (application_t * app,
 718                           session_endpoint_extended_t * sep_ext,
 719                           session_handle_t * res)
 720 {
 721   app_listener_t *app_listener;
 722   u32 table_index, fib_proto;
 723   session_endpoint_t *sep;
 724   app_worker_t *app_wrk;
 725   stream_session_t *ls;
 726   session_handle_t lh;
 727   session_type_t sst;
 728
 729   /*
 730    * Check if sep is already listened on
 731    */
 732   sep = (session_endpoint_t *) sep_ext;
 733   fib_proto = session_endpoint_fib_proto (sep);
 734   table_index = application_session_table (app, fib_proto);
 735   lh = session_lookup_endpoint_listener (table_index, sep, 1);
 736   if (lh != SESSION_INVALID_HANDLE)
 737     {
 738       ls = listen_session_get_from_handle (lh);
 739       if (ls->app_index != app->app_index)
 740         return VNET_API_ERROR_ADDRESS_IN_USE;
 741
 742       app_wrk = app_worker_get (sep_ext->app_wrk_index);
 743       if (ls->app_wrk_index == app_wrk->wrk_index)
 744         return VNET_API_ERROR_ADDRESS_IN_USE;
 745
 746       if (app_worker_start_listen (app_wrk, ls))
 747         return -1;
 748
 749       app_listener = app_listener_get (app, ls->listener_db_index);
 750       app_listener->workers = clib_bitmap_set (app_listener->workers,
 751                                                app_wrk->wrk_map_index, 1);
 752
 753       *res = listen_session_get_handle (ls);
 754       return 0;
 755     }
 756
 757   /*
 758    * Allocate new listener for application
 759    */
 760   sst = session_type_from_proto_and_ip (sep_ext->transport_proto,
 761                                         sep_ext->is_ip4);
 762   ls = listen_session_new (0, sst);
 763   ls->app_index = app->app_index;
 764   lh = listen_session_get_handle (ls);
 765   if (session_listen (ls, sep_ext))
 766     goto err;
 767
 768
 769   ls = listen_session_get_from_handle (lh);
 770   app_listener = app_listener_alloc (app);
 771   ls->listener_db_index = app_listener->al_index;
 772
 773   /*
 774    * Setup app worker as a listener
 775    */
 776   app_wrk = app_worker_get (sep_ext->app_wrk_index);
 777   ls->app_wrk_index = app_wrk->wrk_index;
 778   if (app_worker_start_listen (app_wrk, ls))
 779     goto err;
 780   app_listener->workers = clib_bitmap_set (app_listener->workers,
 781                                            app_wrk->wrk_map_index, 1);
 782
 783   *res = lh;
 784   return 0;
 785
 786 err:
 787   listen_session_del (ls);
 788   return -1;
 789 }
 790
 791 /**
 792  * Stop listening on session associated to handle
 793  *
 794  * @param handle        listener handle
 795  * @param app_index     index of the app owning the handle.
 796  * @param app_wrk_index index of the worker requesting the stop
 797  */
 798 int
 799 application_stop_listen (u32 app_index, u32 app_wrk_index,
 800                          session_handle_t handle)
 801 {
 802   app_listener_t *app_listener;
 803   stream_session_t *listener;
 804   app_worker_t *app_wrk;
 805   application_t *app;
 806
 807   listener = listen_session_get_from_handle (handle);
 808   app = application_get (app_index);
 809   if (PREDICT_FALSE (!app || app->app_index != listener->app_index))
 810     {
 811       clib_warning ("app doesn't own handle %llu!", handle);
 812       return -1;
 813     }
 814
 815   app_listener = app_listener_get (app, listener->listener_db_index);
 816   if (!clib_bitmap_get (app_listener->workers, app_wrk_index))
 817     {
 818       clib_warning ("worker not listening on handle %lu", handle);
 819       return 0;
 820     }
 821
 822   app_wrk = application_get_worker (app, app_wrk_index);
 823   app_worker_stop_listen (app_wrk, handle);
 824   clib_bitmap_set_no_check (app_listener->workers, app_wrk_index, 0);
 825
 826   if (clib_bitmap_is_zero (app_listener->workers))
 827     {
 828       session_stop_listen (listener);
 829       app_listener_free (app, app_listener);
 830       listen_session_del (listener);
 831     }
 832
 833   return 0;
 834 }
 835
 836 int
 837 app_worker_open_session (app_worker_t * app, session_endpoint_t * sep,
 838                          u32 api_context)
 839 {
 840   int rv;
 841
 842   /* Make sure we have a segment manager for connects */
 843   app_worker_alloc_connects_segment_manager (app);
 844
 845   if ((rv = session_open (app->wrk_index, sep, api_context)))
 846     return rv;
 847
 848   return 0;
 849 }
 850
 851 int
 852 app_worker_alloc_connects_segment_manager (app_worker_t * app_wrk)
 853 {
 854   segment_manager_t *sm;
 855
 856   if (app_wrk->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
 857     {
 858       sm = app_worker_alloc_segment_manager (app_wrk);
 859       if (sm == 0)
 860         return -1;
 861       app_wrk->connects_seg_manager = segment_manager_index (sm);
 862     }
 863   return 0;
 864 }
 865
 866 segment_manager_t *
 867 app_worker_get_connect_segment_manager (app_worker_t * app)
 868 {
 869   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 870   return segment_manager_get (app->connects_seg_manager);
 871 }
 872
 873 segment_manager_t *
 874 app_worker_get_listen_segment_manager (app_worker_t * app,
 875                                        stream_session_t * listener)
 876 {
 877   uword *smp;
 878   smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
 879   ASSERT (smp != 0);
 880   return segment_manager_get (*smp);
 881 }
 882
 883 clib_error_t *
 884 vnet_app_worker_add_del (vnet_app_worker_add_del_args_t * a)
 885 {
 886   svm_fifo_segment_private_t *fs;
 887   app_worker_map_t *wrk_map;
 888   app_worker_t *app_wrk;
 889   segment_manager_t *sm;
 890   application_t *app;
 891   int rv;
 892
 893   app = application_get (a->app_index);
 894   if (!app)
 895     return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
 896                                    "App %u does not exist", a->app_index);
 897
 898   if (a->is_add)
 899     {
 900       if ((rv = app_worker_alloc_and_init (app, &app_wrk)))
 901         return clib_error_return_code (0, rv, 0, "app wrk init: %d", rv);
 902       sm = segment_manager_get (app_wrk->first_segment_manager);
 903       fs = segment_manager_get_segment_w_lock (sm, 0);
 904       a->segment = &fs->ssvm;
 905       segment_manager_segment_reader_unlock (sm);
 906       a->evt_q = app_wrk->event_queue;
 907       a->wrk_index = app_wrk->wrk_map_index;
 908     }
 909   else
 910     {
 911       wrk_map = app_worker_map_get (app, a->wrk_index);
 912       if (!wrk_map)
 913         return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
 914                                        "App %u does not have worker %u",
 915                                        app->app_index, a->wrk_index);
 916       app_wrk = app_worker_get (wrk_map->wrk_index);
 917       app_worker_map_free (app, wrk_map);
 918       if (!app_wrk)
 919         return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
 920                                        "No worker %u", a->wrk_index);
 921       app_worker_free (app_wrk);
 922     }
 923   return 0;
 924 }
 925
 926 segment_manager_t *
 927 application_get_local_segment_manager (app_worker_t * app)
 928 {
 929   return segment_manager_get (app->local_segment_manager);
 930 }
 931
 932 segment_manager_t *
 933 application_get_local_segment_manager_w_session (app_worker_t * app,
 934                                                  local_session_t * ls)
 935 {
 936   stream_session_t *listener;
 937   if (application_local_session_listener_has_transport (ls))
 938     {
 939       listener = listen_session_get (ls->listener_index);
 940       return app_worker_get_listen_segment_manager (app, listener);
 941     }
 942   return segment_manager_get (app->local_segment_manager);
 943 }
 944
 945 int
 946 application_is_proxy (application_t * app)
 947 {
 948   return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
 949 }
 950
 951 int
 952 application_is_builtin (application_t * app)
 953 {
 954   return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
 955 }
 956
 957 int
 958 application_is_builtin_proxy (application_t * app)
 959 {
 960   return (application_is_proxy (app) && application_is_builtin (app));
 961 }
 962
 963 u8
 964 application_has_local_scope (application_t * app)
 965 {
 966   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
 967 }
 968
 969 u8
 970 application_has_global_scope (application_t * app)
 971 {
 972   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 973 }
 974
 975 u8
 976 application_use_mq_for_ctrl (application_t * app)
 977 {
 978   return app->flags & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
 979 }
 980
 981 /**
 982  * Send an API message to the external app, to map new segment
 983  */
 984 int
 985 app_worker_add_segment_notify (u32 app_wrk_index, ssvm_private_t * fs)
 986 {
 987   app_worker_t *app_wrk = app_worker_get (app_wrk_index);
 988   application_t *app = application_get (app_wrk->app_index);
 989   return app->cb_fns.add_segment_callback (app->api_client_index, fs);
 990 }
 991
 992 u32
 993 application_n_listeners (app_worker_t * app)
 994 {
 995   return hash_elts (app->listeners_table);
 996 }
 997
 998 stream_session_t *
 999 app_worker_first_listener (app_worker_t * app, u8 fib_proto,
1000                            u8 transport_proto)
1001 {
1002   stream_session_t *listener;
1003   u64 handle;
1004   u32 sm_index;
1005   u8 sst;
1006
1007   sst = session_type_from_proto_and_ip (transport_proto,
1008                                         fib_proto == FIB_PROTOCOL_IP4);
1009
1010   /* *INDENT-OFF* */
1011    hash_foreach (handle, sm_index, app->listeners_table, ({
1012      listener = listen_session_get_from_handle (handle);
1013      if (listener->session_type == sst
1014          && listener->enqueue_epoch != SESSION_PROXY_LISTENER_INDEX)
1015        return listener;
1016    }));
1017   /* *INDENT-ON* */
1018
1019   return 0;
1020 }
1021
1022 u8
1023 app_worker_application_is_builtin (app_worker_t * app_wrk)
1024 {
1025   return app_wrk->app_is_builtin;
1026 }
1027
1028 stream_session_t *
1029 application_proxy_listener (app_worker_t * app, u8 fib_proto,
1030                             u8 transport_proto)
1031 {
1032   stream_session_t *listener;
1033   u64 handle;
1034   u32 sm_index;
1035   u8 sst;
1036
1037   sst = session_type_from_proto_and_ip (transport_proto,
1038                                         fib_proto == FIB_PROTOCOL_IP4);
1039
1040   /* *INDENT-OFF* */
1041    hash_foreach (handle, sm_index, app->listeners_table, ({
1042      listener = listen_session_get_from_handle (handle);
1043      if (listener->session_type == sst
1044          && listener->enqueue_epoch == SESSION_PROXY_LISTENER_INDEX)
1045        return listener;
1046    }));
1047   /* *INDENT-ON* */
1048
1049   return 0;
1050 }
1051
1052 static clib_error_t *
1053 application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
1054                                         u8 transport_proto, u8 is_start)
1055 {
1056   app_namespace_t *app_ns = app_namespace_get (app->ns_index);
1057   u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
1058   session_endpoint_extended_t sep = SESSION_ENDPOINT_EXT_NULL;
1059   transport_connection_t *tc;
1060   app_worker_t *app_wrk;
1061   stream_session_t *s;
1062   u64 handle;
1063
1064   /* TODO decide if we want proxy to be enabled for all workers */
1065   app_wrk = application_get_default_worker (app);
1066   if (is_start)
1067     {
1068       s = app_worker_first_listener (app_wrk, fib_proto, transport_proto);
1069       if (!s)
1070         {
1071           sep.is_ip4 = is_ip4;
1072           sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1073           sep.sw_if_index = app_ns->sw_if_index;
1074           sep.transport_proto = transport_proto;
1075           sep.app_wrk_index = app_wrk->wrk_index;       /* only default */
1076           application_start_listen (app, &sep, &handle);
1077           s = listen_session_get_from_handle (handle);
1078           s->enqueue_epoch = SESSION_PROXY_LISTENER_INDEX;
1079         }
1080     }
1081   else
1082     {
1083       s = application_proxy_listener (app_wrk, fib_proto, transport_proto);
1084       ASSERT (s);
1085     }
1086
1087   tc = listen_session_get_transport (s);
1088
1089   if (!ip_is_zero (&tc->lcl_ip, 1))
1090     {
1091       u32 sti;
1092       sep.is_ip4 = is_ip4;
1093       sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1094       sep.transport_proto = transport_proto;
1095       sep.port = 0;
1096       sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
1097       if (is_start)
1098         session_lookup_add_session_endpoint (sti,
1099                                              (session_endpoint_t *) & sep,
1100                                              s->session_index);
1101       else
1102         session_lookup_del_session_endpoint (sti,
1103                                              (session_endpoint_t *) & sep);
1104     }
1105
1106   return 0;
1107 }
1108
1109 static void
1110 application_start_stop_proxy_local_scope (application_t * app,
1111                                           u8 transport_proto, u8 is_start)
1112 {
1113   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
1114   app_namespace_t *app_ns;
1115   app_ns = app_namespace_get (app->ns_index);
1116   sep.is_ip4 = 1;
1117   sep.transport_proto = transport_proto;
1118   sep.port = 0;
1119
1120   if (is_start)
1121     {
1122       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1123                                            app->app_index);
1124       sep.is_ip4 = 0;
1125       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1126                                            app->app_index);
1127     }
1128   else
1129     {
1130       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1131       sep.is_ip4 = 0;
1132       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1133     }
1134 }
1135
1136 void
1137 application_start_stop_proxy (application_t * app,
1138                               transport_proto_t transport_proto, u8 is_start)
1139 {
1140   if (application_has_local_scope (app))
1141     application_start_stop_proxy_local_scope (app, transport_proto, is_start);
1142
1143   if (application_has_global_scope (app))
1144     {
1145       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4,
1146                                               transport_proto, is_start);
1147       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6,
1148                                               transport_proto, is_start);
1149     }
1150 }
1151
1152 void
1153 application_setup_proxy (application_t * app)
1154 {
1155   u16 transports = app->proxied_transports;
1156   transport_proto_t tp;
1157
1158   ASSERT (application_is_proxy (app));
1159
1160   /* *INDENT-OFF* */
1161   transport_proto_foreach (tp, ({
1162     if (transports & (1 << tp))
1163       application_start_stop_proxy (app, tp, 1);
1164   }));
1165   /* *INDENT-ON* */
1166 }
1167
1168 void
1169 application_remove_proxy (application_t * app)
1170 {
1171   u16 transports = app->proxied_transports;
1172   transport_proto_t tp;
1173
1174   ASSERT (application_is_proxy (app));
1175
1176   /* *INDENT-OFF* */
1177   transport_proto_foreach (tp, ({
1178     if (transports & (1 << tp))
1179       application_start_stop_proxy (app, tp, 0);
1180   }));
1181   /* *INDENT-ON* */
1182 }
1183
1184 segment_manager_properties_t *
1185 application_segment_manager_properties (application_t * app)
1186 {
1187   return &app->sm_properties;
1188 }
1189
1190 segment_manager_properties_t *
1191 application_get_segment_manager_properties (u32 app_index)
1192 {
1193   application_t *app = application_get (app_index);
1194   return &app->sm_properties;
1195 }
1196
1197 static inline int
1198 app_enqueue_evt (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, u8 lock)
1199 {
1200   if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
1201     {
1202       clib_warning ("evt q full");
1203       svm_msg_q_free_msg (mq, msg);
1204       if (lock)
1205         svm_msg_q_unlock (mq);
1206       return -1;
1207     }
1208
1209   if (lock)
1210     {
1211       svm_msg_q_add_and_unlock (mq, msg);
1212       return 0;
1213     }
1214
1215   /* Even when not locking the ring, we must wait for queue mutex */
1216   if (svm_msg_q_add (mq, msg, SVM_Q_WAIT))
1217     {
1218       clib_warning ("msg q add returned");
1219       return -1;
1220     }
1221   return 0;
1222 }
1223
1224 static inline int
1225 app_send_io_evt_rx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
1226 {
1227   session_event_t *evt;
1228   svm_msg_q_msg_t msg;
1229   svm_msg_q_t *mq;
1230
1231   if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY
1232                      && s->session_state != SESSION_STATE_LISTENING))
1233     {
1234       /* Session is closed so app will never clean up. Flush rx fifo */
1235       if (s->session_state == SESSION_STATE_CLOSED)
1236         svm_fifo_dequeue_drop_all (s->server_rx_fifo);
1237       return 0;
1238     }
1239
1240   if (app_worker_application_is_builtin (app_wrk))
1241     {
1242       application_t *app = application_get (app_wrk->app_index);
1243       return app->cb_fns.builtin_app_rx_callback (s);
1244     }
1245
1246   if (svm_fifo_has_event (s->server_rx_fifo)
1247       || svm_fifo_is_empty (s->server_rx_fifo))
1248     return 0;
1249
1250   mq = app_wrk->event_queue;
1251   if (lock)
1252     svm_msg_q_lock (mq);
1253
1254   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
1255     {
1256       clib_warning ("evt q rings full");
1257       if (lock)
1258         svm_msg_q_unlock (mq);
1259       return -1;
1260     }
1261
1262   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
1263   ASSERT (!svm_msg_q_msg_is_invalid (&msg));
1264
1265   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
1266   evt->fifo = s->server_rx_fifo;
1267   evt->event_type = FIFO_EVENT_APP_RX;
1268
1269   (void) svm_fifo_set_event (s->server_rx_fifo);
1270
1271   if (app_enqueue_evt (mq, &msg, lock))
1272     return -1;
1273   return 0;
1274 }
1275
1276 static inline int
1277 app_send_io_evt_tx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
1278 {
1279   svm_msg_q_t *mq;
1280   session_event_t *evt;
1281   svm_msg_q_msg_t msg;
1282
1283   if (app_worker_application_is_builtin (app_wrk))
1284     return 0;
1285
1286   mq = app_wrk->event_queue;
1287   if (lock)
1288     svm_msg_q_lock (mq);
1289
1290   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
1291     {
1292       clib_warning ("evt q rings full");
1293       if (lock)
1294         svm_msg_q_unlock (mq);
1295       return -1;
1296     }
1297
1298   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
1299   ASSERT (!svm_msg_q_msg_is_invalid (&msg));
1300
1301   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
1302   evt->event_type = FIFO_EVENT_APP_TX;
1303   evt->fifo = s->server_tx_fifo;
1304
1305   return app_enqueue_evt (mq, &msg, lock);
1306 }
1307
1308 /* *INDENT-OFF* */
1309 typedef int (app_send_evt_handler_fn) (app_worker_t *app,
1310                                        stream_session_t *s,
1311                                        u8 lock);
1312 static app_send_evt_handler_fn * const app_send_evt_handler_fns[3] = {
1313     app_send_io_evt_rx,
1314     0,
1315     app_send_io_evt_tx,
1316 };
1317 /* *INDENT-ON* */
1318
1319 /**
1320  * Send event to application
1321  *
1322  * Logic from queue perspective is non-blocking. If there's
1323  * not enough space to enqueue a message, we return.
1324  */
1325 int
1326 app_worker_send_event (app_worker_t * app, stream_session_t * s, u8 evt_type)
1327 {
1328   ASSERT (app && evt_type <= FIFO_EVENT_APP_TX);
1329   return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ );
1330 }
1331
1332 /**
1333  * Send event to application
1334  *
1335  * Logic from queue perspective is blocking. However, if queue is full,
1336  * we return.
1337  */
1338 int
1339 app_worker_lock_and_send_event (app_worker_t * app, stream_session_t * s,
1340                                 u8 evt_type)
1341 {
1342   return app_send_evt_handler_fns[evt_type] (app, s, 1 /* lock */ );
1343 }
1344
1345 local_session_t *
1346 application_local_session_alloc (app_worker_t * app_wrk)
1347 {
1348   local_session_t *s;
1349   pool_get (app_wrk->local_sessions, s);
1350   memset (s, 0, sizeof (*s));
1351   s->app_wrk_index = app_wrk->wrk_index;
1352   s->session_index = s - app_wrk->local_sessions;
1353   s->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
1354   return s;
1355 }
1356
1357 void
1358 application_local_session_free (app_worker_t * app, local_session_t * s)
1359 {
1360   pool_put (app->local_sessions, s);
1361   if (CLIB_DEBUG)
1362     memset (s, 0xfc, sizeof (*s));
1363 }
1364
1365 local_session_t *
1366 application_get_local_session (app_worker_t * app_wrk, u32 session_index)
1367 {
1368   if (pool_is_free_index (app_wrk->local_sessions, session_index))
1369     return 0;
1370   return pool_elt_at_index (app_wrk->local_sessions, session_index);
1371 }
1372
1373 local_session_t *
1374 application_get_local_session_from_handle (session_handle_t handle)
1375 {
1376   app_worker_t *server_wrk;
1377   u32 session_index, server_wrk_index;
1378   local_session_parse_handle (handle, &server_wrk_index, &session_index);
1379   server_wrk = app_worker_get_if_valid (server_wrk_index);
1380   if (!server_wrk)
1381     return 0;
1382   return application_get_local_session (server_wrk, session_index);
1383 }
1384
1385 local_session_t *
1386 application_local_listen_session_alloc (application_t * app)
1387 {
1388   local_session_t *ll;
1389   pool_get (app->local_listen_sessions, ll);
1390   memset (ll, 0, sizeof (*ll));
1391   return ll;
1392 }
1393
1394 u32
1395 application_local_listener_index (application_t * app, local_session_t * ll)
1396 {
1397   return (ll - app->local_listen_sessions);
1398 }
1399
1400 void
1401 application_local_listen_session_free (application_t * app,
1402                                        local_session_t * ll)
1403 {
1404   pool_put (app->local_listen_sessions, ll);
1405   if (CLIB_DEBUG)
1406     memset (ll, 0xfb, sizeof (*ll));
1407 }
1408
1409 int
1410 application_start_local_listen (application_t * app,
1411                                 session_endpoint_extended_t * sep_ext,
1412                                 session_handle_t * handle)
1413 {
1414   app_listener_t *app_listener;
1415   session_endpoint_t *sep;
1416   app_worker_t *app_wrk;
1417   session_handle_t lh;
1418   local_session_t *ll;
1419   u32 table_index;
1420
1421   sep = (session_endpoint_t *) sep_ext;
1422   table_index = application_local_session_table (app);
1423   app_wrk = app_worker_get (sep_ext->app_wrk_index);
1424
1425   /* An exact sep match, as opposed to session_lookup_local_listener */
1426   lh = session_lookup_endpoint_listener (table_index, sep, 1);
1427   if (lh != SESSION_INVALID_HANDLE)
1428     {
1429       ll = application_get_local_listener_w_handle (lh);
1430       if (ll->app_index != app->app_index)
1431         return VNET_API_ERROR_ADDRESS_IN_USE;
1432
1433       if (ll->app_wrk_index == app_wrk->wrk_index)
1434         return VNET_API_ERROR_ADDRESS_IN_USE;
1435
1436       app_listener = app_local_listener_get (app, ll->listener_db_index);
1437       app_listener->workers = clib_bitmap_set (app_listener->workers,
1438                                                app_wrk->wrk_map_index, 1);
1439       *handle = application_local_session_handle (ll);
1440       return 0;
1441     }
1442
1443   ll = application_local_listen_session_alloc (app);
1444   ll->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
1445   ll->app_wrk_index = app_wrk->app_index;
1446   ll->session_index = application_local_listener_index (app, ll);
1447   ll->port = sep_ext->port;
1448   /* Store the original session type for the unbind */
1449   ll->listener_session_type =
1450     session_type_from_proto_and_ip (sep_ext->transport_proto,
1451                                     sep_ext->is_ip4);
1452   ll->transport_listener_index = ~0;
1453   ll->app_index = app->app_index;
1454
1455   app_listener = app_local_listener_alloc (app);
1456   ll->listener_db_index = app_listener->al_index;
1457   app_listener->workers = clib_bitmap_set (app_listener->workers,
1458                                            app_wrk->wrk_map_index, 1);
1459
1460   *handle = application_local_session_handle (ll);
1461   session_lookup_add_session_endpoint (table_index, sep, *handle);
1462
1463   return 0;
1464 }
1465
1466 /**
1467  * Clean up local session table. If we have a listener session use it to
1468  * find the port and proto. If not, the handle must be a local table handle
1469  * so parse it.
1470  */
1471 int
1472 application_stop_local_listen (u32 app_index, u32 wrk_map_index,
1473                                session_handle_t lh)
1474 {
1475   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
1476   u32 table_index, ll_index, server_index;
1477   app_listener_t *app_listener;
1478   app_worker_t *server_wrk;
1479   stream_session_t *sl = 0;
1480   local_session_t *ll, *ls;
1481   application_t *server;
1482
1483   server = application_get (app_index);
1484   table_index = application_local_session_table (server);
1485
1486   /* We have both local and global table binds. Figure from global what
1487    * the sep we should be cleaning up is.
1488    */
1489   if (!session_handle_is_local (lh))
1490     {
1491       sl = listen_session_get_from_handle (lh);
1492       if (!sl || listen_session_get_local_session_endpoint (sl, &sep))
1493         {
1494           clib_warning ("broken listener");
1495           return -1;
1496         }
1497       lh = session_lookup_endpoint_listener (table_index, &sep, 0);
1498       if (lh == SESSION_INVALID_HANDLE)
1499         return -1;
1500     }
1501
1502   local_session_parse_handle (lh, &server_index, &ll_index);
1503   if (PREDICT_FALSE (server_index != app_index))
1504     {
1505       clib_warning ("app %u does not own local handle 0x%lx", app_index, lh);
1506       return -1;
1507     }
1508
1509   ll = application_get_local_listen_session (server, ll_index);
1510   if (PREDICT_FALSE (!ll))
1511     {
1512       clib_warning ("no local listener");
1513       return -1;
1514     }
1515
1516   app_listener = app_local_listener_get (server, ll->listener_db_index);
1517   if (!clib_bitmap_get (app_listener->workers, wrk_map_index))
1518     {
1519       clib_warning ("app wrk %u not listening on handle %lu", wrk_map_index,
1520                     lh);
1521       return -1;
1522     }
1523
1524   server_wrk = application_get_worker (server, wrk_map_index);
1525   /* *INDENT-OFF* */
1526   pool_foreach (ls, server_wrk->local_sessions, ({
1527     if (ls->listener_index == ll->session_index)
1528       application_local_session_disconnect (server_wrk->app_index, ls);
1529   }));
1530   /* *INDENT-ON* */
1531
1532   clib_bitmap_set_no_check (app_listener->workers, wrk_map_index, 0);
1533   if (clib_bitmap_is_zero (app_listener->workers))
1534     {
1535       app_local_listener_free (server, app_listener);
1536       application_local_listener_session_endpoint (ll, &sep);
1537       session_lookup_del_session_endpoint (table_index, &sep);
1538       application_local_listen_session_free (server, ll);
1539     }
1540
1541   return 0;
1542 }
1543
1544 static void
1545 application_local_session_fix_eventds (svm_msg_q_t * sq, svm_msg_q_t * cq)
1546 {
1547   int fd;
1548
1549   /*
1550    * segment manager initializes only the producer eventds, since vpp is
1551    * typically the producer. But for local sessions, we also pass to the
1552    * apps the mqs they listen on for events from peer apps, so they are also
1553    * consumer fds.
1554    */
1555   fd = svm_msg_q_get_producer_eventfd (sq);
1556   svm_msg_q_set_consumer_eventfd (sq, fd);
1557   fd = svm_msg_q_get_producer_eventfd (cq);
1558   svm_msg_q_set_consumer_eventfd (cq, fd);
1559 }
1560
1561 int
1562 application_local_session_connect (app_worker_t * client_wrk,
1563                                    app_worker_t * server_wrk,
1564                                    local_session_t * ll, u32 opaque)
1565 {
1566   u32 seg_size, evt_q_sz, evt_q_elts, margin = 16 << 10;
1567   segment_manager_properties_t *props, *cprops;
1568   u32 round_rx_fifo_sz, round_tx_fifo_sz;
1569   int rv, has_transport, seg_index;
1570   svm_fifo_segment_private_t *seg;
1571   application_t *server, *client;
1572   segment_manager_t *sm;
1573   local_session_t *ls;
1574   svm_msg_q_t *sq, *cq;
1575
1576   ls = application_local_session_alloc (server_wrk);
1577   server = application_get (server_wrk->app_index);
1578   client = application_get (client_wrk->app_index);
1579
1580   props = application_segment_manager_properties (server);
1581   cprops = application_segment_manager_properties (client);
1582   evt_q_elts = props->evt_q_size + cprops->evt_q_size;
1583   evt_q_sz = segment_manager_evt_q_expected_size (evt_q_elts);
1584   round_rx_fifo_sz = 1 << max_log2 (props->rx_fifo_size);
1585   round_tx_fifo_sz = 1 << max_log2 (props->tx_fifo_size);
1586   seg_size = round_rx_fifo_sz + round_tx_fifo_sz + evt_q_sz + margin;
1587
1588   has_transport = session_has_transport ((stream_session_t *) ll);
1589   if (!has_transport)
1590     {
1591       /* Local sessions don't have backing transport */
1592       ls->port = ll->port;
1593       sm = application_get_local_segment_manager (server_wrk);
1594     }
1595   else
1596     {
1597       stream_session_t *sl = (stream_session_t *) ll;
1598       transport_connection_t *tc;
1599       tc = listen_session_get_transport (sl);
1600       ls->port = tc->lcl_port;
1601       sm = app_worker_get_listen_segment_manager (server_wrk, sl);
1602     }
1603
1604   seg_index = segment_manager_add_segment (sm, seg_size);
1605   if (seg_index < 0)
1606     {
1607       clib_warning ("failed to add new cut-through segment");
1608       return seg_index;
1609     }
1610   seg = segment_manager_get_segment_w_lock (sm, seg_index);
1611   sq = segment_manager_alloc_queue (seg, props);
1612   cq = segment_manager_alloc_queue (seg, cprops);
1613
1614   if (props->use_mq_eventfd)
1615     application_local_session_fix_eventds (sq, cq);
1616
1617   ls->server_evt_q = pointer_to_uword (sq);
1618   ls->client_evt_q = pointer_to_uword (cq);
1619   rv = segment_manager_try_alloc_fifos (seg, props->rx_fifo_size,
1620                                         props->tx_fifo_size,
1621                                         &ls->server_rx_fifo,
1622                                         &ls->server_tx_fifo);
1623   if (rv)
1624     {
1625       clib_warning ("failed to add fifos in cut-through segment");
1626       segment_manager_segment_reader_unlock (sm);
1627       goto failed;
1628     }
1629   ls->server_rx_fifo->master_session_index = ls->session_index;
1630   ls->server_tx_fifo->master_session_index = ls->session_index;
1631   ls->server_rx_fifo->master_thread_index = ~0;
1632   ls->server_tx_fifo->master_thread_index = ~0;
1633   ls->svm_segment_index = seg_index;
1634   ls->listener_index = ll->session_index;
1635   ls->client_wrk_index = client_wrk->wrk_index;
1636   ls->client_opaque = opaque;
1637   ls->listener_session_type = ll->session_type;
1638   ls->session_state = SESSION_STATE_READY;
1639
1640   if ((rv = server->cb_fns.add_segment_callback (server->api_client_index,
1641                                                  &seg->ssvm)))
1642     {
1643       clib_warning ("failed to notify server of new segment");
1644       segment_manager_segment_reader_unlock (sm);
1645       goto failed;
1646     }
1647   segment_manager_segment_reader_unlock (sm);
1648   if ((rv = server->cb_fns.session_accept_callback ((stream_session_t *) ls)))
1649     {
1650       clib_warning ("failed to send accept cut-through notify to server");
1651       goto failed;
1652     }
1653   if (server->flags & APP_OPTIONS_FLAGS_IS_BUILTIN)
1654     application_local_session_connect_notify (ls);
1655
1656   return 0;
1657
1658 failed:
1659   if (!has_transport)
1660     segment_manager_del_segment (sm, seg);
1661   return rv;
1662 }
1663
1664 static uword
1665 application_client_local_connect_key (local_session_t * ls)
1666 {
1667   return ((uword) ls->app_wrk_index << 32 | (uword) ls->session_index);
1668 }
1669
1670 static void
1671 application_client_local_connect_key_parse (uword key, u32 * app_wrk_index,
1672                                             u32 * session_index)
1673 {
1674   *app_wrk_index = key >> 32;
1675   *session_index = key & 0xFFFFFFFF;
1676 }
1677
1678 int
1679 application_local_session_connect_notify (local_session_t * ls)
1680 {
1681   svm_fifo_segment_private_t *seg;
1682   app_worker_t *client_wrk, *server_wrk;
1683   segment_manager_t *sm;
1684   application_t *client;
1685   int rv, is_fail = 0;
1686   uword client_key;
1687
1688   client_wrk = app_worker_get (ls->client_wrk_index);
1689   server_wrk = app_worker_get (ls->app_wrk_index);
1690   client = application_get (client_wrk->app_index);
1691
1692   sm = application_get_local_segment_manager_w_session (server_wrk, ls);
1693   seg = segment_manager_get_segment_w_lock (sm, ls->svm_segment_index);
1694   if ((rv = client->cb_fns.add_segment_callback (client->api_client_index,
1695                                                  &seg->ssvm)))
1696     {
1697       clib_warning ("failed to notify client %u of new segment",
1698                     ls->client_wrk_index);
1699       segment_manager_segment_reader_unlock (sm);
1700       application_local_session_disconnect (ls->client_wrk_index, ls);
1701       is_fail = 1;
1702     }
1703   else
1704     {
1705       segment_manager_segment_reader_unlock (sm);
1706     }
1707
1708   client->cb_fns.session_connected_callback (client_wrk->wrk_index,
1709                                              ls->client_opaque,
1710                                              (stream_session_t *) ls,
1711                                              is_fail);
1712
1713   client_key = application_client_local_connect_key (ls);
1714   hash_set (client_wrk->local_connects, client_key, client_key);
1715   return 0;
1716 }
1717
1718 int
1719 application_local_session_cleanup (app_worker_t * client_wrk,
1720                                    app_worker_t * server_wrk,
1721                                    local_session_t * ls)
1722 {
1723   svm_fifo_segment_private_t *seg;
1724   stream_session_t *listener;
1725   segment_manager_t *sm;
1726   uword client_key;
1727   u8 has_transport;
1728
1729   /* Retrieve listener transport type as it is the one that decides where
1730    * the fifos are allocated */
1731   has_transport = application_local_session_listener_has_transport (ls);
1732   if (!has_transport)
1733     sm = application_get_local_segment_manager_w_session (server_wrk, ls);
1734   else
1735     {
1736       listener = listen_session_get (ls->listener_index);
1737       sm = app_worker_get_listen_segment_manager (server_wrk, listener);
1738     }
1739
1740   seg = segment_manager_get_segment (sm, ls->svm_segment_index);
1741   if (client_wrk)
1742     {
1743       client_key = application_client_local_connect_key (ls);
1744       hash_unset (client_wrk->local_connects, client_key);
1745     }
1746
1747   if (!has_transport)
1748     {
1749       application_t *server = application_get (server_wrk->app_index);
1750       server->cb_fns.del_segment_callback (server->api_client_index,
1751                                            &seg->ssvm);
1752       if (client_wrk)
1753         {
1754           application_t *client = application_get (client_wrk->app_index);
1755           client->cb_fns.del_segment_callback (client->api_client_index,
1756                                                &seg->ssvm);
1757         }
1758       segment_manager_del_segment (sm, seg);
1759     }
1760
1761   application_local_session_free (server_wrk, ls);
1762
1763   return 0;
1764 }
1765
1766 int
1767 application_local_session_disconnect (u32 app_index, local_session_t * ls)
1768 {
1769   app_worker_t *client_wrk, *server_wrk;
1770   u8 is_server = 0, is_client = 0;
1771   application_t *app;
1772
1773   app = application_get_if_valid (app_index);
1774   if (!app)
1775     return 0;
1776
1777   client_wrk = app_worker_get_if_valid (ls->client_wrk_index);
1778   server_wrk = app_worker_get (ls->app_wrk_index);
1779
1780   if (server_wrk->app_index == app_index)
1781     is_server = 1;
1782   else if (client_wrk && client_wrk->app_index == app_index)
1783     is_client = 1;
1784
1785   if (!is_server && !is_client)
1786     {
1787       clib_warning ("app %u is neither client nor server for session 0x%lx",
1788                     app_index, application_local_session_handle (ls));
1789       return VNET_API_ERROR_INVALID_VALUE;
1790     }
1791
1792   if (ls->session_state == SESSION_STATE_CLOSED)
1793     return application_local_session_cleanup (client_wrk, server_wrk, ls);
1794
1795   if (app_index == ls->client_wrk_index)
1796     {
1797       mq_send_local_session_disconnected_cb (ls->app_wrk_index, ls);
1798     }
1799   else
1800     {
1801       if (!client_wrk)
1802         {
1803           return application_local_session_cleanup (client_wrk, server_wrk,
1804                                                     ls);
1805         }
1806       else if (ls->session_state < SESSION_STATE_READY)
1807         {
1808           application_t *client = application_get (client_wrk->app_index);
1809           client->cb_fns.session_connected_callback (client_wrk->wrk_index,
1810                                                      ls->client_opaque,
1811                                                      (stream_session_t *) ls,
1812                                                      1 /* is_fail */ );
1813           ls->session_state = SESSION_STATE_CLOSED;
1814           return application_local_session_cleanup (client_wrk, server_wrk,
1815                                                     ls);
1816         }
1817       else
1818         {
1819           mq_send_local_session_disconnected_cb (client_wrk->wrk_index, ls);
1820         }
1821     }
1822
1823   ls->session_state = SESSION_STATE_CLOSED;
1824
1825   return 0;
1826 }
1827
1828 int
1829 application_local_session_disconnect_w_index (u32 app_wrk_index, u32 ls_index)
1830 {
1831   app_worker_t *app_wrk;
1832   local_session_t *ls;
1833   app_wrk = app_worker_get (app_wrk_index);
1834   ls = application_get_local_session (app_wrk, ls_index);
1835   return application_local_session_disconnect (app_wrk_index, ls);
1836 }
1837
1838 void
1839 app_worker_local_sessions_free (app_worker_t * app_wrk)
1840 {
1841   u32 index, server_wrk_index, session_index;
1842   u64 handle, *handles = 0;
1843   app_worker_t *server_wrk;
1844   segment_manager_t *sm;
1845   local_session_t *ls;
1846   int i;
1847
1848   /*
1849    * Local sessions
1850    */
1851   if (app_wrk->local_sessions)
1852     {
1853       /* *INDENT-OFF* */
1854       pool_foreach (ls, app_wrk->local_sessions, ({
1855         application_local_session_disconnect (app_wrk->wrk_index, ls);
1856       }));
1857       /* *INDENT-ON* */
1858     }
1859
1860   /*
1861    * Local connects
1862    */
1863   vec_reset_length (handles);
1864   /* *INDENT-OFF* */
1865   hash_foreach (handle, index, app_wrk->local_connects, ({
1866     vec_add1 (handles, handle);
1867   }));
1868   /* *INDENT-ON* */
1869
1870   for (i = 0; i < vec_len (handles); i++)
1871     {
1872       application_client_local_connect_key_parse (handles[i],
1873                                                   &server_wrk_index,
1874                                                   &session_index);
1875       server_wrk = app_worker_get_if_valid (server_wrk_index);
1876       if (server_wrk)
1877         {
1878           ls = application_get_local_session (server_wrk, session_index);
1879           application_local_session_disconnect (app_wrk->wrk_index, ls);
1880         }
1881     }
1882
1883   sm = segment_manager_get (app_wrk->local_segment_manager);
1884   sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
1885   segment_manager_del (sm);
1886 }
1887
1888 clib_error_t *
1889 vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
1890 {
1891   application_t *app;
1892   app = application_get (a->app_index);
1893   if (!app)
1894     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1895                                    0, "app %u doesn't exist", a->app_index);
1896   app->tls_cert = vec_dup (a->cert);
1897   return 0;
1898 }
1899
1900 clib_error_t *
1901 vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
1902 {
1903   application_t *app;
1904   app = application_get (a->app_index);
1905   if (!app)
1906     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1907                                    0, "app %u doesn't exist", a->app_index);
1908   app->tls_key = vec_dup (a->key);
1909   return 0;
1910 }
1911
1912 u8 *
1913 format_app_worker_listener (u8 * s, va_list * args)
1914 {
1915   app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
1916   u64 handle = va_arg (*args, u64);
1917   u32 sm_index = va_arg (*args, u32);
1918   int verbose = va_arg (*args, int);
1919   stream_session_t *listener;
1920   application_t *app;
1921   u8 *app_name, *str;
1922
1923   if (!app_wrk)
1924     {
1925       if (verbose)
1926         s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
1927                     "Wrk", "API Client", "ListenerID", "SegManager");
1928       else
1929         s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
1930
1931       return s;
1932     }
1933
1934   app = application_get (app_wrk->app_index);
1935   app_name = app_get_name_from_reg_index (app);
1936   listener = listen_session_get_from_handle (handle);
1937   str = format (0, "%U", format_stream_session, listener, verbose);
1938
1939   if (verbose)
1940     {
1941       char buf[32];
1942       sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
1943       s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
1944                   buf, app->api_client_index, handle, sm_index);
1945     }
1946   else
1947     s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
1948
1949   vec_free (app_name);
1950   return s;
1951 }
1952
1953 static void
1954 application_format_listeners (application_t * app, int verbose)
1955 {
1956   vlib_main_t *vm = vlib_get_main ();
1957   app_worker_map_t *wrk_map;
1958   app_worker_t *app_wrk;
1959   u32 sm_index;
1960   u64 handle;
1961
1962   if (!app)
1963     {
1964       vlib_cli_output (vm, "%U", format_app_worker_listener, 0 /* header */ ,
1965                        0, 0, verbose);
1966       return;
1967     }
1968
1969   /* *INDENT-OFF* */
1970   pool_foreach (wrk_map, app->worker_maps, ({
1971     app_wrk = app_worker_get (wrk_map->wrk_index);
1972     if (hash_elts (app_wrk->listeners_table) == 0)
1973       continue;
1974     hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
1975       vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
1976                        handle, sm_index, verbose);
1977     }));
1978   }));
1979   /* *INDENT-ON* */
1980 }
1981
1982 static void
1983 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
1984 {
1985   svm_fifo_segment_private_t *fifo_segment;
1986   vlib_main_t *vm = vlib_get_main ();
1987   segment_manager_t *sm;
1988   u8 *app_name, *s = 0;
1989   application_t *app;
1990
1991   /* Header */
1992   if (!app_wrk)
1993     {
1994       if (verbose)
1995         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
1996                          "API Client", "SegManager");
1997       else
1998         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
1999       return;
2000     }
2001
2002   app = application_get (app_wrk->app_index);
2003   if (app_wrk->connects_seg_manager == (u32) ~ 0)
2004     return;
2005
2006   app_name = app_get_name_from_reg_index (app);
2007
2008   /* Across all fifo segments */
2009   sm = segment_manager_get (app_wrk->connects_seg_manager);
2010
2011   /* *INDENT-OFF* */
2012   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
2013     svm_fifo_t *fifo;
2014     u8 *str;
2015
2016     fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
2017     while (fifo)
2018         {
2019           u32 session_index, thread_index;
2020           stream_session_t *session;
2021
2022           session_index = fifo->master_session_index;
2023           thread_index = fifo->master_thread_index;
2024
2025           session = session_get (session_index, thread_index);
2026           str = format (0, "%U", format_stream_session, session, verbose);
2027
2028           if (verbose)
2029             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
2030                         app->api_client_index, app_wrk->connects_seg_manager);
2031           else
2032             s = format (s, "%-40s%-20s", str, app_name);
2033
2034           vlib_cli_output (vm, "%v", s);
2035           vec_reset_length (s);
2036           vec_free (str);
2037
2038           fifo = fifo->next;
2039         }
2040     vec_free (s);
2041   }));
2042   /* *INDENT-ON* */
2043
2044   vec_free (app_name);
2045 }
2046
2047 static void
2048 application_format_connects (application_t * app, int verbose)
2049 {
2050   app_worker_map_t *wrk_map;
2051   app_worker_t *app_wrk;
2052
2053   if (!app)
2054     {
2055       app_worker_format_connects (0, verbose);
2056       return;
2057     }
2058
2059   /* *INDENT-OFF* */
2060   pool_foreach (wrk_map, app->worker_maps, ({
2061     app_wrk = app_worker_get (wrk_map->wrk_index);
2062     app_worker_format_connects (app_wrk, verbose);
2063   }));
2064   /* *INDENT-ON* */
2065 }
2066
2067 static void
2068 app_worker_format_local_sessions (app_worker_t * app_wrk, int verbose)
2069 {
2070   vlib_main_t *vm = vlib_get_main ();
2071   local_session_t *ls;
2072   transport_proto_t tp;
2073   u8 *conn = 0;
2074
2075   /* Header */
2076   if (app_wrk == 0)
2077     {
2078       vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "ServerApp",
2079                        "ClientApp");
2080       return;
2081     }
2082
2083   if (!pool_elts (app_wrk->local_sessions)
2084       && !pool_elts (app_wrk->local_connects))
2085     return;
2086
2087   /* *INDENT-OFF* */
2088   pool_foreach (ls, app_wrk->local_sessions, ({
2089     tp = session_type_transport_proto(ls->listener_session_type);
2090     conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
2091                    ls->port);
2092     vlib_cli_output (vm, "%-40v%-15u%-20u", conn, ls->app_wrk_index,
2093                      ls->client_wrk_index);
2094     vec_reset_length (conn);
2095   }));
2096   /* *INDENT-ON* */
2097
2098   vec_free (conn);
2099 }
2100
2101 static void
2102 application_format_local_sessions (application_t * app, int verbose)
2103 {
2104   vlib_main_t *vm = vlib_get_main ();
2105   app_worker_map_t *wrk_map;
2106   app_worker_t *app_wrk;
2107   transport_proto_t tp;
2108   local_session_t *ls;
2109   u8 *conn = 0;
2110
2111   if (!app)
2112     {
2113       app_worker_format_local_sessions (0, verbose);
2114       return;
2115     }
2116
2117   /*
2118    * Format local listeners
2119    */
2120
2121   /* *INDENT-OFF* */
2122   pool_foreach (ls, app->local_listen_sessions, ({
2123     tp = session_type_transport_proto (ls->listener_session_type);
2124     conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
2125                    ls->port);
2126     vlib_cli_output (vm, "%-40v%-15u%-20s", conn, ls->app_wrk_index, "*");
2127     vec_reset_length (conn);
2128   }));
2129   /* *INDENT-ON* */
2130
2131   /*
2132    * Format local accepted/connected sessions
2133    */
2134   /* *INDENT-OFF* */
2135   pool_foreach (wrk_map, app->worker_maps, ({
2136     app_wrk = app_worker_get (wrk_map->wrk_index);
2137     app_worker_format_local_sessions (app_wrk, verbose);
2138   }));
2139   /* *INDENT-ON* */
2140 }
2141
2142 static void
2143 app_worker_format_local_connects (app_worker_t * app, int verbose)
2144 {
2145   vlib_main_t *vm = vlib_get_main ();
2146   u32 app_wrk_index, session_index;
2147   app_worker_t *server_wrk;
2148   local_session_t *ls;
2149   uword client_key;
2150   u64 value;
2151
2152   /* Header */
2153   if (app == 0)
2154     {
2155       if (verbose)
2156         vlib_cli_output (vm, "%-40s%-15s%-20s%-10s", "Connection", "App",
2157                          "Peer App", "SegManager");
2158       else
2159         vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "App",
2160                          "Peer App");
2161       return;
2162     }
2163
2164   if (!app->local_connects)
2165     return;
2166
2167   /* *INDENT-OFF* */
2168   hash_foreach (client_key, value, app->local_connects, ({
2169     application_client_local_connect_key_parse (client_key, &app_wrk_index,
2170                                                 &session_index);
2171     server_wrk = app_worker_get (app_wrk_index);
2172     ls = application_get_local_session (server_wrk, session_index);
2173     vlib_cli_output (vm, "%-40s%-15s%-20s", "TODO", ls->app_wrk_index,
2174                      ls->client_wrk_index);
2175   }));
2176   /* *INDENT-ON* */
2177 }
2178
2179 static void
2180 application_format_local_connects (application_t * app, int verbose)
2181 {
2182   app_worker_map_t *wrk_map;
2183   app_worker_t *app_wrk;
2184
2185   if (!app)
2186     {
2187       app_worker_format_local_connects (0, verbose);
2188       return;
2189     }
2190
2191   /* *INDENT-OFF* */
2192   pool_foreach (wrk_map, app->worker_maps, ({
2193     app_wrk = app_worker_get (wrk_map->wrk_index);
2194     app_worker_format_local_connects (app_wrk, verbose);
2195   }));
2196   /* *INDENT-ON* */
2197 }
2198
2199 u8 *
2200 format_application (u8 * s, va_list * args)
2201 {
2202   application_t *app = va_arg (*args, application_t *);
2203   CLIB_UNUSED (int verbose) = va_arg (*args, int);
2204   segment_manager_properties_t *props;
2205   const u8 *app_ns_name;
2206   u8 *app_name;
2207
2208   if (app == 0)
2209     {
2210       if (verbose)
2211         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
2212                     "API Client", "Namespace", "Add seg size", "Rx-f size",
2213                     "Tx-f size");
2214       else
2215         s = format (s, "%-10s%-20s%-15s%-40s", "Index", "Name", "API Client",
2216                     "Namespace");
2217       return s;
2218     }
2219
2220   app_name = app_get_name (app);
2221   app_ns_name = app_namespace_id_from_index (app->ns_index);
2222   props = application_segment_manager_properties (app);
2223   if (verbose)
2224     s = format (s, "%-10u%-20s%-15d%-15u%-15U%-15U%-15U", app->app_index,
2225                 app_name, app->api_client_index, app->ns_index,
2226                 format_memory_size, props->add_segment_size,
2227                 format_memory_size, props->rx_fifo_size, format_memory_size,
2228                 props->tx_fifo_size);
2229   else
2230     s = format (s, "%-10u%-20s%-15d%-40s", app->app_index, app_name,
2231                 app->api_client_index, app_ns_name);
2232   return s;
2233 }
2234
2235 void
2236 application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
2237 {
2238   application_t *app;
2239
2240   if (!pool_elts (app_main.app_pool))
2241     {
2242       vlib_cli_output (vm, "No active server bindings");
2243       return;
2244     }
2245
2246   if (do_local)
2247     {
2248       application_format_local_sessions (0, verbose);
2249       /* *INDENT-OFF* */
2250       pool_foreach (app, app_main.app_pool, ({
2251         application_format_local_sessions (app, verbose);
2252       }));
2253       /* *INDENT-ON* */
2254     }
2255   else
2256     {
2257       application_format_listeners (0, verbose);
2258
2259       /* *INDENT-OFF* */
2260       pool_foreach (app, app_main.app_pool, ({
2261         application_format_listeners (app, verbose);
2262       }));
2263       /* *INDENT-ON* */
2264     }
2265 }
2266
2267 void
2268 application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
2269 {
2270   application_t *app;
2271
2272   if (!pool_elts (app_main.app_pool))
2273     {
2274       vlib_cli_output (vm, "No active apps");
2275       return;
2276     }
2277
2278   if (do_local)
2279     {
2280       application_format_local_connects (0, verbose);
2281
2282       /* *INDENT-OFF* */
2283       pool_foreach (app, app_main.app_pool, ({
2284         application_format_local_connects (app, verbose);
2285       }));
2286       /* *INDENT-ON* */
2287     }
2288   else
2289     {
2290       application_format_connects (0, verbose);
2291
2292       /* *INDENT-OFF* */
2293       pool_foreach (app, app_main.app_pool, ({
2294         application_format_connects (app, verbose);
2295       }));
2296       /* *INDENT-ON* */
2297     }
2298 }
2299
2300 static clib_error_t *
2301 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
2302                      vlib_cli_command_t * cmd)
2303 {
2304   int do_server = 0, do_client = 0, do_local = 0;
2305   application_t *app;
2306   int verbose = 0;
2307
2308   session_cli_return_if_not_enabled ();
2309
2310   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2311     {
2312       if (unformat (input, "server"))
2313         do_server = 1;
2314       else if (unformat (input, "client"))
2315         do_client = 1;
2316       else if (unformat (input, "local"))
2317         do_local = 1;
2318       else if (unformat (input, "verbose"))
2319         verbose = 1;
2320       else
2321         break;
2322     }
2323
2324   if (do_server)
2325     application_format_all_listeners (vm, do_local, verbose);
2326
2327   if (do_client)
2328     application_format_all_clients (vm, do_local, verbose);
2329
2330   /* Print app related info */
2331   if (!do_server && !do_client)
2332     {
2333       vlib_cli_output (vm, "%U", format_application, 0, verbose);
2334       /* *INDENT-OFF* */
2335       pool_foreach (app, app_main.app_pool, ({
2336         vlib_cli_output (vm, "%U", format_application, app, verbose);
2337       }));
2338       /* *INDENT-ON* */
2339     }
2340
2341   return 0;
2342 }
2343
2344 /* *INDENT-OFF* */
2345 VLIB_CLI_COMMAND (show_app_command, static) =
2346 {
2347   .path = "show app",
2348   .short_help = "show app [server|client] [verbose]",
2349   .function = show_app_command_fn,
2350 };
2351 /* *INDENT-ON* */
2352
2353 /*
2354  * fd.io coding-style-patch-verification: ON
2355  *
2356  * Local Variables:
2357  * eval: (c-set-style "gnu")
2358  * End:
2359  */