#include <quicly/defaults.h>
+static char *quic_error_strings[] = {
+#define quic_error(n,s) s,
+#include "quic_error.def"
+#undef quic_error
+};
static quic_main_t quic_main;
static void quic_update_timer (quic_ctx_t * ctx);
+static int quic_on_client_connected (quic_ctx_t * ctx);
static u32
quic_ctx_alloc (u32 thread_index)
quic_ctx_free (ctx);
}
+void
+quic_increment_counter (u8 evt, u8 val)
+{
+ vlib_main_t *vm = vlib_get_main ();
+ vlib_node_increment_counter (vm, quic_input_node.index, evt, val);
+}
+
+
+
/**
* Called when quicly return an error
* This function interacts tightly with quic_proto_on_close
/* Read dest address from quicly-provided sockaddr */
if (hdr.is_ip4)
{
- ASSERT (packet->sa.sa_family == AF_INET);
- struct sockaddr_in *sa4 = (struct sockaddr_in *) &packet->sa;
+ ASSERT (packet->dest.sa.sa_family == AF_INET);
+ struct sockaddr_in *sa4 = (struct sockaddr_in *) &packet->dest.sa;
hdr.rmt_port = sa4->sin_port;
hdr.rmt_ip.ip4.as_u32 = sa4->sin_addr.s_addr;
}
else
{
- ASSERT (packet->sa.sa_family == AF_INET6);
- struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &packet->sa;
+ ASSERT (packet->dest.sa.sa_family == AF_INET6);
+ struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &packet->dest.sa;
hdr.rmt_port = sa6->sin6_port;
clib_memcpy (&hdr.rmt_ip.ip6, &sa6->sin6_addr, 16);
}
QUIC_DBG (1, "Not enough space to enqueue payload");
return QUIC_ERROR_FULL_FIFO;
}
+
+ quic_increment_counter (QUIC_ERROR_TX_PACKETS, 1);
+
return 0;
}
qctx = quic_get_conn_ctx (stream->conn);
+ /* Might need to signal that the connection is ready if the first thing the
+ * server does is open a stream */
+ if (qctx->conn_state == QUIC_CONN_STATE_HANDSHAKE)
+ {
+ if (quicly_connection_is_ready (qctx->conn))
+ {
+ qctx->conn_state = QUIC_CONN_STATE_READY;
+ if (quicly_is_client (qctx->conn))
+ {
+ quic_on_client_connected (qctx);
+ /* ctx might be invalidated */
+ qctx = quic_get_conn_ctx (stream->conn);
+ }
+ }
+ }
+
stream_session = session_alloc (qctx->c_thread_index);
QUIC_DBG (2, "ACCEPTED stream_session 0x%lx ctx %u",
session_handle (stream_session), sctx_id);
/* Notify accept on parent qsession, but only if this is not a locally
* initiated stream */
if (!quicly_stream_is_self_initiated (stream))
- {
- quic_accept_stream (stream);
- }
+ quic_accept_stream (stream);
return 0;
}
quicly_ctx->now = &quicly_vpp_now_cb;
quicly_amend_ptls_context (quicly_ctx->tls);
- quicly_ctx->event_log.mask = 0; /* logs */
- quicly_ctx->event_log.cb = quicly_new_default_event_logger (stderr);
-
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;
strlen (quicly_ctx_data->cid_key));
quicly_ctx->cid_encryptor =
quicly_new_default_cid_encryptor (&ptls_openssl_bfecb,
+ &ptls_openssl_aes128ecb,
&ptls_openssl_sha256, key_vec);
if (is_client)
return;
ctx->client_opaque = sep->opaque;
ctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
if (sep->hostname)
- {
- ctx->srv_hostname = format (0, "%v", sep->hostname);
- vec_terminate_c_string (ctx->srv_hostname);
- }
+ ctx->srv_hostname = format (0, "%v", sep->hostname);
else
- {
- /* needed by quic for crypto + determining client / server */
- ctx->srv_hostname =
- format (0, "%U", format_ip46_address, &sep->ip, sep->is_ip4);
- }
+ /* 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;
/* If the app opens a stream in its callback it may invalidate ctx */
ctx = quic_ctx_get (ctx_id, thread_index);
+ /*
+ * app_worker_connect_notify() might have reallocated pool, reload
+ * quic_session pointer
+ */
+ quic_session = session_get (ctx->c_s_index, thread_index);
quic_session->session_state = SESSION_STATE_LISTENING;
return 0;
quicly_ctx = quic_get_quicly_ctx_from_ctx (ctx);
ret = quicly_connect (&ctx->conn, quicly_ctx, (char *) ctx->srv_hostname,
- sa, salen, &quic_main.next_cid,
+ sa, NULL, &quic_main.next_cid, ptls_iovec_init (NULL,
+ 0),
&quic_main.hs_properties, NULL);
++quic_main.next_cid.master_id;
/* Save context handle in quicly connection */
}
ctx_ = quic_ctx_get (index, vlib_get_thread_index ());
conn_ = ctx_->conn;
- if (conn_ && quicly_is_destination (conn_, sa, salen, packet))
+ if (conn_ && quicly_is_destination (conn_, NULL, sa, packet))
{
QUIC_DBG (3, "Connection found");
*ctx_index = index;
return -1;
}
-static int
-quic_receive (quic_ctx_t * ctx, quicly_conn_t * conn,
- quicly_decoded_packet_t packet)
-{
- int rv;
- u32 ctx_id = ctx->c_c_index;
- u32 thread_index = ctx->c_thread_index;
- /* TODO : QUICLY_ERROR_PACKET_IGNORED sould be handled */
- rv = quicly_receive (conn, &packet);
- if (rv)
- {
- QUIC_DBG (2, "quicly_receive errored %U", quic_format_err, rv);
- return 0;
- }
- /* ctx pointer may change if a new stream is opened */
- ctx = quic_ctx_get (ctx_id, thread_index);
- /* Conn may be set to null if the connection is terminated */
- if (ctx->conn && ctx->conn_state == QUIC_CONN_STATE_HANDSHAKE)
- {
- if (quicly_connection_is_ready (conn))
- {
- ctx->conn_state = QUIC_CONN_STATE_READY;
- if (quicly_is_client (conn))
- {
- quic_on_client_connected (ctx);
- ctx = quic_ctx_get (ctx_id, thread_index);
- }
- }
- }
- return quic_send_packets (ctx);
-}
-
static int
quic_create_quic_session (quic_ctx_t * ctx)
{
* TODO: check if socket is actually listening? */
ctx = quic_ctx_get (ctx_index, thread_index);
quicly_ctx = quic_get_quicly_ctx_from_ctx (ctx);
- if ((rv = quicly_accept (&conn, quicly_ctx, sa, salen,
- &packet, ptls_iovec_init (NULL, 0),
- &quic_main.next_cid, NULL)))
+ if ((rv = quicly_accept (&conn, quicly_ctx, NULL, sa,
+ &packet, NULL, &quic_main.next_cid, NULL)))
{
/* Invalid packet, pass */
assert (conn == NULL);
|| 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, sa, salen,
+ dgram = quicly_send_stateless_reset (quicly_ctx, sa, NULL,
&packet.cid.dest.plaintext);
if (dgram == NULL)
return 1;
return rv;
}
-static int
-quic_app_rx_callback (session_t * udp_session)
+typedef struct quic_rx_packet_ctx_
{
- /* Read data from UDP rx_fifo and pass it to the quicly conn. */
quicly_decoded_packet_t packet;
+ u8 data[QUIC_MAX_PACKET_SIZE];
+ u32 ctx_index;
+ u32 thread_index;
+} quic_rx_packet_ctx_t;
+
+static void
+check_quic_client_connected (struct quic_rx_packet_ctx_ *quic_rx_ctx)
+{
+ /* ctx pointer may change if a new stream is opened */
+ quic_ctx_t *ctx = quic_ctx_get (quic_rx_ctx->ctx_index,
+ quic_rx_ctx->thread_index);
+ /* Conn may be set to null if the connection is terminated */
+ if (ctx->conn && ctx->conn_state == QUIC_CONN_STATE_HANDSHAKE)
+ {
+ if (quicly_connection_is_ready (ctx->conn))
+ {
+ ctx->conn_state = QUIC_CONN_STATE_READY;
+ if (quicly_is_client (ctx->conn))
+ {
+ quic_on_client_connected (ctx);
+ }
+ }
+ }
+
+}
+
+static int
+quic_process_one_rx_packet (u64 udp_session_handle,
+ quicly_context_t * quicly_ctx, svm_fifo_t * f,
+ u32 * fifo_offset, u32 * max_packet, u32 packet_n,
+ quic_rx_packet_ctx_t * packet_ctx)
+{
session_dgram_hdr_t ph;
- application_t *app;
quic_ctx_t *ctx = NULL;
- svm_fifo_t *f;
size_t plen;
struct sockaddr_in6 sa6;
struct sockaddr *sa = (struct sockaddr *) &sa6;
socklen_t salen;
- u32 max_deq, full_len, ctx_index = UINT32_MAX, ctx_thread = UINT32_MAX, ret;
- u8 *data;
- int err;
+ u32 full_len, ret;
+ int err, rv = 0;
+ packet_ctx->thread_index = UINT32_MAX;
+ packet_ctx->ctx_index = UINT32_MAX;
+ u32 thread_index = vlib_get_thread_index ();
u32 *opening_ctx_pool, *ctx_index_ptr;
+ u32 cur_deq = svm_fifo_max_dequeue (f) - *fifo_offset;
+
+ if (cur_deq == 0)
+ {
+ *max_packet = packet_n + 1;
+ return 0;
+ }
+
+ if (cur_deq < SESSION_CONN_HDR_LEN)
+ {
+ QUIC_DBG (1, "Not enough data for even a header in RX");
+ return 1;
+ }
+ ret = svm_fifo_peek (f, *fifo_offset, SESSION_CONN_HDR_LEN, (u8 *) & ph);
+ if (ret != SESSION_CONN_HDR_LEN)
+ {
+ QUIC_DBG (1, "Not enough data for header in RX");
+ return 1;
+ }
+ ASSERT (ph.data_offset == 0);
+ full_len = ph.data_length + SESSION_CONN_HDR_LEN;
+ if (full_len > cur_deq)
+ {
+ QUIC_DBG (1, "Not enough data in fifo RX");
+ return 1;
+ }
+
+ /* Quicly can read len bytes from the fifo at offset:
+ * ph.data_offset + SESSION_CONN_HDR_LEN */
+ ret =
+ svm_fifo_peek (f, SESSION_CONN_HDR_LEN + *fifo_offset, ph.data_length,
+ packet_ctx->data);
+ if (ret != ph.data_length)
+ {
+ QUIC_DBG (1, "Not enough data peeked in RX");
+ return 1;
+ }
+
+ quic_increment_counter (QUIC_ERROR_RX_PACKETS, 1);
+ rv = 0;
+ quic_build_sockaddr (sa, &salen, &ph.rmt_ip, ph.rmt_port, ph.is_ip4);
+ quicly_ctx = quic_get_quicly_ctx_from_udp (udp_session_handle);
+ plen =
+ quicly_decode_packet (quicly_ctx, &packet_ctx->packet, packet_ctx->data,
+ ph.data_length);
+
+ if (plen == SIZE_MAX)
+ {
+ *fifo_offset += SESSION_CONN_HDR_LEN + ph.data_length;
+ return 1;
+ }
+
+ err =
+ quic_find_packet_ctx (&packet_ctx->thread_index, &packet_ctx->ctx_index,
+ sa, salen, &packet_ctx->packet, thread_index);
+ if (err == 0)
+ {
+ ctx = quic_ctx_get (packet_ctx->ctx_index, thread_index);
+ rv = quicly_receive (ctx->conn, NULL, sa, &packet_ctx->packet);
+ if (rv)
+ QUIC_DBG (1, "quicly_receive return error %d", rv);
+ }
+ else if (packet_ctx->ctx_index != UINT32_MAX)
+ {
+ /* Connection found but on wrong thread, ask move */
+ *max_packet = packet_n + 1;
+ return 0;
+ }
+ else if ((packet_ctx->packet.octets.base[0] & QUICLY_PACKET_TYPE_BITMASK) ==
+ QUICLY_PACKET_TYPE_INITIAL)
+ {
+ /* Try to find matching "opening" ctx */
+ opening_ctx_pool = quic_main.wrk_ctx[thread_index].opening_ctx_pool;
+
+ /* *INDENT-OFF* */
+ pool_foreach (ctx_index_ptr, opening_ctx_pool,
+ ({
+ ctx = quic_ctx_get (*ctx_index_ptr, thread_index);
+ if (ctx->udp_session_handle == udp_session_handle)
+ {
+ /* Right ctx found, create conn & remove from pool */
+ quic_create_connection(*ctx_index_ptr, sa, salen, packet_ctx->packet);
+ *max_packet = packet_n + 1;
+ packet_ctx->thread_index = thread_index;
+ packet_ctx->ctx_index = *ctx_index_ptr;
+ pool_put (opening_ctx_pool, ctx_index_ptr);
+ goto updateOffset;
+ }
+ }));
+ /* *INDENT-ON* */
+ }
+ else
+ {
+ quic_reset_connection (udp_session_handle, sa, salen,
+ packet_ctx->packet);
+ }
+
+updateOffset:
+ *fifo_offset += SESSION_CONN_HDR_LEN + ph.data_length;
+ return 0;
+}
+
+static int
+quic_app_rx_callback (session_t * udp_session)
+{
+ /* Read data from UDP rx_fifo and pass it to the quicly conn. */
+ application_t *app;
+ quic_ctx_t *ctx = NULL;
+ svm_fifo_t *f;
+ u32 max_deq;
u32 app_index = udp_session->opaque;
u64 udp_session_handle = session_handle (udp_session);
int rv = 0;
+ app = application_get_if_valid (app_index);
u32 thread_index = vlib_get_thread_index ();
- quicly_context_t *quicly_ctx;
+ quic_rx_packet_ctx_t packets_ctx[16];
- app = application_get_if_valid (app_index);
if (!app)
{
QUIC_DBG (1, "Got RX on detached app");
f = udp_session->rx_fifo;
max_deq = svm_fifo_max_dequeue (f);
if (max_deq == 0)
- return 0;
-
- if (max_deq < SESSION_CONN_HDR_LEN)
- {
- QUIC_DBG (1, "Not enough data for even a header in RX");
- return 1;
- }
- ret = svm_fifo_peek (f, 0, SESSION_CONN_HDR_LEN, (u8 *) & ph);
- if (ret != SESSION_CONN_HDR_LEN)
- {
- QUIC_DBG (1, "Not enough data for header in RX");
- return 1;
- }
- ASSERT (ph.data_offset == 0);
- full_len = ph.data_length + SESSION_CONN_HDR_LEN;
- if (full_len > max_deq)
{
- QUIC_DBG (1, "Not enough data in fifo RX");
- return 1;
+ return 0;
}
- /* Quicly can read len bytes from the fifo at offset:
- * ph.data_offset + SESSION_CONN_HDR_LEN */
- data = malloc (ph.data_length);
- ret = svm_fifo_peek (f, SESSION_CONN_HDR_LEN, ph.data_length, data);
- if (ret != ph.data_length)
+ u32 fifo_offset = 0;
+ u32 max_packets = 16;
+ for (int i = 0; i < max_packets; i++)
{
- QUIC_DBG (1, "Not enough data peeked in RX");
- free (data);
- return 1;
+ quic_process_one_rx_packet (udp_session_handle,
+ (quicly_context_t *) app->quicly_ctx, f,
+ &fifo_offset, &max_packets, i,
+ &packets_ctx[i]);
}
- rv = 0;
- quic_build_sockaddr (sa, &salen, &ph.rmt_ip, ph.rmt_port, ph.is_ip4);
-
- quicly_ctx = quic_get_quicly_ctx_from_udp (udp_session_handle);
- plen = quicly_decode_packet (quicly_ctx, &packet, data, ph.data_length);
- if (plen != SIZE_MAX)
+ for (int i = 0; i < max_packets; i++)
{
-
- err = quic_find_packet_ctx (&ctx_thread, &ctx_index, sa, salen,
- &packet, thread_index);
- if (err == 0)
- {
- ctx = quic_ctx_get (ctx_index, thread_index);
- quic_receive (ctx, ctx->conn, packet);
- }
- else if (ctx_index != UINT32_MAX)
- {
- /* Connection found but on wrong thread, just wait for
- * session_migrate_callback to be called */
- return 0;
- }
- else if ((packet.octets.base[0] & QUICLY_PACKET_TYPE_BITMASK) ==
- QUICLY_PACKET_TYPE_INITIAL)
- {
- /* Try to find matching "opening" ctx */
- opening_ctx_pool =
- quic_main.wrk_ctx[thread_index].opening_ctx_pool;
-
- /* *INDENT-OFF* */
- pool_foreach (ctx_index_ptr, opening_ctx_pool,
- ({
- ctx = quic_ctx_get (*ctx_index_ptr, thread_index);
- if (ctx->udp_session_handle == udp_session_handle)
- {
- /* Right ctx found, create conn & remove from pool */
- quic_create_connection (*ctx_index_ptr, sa, salen, packet);
- pool_put (opening_ctx_pool, ctx_index_ptr);
- goto ctx_search_done;
- }
- }));
- /* *INDENT-ON* */
-
- }
- else
- {
- quic_reset_connection (udp_session_handle, sa, salen, packet);
- }
+ if (packets_ctx[i].thread_index != thread_index)
+ continue;
+
+ check_quic_client_connected (&packets_ctx[i]);
+ ctx =
+ quic_ctx_get (packets_ctx[i].ctx_index,
+ packets_ctx[i].thread_index);
+ quic_send_packets (ctx);
}
- ctx_search_done:
- svm_fifo_dequeue_drop (f, full_len);
- free (data);
+ svm_fifo_dequeue_drop (f, fifo_offset);
}
while (1);
return rv;
transport_register_protocol (TRANSPORT_PROTO_QUIC, &quic_proto,
FIB_PROTOCOL_IP6, ~0);
- quic_register_cipher_suite (CRYPTO_ENGINE_VPP, vpp_crypto_cipher_suites);
+ quic_register_cipher_suite (CRYPTO_ENGINE_VPP, quic_crypto_cipher_suites);
quic_register_cipher_suite (CRYPTO_ENGINE_PICOTLS,
ptls_openssl_cipher_suites);
qm->default_cipher = CRYPTO_ENGINE_PICOTLS;
return 0;
}
+static u8 *
+quic_format_ctx_stat (u8 * s, va_list * args)
+{
+ quic_ctx_t *ctx = va_arg (*args, quic_ctx_t *);
+ quicly_stats_t quicly_stats;
+
+ quicly_get_stats (ctx->conn, &quicly_stats);
+
+ s = format (s, "\n\rQUIC conn stats \n\r");
+
+ s =
+ format (s, "RTT: min:%d, smoothed:%d, variance:%d, latest:%d \n\r",
+ quicly_stats.rtt.minimum, quicly_stats.rtt.smoothed,
+ quicly_stats.rtt.variance, quicly_stats.rtt.latest);
+ s = format (s, "Packet loss:%d \n\r", quicly_stats.num_packets.lost);
+
+ return s;
+}
+
+static clib_error_t *
+quic_plugin_showstats_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ quic_main_t *qm = &quic_main;
+ quic_ctx_t *ctx = NULL;
+ u32 num_workers = vlib_num_workers ();
+
+ for (int i = 0; i < num_workers + 1; i++)
+ {
+ /* *INDENT-OFF* */
+ pool_foreach (ctx, qm->ctx_pool[i],
+ ({
+ if(!(ctx->flags & QUIC_F_IS_LISTENER) && !(ctx->flags & QUIC_F_IS_STREAM))
+ vlib_cli_output (vm, "%U", quic_format_ctx_stat, ctx);
+ }));
+ /* *INDENT-ON* */
+ }
+ return 0;
+}
+
/* *INDENT-OFF* */
VLIB_CLI_COMMAND(quic_plugin_crypto_command, static)=
{
.short_help = "quic set crypto api [picotls, vpp]",
.function = quic_plugin_crypto_command_fn,
};
+VLIB_CLI_COMMAND(quic_plugin_stats_command, static)=
+{
+ .path = "show quic stats",
+ .short_help = "show quic stats",
+ .function = quic_plugin_showstats_command_fn,
+};
VLIB_PLUGIN_REGISTER () =
{
.version = VPP_BUILD_VER,
.description = "Quic transport protocol",
+ .default_disabled = 1,
+};
+
+static uword
+quic_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
+{
+ return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (quic_input_node) =
+{
+ .function = quic_node_fn,
+ .name = "quic-input",
+ .vector_size = sizeof (u32),
+ .type = VLIB_NODE_TYPE_INTERNAL,
+ .n_errors = ARRAY_LEN (quic_error_strings),
+ .error_strings = quic_error_strings,
};
/* *INDENT-ON* */