src/vnet/session/application.c

   1 /*
   2  * Copyright (c) 2017-2019 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/application_local.h>
  20 #include <vnet/session/session.h>
  21
  22 static app_main_t app_main;
  23
  24 #define app_interface_check_thread_and_barrier(_fn, _arg)               \
  25   if (PREDICT_FALSE (!vlib_thread_is_main_w_barrier ()))                \
  26     {                                                                   \
  27       vlib_rpc_call_main_thread (_fn, (u8 *) _arg, sizeof(*_arg));      \
  28       return 0;                                                         \
  29     }
  30
  31 static app_listener_t *
  32 app_listener_alloc (application_t * app)
  33 {
  34   app_listener_t *app_listener;
  35   pool_get (app->listeners, app_listener);
  36   clib_memset (app_listener, 0, sizeof (*app_listener));
  37   app_listener->al_index = app_listener - app->listeners;
  38   app_listener->app_index = app->app_index;
  39   app_listener->session_index = SESSION_INVALID_INDEX;
  40   app_listener->local_index = SESSION_INVALID_INDEX;
  41   return app_listener;
  42 }
  43
  44 app_listener_t *
  45 app_listener_get (application_t * app, u32 app_listener_index)
  46 {
  47   return pool_elt_at_index (app->listeners, app_listener_index);
  48 }
  49
  50 static void
  51 app_listener_free (application_t * app, app_listener_t * app_listener)
  52 {
  53   clib_bitmap_free (app_listener->workers);
  54   pool_put (app->listeners, app_listener);
  55   if (CLIB_DEBUG)
  56     clib_memset (app_listener, 0xfa, sizeof (*app_listener));
  57 }
  58
  59 static u32
  60 app_listener_id (app_listener_t * al)
  61 {
  62   ASSERT (al->app_index < 1 << 16 && al->al_index < 1 << 16);
  63   return (al->app_index << 16 | al->al_index);
  64 }
  65
  66 session_handle_t
  67 app_listener_handle (app_listener_t * al)
  68 {
  69   return ((u64) SESSION_LISTENER_PREFIX << 32 | (u64) app_listener_id (al));
  70 }
  71
  72 static void
  73 app_listener_id_parse (u32 listener_id, u32 * app_index,
  74                        u32 * app_listener_index)
  75 {
  76   *app_index = listener_id >> 16;
  77   *app_listener_index = listener_id & 0xFFFF;
  78 }
  79
  80 void
  81 app_listener_handle_parse (session_handle_t handle, u32 * app_index,
  82                            u32 * app_listener_index)
  83 {
  84   app_listener_id_parse (handle & 0xFFFFFFFF, app_index, app_listener_index);
  85 }
  86
  87 static app_listener_t *
  88 app_listener_get_w_id (u32 listener_id)
  89 {
  90   u32 app_index, app_listener_index;
  91   application_t *app;
  92
  93   app_listener_id_parse (listener_id, &app_index, &app_listener_index);
  94   app = application_get_if_valid (app_index);
  95   if (!app)
  96     return 0;
  97   return app_listener_get (app, app_listener_index);
  98 }
  99
 100 app_listener_t *
 101 app_listener_get_w_session (session_t * ls)
 102 {
 103   application_t *app;
 104
 105   app = application_get_if_valid (ls->app_index);
 106   if (!app)
 107     return 0;
 108   return app_listener_get (app, ls->al_index);
 109 }
 110
 111 app_listener_t *
 112 app_listener_get_w_handle (session_handle_t handle)
 113 {
 114
 115   if (handle >> 32 != SESSION_LISTENER_PREFIX)
 116     return 0;
 117
 118   return app_listener_get_w_id (handle & 0xFFFFFFFF);
 119 }
 120
 121 app_listener_t *
 122 app_listener_lookup (application_t * app, session_endpoint_cfg_t * sep_ext)
 123 {
 124   u32 table_index, fib_proto;
 125   session_endpoint_t *sep;
 126   session_handle_t handle;
 127   session_t *ls;
 128
 129   sep = (session_endpoint_t *) sep_ext;
 130   if (application_has_local_scope (app) && session_endpoint_is_local (sep))
 131     {
 132       table_index = application_local_session_table (app);
 133       handle = session_lookup_endpoint_listener (table_index, sep, 1);
 134       if (handle != SESSION_INVALID_HANDLE)
 135         {
 136           ls = listen_session_get_from_handle (handle);
 137           return app_listener_get_w_session (ls);
 138         }
 139     }
 140
 141   fib_proto = session_endpoint_fib_proto (sep);
 142   table_index = application_session_table (app, fib_proto);
 143   handle = session_lookup_endpoint_listener (table_index, sep, 1);
 144   if (handle != SESSION_INVALID_HANDLE)
 145     {
 146       ls = listen_session_get_from_handle (handle);
 147       return app_listener_get_w_session ((session_t *) ls);
 148     }
 149
 150   return 0;
 151 }
 152
 153 int
 154 app_listener_alloc_and_init (application_t * app,
 155                              session_endpoint_cfg_t * sep,
 156                              app_listener_t ** listener)
 157 {
 158   app_listener_t *app_listener;
 159   transport_connection_t *tc;
 160   local_session_t *ll = 0;
 161   session_handle_t lh;
 162   session_type_t st;
 163   session_t *ls = 0;
 164   u32 al_index;
 165   int rv;
 166
 167   app_listener = app_listener_alloc (app);
 168   al_index = app_listener->al_index;
 169   st = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
 170
 171   /*
 172    * Add session endpoint to local session table. Only binds to "inaddr_any"
 173    * (i.e., zero address) are added to local scope table.
 174    */
 175   if (application_has_local_scope (app)
 176       && session_endpoint_is_local ((session_endpoint_t *) sep))
 177     {
 178       session_type_t local_st;
 179       u32 table_index;
 180
 181       local_st = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
 182                                                  sep->is_ip4);
 183       ls = listen_session_alloc (0, local_st);
 184       ls->app_index = app->app_index;
 185       ls->app_wrk_index = sep->app_wrk_index;
 186       lh = session_handle (ls);
 187
 188       if ((rv = session_listen (ls, sep)))
 189         {
 190           ls = session_get_from_handle (lh);
 191           session_free (ls);
 192           return rv;
 193         }
 194
 195       ls = session_get_from_handle (lh);
 196       app_listener = app_listener_get (app, al_index);
 197       app_listener->local_index = ls->session_index;
 198       ls->al_index = al_index;
 199
 200       table_index = application_local_session_table (app);
 201       session_lookup_add_session_endpoint (table_index,
 202                                            (session_endpoint_t *) sep, lh);
 203     }
 204
 205   if (application_has_global_scope (app))
 206     {
 207       /*
 208        * Start listening on local endpoint for requested transport and scope.
 209        * Creates a stream session with state LISTENING to be used in session
 210        * lookups, prior to establishing connection. Requests transport to
 211        * build it's own specific listening connection.
 212        */
 213       ls = listen_session_alloc (0, st);
 214       ls->app_index = app->app_index;
 215       ls->app_wrk_index = sep->app_wrk_index;
 216
 217       /* Listen pool can be reallocated if the transport is
 218        * recursive (tls) */
 219       lh = listen_session_get_handle (ls);
 220
 221       if ((rv = session_listen (ls, sep)))
 222         {
 223           ls = listen_session_get_from_handle (lh);
 224           session_free (ls);
 225           return rv;
 226         }
 227       ls = listen_session_get_from_handle (lh);
 228       app_listener = app_listener_get (app, al_index);
 229       app_listener->session_index = ls->session_index;
 230       ls->al_index = al_index;
 231
 232       /* Add to the global lookup table after transport was initialized.
 233        * Lookup table needs to be populated only now because sessions
 234        * with cut-through transport are are added to app local tables that
 235        * are not related to network fibs, i.e., cannot be added as
 236        * connections */
 237       tc = session_get_transport (ls);
 238       session_lookup_add_connection (tc, lh);
 239     }
 240
 241   if (!ll && !ls)
 242     {
 243       app_listener_free (app, app_listener);
 244       return -1;
 245     }
 246
 247   *listener = app_listener;
 248   return 0;
 249 }
 250
 251 void
 252 app_listener_cleanup (app_listener_t * al)
 253 {
 254   application_t *app = application_get (al->app_index);
 255   session_t *ls;
 256
 257   if (al->session_index != SESSION_INVALID_INDEX)
 258     {
 259       ls = session_get (al->session_index, 0);
 260       session_stop_listen (ls);
 261       listen_session_free (ls);
 262     }
 263   if (al->local_index != SESSION_INVALID_INDEX)
 264     {
 265       session_endpoint_t sep = SESSION_ENDPOINT_NULL;
 266       u32 table_index;
 267
 268       table_index = application_local_session_table (app);
 269       ls = listen_session_get (al->local_index);
 270       application_local_listener_session_endpoint (ls, &sep);
 271       session_lookup_del_session_endpoint (table_index, &sep);
 272       listen_session_free (ls);
 273     }
 274   app_listener_free (app, al);
 275 }
 276
 277 app_worker_t *
 278 app_listener_select_worker (app_listener_t * al)
 279 {
 280   application_t *app;
 281   u32 wrk_index;
 282
 283   app = application_get (al->app_index);
 284   wrk_index = clib_bitmap_next_set (al->workers, al->accept_rotor + 1);
 285   if (wrk_index == ~0)
 286     wrk_index = clib_bitmap_first_set (al->workers);
 287
 288   ASSERT (wrk_index != ~0);
 289   al->accept_rotor = wrk_index;
 290   return application_get_worker (app, wrk_index);
 291 }
 292
 293 session_t *
 294 app_listener_get_session (app_listener_t * al)
 295 {
 296   if (al->session_index == SESSION_INVALID_INDEX)
 297     return 0;
 298
 299   return listen_session_get (al->session_index);
 300 }
 301
 302 session_t *
 303 app_listener_get_local_session (app_listener_t * al)
 304 {
 305   if (al->local_index == SESSION_INVALID_INDEX)
 306     return 0;
 307   return listen_session_get (al->local_index);
 308 }
 309
 310 static app_worker_map_t *
 311 app_worker_map_alloc (application_t * app)
 312 {
 313   app_worker_map_t *map;
 314   pool_get (app->worker_maps, map);
 315   clib_memset (map, 0, sizeof (*map));
 316   return map;
 317 }
 318
 319 static u32
 320 app_worker_map_index (application_t * app, app_worker_map_t * map)
 321 {
 322   return (map - app->worker_maps);
 323 }
 324
 325 static void
 326 app_worker_map_free (application_t * app, app_worker_map_t * map)
 327 {
 328   pool_put (app->worker_maps, map);
 329 }
 330
 331 static app_worker_map_t *
 332 app_worker_map_get (application_t * app, u32 map_index)
 333 {
 334   if (pool_is_free_index (app->worker_maps, map_index))
 335     return 0;
 336   return pool_elt_at_index (app->worker_maps, map_index);
 337 }
 338
 339 static const u8 *
 340 app_get_name (application_t * app)
 341 {
 342   return app->name;
 343 }
 344
 345 u32
 346 application_session_table (application_t * app, u8 fib_proto)
 347 {
 348   app_namespace_t *app_ns;
 349   app_ns = app_namespace_get (app->ns_index);
 350   if (!application_has_global_scope (app))
 351     return APP_INVALID_INDEX;
 352   if (fib_proto == FIB_PROTOCOL_IP4)
 353     return session_lookup_get_index_for_fib (fib_proto,
 354                                              app_ns->ip4_fib_index);
 355   else
 356     return session_lookup_get_index_for_fib (fib_proto,
 357                                              app_ns->ip6_fib_index);
 358 }
 359
 360 u32
 361 application_local_session_table (application_t * app)
 362 {
 363   app_namespace_t *app_ns;
 364   if (!application_has_local_scope (app))
 365     return APP_INVALID_INDEX;
 366   app_ns = app_namespace_get (app->ns_index);
 367   return app_ns->local_table_index;
 368 }
 369
 370 /**
 371  * Returns app name for app-index
 372  */
 373 const u8 *
 374 application_name_from_index (u32 app_index)
 375 {
 376   application_t *app = application_get (app_index);
 377   if (!app)
 378     return 0;
 379   return app_get_name (app);
 380 }
 381
 382 static void
 383 application_api_table_add (u32 app_index, u32 api_client_index)
 384 {
 385   if (api_client_index != APP_INVALID_INDEX)
 386     hash_set (app_main.app_by_api_client_index, api_client_index, app_index);
 387 }
 388
 389 static void
 390 application_api_table_del (u32 api_client_index)
 391 {
 392   hash_unset (app_main.app_by_api_client_index, api_client_index);
 393 }
 394
 395 static void
 396 application_name_table_add (application_t * app)
 397 {
 398   hash_set_mem (app_main.app_by_name, app->name, app->app_index);
 399 }
 400
 401 static void
 402 application_name_table_del (application_t * app)
 403 {
 404   hash_unset_mem (app_main.app_by_name, app->name);
 405 }
 406
 407 application_t *
 408 application_lookup (u32 api_client_index)
 409 {
 410   uword *p;
 411   p = hash_get (app_main.app_by_api_client_index, api_client_index);
 412   if (p)
 413     return application_get_if_valid (p[0]);
 414
 415   return 0;
 416 }
 417
 418 application_t *
 419 application_lookup_name (const u8 * name)
 420 {
 421   uword *p;
 422   p = hash_get_mem (app_main.app_by_name, name);
 423   if (p)
 424     return application_get (p[0]);
 425
 426   return 0;
 427 }
 428
 429 static application_t *
 430 application_alloc (void)
 431 {
 432   application_t *app;
 433   pool_get (app_main.app_pool, app);
 434   clib_memset (app, 0, sizeof (*app));
 435   app->app_index = app - app_main.app_pool;
 436   return app;
 437 }
 438
 439 application_t *
 440 application_get (u32 app_index)
 441 {
 442   if (app_index == APP_INVALID_INDEX)
 443     return 0;
 444   return pool_elt_at_index (app_main.app_pool, app_index);
 445 }
 446
 447 application_t *
 448 application_get_if_valid (u32 app_index)
 449 {
 450   if (pool_is_free_index (app_main.app_pool, app_index))
 451     return 0;
 452
 453   return pool_elt_at_index (app_main.app_pool, app_index);
 454 }
 455
 456 static void
 457 application_verify_cb_fns (session_cb_vft_t * cb_fns)
 458 {
 459   if (cb_fns->session_accept_callback == 0)
 460     clib_warning ("No accept callback function provided");
 461   if (cb_fns->session_connected_callback == 0)
 462     clib_warning ("No session connected callback function provided");
 463   if (cb_fns->session_disconnect_callback == 0)
 464     clib_warning ("No session disconnect callback function provided");
 465   if (cb_fns->session_reset_callback == 0)
 466     clib_warning ("No session reset callback function provided");
 467 }
 468
 469 /**
 470  * Check app config for given segment type
 471  *
 472  * Returns 1 on success and 0 otherwise
 473  */
 474 static u8
 475 application_verify_cfg (ssvm_segment_type_t st)
 476 {
 477   u8 is_valid;
 478   if (st == SSVM_SEGMENT_MEMFD)
 479     {
 480       is_valid = (session_manager_get_evt_q_segment () != 0);
 481       if (!is_valid)
 482         clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
 483       return is_valid;
 484     }
 485   else if (st == SSVM_SEGMENT_SHM)
 486     {
 487       is_valid = (session_manager_get_evt_q_segment () == 0);
 488       if (!is_valid)
 489         clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
 490       return is_valid;
 491     }
 492   else
 493     return 1;
 494 }
 495
 496 static int
 497 application_alloc_and_init (app_init_args_t * a)
 498 {
 499   ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
 500   segment_manager_properties_t *props;
 501   vl_api_registration_t *reg;
 502   application_t *app;
 503   u64 *options;
 504
 505   app = application_alloc ();
 506   options = a->options;
 507   /*
 508    * Make sure we support the requested configuration
 509    */
 510   if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
 511     {
 512       reg = vl_api_client_index_to_registration (a->api_client_index);
 513       if (!reg)
 514         return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 515       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 516         seg_type = SSVM_SEGMENT_SHM;
 517     }
 518   else
 519     {
 520       if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 521         {
 522           clib_warning ("mq eventfds can only be used if socket transport is "
 523                         "used for api");
 524           return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 525         }
 526       seg_type = SSVM_SEGMENT_PRIVATE;
 527     }
 528
 529   if (!application_verify_cfg (seg_type))
 530     return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 531
 532   /* Check that the obvious things are properly set up */
 533   application_verify_cb_fns (a->session_cb_vft);
 534
 535   app->flags = options[APP_OPTIONS_FLAGS];
 536   app->cb_fns = *a->session_cb_vft;
 537   app->ns_index = options[APP_OPTIONS_NAMESPACE];
 538   app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT];
 539   app->name = vec_dup (a->name);
 540
 541   /* If no scope enabled, default to global */
 542   if (!application_has_global_scope (app)
 543       && !application_has_local_scope (app))
 544     app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 545
 546   props = application_segment_manager_properties (app);
 547   segment_manager_properties_init (props);
 548   props->segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
 549   props->prealloc_fifos = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
 550   if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
 551     {
 552       props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
 553       props->add_segment = 1;
 554     }
 555   if (options[APP_OPTIONS_RX_FIFO_SIZE])
 556     props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
 557   if (options[APP_OPTIONS_TX_FIFO_SIZE])
 558     props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
 559   if (options[APP_OPTIONS_EVT_QUEUE_SIZE])
 560     props->evt_q_size = options[APP_OPTIONS_EVT_QUEUE_SIZE];
 561   if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
 562     props->use_mq_eventfd = 1;
 563   if (options[APP_OPTIONS_TLS_ENGINE])
 564     app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
 565   props->segment_type = seg_type;
 566
 567   /* Add app to lookup by api_client_index table */
 568   if (!application_is_builtin (app))
 569     application_api_table_add (app->app_index, a->api_client_index);
 570   else
 571     application_name_table_add (app);
 572
 573   a->app_index = app->app_index;
 574
 575   APP_DBG ("New app name: %v api index: %u index %u", app->name,
 576            app->api_client_index, app->app_index);
 577
 578   return 0;
 579 }
 580
 581 static void
 582 application_free (application_t * app)
 583 {
 584   app_worker_map_t *wrk_map;
 585   app_worker_t *app_wrk;
 586
 587   /*
 588    * The app event queue allocated in first segment is cleared with
 589    * the segment manager. No need to explicitly free it.
 590    */
 591   APP_DBG ("Delete app name %v api index: %d index: %d", app->name,
 592            app->api_client_index, app->app_index);
 593
 594   if (application_is_proxy (app))
 595     application_remove_proxy (app);
 596
 597   /*
 598    * Free workers
 599    */
 600
 601   /* *INDENT-OFF* */
 602   pool_flush (wrk_map, app->worker_maps, ({
 603     app_wrk = app_worker_get (wrk_map->wrk_index);
 604     app_worker_free (app_wrk);
 605   }));
 606   /* *INDENT-ON* */
 607   pool_free (app->worker_maps);
 608
 609   /*
 610    * Cleanup remaining state
 611    */
 612   if (application_is_builtin (app))
 613     application_name_table_del (app);
 614   vec_free (app->name);
 615   vec_free (app->tls_cert);
 616   vec_free (app->tls_key);
 617   pool_put (app_main.app_pool, app);
 618 }
 619
 620 static void
 621 application_detach_process (application_t * app, u32 api_client_index)
 622 {
 623   vnet_app_worker_add_del_args_t _args = { 0 }, *args = &_args;
 624   app_worker_map_t *wrk_map;
 625   u32 *wrks = 0, *wrk_index;
 626   app_worker_t *app_wrk;
 627
 628   if (api_client_index == ~0)
 629     {
 630       application_free (app);
 631       return;
 632     }
 633
 634   APP_DBG ("Detaching for app %v index %u api client index %u", app->name,
 635            app->app_index, app->api_client_index);
 636
 637   /* *INDENT-OFF* */
 638   pool_foreach (wrk_map, app->worker_maps, ({
 639     app_wrk = app_worker_get (wrk_map->wrk_index);
 640     if (app_wrk->api_client_index == api_client_index)
 641       vec_add1 (wrks, app_wrk->wrk_index);
 642   }));
 643   /* *INDENT-ON* */
 644
 645   if (!vec_len (wrks))
 646     {
 647       clib_warning ("no workers for app %u api_index %u", app->app_index,
 648                     api_client_index);
 649       return;
 650     }
 651
 652   args->app_index = app->app_index;
 653   args->api_client_index = api_client_index;
 654   vec_foreach (wrk_index, wrks)
 655   {
 656     app_wrk = app_worker_get (wrk_index[0]);
 657     args->wrk_map_index = app_wrk->wrk_map_index;
 658     args->is_add = 0;
 659     vnet_app_worker_add_del (args);
 660   }
 661   vec_free (wrks);
 662 }
 663
 664 app_worker_t *
 665 application_get_worker (application_t * app, u32 wrk_map_index)
 666 {
 667   app_worker_map_t *map;
 668   map = app_worker_map_get (app, wrk_map_index);
 669   if (!map)
 670     return 0;
 671   return app_worker_get (map->wrk_index);
 672 }
 673
 674 app_worker_t *
 675 application_get_default_worker (application_t * app)
 676 {
 677   return application_get_worker (app, 0);
 678 }
 679
 680 u32
 681 application_n_workers (application_t * app)
 682 {
 683   return pool_elts (app->worker_maps);
 684 }
 685
 686 app_worker_t *
 687 application_listener_select_worker (session_t * ls)
 688 {
 689   app_listener_t *al;
 690
 691   al = app_listener_get_w_session (ls);
 692   return app_listener_select_worker (al);
 693 }
 694
 695 int
 696 application_alloc_worker_and_init (application_t * app, app_worker_t ** wrk)
 697 {
 698   app_worker_map_t *wrk_map;
 699   app_worker_t *app_wrk;
 700   segment_manager_t *sm;
 701   int rv;
 702
 703   app_wrk = app_worker_alloc (app);
 704   wrk_map = app_worker_map_alloc (app);
 705   wrk_map->wrk_index = app_wrk->wrk_index;
 706   app_wrk->wrk_map_index = app_worker_map_index (app, wrk_map);
 707
 708   /*
 709    * Setup first segment manager
 710    */
 711   sm = segment_manager_new ();
 712   sm->app_wrk_index = app_wrk->wrk_index;
 713
 714   if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
 715                                   app->sm_properties.prealloc_fifos)))
 716     {
 717       app_worker_free (app_wrk);
 718       return rv;
 719     }
 720   sm->first_is_protected = 1;
 721
 722   /*
 723    * Setup app worker
 724    */
 725   app_wrk->first_segment_manager = segment_manager_index (sm);
 726   app_wrk->listeners_table = hash_create (0, sizeof (u64));
 727   app_wrk->event_queue = segment_manager_event_queue (sm);
 728   app_wrk->app_is_builtin = application_is_builtin (app);
 729
 730   /*
 731    * Segment manager for local sessions
 732    */
 733   sm = segment_manager_new ();
 734   sm->app_wrk_index = app_wrk->wrk_index;
 735   app_wrk->local_segment_manager = segment_manager_index (sm);
 736   app_wrk->local_connects = hash_create (0, sizeof (u64));
 737
 738   *wrk = app_wrk;
 739
 740   return 0;
 741 }
 742
 743 int
 744 vnet_app_worker_add_del (vnet_app_worker_add_del_args_t * a)
 745 {
 746   svm_fifo_segment_private_t *fs;
 747   app_worker_map_t *wrk_map;
 748   app_worker_t *app_wrk;
 749   segment_manager_t *sm;
 750   application_t *app;
 751   int rv;
 752
 753   app = application_get (a->app_index);
 754   if (!app)
 755     return VNET_API_ERROR_INVALID_VALUE;
 756
 757   if (a->is_add)
 758     {
 759       if ((rv = application_alloc_worker_and_init (app, &app_wrk)))
 760         return rv;
 761
 762       /* Map worker api index to the app */
 763       app_wrk->api_client_index = a->api_client_index;
 764       application_api_table_add (app->app_index, a->api_client_index);
 765
 766       sm = segment_manager_get (app_wrk->first_segment_manager);
 767       fs = segment_manager_get_segment_w_lock (sm, 0);
 768       a->segment = &fs->ssvm;
 769       a->segment_handle = segment_manager_segment_handle (sm, fs);
 770       segment_manager_segment_reader_unlock (sm);
 771       a->evt_q = app_wrk->event_queue;
 772       a->wrk_map_index = app_wrk->wrk_map_index;
 773     }
 774   else
 775     {
 776       wrk_map = app_worker_map_get (app, a->wrk_map_index);
 777       if (!wrk_map)
 778         return VNET_API_ERROR_INVALID_VALUE;
 779
 780       app_wrk = app_worker_get (wrk_map->wrk_index);
 781       if (!app_wrk)
 782         return VNET_API_ERROR_INVALID_VALUE;
 783
 784       application_api_table_del (app_wrk->api_client_index);
 785       app_worker_free (app_wrk);
 786       app_worker_map_free (app, wrk_map);
 787       if (application_n_workers (app) == 0)
 788         application_free (app);
 789     }
 790   return 0;
 791 }
 792
 793 static int
 794 app_validate_namespace (u8 * namespace_id, u64 secret, u32 * app_ns_index)
 795 {
 796   app_namespace_t *app_ns;
 797   if (vec_len (namespace_id) == 0)
 798     {
 799       /* Use default namespace */
 800       *app_ns_index = 0;
 801       return 0;
 802     }
 803
 804   *app_ns_index = app_namespace_index_from_id (namespace_id);
 805   if (*app_ns_index == APP_NAMESPACE_INVALID_INDEX)
 806     return VNET_API_ERROR_APP_INVALID_NS;
 807   app_ns = app_namespace_get (*app_ns_index);
 808   if (!app_ns)
 809     return VNET_API_ERROR_APP_INVALID_NS;
 810   if (app_ns->ns_secret != secret)
 811     return VNET_API_ERROR_APP_WRONG_NS_SECRET;
 812   return 0;
 813 }
 814
 815 static u8 *
 816 app_name_from_api_index (u32 api_client_index)
 817 {
 818   vl_api_registration_t *regp;
 819   regp = vl_api_client_index_to_registration (api_client_index);
 820   if (regp)
 821     return format (0, "%s%c", regp->name, 0);
 822
 823   clib_warning ("api client index %u does not have an api registration!",
 824                 api_client_index);
 825   return format (0, "unknown%c", 0);
 826 }
 827
 828 /**
 829  * Attach application to vpp
 830  *
 831  * Allocates a vpp app, i.e., a structure that keeps back pointers
 832  * to external app and a segment manager for shared memory fifo based
 833  * communication with the external app.
 834  */
 835 int
 836 vnet_application_attach (vnet_app_attach_args_t * a)
 837 {
 838   svm_fifo_segment_private_t *fs;
 839   application_t *app = 0;
 840   app_worker_t *app_wrk;
 841   segment_manager_t *sm;
 842   u32 app_ns_index = 0;
 843   u8 *app_name = 0;
 844   u64 secret;
 845   int rv;
 846
 847   if (a->api_client_index != APP_INVALID_INDEX)
 848     app = application_lookup (a->api_client_index);
 849   else if (a->name)
 850     app = application_lookup_name (a->name);
 851   else
 852     return VNET_API_ERROR_INVALID_VALUE;
 853
 854   if (app)
 855     return VNET_API_ERROR_APP_ALREADY_ATTACHED;
 856
 857   if (a->api_client_index != APP_INVALID_INDEX)
 858     {
 859       app_name = app_name_from_api_index (a->api_client_index);
 860       a->name = app_name;
 861     }
 862
 863   secret = a->options[APP_OPTIONS_NAMESPACE_SECRET];
 864   if ((rv = app_validate_namespace (a->namespace_id, secret, &app_ns_index)))
 865     return rv;
 866   a->options[APP_OPTIONS_NAMESPACE] = app_ns_index;
 867
 868   if ((rv = application_alloc_and_init ((app_init_args_t *) a)))
 869     return rv;
 870
 871   app = application_get (a->app_index);
 872   if ((rv = application_alloc_worker_and_init (app, &app_wrk)))
 873     return rv;
 874
 875   a->app_evt_q = app_wrk->event_queue;
 876   app_wrk->api_client_index = a->api_client_index;
 877   sm = segment_manager_get (app_wrk->first_segment_manager);
 878   fs = segment_manager_get_segment_w_lock (sm, 0);
 879
 880   if (application_is_proxy (app))
 881     application_setup_proxy (app);
 882
 883   ASSERT (vec_len (fs->ssvm.name) <= 128);
 884   a->segment = &fs->ssvm;
 885   a->segment_handle = segment_manager_segment_handle (sm, fs);
 886
 887   segment_manager_segment_reader_unlock (sm);
 888   vec_free (app_name);
 889   return 0;
 890 }
 891
 892 /**
 893  * Detach application from vpp
 894  */
 895 int
 896 vnet_application_detach (vnet_app_detach_args_t * a)
 897 {
 898   application_t *app;
 899
 900   app = application_get_if_valid (a->app_index);
 901   if (!app)
 902     {
 903       clib_warning ("app not attached");
 904       return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 905     }
 906
 907   app_interface_check_thread_and_barrier (vnet_application_detach, a);
 908   application_detach_process (app, a->api_client_index);
 909   return 0;
 910 }
 911
 912
 913 static u8
 914 session_endpoint_in_ns (session_endpoint_t * sep)
 915 {
 916   u8 is_lep = session_endpoint_is_local (sep);
 917   if (!is_lep && sep->sw_if_index != ENDPOINT_INVALID_INDEX
 918       && !ip_interface_has_address (sep->sw_if_index, &sep->ip, sep->is_ip4))
 919     {
 920       clib_warning ("sw_if_index %u not configured with ip %U",
 921                     sep->sw_if_index, format_ip46_address, &sep->ip,
 922                     sep->is_ip4);
 923       return 0;
 924     }
 925   return (is_lep || ip_is_local (sep->fib_index, &sep->ip, sep->is_ip4));
 926 }
 927
 928 static void
 929 session_endpoint_update_for_app (session_endpoint_cfg_t * sep,
 930                                  application_t * app, u8 is_connect)
 931 {
 932   app_namespace_t *app_ns;
 933   u32 ns_index, fib_index;
 934
 935   ns_index = app->ns_index;
 936
 937   /* App is a transport proto, so fetch the calling app's ns */
 938   if (app->flags & APP_OPTIONS_FLAGS_IS_TRANSPORT_APP)
 939     ns_index = sep->ns_index;
 940
 941   app_ns = app_namespace_get (ns_index);
 942   if (!app_ns)
 943     return;
 944
 945   /* Ask transport and network to bind to/connect using local interface
 946    * that "supports" app's namespace. This will fix our local connection
 947    * endpoint.
 948    */
 949
 950   /* If in default namespace and user requested a fib index use it */
 951   if (ns_index == 0 && sep->fib_index != ENDPOINT_INVALID_INDEX)
 952     fib_index = sep->fib_index;
 953   else
 954     fib_index = sep->is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index;
 955   sep->peer.fib_index = fib_index;
 956   sep->fib_index = fib_index;
 957
 958   if (!is_connect)
 959     {
 960       sep->sw_if_index = app_ns->sw_if_index;
 961     }
 962   else
 963     {
 964       if (app_ns->sw_if_index != APP_NAMESPACE_INVALID_INDEX
 965           && sep->peer.sw_if_index != ENDPOINT_INVALID_INDEX
 966           && sep->peer.sw_if_index != app_ns->sw_if_index)
 967         clib_warning ("Local sw_if_index different from app ns sw_if_index");
 968
 969       sep->peer.sw_if_index = app_ns->sw_if_index;
 970     }
 971 }
 972
 973 int
 974 vnet_listen (vnet_listen_args_t * a)
 975 {
 976   app_listener_t *app_listener;
 977   app_worker_t *app_wrk;
 978   application_t *app;
 979   int rv;
 980
 981   app = application_get_if_valid (a->app_index);
 982   if (!app)
 983     return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 984
 985   app_wrk = application_get_worker (app, a->wrk_map_index);
 986   if (!app_wrk)
 987     return VNET_API_ERROR_INVALID_VALUE;
 988
 989   a->sep_ext.app_wrk_index = app_wrk->wrk_index;
 990
 991   session_endpoint_update_for_app (&a->sep_ext, app, 0 /* is_connect */ );
 992   if (!session_endpoint_in_ns (&a->sep))
 993     return VNET_API_ERROR_INVALID_VALUE_2;
 994
 995   /*
 996    * Check if we already have an app listener
 997    */
 998   app_listener = app_listener_lookup (app, &a->sep_ext);
 999   if (app_listener)
1000     {
1001       if (app_listener->app_index != app->app_index)
1002         return VNET_API_ERROR_ADDRESS_IN_USE;
1003       if (app_worker_start_listen (app_wrk, app_listener))
1004         return -1;
1005       a->handle = app_listener_handle (app_listener);
1006       return 0;
1007     }
1008
1009   /*
1010    * Create new app listener
1011    */
1012   if ((rv = app_listener_alloc_and_init (app, &a->sep_ext, &app_listener)))
1013     return rv;
1014
1015   if ((rv = app_worker_start_listen (app_wrk, app_listener)))
1016     {
1017       app_listener_cleanup (app_listener);
1018       return rv;
1019     }
1020
1021   a->handle = app_listener_handle (app_listener);
1022   return 0;
1023 }
1024
1025 int
1026 vnet_connect (vnet_connect_args_t * a)
1027 {
1028   app_worker_t *server_wrk, *client_wrk;
1029   application_t *client;
1030   app_listener_t *al;
1031   u32 table_index;
1032   session_t *ls;
1033   u8 fib_proto;
1034   session_handle_t lh;
1035
1036   if (session_endpoint_is_zero (&a->sep))
1037     return VNET_API_ERROR_INVALID_VALUE;
1038
1039   client = application_get (a->app_index);
1040   session_endpoint_update_for_app (&a->sep_ext, client, 1 /* is_connect */ );
1041   client_wrk = application_get_worker (client, a->wrk_map_index);
1042
1043   /*
1044    * First check the local scope for locally attached destinations.
1045    * If we have local scope, we pass *all* connects through it since we may
1046    * have special policy rules even for non-local destinations, think proxy.
1047    */
1048   if (application_has_local_scope (client))
1049     {
1050       table_index = application_local_session_table (client);
1051       lh = session_lookup_local_endpoint (table_index, &a->sep);
1052       if (lh == SESSION_DROP_HANDLE)
1053         return VNET_API_ERROR_APP_CONNECT_FILTERED;
1054
1055       if (lh == SESSION_INVALID_HANDLE)
1056         goto global_scope;
1057
1058       ls = listen_session_get_from_handle (lh);
1059       al = app_listener_get_w_session (ls);
1060
1061       /*
1062        * Break loop if rule in local table points to connecting app. This
1063        * can happen if client is a generic proxy. Route connect through
1064        * global table instead.
1065        */
1066       if (al->app_index == a->app_index)
1067         goto global_scope;
1068
1069       server_wrk = app_listener_select_worker (al);
1070       return app_worker_local_session_connect (client_wrk, server_wrk, ls,
1071                                                a->api_context);
1072     }
1073
1074   /*
1075    * If nothing found, check the global scope for locally attached
1076    * destinations. Make sure first that we're allowed to.
1077    */
1078
1079 global_scope:
1080   if (session_endpoint_is_local (&a->sep))
1081     return VNET_API_ERROR_SESSION_CONNECT;
1082
1083   if (!application_has_global_scope (client))
1084     return VNET_API_ERROR_APP_CONNECT_SCOPE;
1085
1086   fib_proto = session_endpoint_fib_proto (&a->sep);
1087   table_index = application_session_table (client, fib_proto);
1088   ls = session_lookup_listener (table_index, &a->sep);
1089   if (ls)
1090     {
1091       al = app_listener_get_w_session (ls);
1092       server_wrk = app_listener_select_worker (al);
1093       return app_worker_local_session_connect (client_wrk, server_wrk, ls,
1094                                                a->api_context);
1095     }
1096
1097   /*
1098    * Not connecting to a local server, propagate to transport
1099    */
1100   if (app_worker_connect_session (client_wrk, &a->sep, a->api_context))
1101     return VNET_API_ERROR_SESSION_CONNECT;
1102   return 0;
1103 }
1104
1105 int
1106 vnet_unlisten (vnet_unlisten_args_t * a)
1107 {
1108   app_worker_t *app_wrk;
1109   app_listener_t *al;
1110   application_t *app;
1111
1112   if (!(app = application_get_if_valid (a->app_index)))
1113     return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1114
1115   al = app_listener_get_w_handle (a->handle);
1116   if (al->app_index != app->app_index)
1117     {
1118       clib_warning ("app doesn't own handle %llu!", a->handle);
1119       return -1;
1120     }
1121
1122   app_wrk = application_get_worker (app, a->wrk_map_index);
1123   if (!app_wrk)
1124     {
1125       clib_warning ("no app %u worker %u", app->app_index, a->wrk_map_index);
1126       return -1;
1127     }
1128
1129   return app_worker_stop_listen (app_wrk, al);
1130 }
1131
1132 int
1133 vnet_disconnect_session (vnet_disconnect_args_t * a)
1134 {
1135   if (session_handle_is_local (a->handle))
1136     {
1137       app_worker_t *client_wrk, *server_wrk;
1138       local_session_t *ls;
1139       u32 wrk_index = ~0;
1140
1141       /* Disconnect reply came to worker 1 not main thread */
1142       app_interface_check_thread_and_barrier (vnet_disconnect_session, a);
1143
1144       if (!(ls = app_worker_get_local_session_from_handle (a->handle)))
1145         return 0;
1146
1147       client_wrk = app_worker_get_if_valid (ls->client_wrk_index);
1148       server_wrk = app_worker_get (ls->app_wrk_index);
1149
1150       if (server_wrk->app_index == a->app_index)
1151         wrk_index = server_wrk->wrk_index;
1152       else if (client_wrk && client_wrk->app_index == a->app_index)
1153         wrk_index = client_wrk->wrk_index;
1154
1155       if (wrk_index == ~0)
1156         {
1157           clib_warning ("app %u does not own session 0x%lx", a->app_index,
1158                         application_local_session_handle (ls));
1159           return VNET_API_ERROR_INVALID_VALUE;
1160         }
1161
1162       return app_worker_local_session_disconnect (wrk_index, ls);
1163     }
1164   else
1165     {
1166       app_worker_t *app_wrk;
1167       session_t *s;
1168
1169       s = session_get_from_handle_if_valid (a->handle);
1170       if (!s)
1171         return VNET_API_ERROR_INVALID_VALUE;
1172       app_wrk = app_worker_get (s->app_wrk_index);
1173       if (app_wrk->app_index != a->app_index)
1174         return VNET_API_ERROR_INVALID_VALUE;
1175
1176       /* We're peeking into another's thread pool. Make sure */
1177       ASSERT (s->session_index == session_index_from_handle (a->handle));
1178
1179       session_close (s);
1180     }
1181   return 0;
1182 }
1183
1184 int
1185 application_change_listener_owner (session_t * s, app_worker_t * app_wrk)
1186 {
1187   app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
1188   app_listener_t *app_listener;
1189   application_t *app;
1190
1191   if (!old_wrk)
1192     return -1;
1193
1194   hash_unset (old_wrk->listeners_table, listen_session_get_handle (s));
1195   if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL
1196       && s->rx_fifo)
1197     segment_manager_dealloc_fifos (s->rx_fifo->segment_index, s->rx_fifo,
1198                                    s->tx_fifo);
1199
1200   app = application_get (old_wrk->app_index);
1201   if (!app)
1202     return -1;
1203
1204   app_listener = app_listener_get (app, s->al_index);
1205
1206   /* Only remove from lb for now */
1207   app_listener->workers = clib_bitmap_set (app_listener->workers,
1208                                            old_wrk->wrk_map_index, 0);
1209
1210   if (app_worker_start_listen (app_wrk, app_listener))
1211     return -1;
1212
1213   s->app_wrk_index = app_wrk->wrk_index;
1214
1215   return 0;
1216 }
1217
1218 int
1219 application_is_proxy (application_t * app)
1220 {
1221   return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
1222 }
1223
1224 int
1225 application_is_builtin (application_t * app)
1226 {
1227   return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
1228 }
1229
1230 int
1231 application_is_builtin_proxy (application_t * app)
1232 {
1233   return (application_is_proxy (app) && application_is_builtin (app));
1234 }
1235
1236 u8
1237 application_has_local_scope (application_t * app)
1238 {
1239   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1240 }
1241
1242 u8
1243 application_has_global_scope (application_t * app)
1244 {
1245   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1246 }
1247
1248 u8
1249 application_use_mq_for_ctrl (application_t * app)
1250 {
1251   return app->flags & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
1252 }
1253
1254 static clib_error_t *
1255 application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
1256                                         u8 transport_proto, u8 is_start)
1257 {
1258   app_namespace_t *app_ns = app_namespace_get (app->ns_index);
1259   u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
1260   session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
1261   transport_connection_t *tc;
1262   app_worker_t *app_wrk;
1263   app_listener_t *al;
1264   session_t *s;
1265   u32 flags;
1266
1267   /* TODO decide if we want proxy to be enabled for all workers */
1268   app_wrk = application_get_default_worker (app);
1269   if (is_start)
1270     {
1271       s = app_worker_first_listener (app_wrk, fib_proto, transport_proto);
1272       if (!s)
1273         {
1274           sep.is_ip4 = is_ip4;
1275           sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1276           sep.sw_if_index = app_ns->sw_if_index;
1277           sep.transport_proto = transport_proto;
1278           sep.app_wrk_index = app_wrk->wrk_index;       /* only default */
1279
1280           /* force global scope listener */
1281           flags = app->flags;
1282           app->flags &= ~APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1283           app_listener_alloc_and_init (app, &sep, &al);
1284           app->flags = flags;
1285
1286           app_worker_start_listen (app_wrk, al);
1287           s = listen_session_get (al->session_index);
1288           s->enqueue_epoch = SESSION_PROXY_LISTENER_INDEX;
1289         }
1290     }
1291   else
1292     {
1293       s = app_worker_proxy_listener (app_wrk, fib_proto, transport_proto);
1294       ASSERT (s);
1295     }
1296
1297   tc = listen_session_get_transport (s);
1298
1299   if (!ip_is_zero (&tc->lcl_ip, 1))
1300     {
1301       u32 sti;
1302       sep.is_ip4 = is_ip4;
1303       sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1304       sep.transport_proto = transport_proto;
1305       sep.port = 0;
1306       sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
1307       if (is_start)
1308         session_lookup_add_session_endpoint (sti,
1309                                              (session_endpoint_t *) & sep,
1310                                              s->session_index);
1311       else
1312         session_lookup_del_session_endpoint (sti,
1313                                              (session_endpoint_t *) & sep);
1314     }
1315
1316   return 0;
1317 }
1318
1319 static void
1320 application_start_stop_proxy_local_scope (application_t * app,
1321                                           u8 transport_proto, u8 is_start)
1322 {
1323   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
1324   app_namespace_t *app_ns;
1325   app_ns = app_namespace_get (app->ns_index);
1326   sep.is_ip4 = 1;
1327   sep.transport_proto = transport_proto;
1328   sep.port = 0;
1329
1330   if (is_start)
1331     {
1332       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1333                                            app->app_index);
1334       sep.is_ip4 = 0;
1335       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1336                                            app->app_index);
1337     }
1338   else
1339     {
1340       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1341       sep.is_ip4 = 0;
1342       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1343     }
1344 }
1345
1346 void
1347 application_start_stop_proxy (application_t * app,
1348                               transport_proto_t transport_proto, u8 is_start)
1349 {
1350   if (application_has_local_scope (app))
1351     application_start_stop_proxy_local_scope (app, transport_proto, is_start);
1352
1353   if (application_has_global_scope (app))
1354     {
1355       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4,
1356                                               transport_proto, is_start);
1357       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6,
1358                                               transport_proto, is_start);
1359     }
1360 }
1361
1362 void
1363 application_setup_proxy (application_t * app)
1364 {
1365   u16 transports = app->proxied_transports;
1366   transport_proto_t tp;
1367
1368   ASSERT (application_is_proxy (app));
1369
1370   /* *INDENT-OFF* */
1371   transport_proto_foreach (tp, ({
1372     if (transports & (1 << tp))
1373       application_start_stop_proxy (app, tp, 1);
1374   }));
1375   /* *INDENT-ON* */
1376 }
1377
1378 void
1379 application_remove_proxy (application_t * app)
1380 {
1381   u16 transports = app->proxied_transports;
1382   transport_proto_t tp;
1383
1384   ASSERT (application_is_proxy (app));
1385
1386   /* *INDENT-OFF* */
1387   transport_proto_foreach (tp, ({
1388     if (transports & (1 << tp))
1389       application_start_stop_proxy (app, tp, 0);
1390   }));
1391   /* *INDENT-ON* */
1392 }
1393
1394 segment_manager_properties_t *
1395 application_segment_manager_properties (application_t * app)
1396 {
1397   return &app->sm_properties;
1398 }
1399
1400 segment_manager_properties_t *
1401 application_get_segment_manager_properties (u32 app_index)
1402 {
1403   application_t *app = application_get (app_index);
1404   return &app->sm_properties;
1405 }
1406
1407 clib_error_t *
1408 vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
1409 {
1410   application_t *app;
1411   app = application_get (a->app_index);
1412   if (!app)
1413     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1414                                    0, "app %u doesn't exist", a->app_index);
1415   app->tls_cert = vec_dup (a->cert);
1416   return 0;
1417 }
1418
1419 clib_error_t *
1420 vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
1421 {
1422   application_t *app;
1423   app = application_get (a->app_index);
1424   if (!app)
1425     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1426                                    0, "app %u doesn't exist", a->app_index);
1427   app->tls_key = vec_dup (a->key);
1428   return 0;
1429 }
1430
1431 static void
1432 application_format_listeners (application_t * app, int verbose)
1433 {
1434   vlib_main_t *vm = vlib_get_main ();
1435   app_worker_map_t *wrk_map;
1436   app_worker_t *app_wrk;
1437   u32 sm_index;
1438   u64 handle;
1439
1440   if (!app)
1441     {
1442       vlib_cli_output (vm, "%U", format_app_worker_listener, 0 /* header */ ,
1443                        0, 0, verbose);
1444       return;
1445     }
1446
1447   /* *INDENT-OFF* */
1448   pool_foreach (wrk_map, app->worker_maps, ({
1449     app_wrk = app_worker_get (wrk_map->wrk_index);
1450     if (hash_elts (app_wrk->listeners_table) == 0)
1451       continue;
1452     hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
1453       vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
1454                        handle, sm_index, verbose);
1455     }));
1456   }));
1457   /* *INDENT-ON* */
1458 }
1459
1460 static void
1461 application_format_connects (application_t * app, int verbose)
1462 {
1463   app_worker_map_t *wrk_map;
1464   app_worker_t *app_wrk;
1465
1466   if (!app)
1467     {
1468       app_worker_format_connects (0, verbose);
1469       return;
1470     }
1471
1472   /* *INDENT-OFF* */
1473   pool_foreach (wrk_map, app->worker_maps, ({
1474     app_wrk = app_worker_get (wrk_map->wrk_index);
1475     app_worker_format_connects (app_wrk, verbose);
1476   }));
1477   /* *INDENT-ON* */
1478 }
1479
1480 static void
1481 application_format_local_sessions (application_t * app, int verbose)
1482 {
1483   app_worker_map_t *wrk_map;
1484   app_worker_t *app_wrk;
1485
1486   if (!app)
1487     {
1488       app_worker_format_local_sessions (0, verbose);
1489       return;
1490     }
1491
1492   /*
1493    * Format local accepted/connected sessions
1494    */
1495   /* *INDENT-OFF* */
1496   pool_foreach (wrk_map, app->worker_maps, ({
1497     app_wrk = app_worker_get (wrk_map->wrk_index);
1498     app_worker_format_local_sessions (app_wrk, verbose);
1499   }));
1500   /* *INDENT-ON* */
1501 }
1502
1503 static void
1504 application_format_local_connects (application_t * app, int verbose)
1505 {
1506   app_worker_map_t *wrk_map;
1507   app_worker_t *app_wrk;
1508
1509   if (!app)
1510     {
1511       app_worker_format_local_connects (0, verbose);
1512       return;
1513     }
1514
1515   /* *INDENT-OFF* */
1516   pool_foreach (wrk_map, app->worker_maps, ({
1517     app_wrk = app_worker_get (wrk_map->wrk_index);
1518     app_worker_format_local_connects (app_wrk, verbose);
1519   }));
1520   /* *INDENT-ON* */
1521 }
1522
1523 u8 *
1524 format_application (u8 * s, va_list * args)
1525 {
1526   application_t *app = va_arg (*args, application_t *);
1527   CLIB_UNUSED (int verbose) = va_arg (*args, int);
1528   segment_manager_properties_t *props;
1529   const u8 *app_ns_name, *app_name;
1530   app_worker_map_t *wrk_map;
1531   app_worker_t *app_wrk;
1532
1533   if (app == 0)
1534     {
1535       if (!verbose)
1536         s = format (s, "%-10s%-20s%-40s", "Index", "Name", "Namespace");
1537       return s;
1538     }
1539
1540   app_name = app_get_name (app);
1541   app_ns_name = app_namespace_id_from_index (app->ns_index);
1542   props = application_segment_manager_properties (app);
1543   if (!verbose)
1544     {
1545       s = format (s, "%-10u%-20s%-40s", app->app_index, app_name,
1546                   app_ns_name);
1547       return s;
1548     }
1549
1550   s = format (s, "app-name %s app-index %u ns-index %u seg-size %U\n",
1551               app_name, app->app_index, app->ns_index,
1552               format_memory_size, props->add_segment_size);
1553   s = format (s, "rx-fifo-size %U tx-fifo-size %U workers:\n",
1554               format_memory_size, props->rx_fifo_size,
1555               format_memory_size, props->tx_fifo_size);
1556
1557   /* *INDENT-OFF* */
1558   pool_foreach (wrk_map, app->worker_maps, ({
1559       app_wrk = app_worker_get (wrk_map->wrk_index);
1560       s = format (s, "%U", format_app_worker, app_wrk);
1561   }));
1562   /* *INDENT-ON* */
1563
1564   return s;
1565 }
1566
1567 void
1568 application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
1569 {
1570   application_t *app;
1571
1572   if (!pool_elts (app_main.app_pool))
1573     {
1574       vlib_cli_output (vm, "No active server bindings");
1575       return;
1576     }
1577
1578   if (do_local)
1579     {
1580       application_format_local_sessions (0, verbose);
1581       /* *INDENT-OFF* */
1582       pool_foreach (app, app_main.app_pool, ({
1583         application_format_local_sessions (app, verbose);
1584       }));
1585       /* *INDENT-ON* */
1586     }
1587   else
1588     {
1589       application_format_listeners (0, verbose);
1590
1591       /* *INDENT-OFF* */
1592       pool_foreach (app, app_main.app_pool, ({
1593         application_format_listeners (app, verbose);
1594       }));
1595       /* *INDENT-ON* */
1596     }
1597 }
1598
1599 void
1600 application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
1601 {
1602   application_t *app;
1603
1604   if (!pool_elts (app_main.app_pool))
1605     {
1606       vlib_cli_output (vm, "No active apps");
1607       return;
1608     }
1609
1610   if (do_local)
1611     {
1612       application_format_local_connects (0, verbose);
1613
1614       /* *INDENT-OFF* */
1615       pool_foreach (app, app_main.app_pool, ({
1616         application_format_local_connects (app, verbose);
1617       }));
1618       /* *INDENT-ON* */
1619     }
1620   else
1621     {
1622       application_format_connects (0, verbose);
1623
1624       /* *INDENT-OFF* */
1625       pool_foreach (app, app_main.app_pool, ({
1626         application_format_connects (app, verbose);
1627       }));
1628       /* *INDENT-ON* */
1629     }
1630 }
1631
1632 static clib_error_t *
1633 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
1634                      vlib_cli_command_t * cmd)
1635 {
1636   int do_server = 0, do_client = 0, do_local = 0;
1637   application_t *app;
1638   u32 app_index = ~0;
1639   int verbose = 0;
1640
1641   session_cli_return_if_not_enabled ();
1642
1643   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1644     {
1645       if (unformat (input, "server"))
1646         do_server = 1;
1647       else if (unformat (input, "client"))
1648         do_client = 1;
1649       else if (unformat (input, "local"))
1650         do_local = 1;
1651       else if (unformat (input, "%u", &app_index))
1652         ;
1653       else if (unformat (input, "verbose"))
1654         verbose = 1;
1655       else
1656         return clib_error_return (0, "unknown input `%U'",
1657                                   format_unformat_error, input);
1658     }
1659
1660   if (do_server)
1661     {
1662       application_format_all_listeners (vm, do_local, verbose);
1663       return 0;
1664     }
1665
1666   if (do_client)
1667     {
1668       application_format_all_clients (vm, do_local, verbose);
1669       return 0;
1670     }
1671
1672   if (app_index != ~0)
1673     {
1674       app = application_get_if_valid (app_index);
1675       if (!app)
1676         return clib_error_return (0, "No app with index %u", app_index);
1677
1678       vlib_cli_output (vm, "%U", format_application, app, /* verbose */ 1);
1679       return 0;
1680     }
1681
1682   /* Print app related info */
1683   if (!do_server && !do_client)
1684     {
1685       vlib_cli_output (vm, "%U", format_application, 0, 0);
1686       /* *INDENT-OFF* */
1687       pool_foreach (app, app_main.app_pool, ({
1688         vlib_cli_output (vm, "%U", format_application, app, 0);
1689       }));
1690       /* *INDENT-ON* */
1691     }
1692
1693   return 0;
1694 }
1695
1696 /* *INDENT-OFF* */
1697 VLIB_CLI_COMMAND (show_app_command, static) =
1698 {
1699   .path = "show app",
1700   .short_help = "show app [server|client] [verbose]",
1701   .function = show_app_command_fn,
1702 };
1703 /* *INDENT-ON* */
1704
1705 /*
1706  * fd.io coding-style-patch-verification: ON
1707  *
1708  * Local Variables:
1709  * eval: (c-set-style "gnu")
1710  * End:
1711  */