/*
- * 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:
#include <quic/quic.h>
#include <quic/certs.h>
#include <quic/error.h>
-#include <quic/quic_crypto.h>
#include <quicly/constants.h>
#include <quicly/defaults.h>
+#include <picotls.h>
+
+#include <quic/quic_crypto.h>
+
+extern quicly_crypto_engine_t quic_crypto_engine;
static char *quic_error_strings[] = {
#define quic_error(n,s) s,
#undef quic_error
};
-static quic_main_t quic_main;
+#define DEFAULT_MAX_PACKETS_PER_KEY 16777216
+
+quic_main_t quic_main;
static void quic_update_timer (quic_ctx_t * ctx);
static void quic_check_quic_session_connected (quic_ctx_t * ctx);
static int quic_reset_connection (u64 udp_session_handle,
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 */
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;
}
+static clib_error_t *
+quic_set_max_packets_per_key_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ quic_main_t *qm = &quic_main;
+ unformat_input_t _line_input, *line_input = &_line_input;
+ u64 tmp;
+
+ 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, "%U", unformat_memory_size, &tmp))
+ {
+ qm->max_packets_per_key = tmp;
+ }
+ else
+ return clib_error_return (0, "unknown input '%U'",
+ format_unformat_error, line_input);
+ }
+
+ 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);
+ 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.idle_timeout = qm->connection_timeout;
+ 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.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);
return pool_elt_at_index (quic_main.ctx_pool[thread_index], ctx_index);
}
-static quic_ctx_t *
+quic_ctx_t *
quic_get_conn_ctx (quicly_conn_t * conn)
{
u64 conn_data;
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
}
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;
session_dgram_hdr_t hdr;
svm_fifo_t *f;
transport_connection_t *tc;
- 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);
}
QUIC_ERR ("Not enough space to enqueue header");
return QUIC_ERROR_FULL_FIFO;
}
- ret = svm_fifo_enqueue (f, len, packet->data.base);
+ ret = svm_fifo_enqueue (f, len, packet->iov_base);
if (ret != len)
{
QUIC_ERR ("Not enough space to enqueue payload");
static int
quic_send_packets (quic_ctx_t * ctx)
{
- 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;
+
+ num_packets = QUIC_SEND_PACKET_VEC_SIZE;
+
int err = 0;
/* We have sctx, get qctx */
if (quic_sendable_packet_count (udp_session) < 2)
goto stop_sending;
- pa = quic_get_quicly_ctx_from_ctx (ctx)->packet_allocator;
do
{
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;
for (i = 0; i != num_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]);
}
}
while (num_packets > 0 && num_packets == max_packets);
clib_mem_free (stream->data);
}
-static int
+static void
quic_on_stop_sending (quicly_stream_t * stream, int err)
{
#if QUIC_DEBUG >= 2
session_handle (stream_session), quic_format_err, err);
#endif
/* TODO : handle STOP_SENDING */
- return 0;
}
-static int
+static void
quic_on_receive_reset (quicly_stream_t * stream, int err)
{
quic_stream_data_t *stream_data = (quic_stream_data_t *) stream->data;
session_handle (stream_session), quic_format_err, err);
#endif
session_transport_closing_notify (&sctx->connection);
- return 0;
}
-static int
+static void
quic_on_receive (quicly_stream_t * stream, size_t off, const void *src,
size_t len)
{
svm_fifo_t *f;
quic_stream_data_t *stream_data;
+ if (!len)
+ return;
+
stream_data = (quic_stream_data_t *) stream->data;
sctx = quic_ctx_get (stream_data->ctx_id, stream_data->thread_index);
stream_session = session_get (sctx->c_s_index, stream_data->thread_index);
stream_session->thread_index, f,
max_enq, len, stream_data->app_rx_data_len, off,
off - stream_data->app_rx_data_len + len);
- return 0;
+ return;
}
if (PREDICT_FALSE ((off - stream_data->app_rx_data_len + len) > max_enq))
{
stream_session->thread_index, f,
max_enq, len, stream_data->app_rx_data_len, off,
off - stream_data->app_rx_data_len + len);
- return 1;
+ return; /* This shouldn't happen */
}
if (off == stream_data->app_rx_data_len)
{
len, (u8 *) src);
QUIC_ASSERT (rlen == 0);
}
- return 0;
+ return;
}
void
{
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);
QUIC_ASSERT (!rv);
}
-int
+void
quic_fifo_egress_emit (quicly_stream_t * stream, size_t off, void *dst,
size_t * len, int *wrote_all)
{
- u32 deq_max, first_deq, max_rd_chunk, rem_offset;
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);
if (off + *len > stream_data->app_tx_data_len)
stream_data->app_tx_data_len = off + *len;
- /* TODO, use something like : return svm_fifo_peek (f, off, *len, dst); */
- max_rd_chunk = svm_fifo_max_read_chunk (f);
-
- first_deq = 0;
- if (off < max_rd_chunk)
- {
- first_deq = clib_min (*len, max_rd_chunk - off);
- clib_memcpy_fast (dst, svm_fifo_head (f) + off, first_deq);
- }
-
- if (max_rd_chunk < off + *len)
- {
- rem_offset = max_rd_chunk < off ? off - max_rd_chunk : 0;
- clib_memcpy_fast (dst + first_deq, f->head_chunk->data + rem_offset,
- *len - first_deq);
- }
-
- return 0;
+ svm_fifo_peek (f, off, *len, dst);
}
static const quicly_stream_callbacks_t quic_stream_callbacks = {
}
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
}
/* Transport proto functions */
-
static int
quic_connect_stream (session_t * quic_session, session_endpoint_cfg_t * sep)
{
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;
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);
vec_terminate_c_string (ctx->srv_hostname);
clib_memcpy (&cargs->sep, sep, sizeof (session_endpoint_cfg_t));
- cargs->sep.transport_proto = TRANSPORT_PROTO_UDPC;
+ 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;
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;
}
app = application_get (app_wrk->app_index);
QUIC_DBG (2, "Called quic_start_listen for app %d", app_wrk->app_index);
- sep->transport_proto = TRANSPORT_PROTO_UDPC;
clib_memset (args, 0, sizeof (*args));
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_UDP;
+ args->sep_ext.transport_flags = TRANSPORT_CFG_F_CONNECTED;
if ((rv = vnet_listen (args)))
return rv;
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. */
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;
}
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;
ctx = quic_ctx_get (pctx->ctx_index, pctx->thread_index);
if (ctx->c_s_index != QUIC_SESSION_INVALID)
{
- QUIC_DBG (2, "already accepted ctx 0x%x", ctx_index);
+ QUIC_DBG (2, "already accepted ctx 0x%x", ctx->c_s_index);
return;
}
* 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 &&
+ 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);
+ }
return 0;
}
else if (rv == QUIC_PACKET_TYPE_MIGRATE)
quic_udp_session_rx_callback (session_t * udp_session)
{
/* Read data from UDP rx_fifo and pass it to the quicly conn. */
- quic_ctx_t *ctx = NULL;
+ quic_ctx_t *ctx = NULL, *prev_ctx = NULL;
svm_fifo_t *f = udp_session->rx_fifo;
u32 max_deq;
u64 udp_session_handle = session_handle (udp_session);
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;
break;
}
}
+ ctx = prev_ctx = NULL;
for (i = 0; i < max_packets; i++)
{
+ prev_ctx = ctx;
switch (packets_ctx[i].ptype)
{
case QUIC_PACKET_TYPE_RECEIVE:
packets_ctx[i].thread_index);
break;
default:
- continue;
+ continue; /* this exits the for loop since other packet types are
+ necessarily the last in the batch */
}
- quic_send_packets (ctx);
+ if (ctx != prev_ctx)
+ quic_send_packets (ctx);
}
udp_session = session_get_from_handle (udp_session_handle); /* session alloc might have happened */
.get_transport_endpoint = quic_get_transport_endpoint,
.get_transport_listener_endpoint = quic_get_transport_listener_endpoint,
.transport_options = {
+ .name = "quic",
+ .short_name = "Q",
.tx_type = TRANSPORT_TX_INTERNAL,
.service_type = TRANSPORT_SERVICE_APP,
},
/* *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
vec_validate (qm->ctx_pool, num_threads - 1);
vec_validate (qm->wrk_ctx, num_threads - 1);
+
for (i = 0; i < num_threads; i++)
{
qm->wrk_ctx[i].next_cid.thread_id = i;
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_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)
+ {
+ quic_register_cipher_suite (CRYPTO_ENGINE_VPP,
+ quic_crypto_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_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;
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 = "list quic crypto contextes",
.function = quic_list_crypto_context_command_fn,
};
+VLIB_CLI_COMMAND (quic_set_max_packets_per_key, static) =
+{
+ .path = "set quic max_packets_per_key",
+ .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 (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, "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");
Code Review / vpp.git / blobdiff