FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
tls.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018-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 
17 #include <vppinfra/lock.h>
18 #include <vnet/tls/tls.h>
19 
22 
23 #define TLS_INVALID_HANDLE ~0
24 #define TLS_IDX_MASK 0x00FFFFFF
25 #define TLS_ENGINE_TYPE_SHIFT 28
26 
27 void tls_disconnect (u32 ctx_handle, u32 thread_index);
28 
29 void
31 {
33  .handle = ctx->tls_session_handle,
34  .app_index = tls_main.app_index,
35  };
36 
38  clib_warning ("disconnect returned");
39 }
40 
43 {
44  int i;
45  for (i = 0; i < vec_len (tls_vfts); i++)
46  {
47  if (tls_vfts[i].ctx_alloc)
48  return i;
49  }
50  return CRYPTO_ENGINE_NONE;
51 }
52 
53 int
55 {
56  if (svm_fifo_set_event (s->rx_fifo))
58  return 0;
59 }
60 
61 int
63 {
64  if (svm_fifo_set_event (s->rx_fifo))
66  return 0;
67 }
68 
69 int
71 {
72  if (svm_fifo_set_event (s->tx_fifo))
74  return 0;
75 }
76 
77 static inline int
79 {
80  return app_worker_lock_and_send_event (app, app_session, SESSION_IO_EVT_RX);
81 }
82 
83 u32
85 {
86  tls_main_t *tm = &tls_main;
87  tls_ctx_t *ctx;
88 
90  clib_memset (ctx, 0, sizeof (*ctx));
91  return ctx - tm->listener_ctx_pool;
92 }
93 
94 void
96 {
97  if (CLIB_DEBUG)
98  memset (ctx, 0xfb, sizeof (*ctx));
100 }
101 
102 tls_ctx_t *
104 {
105  return pool_elt_at_index (tls_main.listener_ctx_pool, ctx_index);
106 }
107 
108 u32
110 {
111  return (ctx - tls_main.listener_ctx_pool);
112 }
113 
114 u32
116 {
117  tls_main_t *tm = &tls_main;
118  u8 will_expand = 0;
119  tls_ctx_t *ctx;
120  u32 ctx_index;
121 
122  pool_get_aligned_will_expand (tm->half_open_ctx_pool, will_expand, 0);
123  if (PREDICT_FALSE (will_expand && vlib_num_workers ()))
124  {
127  ctx->c_c_index = ctx - tm->half_open_ctx_pool;
128  ctx_index = ctx->c_c_index;
130  }
131  else
132  {
133  /* reader lock assumption: only main thread will call pool_get */
136  ctx->c_c_index = ctx - tm->half_open_ctx_pool;
137  ctx_index = ctx->c_c_index;
139  }
140  return ctx_index;
141 }
142 
143 void
145 {
146  tls_main_t *tm = &tls_main;
150 }
151 
152 tls_ctx_t *
154 {
155  tls_main_t *tm = &tls_main;
157  return pool_elt_at_index (tm->half_open_ctx_pool, ctx_index);
158 }
159 
160 void
162 {
164 }
165 
166 u32
168 {
169  return (ctx - tls_main.half_open_ctx_pool);
170 }
171 
172 void
174 {
175  app_worker_t *app_wrk;
176  app_wrk = app_worker_get_if_valid (app_session->app_wrk_index);
177  if (PREDICT_TRUE (app_wrk != 0))
178  tls_add_app_q_evt (app_wrk, app_session);
179 }
180 
181 int
183 {
184  session_t *app_listener, *app_session;
185  app_worker_t *app_wrk;
186  tls_ctx_t *lctx;
187  int rv;
188 
189  lctx = tls_listener_ctx_get (ctx->listener_ctx_index);
190  app_listener = listen_session_get_from_handle (lctx->app_session_handle);
191 
192  app_session = session_get (ctx->c_s_index, ctx->c_thread_index);
193  app_session->app_wrk_index = ctx->parent_app_wrk_index;
194  app_session->connection_index = ctx->tls_ctx_handle;
195  app_session->session_type = app_listener->session_type;
196  app_session->listener_handle = listen_session_get_handle (app_listener);
197  app_session->session_state = SESSION_STATE_ACCEPTING;
198 
199  if ((rv = app_worker_init_accepted (app_session)))
200  {
201  TLS_DBG (1, "failed to allocate fifos");
202  session_free (app_session);
203  return rv;
204  }
205  ctx->app_session_handle = session_handle (app_session);
206  ctx->parent_app_wrk_index = app_session->app_wrk_index;
207  app_wrk = app_worker_get (app_session->app_wrk_index);
208  return app_worker_accept_notify (app_wrk, app_session);
209 }
210 
211 int
213 {
214  session_t *app_session;
215  app_worker_t *app_wrk;
216 
217  app_wrk = app_worker_get_if_valid (ctx->parent_app_wrk_index);
218  if (!app_wrk)
219  {
221  return -1;
222  }
223 
224  if (err)
225  {
226  /* Free app session pre-allocated when transport was established */
227  if (ctx->tls_type == TRANSPORT_PROTO_TLS)
228  session_free (session_get (ctx->c_s_index, ctx->c_thread_index));
229  ctx->no_app_session = 1;
230  goto send_reply;
231  }
232 
233  /* For DTLS the app session is not preallocated because the underlying udp
234  * session might migrate to a different worker during the handshake */
235  if (ctx->tls_type == TRANSPORT_PROTO_DTLS)
236  {
237  session_type_t st;
238  /* Cleanup half-open session as we don't get notification from udp */
239  session_half_open_delete_notify (&ctx->connection);
240  app_session = session_alloc (ctx->c_thread_index);
241  app_session->session_state = SESSION_STATE_CREATED;
242  ctx->c_s_index = app_session->session_index;
243  st =
244  session_type_from_proto_and_ip (TRANSPORT_PROTO_DTLS, ctx->tcp_is_ip4);
245  app_session->session_type = st;
246  app_session->connection_index = ctx->tls_ctx_handle;
247  }
248  else
249  {
250  app_session = session_get (ctx->c_s_index, ctx->c_thread_index);
251  }
252 
253  app_session->app_wrk_index = ctx->parent_app_wrk_index;
254 
255  if ((err = app_worker_init_connected (app_wrk, app_session)))
256  goto failed;
257 
258  app_session->session_state = SESSION_STATE_READY;
259  if (app_worker_connect_notify (app_wrk, app_session,
260  SESSION_E_NONE, ctx->parent_app_api_context))
261  {
262  TLS_DBG (1, "failed to notify app");
263  app_session->session_state = SESSION_STATE_CONNECTING;
264  tls_disconnect (ctx->tls_ctx_handle, vlib_get_thread_index ());
265  return -1;
266  }
267 
268  ctx->app_session_handle = session_handle (app_session);
269 
270  return 0;
271 
272 failed:
273  ctx->no_app_session = 1;
274  tls_disconnect (ctx->tls_ctx_handle, vlib_get_thread_index ());
275 send_reply:
276  return app_worker_connect_notify (app_wrk, 0, err,
277  ctx->parent_app_api_context);
278 }
279 
280 static inline void
281 tls_ctx_parse_handle (u32 ctx_handle, u32 * ctx_index, u32 * engine_type)
282 {
283  *ctx_index = ctx_handle & TLS_IDX_MASK;
284  *engine_type = ctx_handle >> TLS_ENGINE_TYPE_SHIFT;
285 }
286 
287 static inline crypto_engine_type_t
289  crypto_engine_type_t preferred)
290 {
291  if (requested != CRYPTO_ENGINE_NONE)
292  {
293  if (tls_vfts[requested].ctx_alloc)
294  return requested;
295  return CRYPTO_ENGINE_NONE;
296  }
297  if (!tls_vfts[preferred].ctx_alloc)
298  return tls_get_available_engine ();
299  return preferred;
300 }
301 
302 static inline u32
304 {
305  u32 ctx_index;
306  ctx_index = tls_vfts[engine_type].ctx_alloc ();
307  return (((u32) engine_type << TLS_ENGINE_TYPE_SHIFT) | ctx_index);
308 }
309 
310 static inline u32
312 {
313  u32 ctx_index;
314  ctx_index = tls_vfts[engine_type].ctx_alloc_w_thread (thread_index);
315  return (((u32) engine_type << TLS_ENGINE_TYPE_SHIFT) | ctx_index);
316 }
317 
318 static inline u32
320 {
321  u32 ctx_index;
322  ctx_index = tls_vfts[engine_type].ctx_attach (thread_index, ctx);
323  return (((u32) engine_type << TLS_ENGINE_TYPE_SHIFT) | ctx_index);
324 }
325 
326 static inline void *
328 {
329  return tls_vfts[ctx->tls_ctx_engine].ctx_detach (ctx);
330 }
331 
332 static inline tls_ctx_t *
333 tls_ctx_get (u32 ctx_handle)
334 {
335  u32 ctx_index, engine_type;
336  tls_ctx_parse_handle (ctx_handle, &ctx_index, &engine_type);
337  return tls_vfts[engine_type].ctx_get (ctx_index);
338 }
339 
340 static inline tls_ctx_t *
342 {
343  u32 ctx_index, engine_type;
344  tls_ctx_parse_handle (ctx_handle, &ctx_index, &engine_type);
345  return tls_vfts[engine_type].ctx_get_w_thread (ctx_index, thread_index);
346 }
347 
348 static inline int
350 {
351  return tls_vfts[ctx->tls_ctx_engine].ctx_init_server (ctx);
352 }
353 
354 static inline int
356 {
357  return tls_vfts[ctx->tls_ctx_engine].ctx_init_client (ctx);
358 }
359 
360 static inline int
363 {
364  u32 n_wrote;
365 
367  n_wrote = tls_vfts[ctx->tls_ctx_engine].ctx_write (ctx, app_session, sp);
368  sp->max_burst_size = n_wrote;
369  return n_wrote > 0 ? clib_max (n_wrote / TRANSPORT_PACER_MIN_MSS, 1) : 0;
370 }
371 
372 static inline int
374 {
375  return tls_vfts[ctx->tls_ctx_engine].ctx_read (ctx, tls_session);
376 }
377 
378 static inline int
380 {
381  return tls_vfts[ctx->tls_ctx_engine].ctx_transport_close (ctx);
382 }
383 
384 static inline int
386 {
387  return tls_vfts[ctx->tls_ctx_engine].ctx_app_close (ctx);
388 }
389 
390 void
392 {
393  tls_vfts[ctx->tls_ctx_engine].ctx_free (ctx);
394 }
395 
396 u8
398 {
399  return tls_vfts[ctx->tls_ctx_engine].ctx_handshake_is_over (ctx);
400 }
401 
402 void
404 {
405  tls_ctx_t *ctx;
407  session_t *app_session;
408 
409  ctx = tls_ctx_get (s->opaque);
410  ctx->is_passive_close = 1;
411  tc = &ctx->connection;
413  {
417  }
418  else
419  if ((app_session =
420  session_get_if_valid (ctx->c_s_index, ctx->c_thread_index)))
421  {
422  session_free (app_session);
423  ctx->c_s_index = SESSION_INVALID_INDEX;
425  }
426 }
427 
428 static void
430 {
431  tls_ctx_t *ctx;
432  u32 ho_index;
433 
434  /* session opaque stores the opaque passed on connect */
435  ho_index = s->opaque;
436  ctx = tls_ctx_half_open_get (ho_index);
437  session_half_open_delete_notify (&ctx->connection);
439  tls_ctx_half_open_free (ho_index);
440 }
441 
442 int
443 tls_add_segment_callback (u32 client_index, u64 segment_handle)
444 {
445  /* No-op for builtin */
446  return 0;
447 }
448 
449 int
450 tls_del_segment_callback (u32 client_index, u64 segment_handle)
451 {
452  return 0;
453 }
454 
455 void
457 {
458  tls_ctx_t *ctx;
459 
460  TLS_DBG (1, "TCP disconnecting handle %x session %u", tls_session->opaque,
461  tls_session->session_index);
462 
463  ASSERT (tls_session->thread_index == vlib_get_thread_index ()
465 
466  ctx = tls_ctx_get_w_thread (tls_session->opaque, tls_session->thread_index);
467  ctx->is_passive_close = 1;
469 }
470 
471 int
473 {
474  session_t *tls_listener, *app_session;
475  tls_ctx_t *lctx, *ctx;
476  u32 ctx_handle;
477 
478  tls_listener =
480  lctx = tls_listener_ctx_get (tls_listener->opaque);
481 
482  ctx_handle = tls_ctx_alloc (lctx->tls_ctx_engine);
483  ctx = tls_ctx_get (ctx_handle);
484  memcpy (ctx, lctx, sizeof (*lctx));
485  ctx->c_thread_index = vlib_get_thread_index ();
486  ctx->tls_ctx_handle = ctx_handle;
487  tls_session->session_state = SESSION_STATE_READY;
488  tls_session->opaque = ctx_handle;
489  ctx->tls_session_handle = session_handle (tls_session);
490  ctx->listener_ctx_index = tls_listener->opaque;
492  ctx->ckpair_index = lctx->ckpair_index;
493 
494  /* Preallocate app session. Avoids allocating a session post handshake
495  * on tls_session rx and potentially invalidating the session pool */
496  app_session = session_alloc (ctx->c_thread_index);
497  app_session->session_state = SESSION_STATE_CREATED;
498  ctx->c_s_index = app_session->session_index;
499 
500  TLS_DBG (1, "Accept on listener %u new connection [%u]%x",
501  tls_listener->opaque, vlib_get_thread_index (), ctx_handle);
502 
503  return tls_ctx_init_server (ctx);
504 }
505 
506 int
508 {
509  tls_ctx_t *ctx;
510 
511  /* DTLS session migrating, wait for next notification */
512  if (PREDICT_FALSE (tls_session->flags & SESSION_F_IS_MIGRATING))
513  return 0;
514 
515  ctx = tls_ctx_get (tls_session->opaque);
516  tls_ctx_read (ctx, tls_session);
517  return 0;
518 }
519 
520 int
522 {
523  tls_ctx_t *ctx;
524 
525  ctx = tls_ctx_get (tls_session->opaque);
526  transport_connection_reschedule (&ctx->connection);
527 
528  return 0;
529 }
530 
531 int
532 tls_session_connected_cb (u32 tls_app_index, u32 ho_ctx_index,
533  session_t *tls_session, session_error_t err)
534 {
535  session_t *app_session;
536  tls_ctx_t *ho_ctx, *ctx;
537  session_type_t st;
538  u32 ctx_handle;
539 
540  ho_ctx = tls_ctx_half_open_get (ho_ctx_index);
541 
542  if (err)
543  {
544  app_worker_t *app_wrk;
545  u32 api_context;
546  int rv = 0;
547 
548  app_wrk = app_worker_get_if_valid (ho_ctx->parent_app_wrk_index);
549  if (app_wrk)
550  {
551  api_context = ho_ctx->parent_app_api_context;
552  app_worker_connect_notify (app_wrk, 0, err, api_context);
553  }
555  return rv;
556  }
557 
558  ctx_handle = tls_ctx_alloc (ho_ctx->tls_ctx_engine);
559  ctx = tls_ctx_get (ctx_handle);
560  clib_memcpy_fast (ctx, ho_ctx, sizeof (*ctx));
561  /* Half-open freed on tcp half-open cleanup notification */
563 
564  ctx->c_thread_index = vlib_get_thread_index ();
565  ctx->tls_ctx_handle = ctx_handle;
567 
568  TLS_DBG (1, "TCP connect for %u returned %u. New connection [%u]%x",
569  ho_ctx_index, err, vlib_get_thread_index (),
570  (ctx) ? ctx_handle : ~0);
571 
572  ctx->tls_session_handle = session_handle (tls_session);
573  tls_session->opaque = ctx_handle;
574  tls_session->session_state = SESSION_STATE_READY;
575 
576  /* Preallocate app session. Avoids allocating a session post handshake
577  * on tls_session rx and potentially invalidating the session pool */
578  app_session = session_alloc (ctx->c_thread_index);
579  app_session->session_state = SESSION_STATE_CREATED;
580  ctx->c_s_index = app_session->session_index;
581  st = session_type_from_proto_and_ip (TRANSPORT_PROTO_TLS, ctx->tcp_is_ip4);
582  app_session->session_type = st;
583  app_session->connection_index = ctx->tls_ctx_handle;
584 
585  return tls_ctx_init_client (ctx);
586 }
587 
588 int
589 dtls_session_connected_cb (u32 app_wrk_index, u32 ctx_handle, session_t *us,
590  session_error_t err)
591 {
592  tls_ctx_t *ctx;
593 
594  ctx = tls_ctx_get_w_thread (ctx_handle, transport_cl_thread ());
595 
596  ctx->tls_session_handle = session_handle (us);
598  us->opaque = ctx_handle;
599 
600  /* We don't preallocate the app session because the udp session might
601  * actually migrate to a different worker at the end of the handshake */
602 
603  return tls_ctx_init_client (ctx);
604 }
605 
606 int
607 tls_session_connected_callback (u32 tls_app_index, u32 ho_ctx_index,
608  session_t *tls_session, session_error_t err)
609 {
610  if (session_get_transport_proto (tls_session) == TRANSPORT_PROTO_TCP)
611  return tls_session_connected_cb (tls_app_index, ho_ctx_index, tls_session,
612  err);
613  else
614  return dtls_session_connected_cb (tls_app_index, ho_ctx_index, tls_session,
615  err);
616 }
617 
618 static void
620 {
621  tls_ctx_t *ctx;
622 
623  if (ntf == SESSION_CLEANUP_TRANSPORT)
624  {
625  /* Allow cleanup of tcp session */
626  if (s->session_state == SESSION_STATE_TRANSPORT_DELETED)
627  session_close (s);
628  return;
629  }
630 
631  ctx = tls_ctx_get (s->opaque);
632  if (!ctx->no_app_session)
633  session_transport_delete_notify (&ctx->connection);
634  tls_ctx_free (ctx);
635 }
636 
637 static void
638 dtls_migrate_ctx (void *arg)
639 {
640  tls_ctx_t *ctx = (tls_ctx_t *) arg;
641  u32 ctx_handle, thread_index;
642  session_t *us;
643 
644  thread_index = session_thread_from_handle (ctx->tls_session_handle);
646 
647  ctx_handle = tls_ctx_attach (ctx->tls_ctx_engine, thread_index, ctx);
648  ctx = tls_ctx_get_w_thread (ctx_handle, thread_index);
649  ctx->tls_ctx_handle = ctx_handle;
650 
651  us = session_get_from_handle (ctx->tls_session_handle);
652  us->opaque = ctx_handle;
653  us->flags &= ~SESSION_F_IS_MIGRATING;
654 
655  /* Probably the app detached while the session was migrating. Cleanup */
656  if (session_half_open_migrated_notify (&ctx->connection))
657  {
658  ctx->no_app_session = 1;
659  tls_disconnect (ctx->tls_ctx_handle, vlib_get_thread_index ());
660  return;
661  }
662 
663  if (svm_fifo_max_dequeue (us->tx_fifo))
665 }
666 
667 static void
669 {
670  u32 new_thread = session_thread_from_handle (new_sh);
671  tls_ctx_t *ctx, *cloned_ctx;
672 
673  /* Migrate dtls context to new thread */
675  ctx->tls_session_handle = new_sh;
676  cloned_ctx = tls_ctx_detach (ctx);
677  ctx->is_migrated = 1;
678  session_half_open_migrate_notify (&ctx->connection);
679 
681  (void *) cloned_ctx);
682 
683  tls_ctx_free (ctx);
684 }
685 
688  .session_disconnect_callback = tls_session_disconnect_callback,
689  .session_connected_callback = tls_session_connected_callback,
690  .session_reset_callback = tls_session_reset_callback,
691  .half_open_cleanup_callback = tls_session_cleanup_ho,
692  .add_segment_callback = tls_add_segment_callback,
693  .del_segment_callback = tls_del_segment_callback,
694  .builtin_app_rx_callback = tls_app_rx_callback,
695  .builtin_app_tx_callback = tls_app_tx_callback,
696  .session_migrate_callback = dtls_session_migrate_callback,
697  .session_cleanup_callback = tls_app_session_cleanup,
698 };
699 
700 int
702 {
703  vnet_connect_args_t _cargs = { {}, }, *cargs = &_cargs;
705  crypto_engine_type_t engine_type;
707  tls_main_t *tm = &tls_main;
708  app_worker_t *app_wrk;
709  application_t *app;
710  tls_ctx_t *ctx;
711  u32 ctx_index;
712  int rv;
713 
714  sep = (session_endpoint_cfg_t *) tep;
715  if (!sep->ext_cfg)
716  return SESSION_E_NOEXTCFG;
717 
718  app_wrk = app_worker_get (sep->app_wrk_index);
719  app = application_get (app_wrk->app_index);
720 
721  ccfg = &sep->ext_cfg->crypto;
722  engine_type = tls_get_engine_type (ccfg->crypto_engine, app->tls_engine);
723  if (engine_type == CRYPTO_ENGINE_NONE)
724  {
725  clib_warning ("No tls engine_type available");
726  return SESSION_E_NOCRYPTOENG;
727  }
728 
729  ctx_index = tls_ctx_half_open_alloc ();
730  ctx = tls_ctx_half_open_get (ctx_index);
731  ctx->parent_app_wrk_index = sep->app_wrk_index;
732  ctx->parent_app_api_context = sep->opaque;
733  ctx->tcp_is_ip4 = sep->is_ip4;
734  ctx->tls_type = sep->transport_proto;
735  ctx->ckpair_index = ccfg->ckpair_index;
736  ctx->c_proto = TRANSPORT_PROTO_TLS;
738  if (ccfg->hostname[0])
739  {
740  ctx->srv_hostname = format (0, "%s", ccfg->hostname);
741  vec_terminate_c_string (ctx->srv_hostname);
742  }
744 
745  ctx->tls_ctx_engine = engine_type;
746 
747  clib_memcpy_fast (&cargs->sep, sep, sizeof (session_endpoint_t));
748  cargs->sep.transport_proto = TRANSPORT_PROTO_TCP;
749  cargs->app_index = tm->app_index;
750  cargs->api_context = ctx_index;
751  cargs->sep_ext.ns_index = app->ns_index;
752  if ((rv = vnet_connect (cargs)))
753  return rv;
754 
755  /* Track half-open tcp session in case we need to clean it up */
756  ctx->tls_session_handle = cargs->sh;
757 
758  TLS_DBG (1, "New connect request %u engine %d", ctx_index, engine_type);
759  return ctx_index;
760 }
761 
762 void
764 {
765  tls_ctx_t *ctx;
766 
767  TLS_DBG (1, "Disconnecting %x", ctx_handle);
768 
769  ctx = tls_ctx_get (ctx_handle);
771 }
772 
773 u32
774 tls_start_listen (u32 app_listener_index, transport_endpoint_t * tep)
775 {
776  vnet_listen_args_t _bargs, *args = &_bargs;
778  app_worker_t *app_wrk;
779  tls_main_t *tm = &tls_main;
780  session_handle_t tls_al_handle;
782  session_t *tls_listener;
783  session_t *app_listener;
784  crypto_engine_type_t engine_type;
785  application_t *app;
786  app_listener_t *al;
787  tls_ctx_t *lctx;
788  u32 lctx_index;
789  int rv;
790 
791  sep = (session_endpoint_cfg_t *) tep;
792  if (!sep->ext_cfg)
793  return SESSION_E_NOEXTCFG;
794 
795  app_wrk = app_worker_get (sep->app_wrk_index);
796  app = application_get (app_wrk->app_index);
797 
798  ccfg = &sep->ext_cfg->crypto;
799  engine_type = tls_get_engine_type (ccfg->crypto_engine, app->tls_engine);
800  if (engine_type == CRYPTO_ENGINE_NONE)
801  {
802  clib_warning ("No tls engine_type available");
803  return SESSION_E_NOCRYPTOENG;
804  }
805 
806  clib_memset (args, 0, sizeof (*args));
807  args->app_index = tm->app_index;
808  args->sep_ext = *sep;
809  args->sep_ext.ns_index = app->ns_index;
810  args->sep_ext.transport_proto = TRANSPORT_PROTO_TCP;
811  if (sep->transport_proto == TRANSPORT_PROTO_DTLS)
812  {
813  args->sep_ext.transport_proto = TRANSPORT_PROTO_UDP;
814  args->sep_ext.transport_flags = TRANSPORT_CFG_F_CONNECTED;
815  }
816  if ((rv = vnet_listen (args)))
817  return rv;
818 
819  lctx_index = tls_listener_ctx_alloc ();
820  tls_al_handle = args->handle;
821  al = app_listener_get_w_handle (tls_al_handle);
822  tls_listener = app_listener_get_session (al);
823  tls_listener->opaque = lctx_index;
824 
825  app_listener = listen_session_get (app_listener_index);
826 
827  lctx = tls_listener_ctx_get (lctx_index);
828  lctx->parent_app_wrk_index = sep->app_wrk_index;
829  lctx->tls_session_handle = tls_al_handle;
830  lctx->app_session_handle = listen_session_get_handle (app_listener);
831  lctx->tcp_is_ip4 = sep->is_ip4;
832  lctx->tls_ctx_engine = engine_type;
833  lctx->tls_type = sep->transport_proto;
834  lctx->ckpair_index = ccfg->ckpair_index;
835 
836  if (tls_vfts[engine_type].ctx_start_listen (lctx))
837  {
839  .handle = lctx->tls_session_handle,
840  .app_index = tls_main.app_index,
841  .wrk_map_index = 0
842  };
843  if ((vnet_unlisten (&a)))
844  clib_warning ("unlisten returned");
845  tls_listener_ctx_free (lctx);
846  lctx_index = SESSION_INVALID_INDEX;
847  }
848 
849  TLS_DBG (1, "Started listening %d, engine type %d", lctx_index,
850  engine_type);
851  return lctx_index;
852 }
853 
854 u32
855 tls_stop_listen (u32 lctx_index)
856 {
858  crypto_engine_type_t engine_type;
860  tls_ctx_t *lctx;
861  session_t *ls;
862  int rv;
863 
864  lctx = tls_listener_ctx_get (lctx_index);
865 
866  /* Cleanup listener from session lookup table */
867  ls = session_get_from_handle (lctx->tls_session_handle);
868  lc = session_get_transport (ls);
869 
870  sep.fib_index = lc->fib_index;
871  sep.port = lc->lcl_port;
872  sep.is_ip4 = lc->is_ip4;
873  sep.transport_proto = lctx->tls_type;
874  clib_memcpy (&sep.ip, &lc->lcl_ip, sizeof (lc->lcl_ip));
876 
878  .handle = lctx->tls_session_handle,
879  .app_index = tls_main.app_index,
880  .wrk_map_index = 0 /* default wrk */
881  };
882  if ((rv = vnet_unlisten (&a)))
883  clib_warning ("unlisten returned %d", rv);
884 
885  engine_type = lctx->tls_ctx_engine;
886  tls_vfts[engine_type].ctx_stop_listen (lctx);
887 
888  tls_listener_ctx_free (lctx);
889  return 0;
890 }
891 
894 {
895  tls_ctx_t *ctx;
896  ctx = tls_ctx_get_w_thread (ctx_index, thread_index);
897  return &ctx->connection;
898 }
899 
901 tls_listener_get (u32 listener_index)
902 {
903  tls_ctx_t *ctx;
904  ctx = tls_listener_ctx_get (listener_index);
905  return &ctx->connection;
906 }
907 
908 static transport_connection_t *
910 {
911  tls_main_t *tm = &tls_main;
912  tls_ctx_t *ctx;
913  ctx = tls_ctx_half_open_get (ho_index);
915  return &ctx->connection;
916 }
917 
918 static void
919 tls_cleanup_ho (u32 ho_index)
920 {
921  tls_main_t *tm = &tls_main;
922  session_handle_t tcp_sh;
923  tls_ctx_t *ctx;
924 
925  ctx = tls_ctx_half_open_get (ho_index);
926  tcp_sh = ctx->tls_session_handle;
928  session_cleanup_half_open (tcp_sh);
929  tls_ctx_half_open_free (ho_index);
930 }
931 
932 int
934 {
935  session_t *app_session = (session_t *) session;
936  tls_ctx_t *ctx;
937 
938  if (PREDICT_FALSE (app_session->session_state
939  >= SESSION_STATE_TRANSPORT_CLOSED))
940  return 0;
941 
942  sp->flags = 0;
943  ctx = tls_ctx_get (app_session->connection_index);
944  return tls_ctx_write (ctx, app_session, sp);
945 }
946 
947 u8 *
948 format_tls_ctx (u8 * s, va_list * args)
949 {
950  u32 tcp_si, tcp_ti, ctx_index, ctx_engine;
951  tls_ctx_t *ctx = va_arg (*args, tls_ctx_t *);
952  char *proto;
953 
954  proto = ctx->tls_type == TRANSPORT_PROTO_TLS ? "TLS" : "DTLS";
955  session_parse_handle (ctx->tls_session_handle, &tcp_si, &tcp_ti);
956  tls_ctx_parse_handle (ctx->tls_ctx_handle, &ctx_index, &ctx_engine);
957  s =
958  format (s, "[%d:%d][%s] app_wrk %u index %u engine %u ts %d:%d",
959  ctx->c_thread_index, ctx->c_s_index, proto,
960  ctx->parent_app_wrk_index, ctx_index, ctx_engine, tcp_ti, tcp_si);
961 
962  return s;
963 }
964 
965 static u8 *
966 format_tls_listener_ctx (u8 * s, va_list * args)
967 {
968  session_t *tls_listener;
969  app_listener_t *al;
970  tls_ctx_t *ctx;
971  char *proto;
972 
973  ctx = va_arg (*args, tls_ctx_t *);
974 
975  proto = ctx->tls_type == TRANSPORT_PROTO_TLS ? "TLS" : "DTLS";
976  al = app_listener_get_w_handle (ctx->tls_session_handle);
977  tls_listener = app_listener_get_session (al);
978  s = format (s, "[%d:%d][%s] app_wrk %u engine %u ts %d:%d",
979  ctx->c_thread_index, ctx->c_s_index, proto,
980  ctx->parent_app_wrk_index, ctx->tls_ctx_engine,
981  tls_listener->thread_index, tls_listener->session_index);
982 
983  return s;
984 }
985 
986 static u8 *
987 format_tls_ctx_state (u8 * s, va_list * args)
988 {
989  tls_ctx_t *ctx;
990  session_t *ts;
991 
992  ctx = va_arg (*args, tls_ctx_t *);
993  ts = session_get (ctx->c_s_index, ctx->c_thread_index);
994  if (ts->session_state == SESSION_STATE_LISTENING)
995  s = format (s, "%s", "LISTEN");
996  else
997  {
998  if (ts->session_state >= SESSION_STATE_TRANSPORT_CLOSED)
999  s = format (s, "%s", "CLOSED");
1000  else if (ts->session_state == SESSION_STATE_APP_CLOSED)
1001  s = format (s, "%s", "APP-CLOSED");
1002  else if (ts->session_state >= SESSION_STATE_TRANSPORT_CLOSING)
1003  s = format (s, "%s", "CLOSING");
1004  else if (tls_ctx_handshake_is_over (ctx))
1005  s = format (s, "%s", "ESTABLISHED");
1006  else
1007  s = format (s, "%s", "HANDSHAKE");
1008  }
1009 
1010  return s;
1011 }
1012 
1013 u8 *
1014 format_tls_connection (u8 * s, va_list * args)
1015 {
1016  u32 ctx_index = va_arg (*args, u32);
1017  u32 thread_index = va_arg (*args, u32);
1018  u32 verbose = va_arg (*args, u32);
1019  tls_ctx_t *ctx;
1020 
1021  ctx = tls_ctx_get_w_thread (ctx_index, thread_index);
1022  if (!ctx)
1023  return s;
1024 
1025  s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_tls_ctx, ctx);
1026  if (verbose)
1027  {
1029  ctx);
1030  if (verbose > 1)
1031  s = format (s, "\n");
1032  }
1033  return s;
1034 }
1035 
1036 u8 *
1037 format_tls_listener (u8 * s, va_list * args)
1038 {
1039  u32 tc_index = va_arg (*args, u32);
1040  u32 __clib_unused thread_index = va_arg (*args, u32);
1041  u32 verbose = va_arg (*args, u32);
1042  tls_ctx_t *ctx = tls_listener_ctx_get (tc_index);
1043 
1045  if (verbose)
1047  return s;
1048 }
1049 
1050 u8 *
1051 format_tls_half_open (u8 * s, va_list * args)
1052 {
1053  u32 ho_index = va_arg (*args, u32);
1054  u32 __clib_unused thread_index = va_arg (*args, u32);
1055  session_t *tcp_ho;
1056  tls_ctx_t *ho_ctx;
1057 
1058  ho_ctx = tls_ctx_half_open_get (ho_index);
1059 
1060  tcp_ho = session_get_from_handle (ho_ctx->tls_session_handle);
1061  s = format (s, "[%d:%d][%s] half-open app_wrk %u engine %u ts %d:%d",
1062  ho_ctx->c_thread_index, ho_ctx->c_s_index, "TLS",
1063  ho_ctx->parent_app_wrk_index, ho_ctx->tls_ctx_engine,
1064  tcp_ho->thread_index, tcp_ho->session_index);
1065 
1067  return s;
1068 }
1069 
1070 static void
1072  transport_endpoint_t * tep, u8 is_lcl)
1073 {
1075  session_t *tcp_session;
1076 
1077  tcp_session = session_get_from_handle (ctx->tls_session_handle);
1078  session_get_endpoint (tcp_session, tep, is_lcl);
1079 }
1080 
1081 static void
1083  transport_endpoint_t * tep, u8 is_lcl)
1084 {
1085  session_t *tls_listener;
1086  app_listener_t *al;
1087  tls_ctx_t *ctx = tls_listener_ctx_get (ctx_handle);
1088 
1089  al = app_listener_get_w_handle (ctx->tls_session_handle);
1090  tls_listener = app_listener_get_session (al);
1091  session_get_endpoint (tls_listener, tep, is_lcl);
1092 }
1093 
1094 static clib_error_t *
1096 {
1097  u32 add_segment_size = 256 << 20, first_seg_size = 32 << 20;
1098  vnet_app_detach_args_t _da, *da = &_da;
1099  vnet_app_attach_args_t _a, *a = &_a;
1101  tls_main_t *tm = &tls_main;
1102  u32 fifo_size = 128 << 12;
1103 
1104  if (!is_en)
1105  {
1106  da->app_index = tm->app_index;
1107  da->api_client_index = APP_INVALID_INDEX;
1109  return 0;
1110  }
1111 
1112  first_seg_size = tm->first_seg_size ? tm->first_seg_size : first_seg_size;
1113  fifo_size = tm->fifo_size ? tm->fifo_size : fifo_size;
1114 
1115  clib_memset (a, 0, sizeof (*a));
1116  clib_memset (options, 0, sizeof (options));
1117 
1118  a->session_cb_vft = &tls_app_cb_vft;
1119  a->api_client_index = APP_INVALID_INDEX;
1120  a->options = options;
1121  a->name = format (0, "tls");
1122  a->options[APP_OPTIONS_SEGMENT_SIZE] = first_seg_size;
1123  a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = add_segment_size;
1124  a->options[APP_OPTIONS_RX_FIFO_SIZE] = fifo_size;
1125  a->options[APP_OPTIONS_TX_FIFO_SIZE] = fifo_size;
1126  a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
1127  a->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1128  a->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_IS_TRANSPORT_APP;
1129 
1130  if (vnet_application_attach (a))
1131  {
1132  clib_warning ("failed to attach tls app");
1133  return clib_error_return (0, "failed to attach tls app");
1134  }
1135 
1136  tm->app_index = a->app_index;
1137  vec_free (a->name);
1138 
1139  return 0;
1140 }
1141 
1143  .enable = tls_enable,
1144  .connect = tls_connect,
1145  .close = tls_disconnect,
1146  .start_listen = tls_start_listen,
1147  .stop_listen = tls_stop_listen,
1148  .get_connection = tls_connection_get,
1149  .get_listener = tls_listener_get,
1150  .get_half_open = tls_half_open_get,
1151  .cleanup_ho = tls_cleanup_ho,
1152  .custom_tx = tls_custom_tx_callback,
1153  .format_connection = format_tls_connection,
1154  .format_half_open = format_tls_half_open,
1155  .format_listener = format_tls_listener,
1156  .get_transport_endpoint = tls_transport_endpoint_get,
1157  .get_transport_listener_endpoint = tls_transport_listener_endpoint_get,
1158  .transport_options = {
1159  .name = "tls",
1160  .short_name = "J",
1161  .tx_type = TRANSPORT_TX_INTERNAL,
1162  .service_type = TRANSPORT_SERVICE_VC,
1163  },
1164 };
1165 
1166 int
1168 {
1169  vnet_connect_args_t _cargs = { {}, }, *cargs = &_cargs;
1171  crypto_engine_type_t engine_type;
1173  tls_main_t *tm = &tls_main;
1174  app_worker_t *app_wrk;
1175  application_t *app;
1176  tls_ctx_t *ctx;
1177  u32 ctx_handle;
1178  int rv;
1179 
1180  sep = (session_endpoint_cfg_t *) tep;
1181  if (!sep->ext_cfg)
1182  return -1;
1183 
1184  app_wrk = app_worker_get (sep->app_wrk_index);
1185  app = application_get (app_wrk->app_index);
1186 
1187  ccfg = &sep->ext_cfg->crypto;
1188  engine_type = tls_get_engine_type (ccfg->crypto_engine, app->tls_engine);
1189  if (engine_type == CRYPTO_ENGINE_NONE)
1190  {
1191  clib_warning ("No tls engine_type available");
1192  return -1;
1193  }
1194 
1195  ctx_handle = tls_ctx_alloc_w_thread (engine_type, transport_cl_thread ());
1196  ctx = tls_ctx_get_w_thread (ctx_handle, transport_cl_thread ());
1197  ctx->parent_app_wrk_index = sep->app_wrk_index;
1198  ctx->parent_app_api_context = sep->opaque;
1199  ctx->tcp_is_ip4 = sep->is_ip4;
1200  ctx->ckpair_index = ccfg->ckpair_index;
1201  ctx->tls_type = sep->transport_proto;
1202  ctx->tls_ctx_handle = ctx_handle;
1203  ctx->c_proto = TRANSPORT_PROTO_DTLS;
1205  if (ccfg->hostname[0])
1206  {
1207  ctx->srv_hostname = format (0, "%s", ccfg->hostname);
1208  vec_terminate_c_string (ctx->srv_hostname);
1209  }
1210 
1211  ctx->tls_ctx_engine = engine_type;
1212 
1213  clib_memcpy_fast (&cargs->sep, sep, sizeof (session_endpoint_t));
1214  cargs->sep.transport_proto = TRANSPORT_PROTO_UDP;
1215  cargs->app_index = tm->app_index;
1216  cargs->api_context = ctx_handle;
1217  cargs->sep_ext.ns_index = app->ns_index;
1218  cargs->sep_ext.transport_flags = TRANSPORT_CFG_F_CONNECTED;
1219  if ((rv = vnet_connect (cargs)))
1220  return rv;
1221 
1222  TLS_DBG (1, "New DTLS connect request %x engine %d", ctx_handle,
1223  engine_type);
1224  return ctx_handle;
1225 }
1226 
1227 static transport_connection_t *
1229 {
1230  tls_ctx_t *ho_ctx;
1231  ho_ctx = tls_ctx_get_w_thread (ho_index, transport_cl_thread ());
1232  return &ho_ctx->connection;
1233 }
1234 
1235 static void
1237 {
1238  /* No op */
1239 }
1240 
1241 static void
1243 {
1244  tls_ctx_t *ctx;
1245  ctx = tls_ctx_get_w_thread (ho_index, transport_cl_thread ());
1246  tls_ctx_free (ctx);
1247 }
1248 
1249 u8 *
1250 format_dtls_half_open (u8 *s, va_list *args)
1251 {
1252  u32 ho_index = va_arg (*args, u32);
1253  u32 __clib_unused thread_index = va_arg (*args, u32);
1254  tls_ctx_t *ho_ctx;
1255  session_t *us;
1256 
1257  ho_ctx = tls_ctx_get_w_thread (ho_index, transport_cl_thread ());
1258 
1259  us = session_get_from_handle (ho_ctx->tls_session_handle);
1260  s = format (s, "[%d:%d][%s] half-open app_wrk %u engine %u us %d:%d",
1261  ho_ctx->c_thread_index, ho_ctx->c_s_index, "DTLS",
1262  ho_ctx->parent_app_wrk_index, ho_ctx->tls_ctx_engine,
1263  us->thread_index, us->session_index);
1264 
1265  return s;
1266 }
1267 
1269  .enable = 0,
1270  .connect = dtls_connect,
1271  .close = tls_disconnect,
1272  .start_listen = tls_start_listen,
1273  .stop_listen = tls_stop_listen,
1274  .get_connection = tls_connection_get,
1275  .get_listener = tls_listener_get,
1276  .get_half_open = dtls_half_open_get,
1277  .custom_tx = tls_custom_tx_callback,
1278  .cleanup = dtls_cleanup_callback,
1279  .cleanup_ho = dtls_cleanup_ho,
1280  .format_connection = format_tls_connection,
1281  .format_half_open = format_dtls_half_open,
1282  .format_listener = format_tls_listener,
1283  .get_transport_endpoint = tls_transport_endpoint_get,
1284  .get_transport_listener_endpoint = tls_transport_listener_endpoint_get,
1285  .transport_options = {
1286  .name = "dtls",
1287  .short_name = "D",
1288  .tx_type = TRANSPORT_TX_INTERNAL,
1289  .service_type = TRANSPORT_SERVICE_VC,
1290  },
1291 };
1292 
1293 void
1295 {
1297  tls_vfts[type] = *vft;
1298 }
1299 
1300 static clib_error_t *
1302 {
1304  tls_main_t *tm = &tls_main;
1305  u32 num_threads;
1306 
1307  num_threads = 1 /* main thread */ + vtm->n_threads;
1308 
1309  if (!tm->ca_cert_path)
1311 
1313 
1314  vec_validate (tm->rx_bufs, num_threads - 1);
1315  vec_validate (tm->tx_bufs, num_threads - 1);
1316 
1317  transport_register_protocol (TRANSPORT_PROTO_TLS, &tls_proto,
1318  FIB_PROTOCOL_IP4, ~0);
1319  transport_register_protocol (TRANSPORT_PROTO_TLS, &tls_proto,
1320  FIB_PROTOCOL_IP6, ~0);
1321 
1322  transport_register_protocol (TRANSPORT_PROTO_DTLS, &dtls_proto,
1323  FIB_PROTOCOL_IP4, ~0);
1324  transport_register_protocol (TRANSPORT_PROTO_DTLS, &dtls_proto,
1325  FIB_PROTOCOL_IP6, ~0);
1326  return 0;
1327 }
1328 
1330 
1331 static clib_error_t *
1333 {
1334  tls_main_t *tm = &tls_main;
1335  uword tmp;
1336  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1337  {
1338  if (unformat (input, "use-test-cert-in-ca"))
1339  tm->use_test_cert_in_ca = 1;
1340  else if (unformat (input, "ca-cert-path %s", &tm->ca_cert_path))
1341  ;
1342  else if (unformat (input, "first-segment-size %U", unformat_memory_size,
1343  &tm->first_seg_size))
1344  ;
1345  else if (unformat (input, "fifo-size %U", unformat_memory_size, &tmp))
1346  {
1347  if (tmp >= 0x100000000ULL)
1348  {
1349  return clib_error_return
1350  (0, "fifo-size %llu (0x%llx) too large", tmp, tmp);
1351  }
1352  tm->fifo_size = tmp;
1353  }
1354  else
1355  return clib_error_return (0, "unknown input `%U'",
1356  format_unformat_error, input);
1357  }
1358  return 0;
1359 }
1360 
1362 
1363 tls_main_t *
1365 {
1366  return &tls_main;
1367 }
1368 
1369 /*
1370  * fd.io coding-style-patch-verification: ON
1371  *
1372  * Local Variables:
1373  * eval: (c-set-style "gnu")
1374  * End:
1375  */
tls_app_tx_callback
int tls_app_tx_callback(session_t *tls_session)
Definition: tls.c:521
vnet_listen
int vnet_listen(vnet_listen_args_t *a)
Definition: application.c:1266
tmp
u32 * tmp
Definition: interface_output.c:1078
tls_main_
Definition: tls.h:90
application_::tls_engine
u8 tls_engine
Preferred tls engine.
Definition: application.h:137
tls_stop_listen
u32 tls_stop_listen(u32 lctx_index)
Definition: tls.c:855
SESSION_CLI_STATE_LEN
#define SESSION_CLI_STATE_LEN
Definition: session_types.h:507
svm_fifo_set_event
static u8 svm_fifo_set_event(svm_fifo_t *f)
Set fifo event flag.
Definition: svm_fifo.h:790
tls_ctx_half_open_free
void tls_ctx_half_open_free(u32 ho_index)
Definition: tls.c:144
crypto_engine_type_t
enum crypto_engine_type_ crypto_engine_type_t
vlib_num_workers
static u32 vlib_num_workers()
Definition: threads.h:354
session_error_t
enum session_error_ session_error_t
tls_ctx_transport_close
static int tls_ctx_transport_close(tls_ctx_t *ctx)
Definition: tls.c:379
dtls_session_connected_cb
int dtls_session_connected_cb(u32 app_wrk_index, u32 ctx_handle, session_t *us, session_error_t err)
Definition: tls.c:589
thread_index
u32 thread_index
Definition: nat44_ei_hairpinning.c:492
vnet_connect
int vnet_connect(vnet_connect_args_t *a)
Definition: application.c:1320
tls_ctx_read
static int tls_ctx_read(tls_ctx_t *ctx, session_t *tls_session)
Definition: tls.c:373
failed
description security check failed
Definition: map.api:373
APP_OPTIONS_RX_FIFO_SIZE
@ APP_OPTIONS_RX_FIFO_SIZE
Definition: application_interface.h:210
session_::session_index
u32 session_index
Index in thread pool where session was allocated.
Definition: session_types.h:188
tls_notify_app_connected
int tls_notify_app_connected(tls_ctx_t *ctx, session_error_t err)
Definition: tls.c:212
tls_engine_vft_::ctx_write
int(* ctx_write)(tls_ctx_t *ctx, session_t *app_session, transport_send_params_t *sp)
Definition: tls.h:120
format_dtls_half_open
u8 * format_dtls_half_open(u8 *s, va_list *args)
Definition: tls.c:1250
clib_memcpy
#define clib_memcpy(d, s, n)
Definition: string.h:197
tls_engine_vft_::ctx_app_close
int(* ctx_app_close)(tls_ctx_t *ctx)
Definition: tls.h:126
SESSION_CLI_ID_LEN
#define SESSION_CLI_ID_LEN
Definition: session_types.h:506
session_type_t
u8 session_type_t
Definition: session_types.h:110
TLS_IDX_MASK
#define TLS_IDX_MASK
Definition: tls.c:24
session_close
void session_close(session_t *s)
Initialize session closing procedure.
Definition: session.c:1496
format_tls_ctx_state
static u8 * format_tls_ctx_state(u8 *s, va_list *args)
Definition: tls.c:987
clib_max
#define clib_max(x, y)
Definition: clib.h:335
tls_ctx_half_open_reader_unlock
void tls_ctx_half_open_reader_unlock()
Definition: tls.c:161
session_parse_handle
static void session_parse_handle(session_handle_t handle, u32 *index, u32 *thread_index)
Definition: session_types.h:301
session_half_open_delete_notify
void session_half_open_delete_notify(transport_connection_t *tc)
Definition: session.c:347
pool_elt_at_index
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:553
tls_ctx_alloc
static u32 tls_ctx_alloc(crypto_engine_type_t engine_type)
Definition: tls.c:303
session_get_endpoint
void session_get_endpoint(session_t *s, transport_endpoint_t *tep, u8 is_lcl)
Definition: session.c:1756
vnet_unlisten
int vnet_unlisten(vnet_unlisten_args_t *a)
Definition: application.c:1359
tls_ctx_attach
static u32 tls_ctx_attach(crypto_engine_type_t engine_type, u32 thread_index, void *ctx)
Definition: tls.c:319
tls_main_::app_index
u32 app_index
Definition: tls.h:92
tls_get_available_engine
crypto_engine_type_t tls_get_available_engine(void)
Definition: tls.c:42
listen_session_get_handle
static u64 listen_session_get_handle(session_t *s)
Definition: session.h:622
session_::tx_fifo
svm_fifo_t * tx_fifo
Definition: session_types.h:179
tls_main_::listener_ctx_pool
tls_ctx_t * listener_ctx_pool
Definition: tls.h:93
tls_main_::tx_bufs
u8 ** tx_bufs
Definition: tls.h:97
tls_add_vpp_q_rx_evt
int tls_add_vpp_q_rx_evt(session_t *s)
Definition: tls.c:54
dtls_cleanup_ho
static void dtls_cleanup_ho(u32 ho_index)
Definition: tls.c:1242
session_
Definition: session_types.h:175
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
session_endpoint_cfg_t
struct _session_endpoint_cfg session_endpoint_cfg_t
session_handle_t
u64 session_handle_t
Definition: session_types.h:111
transport_proto_vft_t
struct _transport_proto_vft transport_proto_vft_t
tls_notify_app_accept
int tls_notify_app_accept(tls_ctx_t *ctx)
Definition: tls.c:182
listen_session_get
static session_t * listen_session_get(u32 ls_index)
Definition: session.h:653
SESSION_INVALID_INDEX
#define SESSION_INVALID_INDEX
Definition: session_types.h:22
tls_notify_app_enqueue
void tls_notify_app_enqueue(tls_ctx_t *ctx, session_t *app_session)
Definition: tls.c:173
session_half_open_migrated_notify
int session_half_open_migrated_notify(transport_connection_t *tc)
Definition: session.c:373
APP_INVALID_INDEX
#define APP_INVALID_INDEX
Definition: application.h:226
SESSION_IO_EVT_RX
@ SESSION_IO_EVT_RX
Definition: session_types.h:328
vnet_application_detach
int vnet_application_detach(vnet_app_detach_args_t *a)
Detach application from vpp.
Definition: application.c:1188
session_::thread_index
u8 thread_index
Index of the thread that allocated the session.
Definition: session_types.h:194
pool_put
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:305
session_::session_type
session_type_t session_type
Type built from transport and network protocol types.
Definition: session_types.h:182
tls_ctx_half_open_get
tls_ctx_t * tls_ctx_half_open_get(u32 ctx_index)
Definition: tls.c:153
tls_ctx_::tls_type
transport_proto_t tls_type
Definition: tls.h:87
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
tls_engine_vft_
Definition: tls.h:108
transport_connection_reschedule
void transport_connection_reschedule(transport_connection_t *tc)
Definition: transport.c:790
session_transport_closed_notify
void session_transport_closed_notify(transport_connection_t *tc)
Notification from transport that it is closed.
Definition: session.c:1150
tls_listener_ctx_free
void tls_listener_ctx_free(tls_ctx_t *ctx)
Definition: tls.c:95
tls_listener_get
transport_connection_t * tls_listener_get(u32 listener_index)
Definition: tls.c:901
vnet_unlisten_args_t
struct _vnet_unlisten_args_t vnet_unlisten_args_t
application_
Definition: application.h:108
APP_OPTIONS_SEGMENT_SIZE
@ APP_OPTIONS_SEGMENT_SIZE
Definition: application_interface.h:207
session_thread_from_handle
static u32 session_thread_from_handle(session_handle_t handle)
Definition: session_types.h:295
vnet_app_detach_args_t
struct _vnet_app_detach_args_t vnet_app_detach_args_t
transport_connection_t
struct _transport_connection transport_connection_t
unformat_input_t
struct _unformat_input_t unformat_input_t
tls_custom_tx_callback
int tls_custom_tx_callback(void *session, transport_send_params_t *sp)
Definition: tls.c:933
clib_rwlock_reader_lock
static void clib_rwlock_reader_lock(clib_rwlock_t *p)
Definition: lock.h:169
dtls_connect
int dtls_connect(transport_endpoint_cfg_t *tep)
Definition: tls.c:1167
transport_endpoint_pair_
Definition: transport_types.h:212
clib_memcpy_fast
static_always_inline void * clib_memcpy_fast(void *restrict dst, const void *restrict src, size_t n)
Definition: string.h:92
clib_rwlock_reader_unlock
static void clib_rwlock_reader_unlock(clib_rwlock_t *p)
Definition: lock.h:184
tls_listener_ctx_index
u32 tls_listener_ctx_index(tls_ctx_t *ctx)
Definition: tls.c:109
session_free
void session_free(session_t *s)
Definition: session.c:227
pool_put_index
#define pool_put_index(p, i)
Free pool element with given index.
Definition: pool.h:337
APP_OPTIONS_N_OPTIONS
@ APP_OPTIONS_N_OPTIONS
Definition: application_interface.h:223
clib_rwlock_writer_unlock
static void clib_rwlock_writer_unlock(clib_rwlock_t *p)
Definition: lock.h:206
VLIB_EARLY_CONFIG_FUNCTION
#define VLIB_EARLY_CONFIG_FUNCTION(x, n,...)
Definition: init.h:220
session_cb_vft_::session_accept_callback
int(* session_accept_callback)(session_t *new_session)
Notify server of newly accepted session.
Definition: application_interface.h:41
tls_proto
static const transport_proto_vft_t tls_proto
Definition: tls.c:1142
pool_get_aligned_will_expand
#define pool_get_aligned_will_expand(P, YESNO, A)
See if pool_get will expand the pool or not.
Definition: pool.h:261
tls_disconnect_transport
void tls_disconnect_transport(tls_ctx_t *ctx)
Definition: tls.c:30
transport_endpt_crypto_cfg_::hostname
u8 hostname[256]
full domain len is 255 as per rfc 3986
Definition: transport_types.h:273
tls_main_::use_test_cert_in_ca
u8 use_test_cert_in_ca
Definition: tls.h:102
tls_ctx_init_server
static int tls_ctx_init_server(tls_ctx_t *ctx)
Definition: tls.c:349
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
SESSION_CLEANUP_TRANSPORT
@ SESSION_CLEANUP_TRANSPORT
Definition: session_types.h:115
application_get
application_t * application_get(u32 app_index)
Definition: application.c:710
tls_main_::ca_cert_path
char * ca_cert_path
Definition: tls.h:103
session_cb_vft_
Definition: application_interface.h:32
tls_listener_ctx_alloc
u32 tls_listener_ctx_alloc(void)
Definition: tls.c:84
tls_session_reset_callback
void tls_session_reset_callback(session_t *s)
Definition: tls.c:403
session_::app_wrk_index
u32 app_wrk_index
Index of the app worker that owns the session.
Definition: session_types.h:191
app_worker_init_connected
int app_worker_init_connected(app_worker_t *app_wrk, session_t *s)
Definition: application_worker.c:358
TLS_DBG
#define TLS_DBG(_lvl, _fmt, _args...)
Definition: tls.h:36
session_::rx_fifo
svm_fifo_t * rx_fifo
Pointers to rx/tx buffers.
Definition: session_types.h:178
unformat_memory_size
unformat_function_t unformat_memory_size
Definition: format.h:288
dtls_proto
static const transport_proto_vft_t dtls_proto
Definition: tls.c:1268
SESSION_IO_EVT_BUILTIN_RX
@ SESSION_IO_EVT_BUILTIN_RX
Definition: session_types.h:331
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
TRANSPORT_PACER_MIN_MSS
#define TRANSPORT_PACER_MIN_MSS
Definition: transport.h:22
tls_add_app_q_evt
static int tls_add_app_q_evt(app_worker_t *app, session_t *app_session)
Definition: tls.c:78
tls_add_vpp_q_builtin_rx_evt
int tls_add_vpp_q_builtin_rx_evt(session_t *s)
Definition: tls.c:62
tls_engine_vft_::ctx_stop_listen
int(* ctx_stop_listen)(tls_ctx_t *ctx)
Definition: tls.h:124
tls_ctx_
Definition: tls.h:59
tls_transport_listener_endpoint_get
static void tls_transport_listener_endpoint_get(u32 ctx_handle, transport_endpoint_t *tep, u8 is_lcl)
Definition: tls.c:1082
vnet_disconnect_args_t
struct _vnet_disconnect_args_t vnet_disconnect_args_t
session_get_transport
transport_connection_t * session_get_transport(session_t *s)
Definition: session.c:1745
lock.h
tls_main_::first_seg_size
u64 first_seg_size
Definition: tls.h:104
PREDICT_FALSE
#define PREDICT_FALSE(x)
Definition: clib.h:124
vlib_get_thread_index
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:208
app_worker_get_if_valid
app_worker_t * app_worker_get_if_valid(u32 wrk_index)
Definition: application_worker.c:47
tls_cleanup_ho
static void tls_cleanup_ho(u32 ho_index)
Definition: tls.c:919
vnet_listen_args_t
struct _vnet_bind_args_t vnet_listen_args_t
unformat_check_input
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
vlib_config_function_runtime_t
Definition: init.h:68
tls_ctx_handshake_is_over
u8 tls_ctx_handshake_is_over(tls_ctx_t *ctx)
Definition: tls.c:397
clib_rwlock_writer_lock
static void clib_rwlock_writer_lock(clib_rwlock_t *p)
Definition: lock.h:192
tls_ctx_::connection
transport_connection_t connection
Definition: tls.h:63
uword
u64 uword
Definition: types.h:112
TLS_CA_CERT_PATH
#define TLS_CA_CERT_PATH
Definition: tls.h:29
dtls_half_open_get
static transport_connection_t * dtls_half_open_get(u32 ho_index)
Definition: tls.c:1228
tls_engine_vft_::ctx_get_w_thread
tls_ctx_t *(* ctx_get_w_thread)(u32 ctx_index, u8 thread_index)
Definition: tls.h:116
vlib_thread_is_main_w_barrier
static u8 vlib_thread_is_main_w_barrier(void)
Definition: threads.h:506
dtls_cleanup_callback
static void dtls_cleanup_callback(u32 ctx_index, u32 thread_index)
Definition: tls.c:1236
format_tls_ctx
u8 * format_tls_ctx(u8 *s, va_list *args)
Definition: tls.c:948
transport_cl_thread
static u32 transport_cl_thread(void)
Definition: session.h:612
tls_add_segment_callback
int tls_add_segment_callback(u32 client_index, u64 segment_handle)
Definition: tls.c:443
tls_engine_vft_::ctx_free
void(* ctx_free)(tls_ctx_t *ctx)
Definition: tls.h:112
session_send_rpc_evt_to_thread
void session_send_rpc_evt_to_thread(u32 thread_index, void *fp, void *rpc_args)
Definition: session.c:116
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
tls_main_::fifo_size
u32 fifo_size
Definition: tls.h:105
session_handle
static session_handle_t session_handle(session_t *s)
Definition: session_types.h:283
TRANSPORT_CFG_F_CONNECTED
@ TRANSPORT_CFG_F_CONNECTED
Definition: transport_types.h:202
application_::ns_index
u32 ns_index
Namespace the application belongs to.
Definition: application.h:129
transport_endpt_crypto_cfg_::ckpair_index
u32 ckpair_index
Definition: transport_types.h:271
session_half_open_migrate_notify
void session_half_open_migrate_notify(transport_connection_t *tc)
Definition: session.c:363
transport_register_protocol
void transport_register_protocol(transport_proto_t transport_proto, const transport_proto_vft_t *vft, fib_protocol_t fib_proto, u32 output_node)
Register transport virtual function table.
Definition: transport.c:246
format_unformat_error
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
pool_get
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:255
session_get_from_handle
static session_t * session_get_from_handle(session_handle_t handle)
Definition: session.h:356
session_cleanup_half_open
void session_cleanup_half_open(session_handle_t ho_handle)
Definition: session.c:304
vec_validate
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment)
Definition: vec.h:523
tls_session_accept_callback
int tls_session_accept_callback(session_t *tls_session)
Definition: tls.c:472
app_worker_init_accepted
int app_worker_init_accepted(session_t *s)
Definition: application_worker.c:328
tls_session_disconnect_callback
void tls_session_disconnect_callback(session_t *tls_session)
Definition: tls.c:456
SESSION_IO_EVT_TX
@ SESSION_IO_EVT_TX
Definition: session_types.h:329
format_tls_listener
u8 * format_tls_listener(u8 *s, va_list *args)
Definition: tls.c:1037
transport_endpt_crypto_cfg_::crypto_engine
u8 crypto_engine
Definition: transport_types.h:272
FIB_PROTOCOL_IP4
@ FIB_PROTOCOL_IP4
Definition: fib_types.h:36
tls_vfts
static tls_engine_vft_t * tls_vfts
Definition: tls.c:21
tls_session_connected_cb
int tls_session_connected_cb(u32 tls_app_index, u32 ho_ctx_index, session_t *tls_session, session_error_t err)
Definition: tls.c:532
session_get
static session_t * session_get(u32 si, u32 thread_index)
Definition: session.h:336
vnet_disconnect_session
int vnet_disconnect_session(vnet_disconnect_args_t *a)
Definition: application.c:1411
session_transport_delete_notify
void session_transport_delete_notify(transport_connection_t *tc)
Notification from transport that connection is being deleted.
Definition: session.c:1084
app_worker_connect_notify
int app_worker_connect_notify(app_worker_t *app_wrk, session_t *s, session_error_t err, u32 opaque)
Definition: application_worker.c:375
clib_rwlock_init
static void clib_rwlock_init(clib_rwlock_t *p)
Definition: lock.h:152
tls_ctx_parse_handle
static void tls_ctx_parse_handle(u32 ctx_handle, u32 *ctx_index, u32 *engine_type)
Definition: tls.c:281
tls_session_cleanup_ho
static void tls_session_cleanup_ho(session_t *s)
Definition: tls.c:429
tls_main_::half_open_ctx_pool
tls_ctx_t * half_open_ctx_pool
Definition: tls.h:94
tls_get_engine_type
static crypto_engine_type_t tls_get_engine_type(crypto_engine_type_t requested, crypto_engine_type_t preferred)
Definition: tls.c:288
tls_del_segment_callback
int tls_del_segment_callback(u32 client_index, u64 segment_handle)
Definition: tls.c:450
TRANSPORT_TX_INTERNAL
@ TRANSPORT_TX_INTERNAL
apps acting as transports
Definition: transport_types.h:32
session_::listener_handle
session_handle_t listener_handle
Parent listener session index if the result of an accept.
Definition: session_types.h:208
app_listener_get_w_handle
app_listener_t * app_listener_get_w_handle(session_handle_t handle)
Get app listener for listener session handle.
Definition: application.c:88
session_type_from_proto_and_ip
static session_type_t session_type_from_proto_and_ip(transport_proto_t proto, u8 is_ip4)
Definition: session_types.h:224
format_tls_half_open
u8 * format_tls_half_open(u8 *s, va_list *args)
Definition: tls.c:1051
tls_connect
int tls_connect(transport_endpoint_cfg_t *tep)
Definition: tls.c:701
vnet_application_attach
int vnet_application_attach(vnet_app_attach_args_t *a)
Attach application to vpp.
Definition: application.c:1114
transport_send_params_
Definition: transport.h:45
TRANSPORT_SERVICE_VC
@ TRANSPORT_SERVICE_VC
virtual circuit service
Definition: transport_types.h:39
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
tls_engine_vft_::ctx_init_server
int(* ctx_init_server)(tls_ctx_t *ctx)
Definition: tls.h:118
tls_engine_vft_::ctx_transport_close
int(* ctx_transport_close)(tls_ctx_t *ctx)
Definition: tls.h:125
tls_app_session_cleanup
static void tls_app_session_cleanup(session_t *s, session_cleanup_ntf_t ntf)
Definition: tls.c:619
APP_OPTIONS_TX_FIFO_SIZE
@ APP_OPTIONS_TX_FIFO_SIZE
Definition: application_interface.h:211
tls_session_connected_callback
int tls_session_connected_callback(u32 tls_app_index, u32 ho_ctx_index, session_t *tls_session, session_error_t err)
Definition: tls.c:607
SESSION_ENDPOINT_NULL
#define SESSION_ENDPOINT_NULL
Definition: session_types.h:67
TRANSPORT_CONNECTION_F_NO_LOOKUP
@ TRANSPORT_CONNECTION_F_NO_LOOKUP
Don't register connection in lookup.
Definition: transport_types.h:52
vnet_tls_get_main
tls_main_t * vnet_tls_get_main(void)
Definition: tls.c:1364
APP_OPTIONS_ADD_SEGMENT_SIZE
@ APP_OPTIONS_ADD_SEGMENT_SIZE
Definition: application_interface.h:208
u64
unsigned long u64
Definition: types.h:89
tls_ctx_detach
static void * tls_ctx_detach(tls_ctx_t *ctx)
Definition: tls.c:327
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
vlib_thread_main_t::n_threads
u32 n_threads
Definition: threads.h:292
format_tls_listener_ctx
static u8 * format_tls_listener_ctx(u8 *s, va_list *args)
Definition: tls.c:966
tls_engine_vft_::ctx_init_client
int(* ctx_init_client)(tls_ctx_t *ctx)
Definition: tls.h:117
tls_engine_vft_::ctx_get
tls_ctx_t *(* ctx_get)(u32 ctx_index)
Definition: tls.h:115
session_get_if_valid
static session_t * session_get_if_valid(u64 si, u32 thread_index)
Definition: session.h:343
session_::opaque
u32 opaque
Opaque, for general use.
Definition: session_types.h:218
tls_ctx_::ckpair_index
u32 ckpair_index
Definition: tls.h:86
u32
unsigned int u32
Definition: types.h:88
VLIB_INIT_FUNCTION
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:172
transport_endpoint_
Definition: transport_types.h:193
options
static struct option options[]
Definition: main.c:52
vlib_thread_main_t
Definition: threads.h:264
app_worker_lock_and_send_event
int app_worker_lock_and_send_event(app_worker_t *app, session_t *s, u8 evt_type)
Send event to application.
Definition: application_worker.c:706
FIB_PROTOCOL_IP6
@ FIB_PROTOCOL_IP6
Definition: fib_types.h:37
tls_enable
static clib_error_t * tls_enable(vlib_main_t *vm, u8 is_en)
Definition: tls.c:1095
tls_engine_vft_::ctx_read
int(* ctx_read)(tls_ctx_t *ctx, session_t *tls_session)
Definition: tls.h:119
ctx
long ctx[MAX_CONNS]
Definition: main.c:144
app_worker_get
app_worker_t * app_worker_get(u32 wrk_index)
Definition: application_worker.c:41
tls_disconnect
void tls_disconnect(u32 ctx_handle, u32 thread_index)
Definition: tls.c:763
tls_start_listen
u32 tls_start_listen(u32 app_listener_index, transport_endpoint_t *tep)
Definition: tls.c:774
app_worker_
Definition: application.h:32
tls_transport_endpoint_get
static void tls_transport_endpoint_get(u32 ctx_handle, u32 thread_index, transport_endpoint_t *tep, u8 is_lcl)
Definition: tls.c:1071
session_endpoint_t
struct _session_endpoint session_endpoint_t
vnet_connect_args_t
struct _vnet_connect_args vnet_connect_args_t
APP_OPTIONS_FLAGS
@ APP_OPTIONS_FLAGS
Definition: application_interface.h:205
tls_add_vpp_q_tx_evt
int tls_add_vpp_q_tx_evt(session_t *s)
Definition: tls.c:70
tls_ctx_half_open_alloc
u32 tls_ctx_half_open_alloc(void)
Definition: tls.c:115
tls_ctx_app_close
static int tls_ctx_app_close(tls_ctx_t *ctx)
Definition: tls.c:385
tls_main
static tls_main_t tls_main
Definition: tls.c:20
tls_ctx_alloc_w_thread
static u32 tls_ctx_alloc_w_thread(crypto_engine_type_t engine_type, u32 thread_index)
Definition: tls.c:311
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
tls.h
session_get_transport_proto
static transport_proto_t session_get_transport_proto(session_t *s)
Definition: session_types.h:242
tls_main_::rx_bufs
u8 ** rx_bufs
Definition: tls.h:96
application_interface.h
transport_send_params_::max_burst_size
u32 max_burst_size
Definition: transport.h:59
pool_get_zero
#define pool_get_zero(P, E)
Allocate an object E from a pool P and zero it.
Definition: pool.h:258
tls_half_open_get
static transport_connection_t * tls_half_open_get(u32 ho_index)
Definition: tls.c:909
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
a
a
Definition: bitmap.h:544
tls_config_fn
static clib_error_t * tls_config_fn(vlib_main_t *vm, unformat_input_t *input)
Definition: tls.c:1332
vlib_init_function_t
clib_error_t *() vlib_init_function_t(struct vlib_main_t *vm)
Definition: init.h:51
vec_terminate_c_string
#define vec_terminate_c_string(V)
(If necessary) NULL terminate a vector containing a c-string.
Definition: vec.h:1132
tls_engine_vft_::ctx_detach
void *(* ctx_detach)(tls_ctx_t *ctx)
Definition: tls.h:113
session_lookup_del_session_endpoint2
int session_lookup_del_session_endpoint2(session_endpoint_t *sep)
Definition: session_lookup.c:307
tls_engine_vft_::ctx_alloc
u32(* ctx_alloc)(void)
Definition: tls.h:110
TLS_ENGINE_TYPE_SHIFT
#define TLS_ENGINE_TYPE_SHIFT
Definition: tls.c:25
format_tls_connection
u8 * format_tls_connection(u8 *s, va_list *args)
Definition: tls.c:1014
transport_send_params_::flags
transport_snd_flags_t flags
Definition: transport.h:62
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
transport_endpt_crypto_cfg_
Definition: transport_types.h:269
tls_ctx_half_open_index
u32 tls_ctx_half_open_index(tls_ctx_t *ctx)
Definition: tls.c:167
session_::flags
u32 flags
Session flags.
Definition: session_types.h:197
rv
int __clib_unused rv
Definition: application.c:491
tls_engine_vft_::ctx_alloc_w_thread
u32(* ctx_alloc_w_thread)(u32 thread_index)
Definition: tls.h:111
tls_listener_ctx_get
tls_ctx_t * tls_listener_ctx_get(u32 ctx_index)
Definition: tls.c:103
vnet_app_attach_args_t
struct _vnet_app_attach_args_t vnet_app_attach_args_t
tls_init
static clib_error_t * tls_init(vlib_main_t *vm)
Definition: tls.c:1301
app_worker_::app_index
u32 app_index
Index of owning app.
Definition: application.h:43
tls_app_cb_vft
static session_cb_vft_t tls_app_cb_vft
Definition: tls.c:686
proto
vl_api_ip_proto_t proto
Definition: acl_types.api:51
tls_register_engine
void tls_register_engine(const tls_engine_vft_t *vft, crypto_engine_type_t type)
Definition: tls.c:1294
tls_engine_vft_::ctx_attach
u32(* ctx_attach)(u32 thread_index, void *ctx)
Definition: tls.h:114
dtls_migrate_ctx
static void dtls_migrate_ctx(void *arg)
Definition: tls.c:638
session_transport_reset_notify
void session_transport_reset_notify(transport_connection_t *tc)
Notify application that connection has been reset.
Definition: session.c:1187
PREDICT_TRUE
#define PREDICT_TRUE(x)
Definition: clib.h:125
vlib_get_thread_main
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:56
app_worker_accept_notify
int app_worker_accept_notify(app_worker_t *app_wrk, session_t *s)
Definition: application_worker.c:351
app_listener_get_session
session_t * app_listener_get_session(app_listener_t *al)
Definition: application.c:306
tls_engine_vft_::ctx_handshake_is_over
u8(* ctx_handshake_is_over)(tls_ctx_t *ctx)
Definition: tls.h:122
session_alloc
session_t * session_alloc(u32 thread_index)
Definition: session.c:201
session_cleanup_ntf_t
session_cleanup_ntf_t
Definition: session_types.h:113
session_send_io_evt_to_thread
int session_send_io_evt_to_thread(svm_fifo_t *f, session_evt_type_t evt_type)
Definition: session.c:84
session_::session_state
volatile u8 session_state
State in session layer state machine.
Definition: session_types.h:185
tls_main_::half_open_rwlock
clib_rwlock_t half_open_rwlock
Definition: tls.h:95
session_::connection_index
u32 connection_index
Index of the transport connection associated to the session.
Definition: session_types.h:200
dtls_session_migrate_callback
static void dtls_session_migrate_callback(session_t *us, session_handle_t new_sh)
Definition: tls.c:668
CRYPTO_ENGINE_NONE
@ CRYPTO_ENGINE_NONE
Definition: application_interface.h:176
tls_ctx_init_client
static int tls_ctx_init_client(tls_ctx_t *ctx)
Definition: tls.c:355
tls_ctx_write
static int tls_ctx_write(tls_ctx_t *ctx, session_t *app_session, transport_send_params_t *sp)
Definition: tls.c:361
tls_ctx_free
void tls_ctx_free(tls_ctx_t *ctx)
Definition: tls.c:391
tls_connection_get
transport_connection_t * tls_connection_get(u32 ctx_index, u32 thread_index)
Definition: tls.c:893
type
vl_api_fib_path_type_t type
Definition: fib_types.api:123
listen_session_get_from_handle
static session_t * listen_session_get_from_handle(session_handle_t handle)
Definition: session.h:630
tls_app_rx_callback
int tls_app_rx_callback(session_t *tls_session)
Definition: tls.c:507
UNFORMAT_END_OF_INPUT
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
svm_fifo_max_dequeue
static u32 svm_fifo_max_dequeue(svm_fifo_t *f)
Fifo max bytes to dequeue.
Definition: svm_fifo.h:516
tls_ctx_get
static tls_ctx_t * tls_ctx_get(u32 ctx_handle)
Definition: tls.c:333
tls_ctx_get_w_thread
static tls_ctx_t * tls_ctx_get_w_thread(u32 ctx_handle, u8 thread_index)
Definition: tls.c:341
app_listener_
Definition: application.h:79