pthread_exit (0);
}
+static void
+session_unlisten_handler (session_unlisten_msg_t * mp)
+{
+ echo_session_t *listen_session;
+ echo_main_t *em = &echo_main;
+ listen_session = pool_elt_at_index (em->sessions, em->listen_session_index);
+ em->proto_cb_vft->cleanup_cb (listen_session, 0 /* parent_died */ );
+ em->state = STATE_DISCONNECTED;
+}
+
static void
session_bound_handler (session_bound_msg_t * mp)
{
if (mp->retval)
{
- ECHO_FAIL (ECHO_FAIL_SESSION_CONNECT,
- "connection failed with code: %U", format_api_error,
- clib_net_to_host_u32 (mp->retval));
+ if (em->proto_cb_vft->connected_cb)
+ em->
+ proto_cb_vft->connected_cb ((session_connected_bundled_msg_t *) mp,
+ listener_index, 1 /* is_failed */ );
return;
}
echo_session_t *s;
ECHO_LOG (1, "passive close session 0x%lx", mp->handle);
if (!(s = echo_get_session_from_handle (em, mp->handle)))
- return;
+ {
+ ECHO_FAIL (ECHO_FAIL_SESSION_DISCONNECT, "Session 0x%lx not found",
+ mp->handle);
+ return;
+ }
em->proto_cb_vft->disconnected_cb (mp, s);
app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
echo_session_t *s = 0;
ECHO_LOG (1, "Reset session 0x%lx", mp->handle);
if (!(s = echo_get_session_from_handle (em, mp->handle)))
- return;
+ {
+ ECHO_FAIL (ECHO_FAIL_SESSION_RESET, "Session 0x%lx not found",
+ mp->handle);
+ return;
+ }
em->proto_cb_vft->reset_cb (mp, s);
app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
switch (e->event_type)
{
case SESSION_CTRL_EVT_BOUND:
- session_bound_handler ((session_bound_msg_t *) e->data);
- break;
+ return session_bound_handler ((session_bound_msg_t *) e->data);
case SESSION_CTRL_EVT_ACCEPTED:
- session_accepted_handler ((session_accepted_msg_t *) e->data);
- break;
+ return session_accepted_handler ((session_accepted_msg_t *) e->data);
case SESSION_CTRL_EVT_CONNECTED:
- session_connected_handler ((session_connected_msg_t *) e->data);
- break;
+ return session_connected_handler ((session_connected_msg_t *) e->data);
case SESSION_CTRL_EVT_DISCONNECTED:
- session_disconnected_handler ((session_disconnected_msg_t *) e->data);
- break;
+ return session_disconnected_handler ((session_disconnected_msg_t *)
+ e->data);
case SESSION_CTRL_EVT_RESET:
- session_reset_handler ((session_reset_msg_t *) e->data);
- break;
+ return session_reset_handler ((session_reset_msg_t *) e->data);
+ case SESSION_CTRL_EVT_UNLISTEN_REPLY:
+ return session_unlisten_handler ((session_unlisten_msg_t *) e->data);
case SESSION_IO_EVT_RX:
break;
default:
vec_validate (msg_vec, em->evt_q_size);
vec_reset_length (msg_vec);
wait_for_state_change (em, STATE_ATTACHED, 0);
- mq = em->our_event_queue;
+ mq = em->app_mq;
if (em->state < STATE_ATTACHED || !mq)
{
ECHO_FAIL (ECHO_FAIL_APP_ATTACH, "Application failed to attach");
u64 i;
echo_notify_event (em, ECHO_EVT_FIRST_QCONNECT);
for (i = 0; i < em->n_connects; i++)
- echo_send_connect (em->uri, SESSION_INVALID_INDEX);
+ echo_send_connect (SESSION_INVALID_HANDLE, SESSION_INVALID_INDEX);
wait_for_state_change (em, STATE_READY, 0);
ECHO_LOG (1, "App is ready");
echo_process_rpcs (em);
static void
server_run (echo_main_t * em)
{
+ echo_session_t *ls;
echo_send_listen (em);
wait_for_state_change (em, STATE_READY, 0);
ECHO_LOG (1, "App is ready");
echo_process_rpcs (em);
/* Cleanup */
- echo_send_unbind (em);
+ ls = pool_elt_at_index (em->sessions, em->listen_session_index);
+ echo_send_unbind (em, ls);
if (wait_for_state_change (em, STATE_DISCONNECTED, TIMEOUT))
{
ECHO_FAIL (ECHO_FAIL_SERVER_DISCONNECT_TIMEOUT,
}
else if (unformat (a, "nthreads %d", &em->n_rx_threads))
;
+ else
+ if (unformat
+ (a, "crypto %U", echo_unformat_crypto_engine,
+ &em->crypto_ctx_engine))
+ ;
else if (unformat (a, "appns %_%v%_", &em->appns_id))
;
else if (unformat (a, "all-scope"))
em->tx_buf_size = 1 << 20;
em->data_source = ECHO_INVALID_DATA_SOURCE;
em->uri = format (0, "%s%c", "tcp://0.0.0.0/1234", 0);
+ em->crypto_ctx_engine = TLS_ENGINE_NONE;
echo_set_each_proto_defaults_before_opts (em);
echo_process_opts (argc, argv);
echo_process_uri (em);
echo_notify_event (em, ECHO_EVT_START);
echo_send_attach (em);
- if (wait_for_state_change (em, STATE_ATTACHED, TIMEOUT))
+ if (wait_for_state_change (em, STATE_ATTACHED_NO_CERT, TIMEOUT))
{
ECHO_FAIL (ECHO_FAIL_ATTACH_TO_VPP,
"Couldn't attach to vpp, did you run <session enable> ?");
goto exit_on_error;
}
+
+ if (em->crypto_ctx_engine == TLS_ENGINE_NONE)
+ /* when no crypto engine specified, dont expect crypto ctx */
+ em->state = STATE_ATTACHED;
+ else
+ {
+ ECHO_LOG (1, "Adding crypto context %U", echo_format_crypto_engine,
+ em->crypto_ctx_engine);
+ echo_send_add_crypto_ctx (em);
+ if (wait_for_state_change (em, STATE_ATTACHED, TIMEOUT))
+ {
+ ECHO_FAIL (ECHO_FAIL_APP_ATTACH,
+ "Couldn't add crypto context to vpp\n");
+ exit (1);
+ }
+ }
+
if (pthread_create (&em->mq_thread_handle,
NULL /*attr */ , echo_mq_thread_fn, 0))
{
ECHO_FAIL (ECHO_FAIL_PTHREAD_CREATE, "pthread create errored");
goto exit_on_error;
}
+
for (i = 0; i < em->n_rx_threads; i++)
if (pthread_create (&em->data_thread_handles[i],
NULL /*attr */ , echo_data_thread_fn, (void *) i))
void
echo_send_attach (echo_main_t * em)
{
- vl_api_application_attach_t *bmp;
- vl_api_application_tls_cert_add_t *cert_mp;
- vl_api_application_tls_key_add_t *key_mp;
-
+ vl_api_app_attach_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
clib_memset (bmp, 0, sizeof (*bmp));
- bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
+ bmp->_vl_msg_id = ntohs (VL_API_APP_ATTACH);
bmp->client_index = em->my_client_index;
bmp->context = ntohl (0xfeedface);
bmp->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_ACCEPT_REDIRECT;
bmp->options[APP_OPTIONS_NAMESPACE_SECRET] = em->appns_secret;
}
vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
+}
+
+void
+echo_send_detach (echo_main_t * em)
+{
+ vl_api_application_detach_t *bmp;
+ bmp = vl_msg_api_alloc (sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
+
+ bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
+ bmp->client_index = em->my_client_index;
+ bmp->context = ntohl (0xfeedface);
+
+ vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
+}
+
+void
+echo_send_add_crypto_ctx (echo_main_t * em)
+{
+ vl_api_application_tls_cert_add_t *cert_mp;
+ vl_api_application_tls_key_add_t *key_mp;
cert_mp = vl_msg_api_alloc (sizeof (*cert_mp) + test_srv_crt_rsa_len);
clib_memset (cert_mp, 0, sizeof (*cert_mp));
vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & key_mp);
}
-void
-echo_send_detach (echo_main_t * em)
-{
- vl_api_application_detach_t *bmp;
- bmp = vl_msg_api_alloc (sizeof (*bmp));
- clib_memset (bmp, 0, sizeof (*bmp));
-
- bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
- bmp->client_index = em->my_client_index;
- bmp->context = ntohl (0xfeedface);
- vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
-}
-
void
echo_send_listen (echo_main_t * em)
{
- vl_api_bind_uri_t *bmp;
- bmp = vl_msg_api_alloc (sizeof (*bmp));
- clib_memset (bmp, 0, sizeof (*bmp));
-
- bmp->_vl_msg_id = ntohs (VL_API_BIND_URI);
- bmp->client_index = em->my_client_index;
- bmp->context = ntohl (0xfeedface);
- memcpy (bmp->uri, em->uri, vec_len (em->uri));
- vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_listen_msg_t *mp;
+ svm_msg_q_t *mq = em->ctrl_mq;
+
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_LISTEN);
+ mp = (session_listen_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = em->my_client_index;
+ mp->context = ntohl (0xfeedface);
+ mp->wrk_index = 0;
+ mp->is_ip4 = em->uri_elts.is_ip4;
+ clib_memcpy_fast (&mp->ip, &em->uri_elts.ip, sizeof (mp->ip));
+ mp->port = em->uri_elts.port;
+ mp->proto = em->uri_elts.transport_proto;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
}
void
-echo_send_unbind (echo_main_t * em)
+echo_send_unbind (echo_main_t * em, echo_session_t * s)
{
- vl_api_unbind_uri_t *ump;
-
- ump = vl_msg_api_alloc (sizeof (*ump));
- clib_memset (ump, 0, sizeof (*ump));
-
- ump->_vl_msg_id = ntohs (VL_API_UNBIND_URI);
- ump->client_index = em->my_client_index;
- memcpy (ump->uri, em->uri, vec_len (em->uri));
- vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & ump);
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_unlisten_msg_t *mp;
+ svm_msg_q_t *mq = em->ctrl_mq;
+
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_UNLISTEN);
+ mp = (session_unlisten_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = em->my_client_index;
+ mp->wrk_index = 0;
+ mp->handle = s->vpp_session_handle;
+ mp->context = 0;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
}
void
-echo_send_connect (u8 * uri, u32 opaque)
+echo_send_connect (u64 parent_session_handle, u32 opaque)
{
echo_main_t *em = &echo_main;
- vl_api_connect_uri_t *cmp;
- cmp = vl_msg_api_alloc (sizeof (*cmp));
- clib_memset (cmp, 0, sizeof (*cmp));
- cmp->_vl_msg_id = ntohs (VL_API_CONNECT_URI);
- cmp->client_index = em->my_client_index;
- cmp->context = ntohl (opaque);
- memcpy (cmp->uri, uri, vec_len (uri));
- vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & cmp);
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_connect_msg_t *mp;
+ svm_msg_q_t *mq = em->ctrl_mq;
+
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_CONNECT);
+ mp = (session_connect_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = em->my_client_index;
+ mp->context = ntohl (opaque);
+ mp->wrk_index = 0;
+ mp->is_ip4 = em->uri_elts.is_ip4;
+ clib_memcpy_fast (&mp->ip, &em->uri_elts.ip, sizeof (mp->ip));
+ mp->port = em->uri_elts.port;
+ mp->proto = em->uri_elts.transport_proto;
+ mp->parent_handle = parent_session_handle;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
}
void
echo_send_disconnect_session (u64 handle, u32 opaque)
{
echo_main_t *em = &echo_main;
- vl_api_disconnect_session_t *dmp;
- dmp = vl_msg_api_alloc (sizeof (*dmp));
- clib_memset (dmp, 0, sizeof (*dmp));
- dmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION);
- dmp->client_index = em->my_client_index;
- dmp->handle = handle;
- ECHO_LOG (1, "Disconnect session 0x%lx", dmp->handle);
- vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & dmp);
+ echo_session_t *s;
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_disconnect_msg_t *mp;
+ svm_msg_q_t *mq = em->ctrl_mq;
+
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_DISCONNECT);
+ mp = (session_disconnect_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = em->my_client_index;
+ mp->handle = handle;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
+
+ if (!(s = echo_get_session_from_handle (em, mp->handle)))
+ return;
+ em->proto_cb_vft->sent_disconnect_cb (s);
}
/*
*/
static void
-vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
- mp)
+ vl_api_application_tls_cert_add_reply_t_handler
+ (vl_api_application_tls_cert_add_reply_t * mp)
+{
+ echo_main_t *em = &echo_main;
+ if (mp->retval)
+ {
+ ECHO_FAIL (ECHO_FAIL_VL_API_TLS_CERT_ADD_REPLY,
+ "tls cert add returned %d",
+ clib_net_to_host_u32 (mp->retval));
+ return;
+ }
+ /* No concurrency here, only bapi thread writes */
+ if (em->state != STATE_ATTACHED_NO_CERT
+ && em->state != STATE_ATTACHED_ONE_CERT)
+ {
+ ECHO_FAIL (ECHO_FAIL_VL_API_TLS_CERT_ADD_REPLY, "Wrong state");
+ return;
+ }
+ em->state++;
+}
+
+static void
+ vl_api_application_tls_key_add_reply_t_handler
+ (vl_api_application_tls_key_add_reply_t * mp)
+{
+ echo_main_t *em = &echo_main;
+ if (mp->retval)
+ {
+ ECHO_FAIL (ECHO_FAIL_VL_API_TLS_KEY_ADD_REPLY,
+ "tls key add returned %d",
+ clib_net_to_host_u32 (mp->retval));
+ return;
+ }
+ /* No concurrency here, only bapi thread writes */
+ if (em->state != STATE_ATTACHED_NO_CERT
+ && em->state != STATE_ATTACHED_ONE_CERT)
+ {
+ ECHO_FAIL (ECHO_FAIL_VL_API_TLS_CERT_ADD_REPLY, "Wrong state");
+ return;
+ }
+ em->state++;
+}
+
+static void
+vl_api_app_attach_reply_t_handler (vl_api_app_attach_reply_t * mp)
{
echo_main_t *em = &echo_main;
int *fds = 0, i;
return;
}
- ASSERT (mp->app_event_queue_address);
- em->our_event_queue = uword_to_pointer (mp->app_event_queue_address,
- svm_msg_q_t *);
+ ASSERT (mp->app_mq);
+ em->app_mq = uword_to_pointer (mp->app_mq, svm_msg_q_t *);
+ em->ctrl_mq = uword_to_pointer (mp->vpp_ctrl_mq, svm_msg_q_t *);
if (mp->n_fds)
{
goto failed;
}
if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
- svm_msg_q_set_consumer_eventfd (em->our_event_queue, fds[n_fds++]);
+ svm_msg_q_set_consumer_eventfd (em->app_mq, fds[n_fds++]);
vec_free (fds);
}
echo_segment_handle_add_del (em, segment_handle, 1 /* add */ );
ECHO_LOG (1, "Mapped segment 0x%lx", segment_handle);
- em->state = STATE_ATTACHED;
+ em->state = STATE_ATTACHED_NO_CERT;
return;
failed:
for (i = clib_max (n_fds - 1, 0); i < vec_len (fds); i++)
echo_main.state = STATE_DETACHED;
}
-
static void
vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
{
vec_free (fds);
}
-static void
-vl_api_bind_uri_reply_t_handler (vl_api_bind_uri_reply_t * mp)
-{
- if (mp->retval)
- {
- ECHO_FAIL (ECHO_FAIL_VL_API_BIND_URI_REPLY, "bind failed: %U",
- format_api_error, clib_net_to_host_u32 (mp->retval));
- }
-}
-
-static void
-vl_api_unbind_uri_reply_t_handler (vl_api_unbind_uri_reply_t * mp)
-{
- echo_session_t *listen_session;
- echo_main_t *em = &echo_main;
- if (mp->retval != 0)
- {
- ECHO_FAIL (ECHO_FAIL_VL_API_UNBIND_REPLY, "unbind_uri returned %d",
- ntohl (mp->retval));
- return;
- }
- listen_session = pool_elt_at_index (em->sessions, em->listen_session_index);
- em->proto_cb_vft->cleanup_cb (listen_session, 0 /* parent_died */ );
- em->state = STATE_DISCONNECTED;
-}
-
-static void
-vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
- mp)
-{
- echo_main_t *em = &echo_main;
- echo_session_t *s;
-
- if (mp->retval)
- {
- ECHO_FAIL (ECHO_FAIL_VL_API_DISCONNECT_SESSION_REPLY,
- "vpp complained about disconnect: %d", ntohl (mp->retval));
- return;
- }
-
- ECHO_LOG (1, "Got disonnected reply for session 0x%lx", mp->handle);
- if (!(s = echo_get_session_from_handle (em, mp->handle)))
- return;
- em->proto_cb_vft->disconnected_reply_cb (s);
-}
-
-static void
- vl_api_application_tls_cert_add_reply_t_handler
- (vl_api_application_tls_cert_add_reply_t * mp)
-{
- if (mp->retval)
- ECHO_FAIL (ECHO_FAIL_VL_API_TLS_CERT_ADD_REPLY,
- "failed to add application tls cert");
-}
-
-static void
- vl_api_application_tls_key_add_reply_t_handler
- (vl_api_application_tls_key_add_reply_t * mp)
-{
- if (mp->retval)
- ECHO_FAIL (ECHO_FAIL_VL_API_TLS_KEY_ADD_REPLY,
- "failed to add application tls key");
-}
-
-static void
-vl_api_connect_uri_reply_t_handler (vl_api_connect_uri_reply_t * mp)
-{
- echo_main_t *em = &echo_main;
- if (mp->retval && (em->proto_cb_vft->connected_cb))
- em->proto_cb_vft->connected_cb ((session_connected_bundled_msg_t *) mp,
- mp->context, 1 /* is_failed */ );
-}
-
-#define foreach_quic_echo_msg \
-_(BIND_URI_REPLY, bind_uri_reply) \
-_(UNBIND_URI_REPLY, unbind_uri_reply) \
-_(DISCONNECT_SESSION_REPLY, disconnect_session_reply) \
-_(APPLICATION_ATTACH_REPLY, application_attach_reply) \
-_(APPLICATION_DETACH_REPLY, application_detach_reply) \
-_(MAP_ANOTHER_SEGMENT, map_another_segment) \
-_(UNMAP_SEGMENT, unmap_segment) \
-_(APPLICATION_TLS_CERT_ADD_REPLY, application_tls_cert_add_reply) \
-_(APPLICATION_TLS_KEY_ADD_REPLY, application_tls_key_add_reply) \
-_(CONNECT_URI_REPLY, connect_uri_reply) \
+#define foreach_quic_echo_msg \
+_(APP_ATTACH_REPLY, app_attach_reply) \
+_(APPLICATION_DETACH_REPLY, application_detach_reply) \
+_(MAP_ANOTHER_SEGMENT, map_another_segment) \
+_(APPLICATION_TLS_CERT_ADD_REPLY, application_tls_cert_add_reply) \
+_(APPLICATION_TLS_KEY_ADD_REPLY, application_tls_key_add_reply) \
+_(UNMAP_SEGMENT, unmap_segment)
void
echo_api_hookup (echo_main_t * em)
return format (s, "STATE_START");
if (state == STATE_ATTACHED)
return format (s, "STATE_ATTACHED");
+ if (state == STATE_ATTACHED_NO_CERT)
+ return format (s, "STATE_ATTACHED_NO_CERT");
+ if (state == STATE_ATTACHED_ONE_CERT)
+ return format (s, "STATE_ATTACHED_ONE_CERT");
if (state == STATE_LISTEN)
return format (s, "STATE_LISTEN");
if (state == STATE_READY)
}
}
+u8 *
+echo_format_crypto_engine (u8 * s, va_list * args)
+{
+ u32 state = va_arg (*args, u32);
+ if (state == TLS_ENGINE_MBEDTLS)
+ return format (s, "mbedtls");
+ if (state == TLS_ENGINE_OPENSSL)
+ return format (s, "openssl");
+ if (state == CRYPTO_ENGINE_PICOTLS)
+ return format (s, "picotls");
+ if (state == CRYPTO_ENGINE_VPP)
+ return format (s, "vpp");
+ else
+ return format (s, "unknown crypto engine");
+}
+
+uword
+echo_unformat_crypto_engine (unformat_input_t * input, va_list * args)
+{
+ u8 *a = va_arg (*args, u8 *);
+ if (unformat (input, "mbedtls"))
+ *a = TLS_ENGINE_MBEDTLS;
+ else if (unformat (input, "openssl"))
+ *a = TLS_ENGINE_OPENSSL;
+ else if (unformat (input, "picotls"))
+ *a = CRYPTO_ENGINE_PICOTLS;
+ else if (unformat (input, "vpp"))
+ *a = CRYPTO_ENGINE_VPP;
+ else
+ return 0;
+ return 1;
+}
+
+
/*
*
* End of format functions
_(ECHO_FAIL_VL_API_DETACH_REPLY, "ECHO_FAIL_VL_API_DETACH_REPLY") \
_(ECHO_FAIL_VL_API_BIND_URI_REPLY, "ECHO_FAIL_VL_API_BIND_URI_REPLY") \
_(ECHO_FAIL_VL_API_UNBIND_REPLY, "ECHO_FAIL_VL_API_UNBIND_REPLY") \
- _(ECHO_FAIL_VL_API_DISCONNECT_SESSION_REPLY, \
- "ECHO_FAIL_VL_API_DISCONNECT_SESSION_REPLY") \
+ _(ECHO_FAIL_SESSION_DISCONNECT, "ECHO_FAIL_SESSION_DISCONNECT") \
+ _(ECHO_FAIL_SESSION_RESET, "ECHO_FAIL_SESSION_RESET") \
_(ECHO_FAIL_VL_API_TLS_CERT_ADD_REPLY, \
"ECHO_FAIL_VL_API_TLS_CERT_ADD_REPLY") \
_(ECHO_FAIL_VL_API_TLS_KEY_ADD_REPLY, \
typedef enum
{
STATE_START,
+ STATE_ATTACHED_NO_CERT,
+ STATE_ATTACHED_ONE_CERT,
STATE_ATTACHED,
STATE_LISTEN,
STATE_READY,
void (*bound_uri_cb) (session_bound_msg_t * mp, echo_session_t * session); /* Session got bound */
void (*reset_cb) (session_reset_msg_t * mp, echo_session_t * s); /* Received RESET on session */
void (*disconnected_cb) (session_disconnected_msg_t * mp, echo_session_t * s); /* Received DISCONNECT on session */
- void (*disconnected_reply_cb) (echo_session_t * s); /* ACK disconnect we sent to vpp */
+ void (*sent_disconnect_cb) (echo_session_t * s); /* ACK disconnect we sent to vpp */
void (*cleanup_cb) (echo_session_t * s, u8 parent_died); /* Session should be cleaned up (parent listener may be dead) */
/* Add CLI options */
int (*process_opts_cb) (unformat_input_t * a);
u32 my_client_index; /* API client handle */
u8 *uri; /* The URI we're playing with */
echo_session_t *sessions; /* Session pool */
- svm_msg_q_t *our_event_queue; /* Our event queue */
+ svm_msg_q_t *app_mq; /* Our receiveing event queue */
+ svm_msg_q_t *ctrl_mq; /* Our control queue (towards vpp) */
clib_time_t clib_time; /* For deadman timers */
u8 *socket_name;
int i_am_master;
u8 log_lvl; /* Verbosity of the logging */
int max_test_msg; /* Limit the number of incorrect data messages */
u32 evt_q_size; /* Size of the vpp MQ (app<->vpp events) */
+ u32 crypto_ctx_engine; /* crypto engine used */
u8 *appns_id;
u64 appns_flags;
f64 timeout);
void echo_notify_event (echo_main_t * em, echo_test_evt_t e);
void echo_session_print_stats (echo_main_t * em, echo_session_t * session);
+u8 *echo_format_crypto_engine (u8 * s, va_list * args);
+uword echo_unformat_crypto_engine (unformat_input_t * input, va_list * args);
/* Binary API */
void echo_send_attach (echo_main_t * em);
void echo_send_detach (echo_main_t * em);
void echo_send_listen (echo_main_t * em);
-void echo_send_unbind (echo_main_t * em);
-void echo_send_connect (u8 * uri, u32 opaque);
+void echo_send_unbind (echo_main_t * em, echo_session_t * s);
+void echo_send_connect (u64 vpp_session_handle, u32 opaque);
void echo_send_disconnect_session (u64 handle, u32 opaque);
void echo_api_hookup (echo_main_t * em);
+void echo_send_add_crypto_ctx (echo_main_t * em);
#endif /* __included_vpp_echo_common_h__ */
{
echo_main_t *em = &echo_main;
quic_echo_proto_main_t *eqm = &quic_echo_proto_main;
- u8 *uri = format (0, "quic://session/%lu", mp->handle);
u64 i;
echo_notify_event (em, ECHO_EVT_FIRST_SCONNECT);
for (i = 0; i < eqm->n_stream_clients; i++)
- echo_send_rpc (em, echo_send_connect, (void *) uri, session_index);
+ echo_send_rpc (em, echo_send_connect, (void *) mp->handle, session_index);
ECHO_LOG (0, "Qsession 0x%llx connected to %U:%d",
mp->handle, format_ip46_address, &mp->lcl.ip,
echo_main_t *em = &echo_main;
quic_echo_proto_main_t *eqm = &quic_echo_proto_main;
ECHO_LOG (1, "Accept on QSession 0x%lx %u", mp->handle);
- u8 *uri = format (0, "quic://session/%lu", mp->handle);
u32 i;
echo_notify_event (em, ECHO_EVT_FIRST_SCONNECT);
for (i = 0; i < eqm->n_stream_clients; i++)
- echo_send_rpc (em, echo_send_connect, (void *) uri, session_index);
+ echo_send_rpc (em, echo_send_connect, (void *) mp->handle, session_index);
}
static void
/* retry connect */
echo_session_t *session;
echo_main_t *em = &echo_main;
- u8 *uri;
if (session_index == SESSION_INVALID_INDEX)
{
ECHO_LOG (1, "Retrying connect %s", em->uri);
- echo_send_rpc (em, echo_send_connect, (void *) em->uri,
+ echo_send_rpc (em, echo_send_connect, (void *) SESSION_INVALID_HANDLE,
SESSION_INVALID_INDEX);
}
else
{
session = pool_elt_at_index (em->sessions, session_index);
- uri = format (0, "quic://session/%lu", session->vpp_session_handle);
- ECHO_LOG (1, "Retrying connect %s", uri);
- echo_send_rpc (em, echo_send_connect, (void *) uri, session_index);
+ ECHO_LOG (1, "Retrying connect 0x%lx", session->vpp_session_handle);
+ echo_send_rpc (em, echo_send_connect,
+ (void *) session->vpp_session_handle, session_index);
}
}
}
static void
-quic_echo_disconnected_reply_cb (echo_session_t * s)
+quic_echo_sent_disconnect_cb (echo_session_t * s)
{
if (s->session_type == ECHO_SESSION_TYPE_STREAM)
s->session_state = ECHO_SESSION_STATE_CLOSING;
echo_main_t *em = &echo_main;
u8 default_f_active;
+ if (em->crypto_ctx_engine == TLS_ENGINE_NONE)
+ em->crypto_ctx_engine = CRYPTO_ENGINE_PICOTLS;
em->n_connects = em->n_clients;
em->n_sessions =
clib_max (1, eqm->n_stream_clients) * em->n_clients + em->n_clients + 1;
.connected_cb = quic_echo_connected_cb,
.accepted_cb = quic_echo_accepted_cb,
.reset_cb = quic_echo_reset_cb,
- .disconnected_reply_cb = quic_echo_disconnected_reply_cb,
+ .sent_disconnect_cb = quic_echo_sent_disconnect_cb,
.cleanup_cb = quic_echo_cleanup_cb,
.process_opts_cb = quic_echo_process_opts_cb,
.print_usage_cb = quic_echo_print_usage_cb,
}
static void
-tcp_echo_disconnected_reply_cb (echo_session_t * s)
+tcp_echo_sent_disconnect_cb (echo_session_t * s)
{
s->session_state = ECHO_SESSION_STATE_CLOSING;
}
s->session_state = ECHO_SESSION_STATE_CLOSING;
}
+static void
+tls_echo_set_defaults_after_opts_cb ()
+{
+ echo_main_t *em = &echo_main;
+ if (em->crypto_ctx_engine == TLS_ENGINE_NONE)
+ em->crypto_ctx_engine = TLS_ENGINE_OPENSSL;
+}
+
echo_proto_cb_vft_t echo_tcp_proto_cb_vft = {
.disconnected_cb = tcp_echo_disconnected_cb,
.connected_cb = tcp_echo_connected_cb,
.accepted_cb = tcp_echo_accepted_cb,
.reset_cb = tcp_echo_reset_cb,
- .disconnected_reply_cb = tcp_echo_disconnected_reply_cb,
+ .sent_disconnect_cb = tcp_echo_sent_disconnect_cb,
+ .cleanup_cb = tcp_echo_cleanup_cb,
+};
+
+echo_proto_cb_vft_t echo_tls_proto_cb_vft = {
+ .disconnected_cb = tcp_echo_disconnected_cb,
+ .connected_cb = tcp_echo_connected_cb,
+ .accepted_cb = tcp_echo_accepted_cb,
+ .reset_cb = tcp_echo_reset_cb,
+ .sent_disconnect_cb = tcp_echo_sent_disconnect_cb,
.cleanup_cb = tcp_echo_cleanup_cb,
+ .set_defaults_after_opts_cb = tls_echo_set_defaults_after_opts_cb,
};
ECHO_REGISTER_PROTO (TRANSPORT_PROTO_TCP, echo_tcp_proto_cb_vft);
}
static void
-udp_echo_disconnected_reply_cb (echo_session_t * s)
+udp_echo_sent_disconnect_cb (echo_session_t * s)
{
s->session_state = ECHO_SESSION_STATE_CLOSING;
}
.connected_cb = udp_echo_connected_cb,
.accepted_cb = udp_echo_accepted_cb,
.reset_cb = udp_echo_reset_cb,
- .disconnected_reply_cb = udp_echo_disconnected_reply_cb,
+ .sent_disconnect_cb = udp_echo_sent_disconnect_cb,
.cleanup_cb = udp_echo_cleanup_cb,
.bound_uri_cb = udp_echo_bound_uri_cb,
};
/* *INDENT-ON* */
static void
-quic_register_cipher_suite (quic_crypto_engine_t type,
+quic_register_cipher_suite (tls_engine_type_t type,
ptls_cipher_suite_t ** ciphers)
{
quic_main_t *qm = &quic_main;
TRANSPORT_CONN_ID_LEN,
"connection data must be less than TRANSPORT_CONN_ID_LEN bytes");
-typedef enum quic_crypto_engine_
-{
- CRYPTO_ENGINE_VPP,
- CRYPTO_ENGINE_PICOTLS,
-} quic_crypto_engine_t;
-
/* single-entry session cache */
typedef struct quic_session_cache_
{
TLS_ENGINE_NONE,
TLS_ENGINE_MBEDTLS,
TLS_ENGINE_OPENSSL,
+ CRYPTO_ENGINE_VPP,
+ CRYPTO_ENGINE_PICOTLS,
TLS_N_ENGINES
} tls_engine_type_t;
Code Review / vpp.git / commitdiff