{
QUIC_DBG (1, "Quic does not support crypto engine %d",
ctx->crypto_engine);
- return VNET_API_ERROR_MISSING_CERT_KEY;
+ return SESSION_E_NOCRYPTOENG;
}
/* Check for exisiting crypto ctx */
error:
quic_crypto_context_free_if_needed (crctx, ctx->c_thread_index);
- return VNET_API_ERROR_MISSING_CERT_KEY;
+ return SESSION_E_NOCRYPTOCKP;
}
/* Helper functions */
quicly_conn_t *conn;
size_t num_packets, i, max_packets;
quicly_address_t dest, src;
-
- num_packets = QUIC_SEND_PACKET_VEC_SIZE;
-
+ u32 n_sent = 0;
int err = 0;
/* We have sctx, get qctx */
goto quicly_error;
conn = ctx->conn;
-
if (!conn)
return 0;
- /* TODO : quicly can assert it can send min_packets up to 2 */
- if (quic_sendable_packet_count (udp_session) < 2)
- goto stop_sending;
-
do
{
+ /* TODO : quicly can assert it can send min_packets up to 2 */
max_packets = quic_sendable_packet_count (udp_session);
if (max_packets < 2)
break;
+
num_packets = max_packets;
if ((err = quicly_send (conn, &dest, &src, packets, &num_packets, buf,
sizeof (buf))))
goto quicly_error;
}
+ n_sent += num_packets;
}
while (num_packets > 0 && num_packets == max_packets);
-stop_sending:
quic_set_udp_tx_evt (udp_session);
QUIC_DBG (3, "%u[TX] %u[RX]", svm_fifo_max_dequeue (udp_session->tx_fifo),
svm_fifo_max_dequeue (udp_session->rx_fifo));
quic_update_timer (ctx);
- return 0;
+ return n_sent;
quicly_error:
if (err && err != QUICLY_ERROR_PACKET_IGNORED
&& err != QUICLY_ERROR_FREE_CONNECTION)
clib_warning ("Quic error '%U'.", quic_format_err, err);
quic_connection_closed (ctx);
- return 1;
+ return 0;
}
/* Quicly callbacks */
quic_connect_connection (session_endpoint_cfg_t * sep)
{
vnet_connect_args_t _cargs, *cargs = &_cargs;
+ transport_endpt_crypto_cfg_t *ccfg;
quic_main_t *qm = &quic_main;
quic_ctx_t *ctx;
app_worker_t *app_wrk;
u32 thread_index = vlib_get_thread_index ();
int error;
+ if (!sep->ext_cfg)
+ return SESSION_E_NOEXTCFG;
+
+ ccfg = &sep->ext_cfg->crypto;
+
clib_memset (cargs, 0, sizeof (*cargs));
ctx_index = quic_ctx_alloc (thread_index);
ctx = quic_ctx_get (ctx_index, thread_index);
ctx->conn_state = QUIC_CONN_STATE_HANDSHAKE;
ctx->client_opaque = sep->opaque;
ctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
- if (sep->hostname)
- ctx->srv_hostname = format (0, "%v", sep->hostname);
+ if (ccfg->hostname[0])
+ ctx->srv_hostname = format (0, "%s", ccfg->hostname);
else
/* needed by quic for crypto + determining client / server */
ctx->srv_hostname = format (0, "%U", format_ip46_address,
&sep->ip, sep->is_ip4);
vec_terminate_c_string (ctx->srv_hostname);
- clib_memcpy (&cargs->sep, sep, sizeof (session_endpoint_cfg_t));
+ clib_memcpy (&cargs->sep_ext, sep, sizeof (session_endpoint_cfg_t));
cargs->sep.transport_proto = TRANSPORT_PROTO_UDP;
cargs->app_index = qm->app_index;
cargs->api_context = ctx_index;
cargs->sep_ext.ns_index = app->ns_index;
cargs->sep_ext.transport_flags = TRANSPORT_CFG_F_CONNECTED;
- ctx->crypto_engine = sep->crypto_engine;
- ctx->ckpair_index = sep->ckpair_index;
+ ctx->crypto_engine = ccfg->crypto_engine;
+ ctx->ckpair_index = ccfg->ckpair_index;
if ((error = quic_acquire_crypto_context (ctx)))
return error;
quic_start_listen (u32 quic_listen_session_index, transport_endpoint_t * tep)
{
vnet_listen_args_t _bargs, *args = &_bargs;
+ transport_endpt_crypto_cfg_t *ccfg;
quic_main_t *qm = &quic_main;
session_handle_t udp_handle;
session_endpoint_cfg_t *sep;
int rv;
sep = (session_endpoint_cfg_t *) tep;
+ if (!sep->ext_cfg)
+ return SESSION_E_NOEXTCFG;
+
+ ccfg = &sep->ext_cfg->crypto;
app_wrk = app_worker_get (sep->app_wrk_index);
/* We need to call this because we call app_worker_init_connected in
* quic_accept_stream, which assumes the connect segment manager exists */
lctx->parent_app_id = app_wrk->app_index;
lctx->udp_session_handle = udp_handle;
lctx->c_s_index = quic_listen_session_index;
- lctx->crypto_engine = sep->crypto_engine;
- lctx->ckpair_index = sep->ckpair_index;
- if (quic_acquire_crypto_context (lctx))
- return -1;
+ lctx->crypto_engine = ccfg->crypto_engine;
+ lctx->ckpair_index = ccfg->ckpair_index;
+ if ((rv = quic_acquire_crypto_context (lctx)))
+ return rv;
QUIC_DBG (2, "Listening UDP session 0x%lx",
session_handle (udp_listen_session));
if (!quicly_sendstate_is_open (&stream->sendstate))
{
QUIC_ERR ("Warning: tried to send on closed stream");
- return -1;
+ return 0;
}
stream_data = (quic_stream_data_t *) stream->data;
QUIC_ASSERT (!rv);
tx_end:
- quic_send_packets (ctx);
- return 0;
+ return quic_send_packets (ctx);
}
/*
em = &vm->error_main;
n = vlib_get_node (vm, quic_input_node.index);
code = event_code;
- /* *INDENT-OFF* */
- foreach_vlib_main(({
- em = &this_vlib_main->error_main;
- i = n->error_heap_index + code;
- c = em->counters[i];
-
- if (i < vec_len (em->counters_last_clear))
- c -= em->counters_last_clear[i];
- sum += c;
- index++;
- }));
- /* *INDENT-ON* */
+ foreach_vlib_main ()
+ {
+ em = &this_vlib_main->error_main;
+ i = n->error_heap_index + code;
+ c = em->counters[i];
+
+ if (i < vec_len (em->counters_last_clear))
+ c -= em->counters_last_clear[i];
+ sum += c;
+ index++;
+ }
return sum;
}
Code Review / vpp.git / blobdiff