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