/*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
static void quic_proto_on_close (u32 ctx_index, u32 thread_index);
static quicly_stream_open_t on_stream_open;
-static quicly_closed_by_peer_t on_closed_by_peer;
+static quicly_closed_by_remote_t on_closed_by_remote;
static quicly_now_t quicly_vpp_now_cb;
/* Crypto contexts */
pool_put (qm->wrk_ctx[thread_index].crypto_ctx_pool, crctx);
}
-static quicly_datagram_t *
-quic_alloc_packet (quicly_packet_allocator_t * self, size_t payloadsize)
-{
- quicly_datagram_t *packet;
- if ((packet =
- clib_mem_alloc (sizeof (*packet) + payloadsize +
- sizeof (quic_encrypt_cb_ctx))) == NULL)
- return NULL;
- packet->data.base =
- (uint8_t *) packet + sizeof (*packet) + sizeof (quic_encrypt_cb_ctx);
- quic_encrypt_cb_ctx *encrypt_cb_ctx =
- (quic_encrypt_cb_ctx *) ((uint8_t *) packet + sizeof (*packet));
-
- clib_memset (encrypt_cb_ctx, 0, sizeof (*encrypt_cb_ctx));
- return packet;
-}
-
-static void
-quic_free_packet (quicly_packet_allocator_t * self,
- quicly_datagram_t * packet)
-{
- clib_mem_free (packet);
-}
-
-quicly_packet_allocator_t quic_packet_allocator =
- { quic_alloc_packet, quic_free_packet };
-
static int
quic_app_cert_key_pair_delete_callback (app_cert_key_pair_t * ckpair)
{
for (i = 0; i < num_threads; i++)
{
/* *INDENT-OFF* */
- pool_foreach (crctx, qm->wrk_ctx[i].crypto_ctx_pool, ({
+ pool_foreach (crctx, qm->wrk_ctx[i].crypto_ctx_pool) {
if (crctx->ckpair_index == ckpair->cert_key_index)
{
quic_crypto_context_make_key_from_crctx (&kv, crctx);
clib_bihash_add_del_24_8 (&qm->wrk_ctx[i].crypto_context_hash, &kv, 0 /* is_add */ );
}
- }));
+ }
/* *INDENT-ON* */
}
return 0;
for (i = 0; i < num_threads; i++)
{
/* *INDENT-OFF* */
- pool_foreach (crctx, qm->wrk_ctx[i].crypto_ctx_pool, ({
+ pool_foreach (crctx, qm->wrk_ctx[i].crypto_ctx_pool) {
vlib_cli_output (vm, "[%d][Q]%U", i, format_crypto_context, crctx);
- }));
+ }
/* *INDENT-ON* */
}
return 0;
return 0;
}
+static clib_error_t *
+quic_set_cc_fn (vlib_main_t *vm, unformat_input_t *input,
+ vlib_cli_command_t *cmd)
+{
+ unformat_input_t _line_input, *line_input = &_line_input;
+ quic_main_t *qm = &quic_main;
+ clib_error_t *e = 0;
+
+ if (!unformat_user (input, unformat_line_input, line_input))
+ return 0;
+
+ while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (line_input, "reno"))
+ qm->default_quic_cc = QUIC_CC_RENO;
+ else if (unformat (line_input, "cubic"))
+ qm->default_quic_cc = QUIC_CC_CUBIC;
+ else
+ {
+ e = clib_error_return (0, "unknown input '%U'",
+ format_unformat_error, line_input);
+ goto done;
+ }
+ }
+done:
+ unformat_free (line_input);
+ return e;
+}
+
static void
quic_release_crypto_context (u32 crypto_context_index, u8 thread_index)
{
ptls_ctx->encrypt_ticket = &qm->session_cache.super;
clib_memcpy (quicly_ctx, &quicly_spec_context, sizeof (quicly_context_t));
- quicly_ctx->max_packet_size = QUIC_MAX_PACKET_SIZE;
quicly_ctx->max_packets_per_key = qm->max_packets_per_key;
quicly_ctx->tls = ptls_ctx;
quicly_ctx->stream_open = &on_stream_open;
- quicly_ctx->closed_by_peer = &on_closed_by_peer;
+ quicly_ctx->closed_by_remote = &on_closed_by_remote;
quicly_ctx->now = &quicly_vpp_now_cb;
quicly_amend_ptls_context (quicly_ctx->tls);
- quicly_ctx->packet_allocator = &quic_packet_allocator;
- quicly_ctx->crypto_engine = &quic_crypto_engine;
+ if (qm->vnet_crypto_enabled &&
+ qm->default_crypto_engine == CRYPTO_ENGINE_VPP)
+ quicly_ctx->crypto_engine = &quic_crypto_engine;
+ else
+ quicly_ctx->crypto_engine = &quicly_default_crypto_engine;
+
quicly_ctx->transport_params.max_data = QUIC_INT_MAX;
quicly_ctx->transport_params.max_streams_uni = (uint64_t) 1 << 60;
quicly_ctx->transport_params.max_streams_bidi = (uint64_t) 1 << 60;
quicly_ctx->transport_params.max_idle_timeout = qm->connection_timeout;
+ if (qm->default_quic_cc == QUIC_CC_CUBIC)
+ quicly_ctx->init_cc = &quicly_cc_cubic_init;
+ else if (qm->default_quic_cc == QUIC_CC_RENO)
+ quicly_ctx->init_cc = &quicly_cc_reno_init;
+
app = application_get (ctx->parent_app_id);
quicly_ctx->transport_params.max_stream_data.bidi_local =
app->sm_properties.rx_fifo_size - 1;
app->sm_properties.tx_fifo_size - 1;
quicly_ctx->transport_params.max_stream_data.uni = QUIC_INT_MAX;
+ quicly_ctx->transport_params.max_udp_payload_size = QUIC_MAX_PACKET_SIZE;
if (!app->quic_iv_set)
{
ptls_openssl_random_bytes (app->quic_iv, QUIC_IV_LEN - 1);
{
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 */
return !(quic_ctx_is_listener (ctx) || quic_ctx_is_stream (ctx));
}
-static session_t *
-get_stream_session_from_stream (quicly_stream_t * stream)
+static inline session_t *
+get_stream_session_and_ctx_from_stream (quicly_stream_t * stream,
+ quic_ctx_t ** ctx)
{
- quic_ctx_t *ctx;
quic_stream_data_t *stream_data;
stream_data = (quic_stream_data_t *) stream->data;
- ctx = quic_ctx_get (stream_data->ctx_id, stream_data->thread_index);
- return session_get (ctx->c_s_index, stream_data->thread_index);
+ *ctx = quic_ctx_get (stream_data->ctx_id, stream_data->thread_index);
+ return session_get ((*ctx)->c_s_index, stream_data->thread_index);
}
static inline void
clib_bihash_kv_16_8_t kv;
quicly_conn_t *conn;
+ if (ctx->conn == NULL)
+ {
+ QUIC_DBG (2, "Skipping redundant delete of connection %u",
+ ctx->c_c_index);
+ return;
+ }
QUIC_DBG (2, "Deleting connection %u", ctx->c_c_index);
QUIC_ASSERT (!quic_ctx_is_stream (ctx));
quic_disconnect_transport (ctx);
- if (ctx->conn)
- quicly_free (ctx->conn);
+ if (conn)
+ quicly_free (conn);
session_transport_delete_notify (&ctx->connection);
}
}
static int
-quic_send_datagram (session_t * udp_session, quicly_datagram_t * packet)
+quic_send_datagram (session_t *udp_session, struct iovec *packet,
+ quicly_address_t *dest, quicly_address_t *src)
{
- u32 max_enqueue;
+ u32 max_enqueue, len;
session_dgram_hdr_t hdr;
- u32 len, ret;
svm_fifo_t *f;
transport_connection_t *tc;
+ int ret;
- len = packet->data.len;
+ len = packet->iov_len;
f = udp_session->tx_fifo;
tc = session_get_transport (udp_session);
max_enqueue = svm_fifo_max_enqueue (f);
/* Read dest address from quicly-provided sockaddr */
if (hdr.is_ip4)
{
- QUIC_ASSERT (packet->dest.sa.sa_family == AF_INET);
- struct sockaddr_in *sa4 = (struct sockaddr_in *) &packet->dest.sa;
+ QUIC_ASSERT (dest->sa.sa_family == AF_INET);
+ struct sockaddr_in *sa4 = (struct sockaddr_in *) &dest->sa;
hdr.rmt_port = sa4->sin_port;
hdr.rmt_ip.ip4.as_u32 = sa4->sin_addr.s_addr;
}
else
{
- QUIC_ASSERT (packet->dest.sa.sa_family == AF_INET6);
- struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &packet->dest.sa;
+ QUIC_ASSERT (dest->sa.sa_family == AF_INET6);
+ struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &dest->sa;
hdr.rmt_port = sa6->sin6_port;
- clib_memcpy (&hdr.rmt_ip.ip6, &sa6->sin6_addr, 16);
+ clib_memcpy_fast (&hdr.rmt_ip.ip6, &sa6->sin6_addr, 16);
}
- ret = svm_fifo_enqueue (f, sizeof (hdr), (u8 *) & hdr);
- if (ret != sizeof (hdr))
- {
- QUIC_ERR ("Not enough space to enqueue header");
- return QUIC_ERROR_FULL_FIFO;
- }
- ret = svm_fifo_enqueue (f, len, packet->data.base);
- if (ret != len)
+ svm_fifo_seg_t segs[2] = { { (u8 *) &hdr, sizeof (hdr) },
+ { packet->iov_base, len } };
+
+ ret = svm_fifo_enqueue_segments (f, segs, 2, 0 /* allow partial */);
+ if (PREDICT_FALSE (ret < 0))
{
- QUIC_ERR ("Not enough space to enqueue payload");
+ QUIC_ERR ("Not enough space to enqueue dgram");
return QUIC_ERROR_FULL_FIFO;
}
static int
quic_send_packets (quic_ctx_t * ctx)
{
- quic_main_t *qm = &quic_main;
- quicly_datagram_t *packets[QUIC_SEND_PACKET_VEC_SIZE];
+ struct iovec packets[QUIC_SEND_PACKET_VEC_SIZE];
+ uint8_t
+ buf[QUIC_SEND_PACKET_VEC_SIZE * quic_get_quicly_ctx_from_ctx (ctx)
+ ->transport_params.max_udp_payload_size];
session_t *udp_session;
quicly_conn_t *conn;
size_t num_packets, i, max_packets;
- quicly_packet_allocator_t *pa;
+ quicly_address_t dest, src;
+ u32 n_sent = 0;
int err = 0;
- u32 thread_index = vlib_get_thread_index ();
/* We have sctx, get qctx */
if (quic_ctx_is_stream (ctx))
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;
-
- pa = quic_get_quicly_ctx_from_ctx (ctx)->packet_allocator;
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, packets, &num_packets)))
+ if ((err = quicly_send (conn, &dest, &src, packets, &num_packets, buf,
+ sizeof (buf))))
goto quicly_error;
- quic_crypto_batch_tx_packets (&qm->wrk_ctx
- [thread_index].crypto_context_batch);
-
for (i = 0; i != num_packets; ++i)
{
- quic_crypto_finalize_send_packet (packets[i]);
- if ((err = quic_send_datagram (udp_session, packets[i])))
+
+ if ((err =
+ quic_send_datagram (udp_session, &packets[i], &dest, &src)))
goto quicly_error;
- pa->free_packet (pa, packets[i]);
}
+ 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 */
size_t len)
{
QUIC_DBG (3, "received data: %lu bytes, offset %lu", len, off);
- u32 max_enq, rlen, rv;
+ u32 max_enq, rv;
quic_ctx_t *sctx;
session_t *stream_session;
app_worker_t *app_wrk;
svm_fifo_t *f;
quic_stream_data_t *stream_data;
+ int rlen;
+
+ if (!len)
+ return;
stream_data = (quic_stream_data_t *) stream->data;
sctx = quic_ctx_get (stream_data->ctx_id, stream_data->thread_index);
{
/* Streams live on the same thread so (f, stream_data) should stay consistent */
rlen = svm_fifo_enqueue (f, len, (u8 *) src);
+ if (PREDICT_FALSE (rlen < 0))
+ {
+ /*
+ * drop, fifo full
+ * drop, fifo grow
+ */
+ return;
+ }
QUIC_DBG (3, "Session [idx %u, app_wrk %u, ti %u, rx-fifo 0x%llx]: "
"Enqueuing %u (rlen %u) at off %u in %u space, ",
stream_session->session_index,
rlen = svm_fifo_enqueue_with_offset (f,
off - stream_data->app_rx_data_len,
len, (u8 *) src);
+ if (PREDICT_FALSE (rlen < 0))
+ {
+ /*
+ * drop, fifo full
+ * drop, fifo grow
+ */
+ return;
+ }
QUIC_ASSERT (rlen == 0);
}
return;
{
quic_stream_data_t *stream_data;
session_t *stream_session;
+ quic_ctx_t *ctx;
svm_fifo_t *f;
u32 rv;
stream_data = (quic_stream_data_t *) stream->data;
- stream_session = get_stream_session_from_stream (stream);
+ stream_session = get_stream_session_and_ctx_from_stream (stream, &ctx);
f = stream_session->tx_fifo;
QUIC_ASSERT (stream_data->app_tx_data_len >= delta);
stream_data->app_tx_data_len -= delta;
+ ctx->bytes_written += delta;
rv = svm_fifo_dequeue_drop (f, delta);
QUIC_ASSERT (rv == delta);
size_t * len, int *wrote_all)
{
quic_stream_data_t *stream_data;
+ quic_ctx_t *ctx;
session_t *stream_session;
svm_fifo_t *f;
u32 deq_max;
stream_data = (quic_stream_data_t *) stream->data;
- stream_session = get_stream_session_from_stream (stream);
+ stream_session = get_stream_session_and_ctx_from_stream (stream, &ctx);
f = stream_session->tx_fifo;
QUIC_DBG (3, "Emitting %u, offset %u", *len, off);
sctx->stream = stream;
sctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
sctx->flags |= QUIC_F_IS_STREAM;
+ sctx->crypto_context_index = qctx->crypto_context_index;
if (quicly_stream_is_unidirectional (stream->stream_id))
stream_session->flags |= SESSION_F_UNIDIRECTIONAL;
}
static void
-quic_on_closed_by_peer (quicly_closed_by_peer_t * self, quicly_conn_t * conn,
- int code, uint64_t frame_type,
- const char *reason, size_t reason_len)
+quic_on_closed_by_remote (quicly_closed_by_remote_t *self, quicly_conn_t *conn,
+ int code, uint64_t frame_type, const char *reason,
+ size_t reason_len)
{
quic_ctx_t *ctx = quic_get_conn_ctx (conn);
#if QUIC_DEBUG >= 2
}
}
- tw = &quic_main.wrk_ctx[vlib_get_thread_index ()].timer_wheel;
+ ASSERT (vlib_get_thread_index () == ctx->c_thread_index ||
+ vlib_get_thread_index () == 0);
+ tw = &quic_main.wrk_ctx[ctx->c_thread_index].timer_wheel;
QUIC_DBG (4, "Timer set to %ld (int %ld) for ctx %u", next_timeout,
next_interval, ctx->c_c_index);
app_worker_t *app_wrk;
quic_ctx_t *qctx, *sctx;
u32 sctx_index;
+ u8 is_unidir;
int rv;
/* Find base session to which the user want to attach a stream */
if (!conn || !quicly_connection_is_ready (conn))
return -1;
- if ((rv =
- quicly_open_stream (conn, &stream,
- sep->flags & SESSION_F_UNIDIRECTIONAL)))
+ is_unidir = sep->transport_flags & TRANSPORT_CFG_F_UNIDIRECTIONAL;
+ if ((rv = quicly_open_stream (conn, &stream, is_unidir)))
{
QUIC_DBG (2, "Stream open failed with %d", rv);
return -1;
quic_increment_counter (QUIC_ERROR_OPENED_STREAM, 1);
sctx->stream = stream;
+ sctx->crypto_context_index = qctx->crypto_context_index;
QUIC_DBG (2, "Opened stream %d, creating session", stream->stream_id);
stream_session->listener_handle = quic_session_handle;
stream_session->session_type =
session_type_from_proto_and_ip (TRANSPORT_PROTO_QUIC, qctx->udp_is_ip4);
- if (sep->flags & SESSION_F_UNIDIRECTIONAL)
+ if (is_unidir)
stream_session->flags |= SESSION_F_UNIDIRECTIONAL;
sctx->c_s_index = stream_session->session_index;
stream_session->session_state = SESSION_STATE_READY;
/* For now we only reset streams. Cleanup will be triggered by timers */
- if (app_worker_init_connected (app_wrk, stream_session))
+ if ((rv = app_worker_init_connected (app_wrk, stream_session)))
{
QUIC_ERR ("failed to app_worker_init_connected");
quicly_reset_stream (stream, QUIC_APP_CONNECT_NOTIFY_ERROR);
- return app_worker_connect_notify (app_wrk, NULL, sep->opaque);
+ return app_worker_connect_notify (app_wrk, NULL, rv, sep->opaque);
}
svm_fifo_add_want_deq_ntf (stream_session->rx_fifo,
SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL |
SVM_FIFO_WANT_DEQ_NOTIF_IF_EMPTY);
- if (app_worker_connect_notify (app_wrk, stream_session, sep->opaque))
+ if (app_worker_connect_notify (app_wrk, stream_session, SESSION_E_NONE,
+ sep->opaque))
{
QUIC_ERR ("failed to notify app");
quic_increment_counter (QUIC_ERROR_CLOSED_STREAM, 1);
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;
+ u32 ctx_index, thread_index;
quic_ctx_t *ctx;
app_worker_t *app_wrk;
application_t *app;
- u32 ctx_index;
- u32 thread_index = vlib_get_thread_index ();
int error;
+ if (!sep->ext_cfg)
+ return SESSION_E_NOEXTCFG;
+
+ /* Use pool on thread 1 if we have workers because of UDP */
+ thread_index = transport_cl_thread ();
+ 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));
- cargs->sep.transport_proto = TRANSPORT_PROTO_UDPC;
+ 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;
app = application_get (app_wrk->app_index);
ctx->parent_app_id = app_wrk->app_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;
static void
quic_proto_on_close (u32 ctx_index, u32 thread_index)
{
+ int err;
quic_ctx_t *ctx = quic_ctx_get_if_valid (ctx_index, thread_index);
if (!ctx)
return;
-#if QUIC_DEBUG >= 2
session_t *stream_session = session_get (ctx->c_s_index,
ctx->c_thread_index);
+#if QUIC_DEBUG >= 2
clib_warning ("Closing session 0x%lx", session_handle (stream_session));
#endif
if (quic_ctx_is_stream (ctx))
if (!quicly_stream_has_send_side (quicly_is_client (stream->conn),
stream->stream_id))
return;
- quicly_reset_stream (stream, QUIC_APP_ERROR_CLOSE_NOTIFY);
+ quicly_sendstate_shutdown (&stream->sendstate, ctx->bytes_written +
+ svm_fifo_max_dequeue
+ (stream_session->tx_fifo));
+ err = quicly_stream_sync_sendbuf (stream, 1);
+ if (err)
+ {
+ QUIC_DBG (1, "sendstate_shutdown failed for stream session %lu",
+ session_handle (stream_session));
+ quicly_reset_stream (stream, QUIC_APP_ERROR_CLOSE_NOTIFY);
+ }
quic_send_packets (ctx);
return;
}
}
static u32
-quic_start_listen (u32 quic_listen_session_index, transport_endpoint_t * tep)
+quic_start_listen (u32 quic_listen_session_index,
+ transport_endpoint_cfg_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 */
- app_worker_alloc_connects_segment_manager (app_wrk);
app = application_get (app_wrk->app_index);
QUIC_DBG (2, "Called quic_start_listen for app %d", app_wrk->app_index);
args->app_index = qm->app_index;
args->sep_ext = *sep;
args->sep_ext.ns_index = app->ns_index;
- args->sep_ext.transport_proto = TRANSPORT_PROTO_UDPC;
+ args->sep_ext.transport_proto = TRANSPORT_PROTO_UDP;
+ args->sep_ext.transport_flags = TRANSPORT_CFG_F_CONNECTED;
if ((rv = vnet_listen (args)))
return rv;
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));
ctx->parent_app_wrk_id);
if (verbose == 1)
- s = format (s, "%-50s%-15d", str, ctx->conn_state);
+ s = format (s, "%-" SESSION_CLI_ID_LEN "s%-" SESSION_CLI_STATE_LEN "d",
+ str, ctx->conn_state);
else
s = format (s, "%s\n", str);
vec_free (str);
/* If quic session connected fails, immediatly close connection */
app_wrk = app_worker_get (ctx->parent_app_wrk_id);
- if (app_worker_init_connected (app_wrk, quic_session))
+ if ((rv = app_worker_init_connected (app_wrk, quic_session)))
{
QUIC_ERR ("failed to app_worker_init_connected");
quic_proto_on_close (ctx_id, thread_index);
- app_worker_connect_notify (app_wrk, NULL, ctx->client_opaque);
+ app_worker_connect_notify (app_wrk, NULL, rv, ctx->client_opaque);
return;
}
quic_session->session_state = SESSION_STATE_CONNECTING;
if ((rv = app_worker_connect_notify (app_wrk, quic_session,
- ctx->client_opaque)))
+ SESSION_E_NONE, ctx->client_opaque)))
{
QUIC_ERR ("failed to notify app %d", rv);
quic_proto_on_close (ctx_id, thread_index);
static int
quic_udp_session_connected_callback (u32 quic_app_index, u32 ctx_index,
- session_t * udp_session, u8 is_fail)
+ session_t * udp_session,
+ session_error_t err)
{
- QUIC_DBG (2, "QSession is now connected (id %u)",
+ QUIC_DBG (2, "UDP Session is now connected (id %u)",
udp_session->session_index);
/* This should always be called before quic_connect returns since UDP always
* connects instantly. */
app_worker_t *app_wrk;
quicly_conn_t *conn;
quic_ctx_t *ctx;
- u32 thread_index = vlib_get_thread_index ();
+ u32 thread_index;
int ret;
quicly_context_t *quicly_ctx;
-
+ /* Allocate session on whatever thread udp used, i.e., probably first
+ * worker, although this may be main thread. If it is main, it's done
+ * with a worker barrier */
+ thread_index = udp_session->thread_index;
+ ASSERT (thread_index == 0 || thread_index == 1);
ctx = quic_ctx_get (ctx_index, thread_index);
- if (is_fail)
+ if (err)
{
u32 api_context;
app_wrk = app_worker_get_if_valid (ctx->parent_app_wrk_id);
if (app_wrk)
{
api_context = ctx->c_s_index;
- app_worker_connect_notify (app_wrk, 0, api_context);
+ app_worker_connect_notify (app_wrk, 0, SESSION_E_NONE, api_context);
}
return 0;
}
- ctx->c_thread_index = thread_index;
- ctx->c_c_index = ctx_index;
-
- QUIC_DBG (2, "Quic connect returned %u. New ctx [%u]%x",
- is_fail, thread_index, (ctx) ? ctx_index : ~0);
+ QUIC_DBG (2, "New ctx [%u]%x", thread_index, (ctx) ? ctx_index : ~0);
ctx->udp_session_handle = session_handle (udp_session);
udp_session->opaque = ctx_index;
QUIC_DBG (2, "Registering conn with id %lu %lu", kv.key[0], kv.key[1]);
clib_bihash_add_del_16_8 (&quic_main.connection_hash, &kv, 1 /* is_add */ );
- /* UDP stack quirk? preemptively transfer connection if that happens */
- if (udp_session->thread_index != thread_index)
- quic_transfer_connection (ctx_index, udp_session->thread_index);
- else
- quic_send_packets (ctx);
+ quic_send_packets (ctx);
return ret;
}
ctx->ckpair_index = lctx->ckpair_index;
quic_acquire_crypto_context (ctx);
udp_session->opaque = ctx_index;
+ udp_session->session_state = SESSION_STATE_READY;
/* TODO timeout to delete these if they never connect */
return 0;
}
static int
-quic_custom_tx_callback (void *s, u32 max_burst_size)
+quic_custom_tx_callback (void *s, transport_send_params_t * sp)
{
session_t *stream_session = (session_t *) s;
quic_stream_data_t *stream_data;
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);
}
/*
* CID, ... */
QUIC_DBG (2, "Sending stateless reset");
int rv;
- quicly_datagram_t *dgram;
session_t *udp_session;
quicly_context_t *quicly_ctx;
if (pctx->packet.cid.dest.plaintext.node_id != 0
|| pctx->packet.cid.dest.plaintext.thread_id != 0)
return 0;
quicly_ctx = quic_get_quicly_ctx_from_udp (udp_session_handle);
- dgram = quicly_send_stateless_reset (quicly_ctx, &pctx->sa, NULL,
- &pctx->packet.cid.dest.plaintext);
- if (dgram == NULL)
+ quic_ctx_t *qctx = quic_ctx_get (pctx->ctx_index, pctx->thread_index);
+
+ quicly_address_t src;
+ uint8_t payload[quicly_ctx->transport_params.max_udp_payload_size];
+ size_t payload_len =
+ quicly_send_stateless_reset (quicly_ctx, &src.sa, payload);
+ if (payload_len == 0)
return 1;
+
+ struct iovec packet;
+ packet.iov_len = payload_len;
+ packet.iov_base = payload;
+
+ struct _st_quicly_conn_public_t *conn =
+ (struct _st_quicly_conn_public_t *) qctx->conn;
+
udp_session = session_get_from_handle (udp_session_handle);
- rv = quic_send_datagram (udp_session, dgram);
+ rv = quic_send_datagram (udp_session, &packet, &conn->remote.address,
+ &conn->local.address);
quic_set_udp_tx_evt (udp_session);
return rv;
}
quic_build_sockaddr (&pctx->sa, &pctx->salen, &pctx->ph.rmt_ip,
pctx->ph.rmt_port, pctx->ph.is_ip4);
quicly_ctx = quic_get_quicly_ctx_from_udp (udp_session_handle);
- plen = quicly_decode_packet (quicly_ctx, &pctx->packet,
- pctx->data, pctx->ph.data_length);
+
+ size_t off = 0;
+ plen = quicly_decode_packet (quicly_ctx, &pctx->packet, pctx->data,
+ pctx->ph.data_length, &off);
if (plen == SIZE_MAX)
{
if (rv == QUIC_PACKET_TYPE_RECEIVE)
{
pctx->ptype = QUIC_PACKET_TYPE_RECEIVE;
- if (quic_main.vnet_crypto_enabled)
+
+ if (quic_main.vnet_crypto_enabled &&
+ quic_main.default_crypto_engine == CRYPTO_ENGINE_VPP)
{
quic_ctx_t *qctx = quic_ctx_get (pctx->ctx_index, thread_index);
quic_crypto_decrypt_packet (qctx, pctx);
quic_udp_session_rx_callback (session_t * udp_session)
{
/* Read data from UDP rx_fifo and pass it to the quicly conn. */
- quic_main_t *qm = &quic_main;
quic_ctx_t *ctx = NULL, *prev_ctx = NULL;
svm_fifo_t *f = udp_session->rx_fifo;
u32 max_deq;
u32 thread_index = vlib_get_thread_index ();
u32 cur_deq, fifo_offset, max_packets, i;
- quic_rx_packet_ctx_t packets_ctx[QUIC_RCV_MAX_BATCH_PACKETS];
+ quic_rx_packet_ctx_t packets_ctx[QUIC_RCV_MAX_PACKETS];
if (udp_session->flags & SESSION_F_IS_MIGRATING)
{
return 0;
fifo_offset = 0;
- max_packets = QUIC_RCV_MAX_BATCH_PACKETS;
+ max_packets = QUIC_RCV_MAX_PACKETS;
#if CLIB_DEBUG > 0
clib_memset (packets_ctx, 0xfa,
- QUIC_RCV_MAX_BATCH_PACKETS * sizeof (quic_rx_packet_ctx_t));
+ QUIC_RCV_MAX_PACKETS * sizeof (quic_rx_packet_ctx_t));
#endif
-
for (i = 0; i < max_packets; i++)
{
packets_ctx[i].thread_index = UINT32_MAX;
}
}
- quic_crypto_batch_rx_packets (&qm->
- wrk_ctx[thread_index].crypto_context_batch);
-
for (i = 0; i < max_packets; i++)
{
switch (packets_ctx[i].ptype)
/* *INDENT-ON* */
static quicly_stream_open_t on_stream_open = { quic_on_stream_open };
-static quicly_closed_by_peer_t on_closed_by_peer = { quic_on_closed_by_peer };
+static quicly_closed_by_remote_t on_closed_by_remote = {
+ quic_on_closed_by_remote
+};
static quicly_now_t quicly_vpp_now_cb = { quic_get_time };
static void
tw->last_run_time = vlib_time_now (vlib_get_main ());
clib_bihash_init_24_8 (&qm->wrk_ctx[i].crypto_context_hash,
"quic crypto contexts", 64, 128 << 10);
-
- qm->wrk_ctx[i].crypto_context_batch.nb_rx_packets = 0;
- qm->wrk_ctx[i].crypto_context_batch.nb_tx_packets = 0;
}
clib_bihash_init_16_8 (&qm->connection_hash, "quic connections", 1024,
clib_bitmap_alloc (qm->available_crypto_engines,
app_crypto_engine_n_types ());
- quic_register_cipher_suite (CRYPTO_ENGINE_VPP, quic_crypto_cipher_suites);
quic_register_cipher_suite (CRYPTO_ENGINE_PICOTLS,
ptls_openssl_cipher_suites);
- qm->default_crypto_engine = CRYPTO_ENGINE_VPP;
- qm->max_packets_per_key = DEFAULT_MAX_PACKETS_PER_KEY;
- clib_rwlock_init (&qm->crypto_keys_quic_rw_lock);
+ qm->default_crypto_engine = CRYPTO_ENGINE_PICOTLS;
vnet_crypto_main_t *cm = &crypto_main;
if (vec_len (cm->engines) == 0)
qm->vnet_crypto_enabled = 0;
else
qm->vnet_crypto_enabled = 1;
+ if (qm->vnet_crypto_enabled == 1)
+ {
+ u8 empty_key[32] = {};
+ quic_register_cipher_suite (CRYPTO_ENGINE_VPP,
+ quic_crypto_cipher_suites);
+ qm->default_crypto_engine = CRYPTO_ENGINE_VPP;
+ vec_validate (qm->per_thread_crypto_key_indices, num_threads);
+ for (i = 0; i < num_threads; i++)
+ {
+ qm->per_thread_crypto_key_indices[i] = vnet_crypto_key_add (
+ vm, VNET_CRYPTO_ALG_AES_256_CTR, empty_key, 32);
+ }
+ }
+
+ qm->max_packets_per_key = DEFAULT_MAX_PACKETS_PER_KEY;
+ qm->default_quic_cc = QUIC_CC_RENO;
vec_free (a->name);
return 0;
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
+ unformat_input_t _line_input, *line_input = &_line_input;
quic_main_t *qm = &quic_main;
- if (unformat_check_input (input) == UNFORMAT_END_OF_INPUT)
- return clib_error_return (0, "unknown input '%U'",
- format_unformat_error, input);
- if (unformat (input, "vpp"))
- qm->default_crypto_engine = CRYPTO_ENGINE_VPP;
- else if (unformat (input, "picotls"))
- qm->default_crypto_engine = CRYPTO_ENGINE_PICOTLS;
- else
- return clib_error_return (0, "unknown input '%U'",
- format_unformat_error, input);
- return 0;
+ clib_error_t *e = 0;
+
+ if (!unformat_user (input, unformat_line_input, line_input))
+ return 0;
+
+ while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (line_input, "vpp"))
+ qm->default_crypto_engine = CRYPTO_ENGINE_VPP;
+ else if (unformat (line_input, "picotls"))
+ qm->default_crypto_engine = CRYPTO_ENGINE_PICOTLS;
+ else
+ {
+ e = clib_error_return (0, "unknown input '%U'",
+ format_unformat_error, line_input);
+ goto done;
+ }
+ }
+done:
+ unformat_free (line_input);
+ return e;
}
u64 quic_fifosize = 0;
u32 code, i;
u64 c, sum = 0;
- int index = 0;
vm = vlib_get_main ();
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;
+ }
return sum;
}
for (i = 0; i < num_workers + 1; i++)
{
/* *INDENT-OFF* */
- pool_foreach (ctx, qm->ctx_pool[i],
- ({
+ pool_foreach (ctx, qm->ctx_pool[i])
+ {
if (quic_ctx_is_conn (ctx) && ctx->conn)
{
quicly_get_stats (ctx->conn, &st);
}
else if (quic_ctx_is_stream (ctx))
nstream++;
- }));
+ }
/* *INDENT-ON* */
}
vlib_cli_output (vm, "-------- Connections --------");
quicly_stats.num_packets.received,
quicly_stats.num_packets.lost,
quicly_stats.num_packets.ack_received);
+ s =
+ format (s, "\ncwnd:%u ssthresh:%u recovery_end:%lu", quicly_stats.cc.cwnd,
+ quicly_stats.cc.ssthresh, quicly_stats.cc.recovery_end);
+
+ quicly_context_t *quicly_ctx = quic_get_quicly_ctx_from_ctx (ctx);
+ if (quicly_ctx->init_cc == &quicly_cc_cubic_init)
+ {
+ s = format (
+ s,
+ "\nk:%d w_max:%u w_last_max:%u avoidance_start:%ld last_sent_time:%ld",
+ quicly_stats.cc.state.cubic.k, quicly_stats.cc.state.cubic.w_max,
+ quicly_stats.cc.state.cubic.w_last_max,
+ quicly_stats.cc.state.cubic.avoidance_start,
+ quicly_stats.cc.state.cubic.last_sent_time);
+ }
+ else if (quicly_ctx->init_cc == &quicly_cc_reno_init)
+ {
+ s = format (s, " stash:%u", quicly_stats.cc.state.reno.stash);
+ }
+
return s;
}
for (int i = 0; i < num_workers + 1; i++)
{
/* *INDENT-OFF* */
- pool_foreach (ctx, qm->ctx_pool[i],
- ({
+ pool_foreach (ctx, qm->ctx_pool[i])
+ {
if (quic_ctx_is_stream (ctx) && show_stream)
vlib_cli_output (vm, "%U", quic_format_stream_ctx, ctx);
else if (quic_ctx_is_listener (ctx) && show_listeners)
vlib_cli_output (vm, "%U", quic_format_listener_ctx, ctx);
else if (quic_ctx_is_conn (ctx) && show_conn)
vlib_cli_output (vm, "%U", quic_format_connection_ctx, ctx);
- }));
+ }
/* *INDENT-ON* */
}
}
/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (quic_plugin_crypto_command, static) =
-{
+VLIB_CLI_COMMAND (quic_plugin_crypto_command, static) = {
.path = "quic set crypto api",
- .short_help = "quic set crypto api [picotls, vpp]",
+ .short_help = "quic set crypto api [picotls|vpp]",
.function = quic_plugin_crypto_command_fn,
};
VLIB_CLI_COMMAND(quic_plugin_set_fifo_size_command, static)=
.short_help = "set quic max_packets_per_key 16777216",
.function = quic_set_max_packets_per_key_fn,
};
+VLIB_CLI_COMMAND (quic_set_cc, static) = {
+ .path = "set quic cc",
+ .short_help = "set quic cc [reno|cubic]",
+ .function = quic_set_cc_fn,
+};
VLIB_PLUGIN_REGISTER () =
{
.version = VPP_BUILD_VER,
static clib_error_t *
quic_config_fn (vlib_main_t * vm, unformat_input_t * input)
{
+ unformat_input_t _line_input, *line_input = &_line_input;
quic_main_t *qm = &quic_main;
+ clib_error_t *error = 0;
uword tmp;
u32 i;
qm->udp_fifo_size = QUIC_DEFAULT_FIFO_SIZE;
qm->udp_fifo_prealloc = 0;
qm->connection_timeout = QUIC_DEFAULT_CONN_TIMEOUT;
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+
+ if (!unformat_user (input, unformat_line_input, line_input))
+ return 0;
+
+ while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (input, "fifo-size %U", unformat_memory_size, &tmp))
+ if (unformat (line_input, "fifo-size %U", unformat_memory_size, &tmp))
{
if (tmp >= 0x100000000ULL)
{
- return clib_error_return (0,
- "fifo-size %llu (0x%llx) too large",
- tmp, tmp);
+ error = clib_error_return (0,
+ "fifo-size %llu (0x%llx) too large",
+ tmp, tmp);
+ goto done;
}
qm->udp_fifo_size = tmp;
}
- else if (unformat (input, "conn-timeout %u", &i))
+ else if (unformat (line_input, "conn-timeout %u", &i))
qm->connection_timeout = i;
- else if (unformat (input, "fifo-prealloc %u", &i))
+ else if (unformat (line_input, "fifo-prealloc %u", &i))
qm->udp_fifo_prealloc = i;
else
- return clib_error_return (0, "unknown input '%U'",
- format_unformat_error, input);
+ {
+ error = clib_error_return (0, "unknown input '%U'",
+ format_unformat_error, line_input);
+ goto done;
+ }
}
-
- return 0;
+done:
+ unformat_free (line_input);
+ return error;
}
VLIB_EARLY_CONFIG_FUNCTION (quic_config_fn, "quic");