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     ns_index = sep->ns_index;
 959
 960   app_ns = app_namespace_get (ns_index);
 961   if (!app_ns)
 962     return;
 963
 964   /* Ask transport and network to bind to/connect using local interface
 965    * that "supports" app's namespace. This will fix our local connection
 966    * endpoint.
 967    */
 968
 969   /* If in default namespace and user requested a fib index use it */
 970   if (ns_index == 0 && sep->fib_index != ENDPOINT_INVALID_INDEX)
 971     fib_index = sep->fib_index;
 972   else
 973     fib_index = sep->is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index;
 974   sep->peer.fib_index = fib_index;
 975   sep->fib_index = fib_index;
 976
 977   if (!is_connect)
 978     {
 979       sep->sw_if_index = app_ns->sw_if_index;
 980     }
 981   else
 982     {
 983       if (app_ns->sw_if_index != APP_NAMESPACE_INVALID_INDEX
 984           && sep->peer.sw_if_index != ENDPOINT_INVALID_INDEX
 985           && sep->peer.sw_if_index != app_ns->sw_if_index)
 986         clib_warning ("Local sw_if_index different from app ns sw_if_index");
 987
 988       sep->peer.sw_if_index = app_ns->sw_if_index;
 989     }
 990 }
 991
 992 int
 993 vnet_listen (vnet_listen_args_t * a)
 994 {
 995   app_listener_t *app_listener;
 996   app_worker_t *app_wrk;
 997   application_t *app;
 998   int rv;
 999
1000   app = application_get_if_valid (a->app_index);
1001   if (!app)
1002     return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1003
1004   app_wrk = application_get_worker (app, a->wrk_map_index);
1005   if (!app_wrk)
1006     return VNET_API_ERROR_INVALID_VALUE;
1007
1008   a->sep_ext.app_wrk_index = app_wrk->wrk_index;
1009
1010   session_endpoint_update_for_app (&a->sep_ext, app, 0 /* is_connect */ );
1011   if (!session_endpoint_in_ns (&a->sep))
1012     return VNET_API_ERROR_INVALID_VALUE_2;
1013
1014   /*
1015    * Check if we already have an app listener
1016    */
1017   app_listener = app_listener_lookup (app, &a->sep_ext);
1018   if (app_listener)
1019     {
1020       if (app_listener->app_index != app->app_index)
1021         return VNET_API_ERROR_ADDRESS_IN_USE;
1022       if (app_worker_start_listen (app_wrk, app_listener))
1023         return -1;
1024       a->handle = app_listener_handle (app_listener);
1025       return 0;
1026     }
1027
1028   /*
1029    * Create new app listener
1030    */
1031   if ((rv = app_listener_alloc_and_init (app, &a->sep_ext, &app_listener)))
1032     return rv;
1033
1034   if ((rv = app_worker_start_listen (app_wrk, app_listener)))
1035     {
1036       app_listener_cleanup (app_listener);
1037       return rv;
1038     }
1039
1040   a->handle = app_listener_handle (app_listener);
1041   return 0;
1042 }
1043
1044 int
1045 vnet_connect (vnet_connect_args_t * a)
1046 {
1047   app_worker_t *server_wrk, *client_wrk;
1048   application_t *client;
1049   local_session_t *ll;
1050   app_listener_t *al;
1051   u32 table_index;
1052   session_t *ls;
1053   u8 fib_proto;
1054   u64 lh;
1055
1056   if (session_endpoint_is_zero (&a->sep))
1057     return VNET_API_ERROR_INVALID_VALUE;
1058
1059   client = application_get (a->app_index);
1060   session_endpoint_update_for_app (&a->sep_ext, client, 1 /* is_connect */ );
1061   client_wrk = application_get_worker (client, a->wrk_map_index);
1062
1063   /*
1064    * First check the local scope for locally attached destinations.
1065    * If we have local scope, we pass *all* connects through it since we may
1066    * have special policy rules even for non-local destinations, think proxy.
1067    */
1068   if (application_has_local_scope (client))
1069     {
1070       table_index = application_local_session_table (client);
1071       lh = session_lookup_local_endpoint (table_index, &a->sep);
1072       if (lh == SESSION_DROP_HANDLE)
1073         return VNET_API_ERROR_APP_CONNECT_FILTERED;
1074
1075       if (lh == SESSION_INVALID_HANDLE)
1076         goto global_scope;
1077
1078       ll = application_get_local_listener_w_handle (lh);
1079       al = app_listener_get_w_session ((session_t *) ll);
1080
1081       /*
1082        * Break loop if rule in local table points to connecting app. This
1083        * can happen if client is a generic proxy. Route connect through
1084        * global table instead.
1085        */
1086       if (al->app_index == a->app_index)
1087         goto global_scope;
1088
1089       server_wrk = app_listener_select_worker (al);
1090       return app_worker_local_session_connect (client_wrk, server_wrk, ll,
1091                                                a->api_context);
1092     }
1093
1094   /*
1095    * If nothing found, check the global scope for locally attached
1096    * destinations. Make sure first that we're allowed to.
1097    */
1098
1099 global_scope:
1100   if (session_endpoint_is_local (&a->sep))
1101     return VNET_API_ERROR_SESSION_CONNECT;
1102
1103   if (!application_has_global_scope (client))
1104     return VNET_API_ERROR_APP_CONNECT_SCOPE;
1105
1106   fib_proto = session_endpoint_fib_proto (&a->sep);
1107   table_index = application_session_table (client, fib_proto);
1108   ls = session_lookup_listener (table_index, &a->sep);
1109   if (ls)
1110     {
1111       al = app_listener_get_w_session (ls);
1112       server_wrk = app_listener_select_worker (al);
1113       ll = (local_session_t *) ls;
1114       return app_worker_local_session_connect (client_wrk, server_wrk, ll,
1115                                                a->api_context);
1116     }
1117
1118   /*
1119    * Not connecting to a local server, propagate to transport
1120    */
1121   if (app_worker_connect_session (client_wrk, &a->sep, a->api_context))
1122     return VNET_API_ERROR_SESSION_CONNECT;
1123   return 0;
1124 }
1125
1126 int
1127 vnet_unlisten (vnet_unlisten_args_t * a)
1128 {
1129   app_worker_t *app_wrk;
1130   app_listener_t *al;
1131   application_t *app;
1132
1133   if (!(app = application_get_if_valid (a->app_index)))
1134     return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1135
1136   al = app_listener_get_w_handle (a->handle);
1137   if (al->app_index != app->app_index)
1138     {
1139       clib_warning ("app doesn't own handle %llu!", a->handle);
1140       return -1;
1141     }
1142
1143   app_wrk = application_get_worker (app, a->wrk_map_index);
1144   if (!app_wrk)
1145     {
1146       clib_warning ("no app %u worker %u", app->app_index, a->wrk_map_index);
1147       return -1;
1148     }
1149
1150   return app_worker_stop_listen (app_wrk, al);
1151 }
1152
1153 int
1154 vnet_disconnect_session (vnet_disconnect_args_t * a)
1155 {
1156   if (session_handle_is_local (a->handle))
1157     {
1158       local_session_t *ls;
1159
1160       /* Disconnect reply came to worker 1 not main thread */
1161       app_interface_check_thread_and_barrier (vnet_disconnect_session, a);
1162
1163       if (!(ls = app_worker_get_local_session_from_handle (a->handle)))
1164         return 0;
1165
1166       return app_worker_local_session_disconnect (a->app_index, ls);
1167     }
1168   else
1169     {
1170       app_worker_t *app_wrk;
1171       session_t *s;
1172
1173       s = session_get_from_handle_if_valid (a->handle);
1174       if (!s)
1175         return VNET_API_ERROR_INVALID_VALUE;
1176       app_wrk = app_worker_get (s->app_wrk_index);
1177       if (app_wrk->app_index != a->app_index)
1178         return VNET_API_ERROR_INVALID_VALUE;
1179
1180       /* We're peeking into another's thread pool. Make sure */
1181       ASSERT (s->session_index == session_index_from_handle (a->handle));
1182
1183       session_close (s);
1184     }
1185   return 0;
1186 }
1187
1188 int
1189 application_change_listener_owner (session_t * s, app_worker_t * app_wrk)
1190 {
1191   app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
1192   app_listener_t *app_listener;
1193   application_t *app;
1194
1195   if (!old_wrk)
1196     return -1;
1197
1198   hash_unset (old_wrk->listeners_table, listen_session_get_handle (s));
1199   if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL
1200       && s->rx_fifo)
1201     segment_manager_dealloc_fifos (s->rx_fifo->segment_index, s->rx_fifo,
1202                                    s->tx_fifo);
1203
1204   app = application_get (old_wrk->app_index);
1205   if (!app)
1206     return -1;
1207
1208   app_listener = app_listener_get (app, s->al_index);
1209
1210   /* Only remove from lb for now */
1211   app_listener->workers = clib_bitmap_set (app_listener->workers,
1212                                            old_wrk->wrk_map_index, 0);
1213
1214   if (app_worker_start_listen (app_wrk, app_listener))
1215     return -1;
1216
1217   s->app_wrk_index = app_wrk->wrk_index;
1218
1219   return 0;
1220 }
1221
1222 int
1223 application_is_proxy (application_t * app)
1224 {
1225   return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
1226 }
1227
1228 int
1229 application_is_builtin (application_t * app)
1230 {
1231   return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
1232 }
1233
1234 int
1235 application_is_builtin_proxy (application_t * app)
1236 {
1237   return (application_is_proxy (app) && application_is_builtin (app));
1238 }
1239
1240 u8
1241 application_has_local_scope (application_t * app)
1242 {
1243   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1244 }
1245
1246 u8
1247 application_has_global_scope (application_t * app)
1248 {
1249   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1250 }
1251
1252 u8
1253 application_use_mq_for_ctrl (application_t * app)
1254 {
1255   return app->flags & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
1256 }
1257
1258 static clib_error_t *
1259 application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
1260                                         u8 transport_proto, u8 is_start)
1261 {
1262   app_namespace_t *app_ns = app_namespace_get (app->ns_index);
1263   u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
1264   session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
1265   transport_connection_t *tc;
1266   app_worker_t *app_wrk;
1267   app_listener_t *al;
1268   session_t *s;
1269   u32 flags;
1270
1271   /* TODO decide if we want proxy to be enabled for all workers */
1272   app_wrk = application_get_default_worker (app);
1273   if (is_start)
1274     {
1275       s = app_worker_first_listener (app_wrk, fib_proto, transport_proto);
1276       if (!s)
1277         {
1278           sep.is_ip4 = is_ip4;
1279           sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1280           sep.sw_if_index = app_ns->sw_if_index;
1281           sep.transport_proto = transport_proto;
1282           sep.app_wrk_index = app_wrk->wrk_index;       /* only default */
1283
1284           /* force global scope listener */
1285           flags = app->flags;
1286           app->flags &= ~APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1287           app_listener_alloc_and_init (app, &sep, &al);
1288           app->flags = flags;
1289
1290           app_worker_start_listen (app_wrk, al);
1291           s = listen_session_get (al->session_index);
1292           s->enqueue_epoch = SESSION_PROXY_LISTENER_INDEX;
1293         }
1294     }
1295   else
1296     {
1297       s = app_worker_proxy_listener (app_wrk, fib_proto, transport_proto);
1298       ASSERT (s);
1299     }
1300
1301   tc = listen_session_get_transport (s);
1302
1303   if (!ip_is_zero (&tc->lcl_ip, 1))
1304     {
1305       u32 sti;
1306       sep.is_ip4 = is_ip4;
1307       sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1308       sep.transport_proto = transport_proto;
1309       sep.port = 0;
1310       sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
1311       if (is_start)
1312         session_lookup_add_session_endpoint (sti,
1313                                              (session_endpoint_t *) & sep,
1314                                              s->session_index);
1315       else
1316         session_lookup_del_session_endpoint (sti,
1317                                              (session_endpoint_t *) & sep);
1318     }
1319
1320   return 0;
1321 }
1322
1323 static void
1324 application_start_stop_proxy_local_scope (application_t * app,
1325                                           u8 transport_proto, u8 is_start)
1326 {
1327   session_endpoint_t sep = SESSION_ENDPOINT_NULL;
1328   app_namespace_t *app_ns;
1329   app_ns = app_namespace_get (app->ns_index);
1330   sep.is_ip4 = 1;
1331   sep.transport_proto = transport_proto;
1332   sep.port = 0;
1333
1334   if (is_start)
1335     {
1336       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1337                                            app->app_index);
1338       sep.is_ip4 = 0;
1339       session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1340                                            app->app_index);
1341     }
1342   else
1343     {
1344       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1345       sep.is_ip4 = 0;
1346       session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1347     }
1348 }
1349
1350 void
1351 application_start_stop_proxy (application_t * app,
1352                               transport_proto_t transport_proto, u8 is_start)
1353 {
1354   if (application_has_local_scope (app))
1355     application_start_stop_proxy_local_scope (app, transport_proto, is_start);
1356
1357   if (application_has_global_scope (app))
1358     {
1359       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4,
1360                                               transport_proto, is_start);
1361       application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6,
1362                                               transport_proto, is_start);
1363     }
1364 }
1365
1366 void
1367 application_setup_proxy (application_t * app)
1368 {
1369   u16 transports = app->proxied_transports;
1370   transport_proto_t tp;
1371
1372   ASSERT (application_is_proxy (app));
1373
1374   /* *INDENT-OFF* */
1375   transport_proto_foreach (tp, ({
1376     if (transports & (1 << tp))
1377       application_start_stop_proxy (app, tp, 1);
1378   }));
1379   /* *INDENT-ON* */
1380 }
1381
1382 void
1383 application_remove_proxy (application_t * app)
1384 {
1385   u16 transports = app->proxied_transports;
1386   transport_proto_t tp;
1387
1388   ASSERT (application_is_proxy (app));
1389
1390   /* *INDENT-OFF* */
1391   transport_proto_foreach (tp, ({
1392     if (transports & (1 << tp))
1393       application_start_stop_proxy (app, tp, 0);
1394   }));
1395   /* *INDENT-ON* */
1396 }
1397
1398 segment_manager_properties_t *
1399 application_segment_manager_properties (application_t * app)
1400 {
1401   return &app->sm_properties;
1402 }
1403
1404 segment_manager_properties_t *
1405 application_get_segment_manager_properties (u32 app_index)
1406 {
1407   application_t *app = application_get (app_index);
1408   return &app->sm_properties;
1409 }
1410
1411 clib_error_t *
1412 vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
1413 {
1414   application_t *app;
1415   app = application_get (a->app_index);
1416   if (!app)
1417     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1418                                    0, "app %u doesn't exist", a->app_index);
1419   app->tls_cert = vec_dup (a->cert);
1420   return 0;
1421 }
1422
1423 clib_error_t *
1424 vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
1425 {
1426   application_t *app;
1427   app = application_get (a->app_index);
1428   if (!app)
1429     return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1430                                    0, "app %u doesn't exist", a->app_index);
1431   app->tls_key = vec_dup (a->key);
1432   return 0;
1433 }
1434
1435 static void
1436 application_format_listeners (application_t * app, int verbose)
1437 {
1438   vlib_main_t *vm = vlib_get_main ();
1439   app_worker_map_t *wrk_map;
1440   app_worker_t *app_wrk;
1441   u32 sm_index;
1442   u64 handle;
1443
1444   if (!app)
1445     {
1446       vlib_cli_output (vm, "%U", format_app_worker_listener, 0 /* header */ ,
1447                        0, 0, verbose);
1448       return;
1449     }
1450
1451   /* *INDENT-OFF* */
1452   pool_foreach (wrk_map, app->worker_maps, ({
1453     app_wrk = app_worker_get (wrk_map->wrk_index);
1454     if (hash_elts (app_wrk->listeners_table) == 0)
1455       continue;
1456     hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
1457       vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
1458                        handle, sm_index, verbose);
1459     }));
1460   }));
1461   /* *INDENT-ON* */
1462 }
1463
1464 static void
1465 application_format_connects (application_t * app, int verbose)
1466 {
1467   app_worker_map_t *wrk_map;
1468   app_worker_t *app_wrk;
1469
1470   if (!app)
1471     {
1472       app_worker_format_connects (0, verbose);
1473       return;
1474     }
1475
1476   /* *INDENT-OFF* */
1477   pool_foreach (wrk_map, app->worker_maps, ({
1478     app_wrk = app_worker_get (wrk_map->wrk_index);
1479     app_worker_format_connects (app_wrk, verbose);
1480   }));
1481   /* *INDENT-ON* */
1482 }
1483
1484 static void
1485 application_format_local_sessions (application_t * app, int verbose)
1486 {
1487   vlib_main_t *vm = vlib_get_main ();
1488   app_worker_map_t *wrk_map;
1489   app_worker_t *app_wrk;
1490   transport_proto_t tp;
1491   local_session_t *ls;
1492   u8 *conn = 0;
1493
1494   if (!app)
1495     {
1496       app_worker_format_local_sessions (0, verbose);
1497       return;
1498     }
1499
1500   /*
1501    * Format local listeners
1502    */
1503
1504   /* *INDENT-OFF* */
1505   pool_foreach (ls, app->local_listen_sessions, ({
1506     tp = session_type_transport_proto (ls->listener_session_type);
1507     conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
1508                    ls->port);
1509     vlib_cli_output (vm, "%-40v%-15u%-20s", conn, ls->app_wrk_index, "*");
1510     vec_reset_length (conn);
1511   }));
1512   /* *INDENT-ON* */
1513
1514   /*
1515    * Format local accepted/connected sessions
1516    */
1517   /* *INDENT-OFF* */
1518   pool_foreach (wrk_map, app->worker_maps, ({
1519     app_wrk = app_worker_get (wrk_map->wrk_index);
1520     app_worker_format_local_sessions (app_wrk, verbose);
1521   }));
1522   /* *INDENT-ON* */
1523 }
1524
1525 static void
1526 application_format_local_connects (application_t * app, int verbose)
1527 {
1528   app_worker_map_t *wrk_map;
1529   app_worker_t *app_wrk;
1530
1531   if (!app)
1532     {
1533       app_worker_format_local_connects (0, verbose);
1534       return;
1535     }
1536
1537   /* *INDENT-OFF* */
1538   pool_foreach (wrk_map, app->worker_maps, ({
1539     app_wrk = app_worker_get (wrk_map->wrk_index);
1540     app_worker_format_local_connects (app_wrk, verbose);
1541   }));
1542   /* *INDENT-ON* */
1543 }
1544
1545 u8 *
1546 format_application (u8 * s, va_list * args)
1547 {
1548   application_t *app = va_arg (*args, application_t *);
1549   CLIB_UNUSED (int verbose) = va_arg (*args, int);
1550   segment_manager_properties_t *props;
1551   const u8 *app_ns_name, *app_name;
1552   app_worker_map_t *wrk_map;
1553   app_worker_t *app_wrk;
1554
1555   if (app == 0)
1556     {
1557       if (!verbose)
1558         s = format (s, "%-10s%-20s%-40s", "Index", "Name", "Namespace");
1559       return s;
1560     }
1561
1562   app_name = app_get_name (app);
1563   app_ns_name = app_namespace_id_from_index (app->ns_index);
1564   props = application_segment_manager_properties (app);
1565   if (!verbose)
1566     {
1567       s = format (s, "%-10u%-20s%-40s", app->app_index, app_name,
1568                   app_ns_name);
1569       return s;
1570     }
1571
1572   s = format (s, "app-name %s app-index %u ns-index %u seg-size %U\n",
1573               app_name, app->app_index, app->ns_index,
1574               format_memory_size, props->add_segment_size);
1575   s = format (s, "rx-fifo-size %U tx-fifo-size %U workers:\n",
1576               format_memory_size, props->rx_fifo_size,
1577               format_memory_size, props->tx_fifo_size);
1578
1579   /* *INDENT-OFF* */
1580   pool_foreach (wrk_map, app->worker_maps, ({
1581       app_wrk = app_worker_get (wrk_map->wrk_index);
1582       s = format (s, "%U", format_app_worker, app_wrk);
1583   }));
1584   /* *INDENT-ON* */
1585
1586   return s;
1587 }
1588
1589 void
1590 application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
1591 {
1592   application_t *app;
1593
1594   if (!pool_elts (app_main.app_pool))
1595     {
1596       vlib_cli_output (vm, "No active server bindings");
1597       return;
1598     }
1599
1600   if (do_local)
1601     {
1602       application_format_local_sessions (0, verbose);
1603       /* *INDENT-OFF* */
1604       pool_foreach (app, app_main.app_pool, ({
1605         application_format_local_sessions (app, verbose);
1606       }));
1607       /* *INDENT-ON* */
1608     }
1609   else
1610     {
1611       application_format_listeners (0, verbose);
1612
1613       /* *INDENT-OFF* */
1614       pool_foreach (app, app_main.app_pool, ({
1615         application_format_listeners (app, verbose);
1616       }));
1617       /* *INDENT-ON* */
1618     }
1619 }
1620
1621 void
1622 application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
1623 {
1624   application_t *app;
1625
1626   if (!pool_elts (app_main.app_pool))
1627     {
1628       vlib_cli_output (vm, "No active apps");
1629       return;
1630     }
1631
1632   if (do_local)
1633     {
1634       application_format_local_connects (0, verbose);
1635
1636       /* *INDENT-OFF* */
1637       pool_foreach (app, app_main.app_pool, ({
1638         application_format_local_connects (app, verbose);
1639       }));
1640       /* *INDENT-ON* */
1641     }
1642   else
1643     {
1644       application_format_connects (0, verbose);
1645
1646       /* *INDENT-OFF* */
1647       pool_foreach (app, app_main.app_pool, ({
1648         application_format_connects (app, verbose);
1649       }));
1650       /* *INDENT-ON* */
1651     }
1652 }
1653
1654 static clib_error_t *
1655 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
1656                      vlib_cli_command_t * cmd)
1657 {
1658   int do_server = 0, do_client = 0, do_local = 0;
1659   application_t *app;
1660   u32 app_index = ~0;
1661   int verbose = 0;
1662
1663   session_cli_return_if_not_enabled ();
1664
1665   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1666     {
1667       if (unformat (input, "server"))
1668         do_server = 1;
1669       else if (unformat (input, "client"))
1670         do_client = 1;
1671       else if (unformat (input, "local"))
1672         do_local = 1;
1673       else if (unformat (input, "%u", &app_index))
1674         ;
1675       else if (unformat (input, "verbose"))
1676         verbose = 1;
1677       else
1678         return clib_error_return (0, "unknown input `%U'",
1679                                   format_unformat_error, input);
1680     }
1681
1682   if (do_server)
1683     {
1684       application_format_all_listeners (vm, do_local, verbose);
1685       return 0;
1686     }
1687
1688   if (do_client)
1689     {
1690       application_format_all_clients (vm, do_local, verbose);
1691       return 0;
1692     }
1693
1694   if (app_index != ~0)
1695     {
1696       app = application_get_if_valid (app_index);
1697       if (!app)
1698         return clib_error_return (0, "No app with index %u", app_index);
1699
1700       vlib_cli_output (vm, "%U", format_application, app, /* verbose */ 1);
1701       return 0;
1702     }
1703
1704   /* Print app related info */
1705   if (!do_server && !do_client)
1706     {
1707       vlib_cli_output (vm, "%U", format_application, 0, 0);
1708       /* *INDENT-OFF* */
1709       pool_foreach (app, app_main.app_pool, ({
1710         vlib_cli_output (vm, "%U", format_application, app, 0);
1711       }));
1712       /* *INDENT-ON* */
1713     }
1714
1715   return 0;
1716 }
1717
1718 /* *INDENT-OFF* */
1719 VLIB_CLI_COMMAND (show_app_command, static) =
1720 {
1721   .path = "show app",
1722   .short_help = "show app [server|client] [verbose]",
1723   .function = show_app_command_fn,
1724 };
1725 /* *INDENT-ON* */
1726
1727 /*
1728  * fd.io coding-style-patch-verification: ON
1729  *
1730  * Local Variables:
1731  * eval: (c-set-style "gnu")
1732  * End:
1733  */