FD.io VPP  v20.01-48-g3e0dafb74
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 
520  /* Check that the obvious things are properly set up */
521  application_verify_cb_fns (a->session_cb_vft);
522 
523  app->flags = options[APP_OPTIONS_FLAGS];
524  app->cb_fns = *a->session_cb_vft;
525  app->ns_index = options[APP_OPTIONS_NAMESPACE];
527  app->name = vec_dup (a->name);
528 
529  /* If no scope enabled, default to global */
531  && !application_has_local_scope (app))
532  app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
533 
536  props->segment_size = options[APP_OPTIONS_SEGMENT_SIZE];
537  props->prealloc_fifos = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
538  if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
539  {
540  props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
541  props->add_segment = 1;
542  }
543  if (options[APP_OPTIONS_RX_FIFO_SIZE])
544  props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
545  if (options[APP_OPTIONS_TX_FIFO_SIZE])
546  props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
547  if (options[APP_OPTIONS_EVT_QUEUE_SIZE])
548  props->evt_q_size = options[APP_OPTIONS_EVT_QUEUE_SIZE];
549  if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
550  props->use_mq_eventfd = 1;
551  if (options[APP_OPTIONS_TLS_ENGINE])
552  app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
553  props->segment_type = seg_type;
554 
555  /* Add app to lookup by api_client_index table */
556  if (!application_is_builtin (app))
557  application_api_table_add (app->app_index, a->api_client_index);
558  else
560 
561  a->app_index = app->app_index;
562 
563  APP_DBG ("New app name: %v api index: %u index %u", app->name,
564  a->api_client_index, app->app_index);
565 
566  return 0;
567 }
568 
569 static void
571 {
572  app_worker_map_t *wrk_map;
573  app_worker_t *app_wrk;
574 
575  /*
576  * The app event queue allocated in first segment is cleared with
577  * the segment manager. No need to explicitly free it.
578  */
579  APP_DBG ("Delete app name %v index: %d", app->name, app->app_index);
580 
581  if (application_is_proxy (app))
583 
584  /*
585  * Free workers
586  */
587 
588  /* *INDENT-OFF* */
589  pool_flush (wrk_map, app->worker_maps, ({
590  app_wrk = app_worker_get (wrk_map->wrk_index);
591  app_worker_free (app_wrk);
592  }));
593  /* *INDENT-ON* */
594  pool_free (app->worker_maps);
595 
596  /*
597  * Cleanup remaining state
598  */
599  if (application_is_builtin (app))
601  vec_free (app->name);
602  pool_put (app_main.app_pool, app);
603 }
604 
605 static void
607 {
608  vnet_app_worker_add_del_args_t _args = { 0 }, *args = &_args;
609  app_worker_map_t *wrk_map;
610  u32 *wrks = 0, *wrk_index;
611  app_worker_t *app_wrk;
612 
613  if (api_client_index == ~0)
614  {
615  application_free (app);
616  return;
617  }
618 
619  APP_DBG ("Detaching for app %v index %u api client index %u", app->name,
620  app->app_index, api_client_index);
621 
622  /* *INDENT-OFF* */
623  pool_foreach (wrk_map, app->worker_maps, ({
624  app_wrk = app_worker_get (wrk_map->wrk_index);
625  if (app_wrk->api_client_index == api_client_index)
626  vec_add1 (wrks, app_wrk->wrk_index);
627  }));
628  /* *INDENT-ON* */
629 
630  if (!vec_len (wrks))
631  {
632  clib_warning ("no workers for app %u api_index %u", app->app_index,
633  api_client_index);
634  return;
635  }
636 
637  args->app_index = app->app_index;
638  args->api_client_index = api_client_index;
639  vec_foreach (wrk_index, wrks)
640  {
641  app_wrk = app_worker_get (wrk_index[0]);
642  args->wrk_map_index = app_wrk->wrk_map_index;
643  args->is_add = 0;
645  }
646  vec_free (wrks);
647 }
648 
649 app_worker_t *
651 {
652  app_worker_map_t *map;
653  map = app_worker_map_get (app, wrk_map_index);
654  if (!map)
655  return 0;
656  return app_worker_get (map->wrk_index);
657 }
658 
659 app_worker_t *
661 {
662  return application_get_worker (app, 0);
663 }
664 
665 u32
667 {
668  return pool_elts (app->worker_maps);
669 }
670 
671 app_worker_t *
673 {
674  application_t *app;
675  app_listener_t *al;
676 
677  app = application_get (ls->app_index);
678  al = app_listener_get (app, ls->al_index);
679  return app_listener_select_worker (app, al);
680 }
681 
682 int
684 {
685  app_worker_map_t *wrk_map;
686  app_worker_t *app_wrk;
687  segment_manager_t *sm;
688  int rv;
689 
690  app_wrk = app_worker_alloc (app);
691  wrk_map = app_worker_map_alloc (app);
692  wrk_map->wrk_index = app_wrk->wrk_index;
693  app_wrk->wrk_map_index = app_worker_map_index (app, wrk_map);
694 
695  /*
696  * Setup first segment manager
697  */
698  sm = segment_manager_alloc ();
699  sm->app_wrk_index = app_wrk->wrk_index;
700 
701  if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
702  app->sm_properties.prealloc_fifos)))
703  {
704  app_worker_free (app_wrk);
705  return rv;
706  }
707  sm->first_is_protected = 1;
708 
709  /*
710  * Setup app worker
711  */
713  app_wrk->listeners_table = hash_create (0, sizeof (u64));
715  app_wrk->app_is_builtin = application_is_builtin (app);
716 
717  *wrk = app_wrk;
718 
719  return 0;
720 }
721 
722 int
724 {
725  fifo_segment_t *fs;
726  app_worker_map_t *wrk_map;
727  app_worker_t *app_wrk;
728  segment_manager_t *sm;
729  application_t *app;
730  int rv;
731 
732  app = application_get (a->app_index);
733  if (!app)
734  return VNET_API_ERROR_INVALID_VALUE;
735 
736  if (a->is_add)
737  {
738  if ((rv = application_alloc_worker_and_init (app, &app_wrk)))
739  return rv;
740 
741  /* Map worker api index to the app */
742  app_wrk->api_client_index = a->api_client_index;
743  application_api_table_add (app->app_index, a->api_client_index);
744 
747  a->segment = &fs->ssvm;
748  a->segment_handle = segment_manager_segment_handle (sm, fs);
750  a->evt_q = app_wrk->event_queue;
751  a->wrk_map_index = app_wrk->wrk_map_index;
752  }
753  else
754  {
755  wrk_map = app_worker_map_get (app, a->wrk_map_index);
756  if (!wrk_map)
757  return VNET_API_ERROR_INVALID_VALUE;
758 
759  app_wrk = app_worker_get (wrk_map->wrk_index);
760  if (!app_wrk)
761  return VNET_API_ERROR_INVALID_VALUE;
762 
764  app_worker_free (app_wrk);
765  app_worker_map_free (app, wrk_map);
766  if (application_n_workers (app) == 0)
767  application_free (app);
768  }
769  return 0;
770 }
771 
772 static int
773 app_validate_namespace (u8 * namespace_id, u64 secret, u32 * app_ns_index)
774 {
775  app_namespace_t *app_ns;
776  if (vec_len (namespace_id) == 0)
777  {
778  /* Use default namespace */
779  *app_ns_index = 0;
780  return 0;
781  }
782 
783  *app_ns_index = app_namespace_index_from_id (namespace_id);
784  if (*app_ns_index == APP_NAMESPACE_INVALID_INDEX)
785  return VNET_API_ERROR_APP_INVALID_NS;
786  app_ns = app_namespace_get (*app_ns_index);
787  if (!app_ns)
788  return VNET_API_ERROR_APP_INVALID_NS;
789  if (app_ns->ns_secret != secret)
790  return VNET_API_ERROR_APP_WRONG_NS_SECRET;
791  return 0;
792 }
793 
794 static u8 *
795 app_name_from_api_index (u32 api_client_index)
796 {
797  vl_api_registration_t *regp;
798  regp = vl_api_client_index_to_registration (api_client_index);
799  if (regp)
800  return format (0, "%s", regp->name);
801 
802  clib_warning ("api client index %u does not have an api registration!",
803  api_client_index);
804  return format (0, "unknown");
805 }
806 
807 /**
808  * Attach application to vpp
809  *
810  * Allocates a vpp app, i.e., a structure that keeps back pointers
811  * to external app and a segment manager for shared memory fifo based
812  * communication with the external app.
813  */
814 int
816 {
817  fifo_segment_t *fs;
818  application_t *app = 0;
819  app_worker_t *app_wrk;
820  segment_manager_t *sm;
821  u32 app_ns_index = 0;
822  u8 *app_name = 0;
823  u64 secret;
824  int rv;
825 
826  if (a->api_client_index != APP_INVALID_INDEX)
827  app = application_lookup (a->api_client_index);
828  else if (a->name)
829  app = application_lookup_name (a->name);
830  else
831  return VNET_API_ERROR_INVALID_VALUE;
832 
833  if (app)
834  return VNET_API_ERROR_APP_ALREADY_ATTACHED;
835 
836  if (a->api_client_index != APP_INVALID_INDEX)
837  {
838  app_name = app_name_from_api_index (a->api_client_index);
839  a->name = app_name;
840  }
841 
842  secret = a->options[APP_OPTIONS_NAMESPACE_SECRET];
843  if ((rv = app_validate_namespace (a->namespace_id, secret, &app_ns_index)))
844  return rv;
845  a->options[APP_OPTIONS_NAMESPACE] = app_ns_index;
846 
847  if ((rv = application_alloc_and_init ((app_init_args_t *) a)))
848  return rv;
849 
850  app = application_get (a->app_index);
851  if ((rv = application_alloc_worker_and_init (app, &app_wrk)))
852  return rv;
853 
854  a->app_evt_q = app_wrk->event_queue;
855  app_wrk->api_client_index = a->api_client_index;
858 
859  if (application_is_proxy (app))
861 
862  ASSERT (vec_len (fs->ssvm.name) <= 128);
863  a->segment = &fs->ssvm;
864  a->segment_handle = segment_manager_segment_handle (sm, fs);
865 
867  vec_free (app_name);
868  return 0;
869 }
870 
871 /**
872  * Detach application from vpp
873  */
874 int
876 {
877  application_t *app;
878 
879  app = application_get_if_valid (a->app_index);
880  if (!app)
881  {
882  clib_warning ("app not attached");
883  return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
884  }
885 
887  application_detach_process (app, a->api_client_index);
888  return 0;
889 }
890 
891 
892 static u8
894 {
895  u8 is_lep = session_endpoint_is_local (sep);
896  if (!is_lep && sep->sw_if_index != ENDPOINT_INVALID_INDEX
897  && !ip_interface_has_address (sep->sw_if_index, &sep->ip, sep->is_ip4))
898  {
899  clib_warning ("sw_if_index %u not configured with ip %U",
900  sep->sw_if_index, format_ip46_address, &sep->ip,
901  sep->is_ip4);
902  return 0;
903  }
904  return (is_lep || ip_is_local (sep->fib_index, &sep->ip, sep->is_ip4));
905 }
906 
907 static void
909  application_t * app, u8 is_connect)
910 {
911  app_namespace_t *app_ns;
912  u32 ns_index, fib_index;
913 
914  ns_index = app->ns_index;
915 
916  /* App is a transport proto, so fetch the calling app's ns */
917  if (app->flags & APP_OPTIONS_FLAGS_IS_TRANSPORT_APP)
918  ns_index = sep->ns_index;
919 
920  app_ns = app_namespace_get (ns_index);
921  if (!app_ns)
922  return;
923 
924  /* Ask transport and network to bind to/connect using local interface
925  * that "supports" app's namespace. This will fix our local connection
926  * endpoint.
927  */
928 
929  /* If in default namespace and user requested a fib index use it */
930  if (ns_index == 0 && sep->fib_index != ENDPOINT_INVALID_INDEX)
931  fib_index = sep->fib_index;
932  else
933  fib_index = sep->is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index;
934  sep->peer.fib_index = fib_index;
935  sep->fib_index = fib_index;
936 
937  if (!is_connect)
938  {
939  sep->sw_if_index = app_ns->sw_if_index;
940  }
941  else
942  {
943  if (app_ns->sw_if_index != APP_NAMESPACE_INVALID_INDEX
944  && sep->peer.sw_if_index != ENDPOINT_INVALID_INDEX
945  && sep->peer.sw_if_index != app_ns->sw_if_index)
946  clib_warning ("Local sw_if_index different from app ns sw_if_index");
947 
948  sep->peer.sw_if_index = app_ns->sw_if_index;
949  }
950 }
951 
952 int
954 {
955  app_listener_t *app_listener;
956  app_worker_t *app_wrk;
957  application_t *app;
958  int rv;
959 
961 
962  app = application_get_if_valid (a->app_index);
963  if (!app)
964  return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
965 
966  app_wrk = application_get_worker (app, a->wrk_map_index);
967  if (!app_wrk)
968  return VNET_API_ERROR_INVALID_VALUE;
969 
970  a->sep_ext.app_wrk_index = app_wrk->wrk_index;
971 
972  session_endpoint_update_for_app (&a->sep_ext, app, 0 /* is_connect */ );
973  if (!session_endpoint_in_ns (&a->sep))
974  return VNET_API_ERROR_INVALID_VALUE_2;
975 
976  /*
977  * Check if we already have an app listener
978  */
979  app_listener = app_listener_lookup (app, &a->sep_ext);
980  if (app_listener)
981  {
982  if (app_listener->app_index != app->app_index)
983  return VNET_API_ERROR_ADDRESS_IN_USE;
984  if (app_worker_start_listen (app_wrk, app_listener))
985  return -1;
986  a->handle = app_listener_handle (app_listener);
987  return 0;
988  }
989 
990  /*
991  * Create new app listener
992  */
993  if ((rv = app_listener_alloc_and_init (app, &a->sep_ext, &app_listener)))
994  return rv;
995 
996  if ((rv = app_worker_start_listen (app_wrk, app_listener)))
997  {
998  app_listener_cleanup (app_listener);
999  return rv;
1000  }
1001 
1002  a->handle = app_listener_handle (app_listener);
1003  return 0;
1004 }
1005 
1006 int
1008 {
1009  app_worker_t *client_wrk;
1010  application_t *client;
1011 
1013 
1014  if (session_endpoint_is_zero (&a->sep))
1015  return VNET_API_ERROR_INVALID_VALUE;
1016 
1017  client = application_get (a->app_index);
1018  session_endpoint_update_for_app (&a->sep_ext, client, 1 /* is_connect */ );
1019  client_wrk = application_get_worker (client, a->wrk_map_index);
1020 
1021  /*
1022  * First check the local scope for locally attached destinations.
1023  * If we have local scope, we pass *all* connects through it since we may
1024  * have special policy rules even for non-local destinations, think proxy.
1025  */
1026  if (application_has_local_scope (client))
1027  {
1028  int rv;
1029 
1030  a->sep_ext.original_tp = a->sep_ext.transport_proto;
1031  a->sep_ext.transport_proto = TRANSPORT_PROTO_NONE;
1032  rv = app_worker_connect_session (client_wrk, &a->sep, a->api_context);
1033  if (rv <= 0)
1034  return rv;
1035  }
1036  /*
1037  * Not connecting to a local server, propagate to transport
1038  */
1039  if (app_worker_connect_session (client_wrk, &a->sep, a->api_context))
1040  return VNET_API_ERROR_SESSION_CONNECT;
1041  return 0;
1042 }
1043 
1044 int
1046 {
1047  app_worker_t *app_wrk;
1048  app_listener_t *al;
1049  application_t *app;
1050 
1052 
1053  if (!(app = application_get_if_valid (a->app_index)))
1054  return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1055 
1056  if (!(al = app_listener_get_w_handle (a->handle)))
1057  return -1;
1058 
1059  if (al->app_index != app->app_index)
1060  {
1061  clib_warning ("app doesn't own handle %llu!", a->handle);
1062  return -1;
1063  }
1064 
1065  app_wrk = application_get_worker (app, a->wrk_map_index);
1066  if (!app_wrk)
1067  {
1068  clib_warning ("no app %u worker %u", app->app_index, a->wrk_map_index);
1069  return -1;
1070  }
1071 
1072  return app_worker_stop_listen (app_wrk, al);
1073 }
1074 
1075 int
1077 {
1078  app_worker_t *app_wrk;
1079  session_t *s;
1080 
1081  s = session_get_from_handle_if_valid (a->handle);
1082  if (!s)
1083  return VNET_API_ERROR_INVALID_VALUE;
1084  app_wrk = app_worker_get (s->app_wrk_index);
1085  if (app_wrk->app_index != a->app_index)
1086  return VNET_API_ERROR_INVALID_VALUE;
1087 
1088  /* We're peeking into another's thread pool. Make sure */
1089  ASSERT (s->session_index == session_index_from_handle (a->handle));
1090 
1091  session_close (s);
1092  return 0;
1093 }
1094 
1095 int
1097 {
1098  app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
1099  app_listener_t *app_listener;
1100  application_t *app;
1101 
1102  if (!old_wrk)
1103  return -1;
1104 
1107  && s->rx_fifo)
1109 
1110  app = application_get (old_wrk->app_index);
1111  if (!app)
1112  return -1;
1113 
1114  app_listener = app_listener_get (app, s->al_index);
1115 
1116  /* Only remove from lb for now */
1117  app_listener->workers = clib_bitmap_set (app_listener->workers,
1118  old_wrk->wrk_map_index, 0);
1119 
1120  if (app_worker_start_listen (app_wrk, app_listener))
1121  return -1;
1122 
1123  s->app_wrk_index = app_wrk->wrk_index;
1124 
1125  return 0;
1126 }
1127 
1128 int
1130 {
1131  return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
1132 }
1133 
1134 int
1136 {
1137  return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
1138 }
1139 
1140 int
1142 {
1143  return (application_is_proxy (app) && application_is_builtin (app));
1144 }
1145 
1146 u8
1148 {
1149  return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1150 }
1151 
1152 u8
1154 {
1155  return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1156 }
1157 
1158 static clib_error_t *
1160  u8 transport_proto, u8 is_start)
1161 {
1162  app_namespace_t *app_ns = app_namespace_get (app->ns_index);
1163  u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
1166  app_worker_t *app_wrk;
1167  app_listener_t *al;
1168  session_t *s;
1169  u32 flags;
1170 
1171  /* TODO decide if we want proxy to be enabled for all workers */
1172  app_wrk = application_get_default_worker (app);
1173  if (is_start)
1174  {
1175  s = app_worker_first_listener (app_wrk, fib_proto, transport_proto);
1176  if (!s)
1177  {
1178  sep.is_ip4 = is_ip4;
1179  sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1180  sep.sw_if_index = app_ns->sw_if_index;
1181  sep.transport_proto = transport_proto;
1182  sep.app_wrk_index = app_wrk->wrk_index; /* only default */
1183 
1184  /* force global scope listener */
1185  flags = app->flags;
1186  app->flags &= ~APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1187  app_listener_alloc_and_init (app, &sep, &al);
1188  app->flags = flags;
1189 
1190  app_worker_start_listen (app_wrk, al);
1192  s->flags |= SESSION_F_PROXY;
1193  }
1194  }
1195  else
1196  {
1197  s = app_worker_proxy_listener (app_wrk, fib_proto, transport_proto);
1198  ASSERT (s);
1199  }
1200 
1202 
1203  if (!ip_is_zero (&tc->lcl_ip, 1))
1204  {
1205  u32 sti;
1206  sep.is_ip4 = is_ip4;
1207  sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1208  sep.transport_proto = transport_proto;
1209  sep.port = 0;
1210  sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
1211  if (is_start)
1213  (session_endpoint_t *) & sep,
1214  s->session_index);
1215  else
1217  (session_endpoint_t *) & sep);
1218  }
1219 
1220  return 0;
1221 }
1222 
1223 static void
1225  u8 transport_proto, u8 is_start)
1226 {
1228  app_namespace_t *app_ns;
1229  app_ns = app_namespace_get (app->ns_index);
1230  sep.is_ip4 = 1;
1231  sep.transport_proto = transport_proto;
1232  sep.port = 0;
1233 
1234  if (is_start)
1235  {
1236  session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1237  app->app_index);
1238  sep.is_ip4 = 0;
1239  session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1240  app->app_index);
1241  }
1242  else
1243  {
1244  session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1245  sep.is_ip4 = 0;
1246  session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1247  }
1248 }
1249 
1250 void
1252  transport_proto_t transport_proto, u8 is_start)
1253 {
1254  if (application_has_local_scope (app))
1255  application_start_stop_proxy_local_scope (app, transport_proto, is_start);
1256 
1257  if (application_has_global_scope (app))
1258  {
1260  transport_proto, is_start);
1262  transport_proto, is_start);
1263  }
1264 }
1265 
1266 void
1268 {
1269  u16 transports = app->proxied_transports;
1270  transport_proto_t tp;
1271 
1272  ASSERT (application_is_proxy (app));
1273 
1274  /* *INDENT-OFF* */
1275  transport_proto_foreach (tp, ({
1276  if (transports & (1 << tp))
1277  application_start_stop_proxy (app, tp, 1);
1278  }));
1279  /* *INDENT-ON* */
1280 }
1281 
1282 void
1284 {
1285  u16 transports = app->proxied_transports;
1286  transport_proto_t tp;
1287 
1288  ASSERT (application_is_proxy (app));
1289 
1290  /* *INDENT-OFF* */
1291  transport_proto_foreach (tp, ({
1292  if (transports & (1 << tp))
1293  application_start_stop_proxy (app, tp, 0);
1294  }));
1295  /* *INDENT-ON* */
1296 }
1297 
1300 {
1301  return &app->sm_properties;
1302 }
1303 
1306 {
1307  application_t *app = application_get (app_index);
1308  return &app->sm_properties;
1309 }
1310 
1311 clib_error_t *
1313 {
1314  /* Deprected, will be remove after 20.01 */
1315  app_cert_key_pair_t *ckpair;
1316  ckpair = app_cert_key_pair_get_default ();
1317  ckpair->cert = vec_dup (a->cert);
1318  return 0;
1319 }
1320 
1321 clib_error_t *
1323 {
1324  /* Deprected, will be remove after 20.01 */
1325  app_cert_key_pair_t *ckpair;
1326  ckpair = app_cert_key_pair_get_default ();
1327  ckpair->key = vec_dup (a->key);
1328  return 0;
1329 }
1330 
1331 static void
1333 {
1335  app_worker_map_t *wrk_map;
1336  app_worker_t *app_wrk;
1337  u32 sm_index;
1338  u64 handle;
1339 
1340  if (!app)
1341  {
1342  vlib_cli_output (vm, "%U", format_app_worker_listener, 0 /* header */ ,
1343  0, 0, verbose);
1344  return;
1345  }
1346 
1347  /* *INDENT-OFF* */
1348  pool_foreach (wrk_map, app->worker_maps, ({
1349  app_wrk = app_worker_get (wrk_map->wrk_index);
1350  if (hash_elts (app_wrk->listeners_table) == 0)
1351  continue;
1352  hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
1353  vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
1354  handle, sm_index, verbose);
1355  }));
1356  }));
1357  /* *INDENT-ON* */
1358 }
1359 
1360 static void
1362 {
1363  app_worker_map_t *wrk_map;
1364  app_worker_t *app_wrk;
1365 
1366  if (!app)
1367  {
1368  app_worker_format_connects (0, verbose);
1369  return;
1370  }
1371 
1372  /* *INDENT-OFF* */
1373  pool_foreach (wrk_map, app->worker_maps, ({
1374  app_wrk = app_worker_get (wrk_map->wrk_index);
1375  app_worker_format_connects (app_wrk, verbose);
1376  }));
1377  /* *INDENT-ON* */
1378 }
1379 
1380 u8 *
1381 format_cert_key_pair (u8 * s, va_list * args)
1382 {
1383  app_cert_key_pair_t *ckpair = va_arg (*args, app_cert_key_pair_t *);
1384  int key_len = 0, cert_len = 0;
1385  cert_len = vec_len (ckpair->cert);
1386  key_len = vec_len (ckpair->key);
1387  if (ckpair->cert_key_index == 0)
1388  s = format (s, "DEFAULT (cert:%d, key:%d)", cert_len, key_len);
1389  else
1390  s = format (s, "%d (cert:%d, key:%d)", ckpair->cert_key_index,
1391  cert_len, key_len);
1392  return s;
1393 }
1394 
1395 u8 *
1396 format_crypto_engine (u8 * s, va_list * args)
1397 {
1398  u32 engine = va_arg (*args, u32);
1399  switch (engine)
1400  {
1401  case CRYPTO_ENGINE_NONE:
1402  return format (s, "none");
1403  case CRYPTO_ENGINE_MBEDTLS:
1404  return format (s, "mbedtls");
1405  case CRYPTO_ENGINE_OPENSSL:
1406  return format (s, "openssl");
1407  case CRYPTO_ENGINE_PICOTLS:
1408  return format (s, "picotls");
1409  case CRYPTO_ENGINE_VPP:
1410  return format (s, "vpp");
1411  default:
1412  return format (s, "unknown engine");
1413  }
1414  return s;
1415 }
1416 
1417 uword
1418 unformat_crypto_engine (unformat_input_t * input, va_list * args)
1419 {
1420  u8 *a = va_arg (*args, u8 *);
1421  if (unformat (input, "mbedtls"))
1422  *a = CRYPTO_ENGINE_MBEDTLS;
1423  else if (unformat (input, "openssl"))
1424  *a = CRYPTO_ENGINE_OPENSSL;
1425  else if (unformat (input, "picotls"))
1426  *a = CRYPTO_ENGINE_PICOTLS;
1427  else if (unformat (input, "vpp"))
1428  *a = CRYPTO_ENGINE_VPP;
1429  else
1430  return 0;
1431  return 1;
1432 }
1433 
1434 u8 *
1435 format_crypto_context (u8 * s, va_list * args)
1436 {
1437  crypto_context_t *crctx = va_arg (*args, crypto_context_t *);
1438  s = format (s, "[0x%x][sub%d,ckpair%x]", crctx->ctx_index,
1439  crctx->n_subscribers, crctx->ckpair_index);
1440  s = format (s, "[%U]", format_crypto_engine, crctx->crypto_engine);
1441  return s;
1442 }
1443 
1444 u8 *
1445 format_application (u8 * s, va_list * args)
1446 {
1447  application_t *app = va_arg (*args, application_t *);
1448  CLIB_UNUSED (int verbose) = va_arg (*args, int);
1449  segment_manager_props_t *props;
1450  const u8 *app_ns_name, *app_name;
1451  app_worker_map_t *wrk_map;
1452  app_worker_t *app_wrk;
1453 
1454  if (app == 0)
1455  {
1456  if (!verbose)
1457  s = format (s, "%-10s%-20s%-40s", "Index", "Name", "Namespace");
1458  return s;
1459  }
1460 
1461  app_name = app_get_name (app);
1462  app_ns_name = app_namespace_id_from_index (app->ns_index);
1464  if (!verbose)
1465  {
1466  s = format (s, "%-10u%-20v%-40s", app->app_index, app_name,
1467  app_ns_name);
1468  return s;
1469  }
1470 
1471  s = format (s, "app-name %v app-index %u ns-index %u seg-size %U\n",
1472  app_name, app->app_index, app->ns_index,
1473  format_memory_size, props->add_segment_size);
1474  s = format (s, "rx-fifo-size %U tx-fifo-size %U workers:\n",
1475  format_memory_size, props->rx_fifo_size,
1476  format_memory_size, props->tx_fifo_size);
1477 
1478  /* *INDENT-OFF* */
1479  pool_foreach (wrk_map, app->worker_maps, ({
1480  app_wrk = app_worker_get (wrk_map->wrk_index);
1481  s = format (s, "%U", format_app_worker, app_wrk);
1482  }));
1483  /* *INDENT-ON* */
1484 
1485  return s;
1486 }
1487 
1488 void
1490 {
1491  application_t *app;
1492 
1493  if (!pool_elts (app_main.app_pool))
1494  {
1495  vlib_cli_output (vm, "No active server bindings");
1496  return;
1497  }
1498 
1499  application_format_listeners (0, verbose);
1500 
1501  /* *INDENT-OFF* */
1502  pool_foreach (app, app_main.app_pool, ({
1503  application_format_listeners (app, verbose);
1504  }));
1505  /* *INDENT-ON* */
1506 }
1507 
1508 void
1510 {
1511  application_t *app;
1512 
1513  if (!pool_elts (app_main.app_pool))
1514  {
1515  vlib_cli_output (vm, "No active apps");
1516  return;
1517  }
1518 
1519  application_format_connects (0, verbose);
1520 
1521  /* *INDENT-OFF* */
1522  pool_foreach (app, app_main.app_pool, ({
1523  application_format_connects (app, verbose);
1524  }));
1525  /* *INDENT-ON* */
1526 }
1527 
1528 static clib_error_t *
1530  vlib_cli_command_t * cmd)
1531 {
1532  app_cert_key_pair_t *ckpair;
1534 
1535  /* *INDENT-OFF* */
1536  pool_foreach (ckpair, app_main.cert_key_pair_store, ({
1537  vlib_cli_output (vm, "%U", format_cert_key_pair, ckpair);
1538  }));
1539  /* *INDENT-ON* */
1540  return 0;
1541 }
1542 
1543 static inline void
1545 {
1546  app_worker_map_t *map;
1547  app_worker_t *wrk;
1548  /* *INDENT-OFF* */
1549  pool_foreach (map, app->worker_maps, ({
1550  wrk = app_worker_get (map->wrk_index);
1551  vlib_cli_output (vm, "[A%d][%d]%U", app->app_index,
1552  map->wrk_index, format_svm_msg_q,
1553  wrk->event_queue);
1554  }));
1555  /* *INDENT-ON* */
1556 }
1557 
1558 static clib_error_t *
1560 {
1561  application_t *app;
1562  int i, n_threads;
1563 
1564  n_threads = vec_len (vlib_mains);
1565 
1566  for (i = 0; i < n_threads; i++)
1567  {
1568  vlib_cli_output (vm, "[Ctrl%d]%U", i, format_svm_msg_q,
1570  }
1571 
1572  /* *INDENT-OFF* */
1573  pool_foreach (app, app_main.app_pool, ({
1574  appliction_format_app_mq (vm, app);
1575  }));
1576  /* *INDENT-ON* */
1577  return 0;
1578 }
1579 
1580 static clib_error_t *
1582  vlib_cli_command_t * cmd)
1583 {
1584  int do_server = 0, do_client = 0, do_mq = 0;
1585  application_t *app;
1586  u32 app_index = ~0;
1587  int verbose = 0;
1588 
1590 
1591  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1592  {
1593  if (unformat (input, "server"))
1594  do_server = 1;
1595  else if (unformat (input, "client"))
1596  do_client = 1;
1597  else if (unformat (input, "mq"))
1598  do_mq = 1;
1599  else if (unformat (input, "%u", &app_index))
1600  ;
1601  else if (unformat (input, "verbose"))
1602  verbose = 1;
1603  else
1604  return clib_error_return (0, "unknown input `%U'",
1605  format_unformat_error, input);
1606  }
1607 
1608  if (do_mq && app_index != ~0)
1609  {
1610  app = application_get_if_valid (app_index);
1611  if (!app)
1612  return clib_error_return (0, "No app with index %u", app_index);
1613 
1614  appliction_format_app_mq (vm, app);
1615  return 0;
1616  }
1617 
1618  if (do_mq)
1619  {
1621  return 0;
1622  }
1623 
1624  if (do_server)
1625  {
1626  application_format_all_listeners (vm, verbose);
1627  return 0;
1628  }
1629 
1630  if (do_client)
1631  {
1632  application_format_all_clients (vm, verbose);
1633  return 0;
1634  }
1635 
1636  if (app_index != ~0)
1637  {
1638  app = application_get_if_valid (app_index);
1639  if (!app)
1640  return clib_error_return (0, "No app with index %u", app_index);
1641 
1642  vlib_cli_output (vm, "%U", format_application, app, /* verbose */ 1);
1643  return 0;
1644  }
1645 
1646  /* Print app related info */
1647  if (!do_server && !do_client)
1648  {
1649  vlib_cli_output (vm, "%U", format_application, 0, 0);
1650  /* *INDENT-OFF* */
1651  pool_foreach (app, app_main.app_pool, ({
1652  vlib_cli_output (vm, "%U", format_application, app, 0);
1653  }));
1654  /* *INDENT-ON* */
1655  }
1656 
1657  return 0;
1658 }
1659 
1660 /* Certificate store */
1661 
1662 static app_cert_key_pair_t *
1664 {
1665  app_cert_key_pair_t *ckpair;
1666  pool_get (app_main.cert_key_pair_store, ckpair);
1667  clib_memset (ckpair, 0, sizeof (*ckpair));
1668  ckpair->cert_key_index = ckpair - app_main.cert_key_pair_store;
1669  return ckpair;
1670 }
1671 
1674 {
1675  if (pool_is_free_index (app_main.cert_key_pair_store, index))
1676  return 0;
1677  return app_cert_key_pair_get (index);
1678 }
1679 
1682 {
1683  return pool_elt_at_index (app_main.cert_key_pair_store, index);
1684 }
1685 
1688 {
1689  /* To maintain legacy bapi */
1690  return app_cert_key_pair_get (0);
1691 }
1692 
1693 int
1695 {
1697  ckpair->cert = vec_dup (a->cert);
1698  ckpair->key = vec_dup (a->key);
1699  a->index = ckpair->cert_key_index;
1700  return 0;
1701 }
1702 
1703 int
1705 {
1706  app_cert_key_pair_t *ckpair;
1707  if (!(ckpair = app_cert_key_pair_get_if_valid (index)))
1708  return -1;
1709  if (vec_search (ckpair->app_interests, app_index) != ~0)
1710  vec_add1 (ckpair->app_interests, app_index);
1711  return 0;
1712 }
1713 
1714 int
1716 {
1717  app_cert_key_pair_t *ckpair;
1718  application_t *app;
1719  u32 *app_index;
1720 
1721  if (!(ckpair = app_cert_key_pair_get_if_valid (index)))
1722  return (VNET_API_ERROR_INVALID_VALUE);
1723 
1724  vec_foreach (app_index, ckpair->app_interests)
1725  {
1726  if ((app = application_get_if_valid (*app_index))
1729  }
1730 
1731  vec_free (ckpair->cert);
1732  vec_free (ckpair->key);
1733  pool_put (app_main.cert_key_pair_store, ckpair);
1734  return 0;
1735 }
1736 
1737 clib_error_t *
1739 {
1740  /* Add a certificate with index 0 to support legacy apis */
1741  (void) app_cert_key_pair_alloc ();
1743  return 0;
1744 }
1745 
1746 /* *INDENT-OFF* */
1748 
1749 VLIB_CLI_COMMAND (show_app_command, static) =
1750 {
1751  .path = "show app",
1752  .short_help = "show app [app_id] [server|client] [mq] [verbose]",
1753  .function = show_app_command_fn,
1754 };
1755 
1756 VLIB_CLI_COMMAND (show_certificate_command, static) =
1757 {
1758  .path = "show app certificate",
1759  .short_help = "list app certs and keys present in store",
1760  .function = show_certificate_command_fn,
1761 };
1762 /* *INDENT-ON* */
1763 
1766 {
1767  return (++app_main.last_crypto_engine);
1768 }
1769 
1770 u8
1772 {
1773  return (app_main.last_crypto_engine + 1);
1774 }
1775 
1776 /*
1777  * fd.io coding-style-patch-verification: ON
1778  *
1779  * Local Variables:
1780  * eval: (c-set-style "gnu")
1781  * End:
1782  */
u32 segment_manager_index(segment_manager_t *sm)
static void application_name_table_del(application_t *app)
Definition: application.c:388
u32 flags
Flags.
Definition: application.h:92
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:53
#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:82
app_cert_key_pair_t * app_cert_key_pair_get_default()
Definition: application.c:1687
static void application_detach_process(application_t *app, u32 api_client_index)
Definition: application.c:606
int vnet_app_add_cert_key_pair(vnet_app_add_cert_key_pair_args_t *a)
Definition: application.c:1694
u32 al_index
app listener index in app pool
Definition: application.h:77
#define hash_unset(h, key)
Definition: hash.h:261
a
Definition: bitmap.h:538
#define SESSION_TABLE_INVALID_INDEX
Definition: session_table.h:56
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:107
u8 application_has_global_scope(application_t *app)
Definition: application.c:1153
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:1096
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:1191
#define session_cli_return_if_not_enabled()
Definition: session.h:618
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:1581
unsigned long u64
Definition: types.h:89
transport_connection_t * listen_session_get_transport(session_t *s)
Definition: session.c:1484
static svm_msg_q_t * session_main_get_vpp_event_queue(u32 thread_index)
Definition: session.h:607
crypto_engine_type_t app_crypto_engine_type_add(void)
Definition: application.c:1765
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:1681
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
transport_connection_t * session_get_transport(session_t *s)
Definition: session.c:1461
application_t * application_lookup_name(const u8 *name)
Definition: application.c:405
svm_fifo_t * rx_fifo
Pointers to rx/tx buffers.
u8 ip_interface_has_address(u32 sw_if_index, ip46_address_t *ip, u8 is_ip4)
Definition: ip.c:100
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:546
int vnet_app_del_cert_key_pair(u32 index)
Definition: application.c:1715
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
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:112
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:559
int i
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:143
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:295
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
int vnet_unlisten(vnet_unlisten_args_t *a)
Definition: application.c:1045
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:237
uword unformat_crypto_engine(unformat_input_t *input, va_list *args)
Definition: application.c:1418
int segment_manager_init(segment_manager_t *sm, uword first_seg_size, u32 prealloc_fifo_pairs)
Initializes segment manager based on options provided.
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:1312
unsigned char u8
Definition: types.h:56
app_worker_t * application_get_worker(application_t *app, u32 wrk_map_index)
Definition: application.c:650
#define SESSION_ENDPOINT_NULL
Definition: session_types.h:68
static u8 session_endpoint_in_ns(session_endpoint_t *sep)
Definition: application.c:893
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:1299
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:78
int application_is_proxy(application_t *app)
Definition: application.c:1129
enum ssvm_segment_type_ ssvm_segment_type_t
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:498
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:79
u32 session_index
global listening session index
Definition: application.h:80
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:943
u32 app_namespace_index_from_id(const u8 *ns_id)
u16 proxied_transports
Definition: application.h:109
static int app_validate_namespace(u8 *namespace_id, u64 secret, u32 *app_ns_index)
Definition: application.c:773
#define SESSION_INVALID_HANDLE
Definition: session_types.h:23
u8 tls_engine
Preferred tls engine.
Definition: application.h:115
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:558
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:1322
int application_is_builtin(application_t *app)
Definition: application.c:1135
#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:519
#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:77
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:315
session_t * app_listener_get_session(app_listener_t *al)
Definition: application.c:280
int(* session_connected_callback)(u32 app_wrk_index, u32 opaque, session_t *s, u8 code)
Connection request callback.
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:1396
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:287
#define APP_INVALID_INDEX
Definition: application.h:169
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:376
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:1544
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:1529
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)
vlib_main_t * vm
Definition: in2out_ed.c:1810
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:1381
static u64 listen_session_get_handle(session_t *s)
Definition: session.h:538
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:101
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:815
static session_t * session_get_from_handle_if_valid(session_handle_t handle)
Definition: session.h:324
#define pool_free(p)
Free a pool.
Definition: pool.h:412
An API client registration, only in vpp/vlib.
Definition: api_common.h:46
svm_msg_q_t * segment_manager_event_queue(segment_manager_t *sm)
u32 application_local_session_table(application_t *app)
Definition: application.c:347
u8 is_ip4
Definition: lisp_gpe.api:232
app_cert_key_pair_t * app_cert_key_pair_get_if_valid(u32 index)
Definition: application.c:1673
ssvm_private_t ssvm
ssvm segment data
Definition: fifo_segment.h:63
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
u32 ckpair_index
certificate & key
u32 flags
Definition: vhost_user.h:141
uword * app_by_name
Hash table of builtin apps by name.
Definition: application.h:138
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)
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
segment_manager_props_t sm_properties
Segment manager properties.
Definition: application.h:98
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:196
#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:908
Don&#39;t register connection in lookup Does not apply to local apps and transports using the network lay...
clib_bitmap_t * workers
workers accepting connections
Definition: application.h:75
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:284
const u8 * app_namespace_id_from_index(u32 index)
void application_format_all_clients(vlib_main_t *vm, int verbose)
Definition: application.c:1509
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:57
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:65
string name[64]
Definition: ip.api:44
static u8 vlib_thread_is_main_w_barrier(void)
Definition: threads.h:517
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 vnet_app_add_cert_key_interest(u32 index, u32 app_index)
Ask for app cb on pair deletion.
Definition: application.c:1704
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:152
segment_manager_props_t * application_get_segment_manager_properties(u32 app_index)
Definition: application.c:1305
int session_listen(session_t *ls, session_endpoint_cfg_t *sep)
Ask transport to listen on session endpoint.
Definition: session.c:1163
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:683
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:672
static u8 * app_name_from_api_index(u32 api_client_index)
Definition: application.c:795
int vnet_listen(vnet_listen_args_t *a)
Definition: application.c:953
uword * app_by_api_client_index
Hash table of apps by api client index.
Definition: application.h:133
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:875
void application_remove_proxy(application_t *app)
Definition: application.c:1283
session_cb_vft_t cb_fns
Callbacks: shoulder-taps for the server/client.
Definition: application.h:95
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:76
struct _vnet_app_detach_args_t vnet_app_detach_args_t
int vnet_connect(vnet_connect_args_t *a)
Definition: application.c:1007
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u8 * name
Definition: ssvm.h:87
static void listen_session_free(session_t *s)
Definition: session.h:575
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:89
app_worker_t * app_worker_get(u32 wrk_index)
application_t * app_pool
Pool from which we allocate all applications.
Definition: application.h:128
u64 session_handle_t
static void application_free(application_t *app)
Definition: application.c:570
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u8 * format_application(u8 *s, va_list *args)
Definition: application.c:1445
void(* session_disconnect_callback)(session_t *s)
Notify app that session is closing.
u8 * name
Name registered by builtin apps.
Definition: application.h:104
void session_close(session_t *s)
Initialize session closing procedure.
Definition: session.c:1216
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:81
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:1394
connectionless service
int vnet_disconnect_session(vnet_disconnect_args_t *a)
Definition: application.c:1076
app_worker_t * application_get_default_worker(application_t *app)
Definition: application.c:660
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:666
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:723
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:1332
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:1159
#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:1771
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:1224
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:1663
#define transport_proto_foreach(VAR, BODY)
Definition: transport.h:97
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:1267
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:1361
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:1141
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:1251
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 vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:689
void application_format_all_listeners(vlib_main_t *vm, int verbose)
Definition: application.c:1489
#define APP_DBG(_fmt, _args...)
Definition: application.h:29
clib_error_t * application_init(vlib_main_t *vm)
Definition: application.c:1738
crypto_engine_type_t last_crypto_engine
Definition: application.h:148
static session_t * listen_session_get(u32 ls_index)
Definition: session.h:569
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:1559
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:1435
u8 application_has_local_scope(application_t *app)
Definition: application.c:1147
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128