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