#include <picotls/openssl.h>
#include <picotls/pembase64.h>
-static quic_main_t quic_main;
+#include <quic/quic_crypto.h>
+static quic_main_t quic_main;
static void quic_update_timer (quic_ctx_t * ctx);
-static void quic_connection_closed (u32 conn_index, u32 thread_index);
-static void quic_proto_on_close (u32 ctx_index, u32 thread_index);
-static int quic_connect_new_stream (session_endpoint_cfg_t * sep);
-static int quic_connect_new_connection (session_endpoint_cfg_t * sep);
-
-static int64_t quic_get_time (quicly_now_t * self);
-static quicly_now_t quicly_vpp_now_cb = { quic_get_time };
-
-static void quic_transfer_connection (u32 ctx_index, u32 dest_thread);
-
-#define QUIC_TIMER_HANDLE_INVALID ((u32) ~0)
-#define QUIC_SESSION_INVALID ((u32) ~0 - 1)
-#define QUIC_MAX_PACKET_SIZE 1280
-
-#define QUIC_INT_MAX 0x3FFFFFFFFFFFFFFF
-
-/* Taken from quicly.c */
-#define QUICLY_QUIC_BIT 0x40
-#define QUICLY_PACKET_TYPE_INITIAL (QUICLY_LONG_HEADER_BIT | QUICLY_QUIC_BIT | 0)
-#define QUICLY_PACKET_TYPE_0RTT (QUICLY_LONG_HEADER_BIT | QUICLY_QUIC_BIT | 0x10)
-#define QUICLY_PACKET_TYPE_HANDSHAKE (QUICLY_LONG_HEADER_BIT | QUICLY_QUIC_BIT | 0x20)
-#define QUICLY_PACKET_TYPE_RETRY (QUICLY_LONG_HEADER_BIT | QUICLY_QUIC_BIT | 0x30)
-#define QUICLY_PACKET_TYPE_BITMASK 0xf0
-#define QUIC_FIFO_SIZE (64 << 10)
-
-#define QUIC_ERROR_FULL_FIFO 0xff10
-#define QUIC_APP_ERROR_NONE QUICLY_ERROR_FROM_APPLICATION_ERROR_CODE(0x1)
-#define QUIC_APP_ALLOCATION_ERROR QUICLY_ERROR_FROM_APPLICATION_ERROR_CODE(0x1)
-#define QUIC_APP_ACCEPT_NOTIFY_ERROR QUICLY_ERROR_FROM_APPLICATION_ERROR_CODE(0x2)
-#define QUIC_APP_CONNECT_NOTIFY_ERROR QUICLY_ERROR_FROM_APPLICATION_ERROR_CODE(0x3)
-
-static char *
-quic_format_err (u64 code)
+static u8 *
+quic_format_err (u8 * s, va_list * args)
{
+ u64 code = va_arg (*args, u64);
switch (code)
{
+ case 0:
+ s = format (s, "no error");
+ break;
+ /* app errors */
case QUIC_ERROR_FULL_FIFO:
- return "full fifo";
+ s = format (s, "full fifo");
+ break;
+ case QUIC_APP_ERROR_CLOSE_NOTIFY:
+ s = format (s, "QUIC_APP_ERROR_CLOSE_NOTIFY");
+ break;
+ case QUIC_APP_ALLOCATION_ERROR:
+ s = format (s, "QUIC_APP_ALLOCATION_ERROR");
+ break;
+ case QUIC_APP_ACCEPT_NOTIFY_ERROR:
+ s = format (s, "QUIC_APP_ACCEPT_NOTIFY_ERROR");
+ break;
+ case QUIC_APP_CONNECT_NOTIFY_ERROR:
+ s = format (s, "QUIC_APP_CONNECT_NOTIFY_ERROR");
+ break;
+ /* quicly errors */
case QUICLY_ERROR_PACKET_IGNORED:
- return "QUICLY_ERROR_PACKET_IGNORED";
+ s = format (s, "QUICLY_ERROR_PACKET_IGNORED");
+ break;
case QUICLY_ERROR_SENDBUF_FULL:
- return "QUICLY_ERROR_SENDBUF_FULL";
+ s = format (s, "QUICLY_ERROR_SENDBUF_FULL");
+ break;
case QUICLY_ERROR_FREE_CONNECTION:
- return "QUICLY_ERROR_FREE_CONNECTION";
+ s = format (s, "QUICLY_ERROR_FREE_CONNECTION");
+ break;
case QUICLY_ERROR_RECEIVED_STATELESS_RESET:
- return "QUICLY_ERROR_RECEIVED_STATELESS_RESET";
+ s = format (s, "QUICLY_ERROR_RECEIVED_STATELESS_RESET");
+ break;
case QUICLY_TRANSPORT_ERROR_NONE:
- return "QUICLY_TRANSPORT_ERROR_NONE";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_NONE");
+ break;
case QUICLY_TRANSPORT_ERROR_INTERNAL:
- return "QUICLY_TRANSPORT_ERROR_INTERNAL";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_INTERNAL");
+ break;
case QUICLY_TRANSPORT_ERROR_SERVER_BUSY:
- return "QUICLY_TRANSPORT_ERROR_SERVER_BUSY";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_SERVER_BUSY");
+ break;
case QUICLY_TRANSPORT_ERROR_FLOW_CONTROL:
- return "QUICLY_TRANSPORT_ERROR_FLOW_CONTROL";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_FLOW_CONTROL");
+ break;
case QUICLY_TRANSPORT_ERROR_STREAM_ID:
- return "QUICLY_TRANSPORT_ERROR_STREAM_ID";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_STREAM_ID");
+ break;
case QUICLY_TRANSPORT_ERROR_STREAM_STATE:
- return "QUICLY_TRANSPORT_ERROR_STREAM_STATE";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_STREAM_STATE");
+ break;
case QUICLY_TRANSPORT_ERROR_FINAL_OFFSET:
- return "QUICLY_TRANSPORT_ERROR_FINAL_OFFSET";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_FINAL_OFFSET");
+ break;
case QUICLY_TRANSPORT_ERROR_FRAME_ENCODING:
- return "QUICLY_TRANSPORT_ERROR_FRAME_ENCODING";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_FRAME_ENCODING");
+ break;
case QUICLY_TRANSPORT_ERROR_TRANSPORT_PARAMETER:
- return "QUICLY_TRANSPORT_ERROR_TRANSPORT_PARAMETER";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_TRANSPORT_PARAMETER");
+ break;
case QUICLY_TRANSPORT_ERROR_VERSION_NEGOTIATION:
- return "QUICLY_TRANSPORT_ERROR_VERSION_NEGOTIATION";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_VERSION_NEGOTIATION");
+ break;
case QUICLY_TRANSPORT_ERROR_PROTOCOL_VIOLATION:
- return "QUICLY_TRANSPORT_ERROR_PROTOCOL_VIOLATION";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_PROTOCOL_VIOLATION");
+ break;
case QUICLY_TRANSPORT_ERROR_INVALID_MIGRATION:
- return "QUICLY_TRANSPORT_ERROR_INVALID_MIGRATION";
- case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE:
- return "QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE";
+ s = format (s, "QUICLY_TRANSPORT_ERROR_INVALID_MIGRATION");
+ break;
+ /* picotls errors */
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_CLOSE_NOTIFY):
+ s =
+ format (s, "PTLS_ALERT_CLOSE_NOTIFY");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_UNEXPECTED_MESSAGE):
+ s =
+ format (s, "PTLS_ALERT_UNEXPECTED_MESSAGE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_BAD_RECORD_MAC):
+ s =
+ format (s, "PTLS_ALERT_BAD_RECORD_MAC");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_HANDSHAKE_FAILURE):
+ s =
+ format (s, "PTLS_ALERT_HANDSHAKE_FAILURE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_BAD_CERTIFICATE):
+ s =
+ format (s, "PTLS_ALERT_BAD_CERTIFICATE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_CERTIFICATE_REVOKED):
+ s =
+ format (s, "PTLS_ALERT_CERTIFICATE_REVOKED");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_CERTIFICATE_EXPIRED):
+ s =
+ format (s, "PTLS_ALERT_CERTIFICATE_EXPIRED");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_CERTIFICATE_UNKNOWN):
+ s =
+ format (s, "PTLS_ALERT_CERTIFICATE_UNKNOWN");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_ILLEGAL_PARAMETER):
+ s =
+ format (s, "PTLS_ALERT_ILLEGAL_PARAMETER");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_UNKNOWN_CA):
+ s =
+ format (s, "PTLS_ALERT_UNKNOWN_CA");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_DECODE_ERROR):
+ s =
+ format (s, "PTLS_ALERT_DECODE_ERROR");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_DECRYPT_ERROR):
+ s =
+ format (s, "PTLS_ALERT_DECRYPT_ERROR");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_PROTOCOL_VERSION):
+ s =
+ format (s, "PTLS_ALERT_PROTOCOL_VERSION");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_INTERNAL_ERROR):
+ s =
+ format (s, "PTLS_ALERT_INTERNAL_ERROR");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_USER_CANCELED):
+ s =
+ format (s, "PTLS_ALERT_USER_CANCELED");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_MISSING_EXTENSION):
+ s =
+ format (s, "PTLS_ALERT_MISSING_EXTENSION");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_UNRECOGNIZED_NAME):
+ s =
+ format (s, "PTLS_ALERT_UNRECOGNIZED_NAME");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_CERTIFICATE_REQUIRED):
+ s =
+ format (s, "PTLS_ALERT_CERTIFICATE_REQUIRED");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ALERT_NO_APPLICATION_PROTOCOL):
+ s =
+ format (s, "PTLS_ALERT_NO_APPLICATION_PROTOCOL");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_NO_MEMORY):
+ s =
+ format (s, "PTLS_ERROR_NO_MEMORY");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_IN_PROGRESS):
+ s =
+ format (s, "PTLS_ERROR_IN_PROGRESS");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_LIBRARY):
+ s =
+ format (s, "PTLS_ERROR_LIBRARY");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_INCOMPATIBLE_KEY):
+ s =
+ format (s, "PTLS_ERROR_INCOMPATIBLE_KEY");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_SESSION_NOT_FOUND):
+ s =
+ format (s, "PTLS_ERROR_SESSION_NOT_FOUND");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_STATELESS_RETRY):
+ s =
+ format (s, "PTLS_ERROR_STATELESS_RETRY");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_NOT_AVAILABLE):
+ s =
+ format (s, "PTLS_ERROR_NOT_AVAILABLE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_COMPRESSION_FAILURE):
+ s =
+ format (s, "PTLS_ERROR_COMPRESSION_FAILURE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_BER_INCORRECT_ENCODING):
+ s =
+ format (s, "PTLS_ERROR_BER_INCORRECT_ENCODING");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_BER_MALFORMED_TYPE):
+ s =
+ format (s, "PTLS_ERROR_BER_MALFORMED_TYPE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_BER_MALFORMED_LENGTH):
+ s =
+ format (s, "PTLS_ERROR_BER_MALFORMED_LENGTH");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_BER_EXCESSIVE_LENGTH):
+ s =
+ format (s, "PTLS_ERROR_BER_EXCESSIVE_LENGTH");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_BER_ELEMENT_TOO_SHORT):
+ s =
+ format (s, "PTLS_ERROR_BER_ELEMENT_TOO_SHORT");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_BER_UNEXPECTED_EOC):
+ s =
+ format (s, "PTLS_ERROR_BER_UNEXPECTED_EOC");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_DER_INDEFINITE_LENGTH):
+ s =
+ format (s, "PTLS_ERROR_DER_INDEFINITE_LENGTH");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_INCORRECT_ASN1_SYNTAX):
+ s =
+ format (s, "PTLS_ERROR_INCORRECT_ASN1_SYNTAX");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_INCORRECT_PEM_KEY_VERSION):
+ s =
+ format (s, "PTLS_ERROR_INCORRECT_PEM_KEY_VERSION");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_INCORRECT_PEM_ECDSA_KEY_VERSION):
+ s =
+ format (s, "PTLS_ERROR_INCORRECT_PEM_ECDSA_KEY_VERSION");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_INCORRECT_PEM_ECDSA_CURVE):
+ s =
+ format (s, "PTLS_ERROR_INCORRECT_PEM_ECDSA_CURVE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_INCORRECT_PEM_ECDSA_KEYSIZE):
+ s =
+ format (s, "PTLS_ERROR_INCORRECT_PEM_ECDSA_KEYSIZE");
+ break;
+ case QUICLY_TRANSPORT_ERROR_TLS_ALERT_BASE + PTLS_ERROR_TO_ALERT (PTLS_ERROR_INCORRECT_ASN1_ECDSA_KEY_SYNTAX):
+ s =
+ format (s, "PTLS_ERROR_INCORRECT_ASN1_ECDSA_KEY_SYNTAX");
+ break;
default:
- return "unknown error";
+ s = format (s, "unknown error 0x%lx", code);
+ break;
}
+ return s;
}
static u32
return pool_elt_at_index (quic_main.ctx_pool[thread_index], ctx_index);
}
+static quic_ctx_t *
+quic_ctx_get_if_valid (u32 ctx_index, u32 thread_index)
+{
+ if (pool_is_free_index (quic_main.ctx_pool[thread_index], ctx_index))
+ return 0;
+ return pool_elt_at_index (quic_main.ctx_pool[thread_index], ctx_index);
+}
+
static quic_ctx_t *
quic_get_conn_ctx (quicly_conn_t * conn)
{
(void *) (((u64) ctx->c_thread_index) << 32 | (u64) ctx->c_c_index);
}
+static inline int
+quic_ctx_is_stream (quic_ctx_t * ctx)
+{
+ return (ctx->flags & QUIC_F_IS_STREAM);
+}
+
+static inline int
+quic_ctx_is_listener (quic_ctx_t * ctx)
+{
+ return (ctx->flags & QUIC_F_IS_LISTENER);
+}
+
+static session_t *
+get_stream_session_from_stream (quicly_stream_t * stream)
+{
+ 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);
+}
+
+static inline void
+quic_make_connection_key (clib_bihash_kv_16_8_t * kv,
+ const quicly_cid_plaintext_t * id)
+{
+ kv->key[0] = ((u64) id->master_id) << 32 | (u64) id->thread_id;
+ kv->key[1] = id->node_id;
+}
+
+static int
+quic_sendable_packet_count (session_t * udp_session)
+{
+ u32 max_enqueue;
+ u32 packet_size = QUIC_MAX_PACKET_SIZE + SESSION_CONN_HDR_LEN;
+ max_enqueue = svm_fifo_max_enqueue (udp_session->tx_fifo);
+ return clib_min (max_enqueue / packet_size, QUIC_SEND_PACKET_VEC_SIZE);
+}
+
+
+static void
+quic_ack_rx_data (session_t * stream_session)
+{
+ u32 max_deq;
+ quic_ctx_t *sctx;
+ svm_fifo_t *f;
+ quicly_stream_t *stream;
+ quic_stream_data_t *stream_data;
+
+ sctx =
+ quic_ctx_get (stream_session->connection_index,
+ stream_session->thread_index);
+ ASSERT (quic_ctx_is_stream (sctx));
+ stream = sctx->c_quic_ctx_id.stream;
+ stream_data = (quic_stream_data_t *) stream->data;
+
+ f = stream_session->rx_fifo;
+ max_deq = svm_fifo_max_dequeue (f);
+
+ ASSERT (stream_data->app_rx_data_len >= max_deq);
+ quicly_stream_sync_recvbuf (stream, stream_data->app_rx_data_len - max_deq);
+ QUIC_DBG (3, "Acking %u bytes", stream_data->app_rx_data_len - max_deq);
+ stream_data->app_rx_data_len = max_deq;
+}
+
static void
quic_disconnect_transport (quic_ctx_t * ctx)
{
- QUIC_DBG (2, "Called quic_disconnect_transport");
+ QUIC_DBG (2, "Disconnecting transport 0x%lx", ctx->udp_session_handle);
vnet_disconnect_args_t a = {
- .handle = ctx->c_quic_ctx_id.udp_session_handle,
+ .handle = ctx->udp_session_handle,
.app_index = quic_main.app_index,
};
if (vnet_disconnect_session (&a))
- clib_warning ("UDP session disconnect errored");
+ clib_warning ("UDP session 0x%lx disconnect errored",
+ ctx->udp_session_handle);
+}
+
+static void
+quic_connection_closed (u32 ctx_index, u32 thread_index, u8 notify_transport)
+{
+ QUIC_DBG (2, "QUIC connection closed");
+ tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
+ clib_bihash_kv_16_8_t kv;
+ quicly_conn_t *conn;
+ quic_ctx_t *ctx;
+
+ ctx = quic_ctx_get (ctx_index, thread_index);
+ ASSERT (!quic_ctx_is_stream (ctx));
+ /* TODO if connection is not established, just delete the session? */
+
+ /* Stop the timer */
+ if (ctx->timer_handle != QUIC_TIMER_HANDLE_INVALID)
+ {
+ tw = &quic_main.wrk_ctx[thread_index].timer_wheel;
+ tw_timer_stop_1t_3w_1024sl_ov (tw, ctx->timer_handle);
+ }
+
+ /* Delete the connection from the connection map */
+ conn = ctx->c_quic_ctx_id.conn;
+ quic_make_connection_key (&kv, quicly_get_master_id (conn));
+ QUIC_DBG (2, "Deleting conn with id %lu %lu", kv.key[0], kv.key[1]);
+ clib_bihash_add_del_16_8 (&quic_main.connection_hash, &kv, 0 /* is_add */ );
+
+ quic_disconnect_transport (ctx);
+ if (notify_transport)
+ session_transport_closing_notify (&ctx->connection);
+ else
+ session_transport_delete_notify (&ctx->connection);
+ /* Do not try to send anything anymore */
+ quicly_free (ctx->c_quic_ctx_id.conn);
+ ctx->c_quic_ctx_id.conn = NULL;
+ quic_ctx_free (ctx);
}
static int
len = packet->data.len;
f = udp_session->tx_fifo;
tc = session_get_transport (udp_session);
-
max_enqueue = svm_fifo_max_enqueue (f);
- if (max_enqueue <= sizeof (session_dgram_hdr_t))
- {
- QUIC_DBG (1, "Not enough space to enqueue header");
- return QUIC_ERROR_FULL_FIFO;
- }
-
- max_enqueue -= sizeof (session_dgram_hdr_t);
-
- if (max_enqueue < len)
+ if (max_enqueue < SESSION_CONN_HDR_LEN + len)
{
QUIC_DBG (1, "Too much data to send, max_enqueue %u, len %u",
- max_enqueue, len);
+ max_enqueue, len + SESSION_CONN_HDR_LEN);
return QUIC_ERROR_FULL_FIFO;
}
return 0;
}
-#define QUIC_SEND_PACKET_VEC_SIZE 16
-
-static int
-quic_sendable_packet_count (session_t * udp_session)
-{
- u32 max_enqueue;
- max_enqueue = svm_fifo_max_enqueue (udp_session->tx_fifo);
- return clib_min (max_enqueue /
- (QUIC_MAX_PACKET_SIZE + sizeof (session_dgram_hdr_t)),
- QUIC_SEND_PACKET_VEC_SIZE);
-}
-
static int
quic_send_packets (quic_ctx_t * ctx)
{
quicly_context_t *quicly_context;
app_worker_t *app_wrk;
application_t *app;
- int err;
+ int err = 0;
/* We have sctx, get qctx */
- if (ctx->c_quic_ctx_id.is_stream)
+ if (quic_ctx_is_stream (ctx))
ctx =
quic_ctx_get (ctx->c_quic_ctx_id.quic_connection_ctx_id,
ctx->c_thread_index);
- ASSERT (!ctx->c_quic_ctx_id.is_stream);
+ ASSERT (!quic_ctx_is_stream (ctx));
+
+ udp_session = session_get_from_handle_if_valid (ctx->udp_session_handle);
+ if (!udp_session)
+ goto quicly_error;
- udp_session =
- session_get_from_handle (ctx->c_quic_ctx_id.udp_session_handle);
conn = ctx->c_quic_ctx_id.conn;
if (!conn)
if (quic_sendable_packet_count (udp_session) < 2)
goto stop_sending;
- app_wrk = app_worker_get_if_valid (ctx->c_quic_ctx_id.parent_app_wrk_id);
+ app_wrk = app_worker_get_if_valid (ctx->parent_app_wrk_id);
if (!app_wrk)
{
clib_warning ("Tried to send packets on non existing app worker %u",
- ctx->c_quic_ctx_id.parent_app_wrk_id);
- quic_connection_closed (ctx->c_c_index, ctx->c_thread_index);
+ ctx->parent_app_wrk_id);
+ quic_connection_closed (ctx->c_c_index, ctx->c_thread_index,
+ 1 /* notify_transport */ );
return 1;
}
app = application_get (app_wrk->app_index);
}
while (num_packets > 0 && num_packets == max_packets);
+stop_sending:
if (svm_fifo_set_event (udp_session->tx_fifo))
- session_send_io_evt_to_thread (udp_session->tx_fifo, SESSION_IO_EVT_TX);
+ if ((err =
+ session_send_io_evt_to_thread (udp_session->tx_fifo,
+ SESSION_IO_EVT_TX)))
+ clib_warning ("Event enqueue errored %d", err);
-stop_sending:
+ 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;
quicly_error:
- if ((err != QUICLY_ERROR_PACKET_IGNORED) & (err !=
- QUICLY_ERROR_FREE_CONNECTION))
- clib_warning ("Quic error '%s'.", quic_format_err (err));
- quic_connection_closed (ctx->c_c_index, ctx->c_thread_index);
+ 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->c_c_index, ctx->c_thread_index,
+ 1 /* notify_transport */ );
return 1;
}
/*****************************************************************************
+ *
* START QUICLY CALLBACKS
* Called from QUIC lib
+ *
*****************************************************************************/
static void
quic_ctx_get (stream_data->ctx_id, stream_data->thread_index);
session_t *stream_session =
session_get (sctx->c_s_index, sctx->c_thread_index);
- QUIC_DBG (2, "DESTROYED_STREAM: session 0x%lx (code 0x%x)",
- session_handle (stream_session), err);
+ QUIC_DBG (2, "DESTROYED_STREAM: session 0x%lx (%U)",
+ session_handle (stream_session), quic_format_err, err);
stream_session->session_state = SESSION_STATE_CLOSED;
session_transport_delete_notify (&sctx->connection);
quic_ctx_get (stream_data->ctx_id, stream_data->thread_index);
session_t *stream_session =
session_get (sctx->c_s_index, sctx->c_thread_index);
- clib_warning ("(NOT IMPLEMENTD) STOP_SENDING: session 0x%lx (code 0x%x)",
- session_handle (stream_session), err);
+ clib_warning ("(NOT IMPLEMENTD) STOP_SENDING: session 0x%lx (%U)",
+ session_handle (stream_session), quic_format_err, err);
#endif
/* TODO : handle STOP_SENDING */
return 0;
#if QUIC_DEBUG >= 2
session_t *stream_session =
session_get (sctx->c_s_index, sctx->c_thread_index);
- clib_warning ("RESET_STREAM: session 0x%lx (code 0x%x)",
- session_handle (stream_session), err);
+ clib_warning ("RESET_STREAM: session 0x%lx (%U)",
+ session_handle (stream_session), quic_format_err, err);
#endif
-
session_transport_closing_notify (&sctx->connection);
return 0;
}
-static session_t *
-get_stream_session_from_stream (quicly_stream_t * stream)
-{
- 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);
-}
-
static int
quic_on_receive (quicly_stream_t * stream, size_t off, const void *src,
size_t len)
max_enq = svm_fifo_max_enqueue_prod (f);
QUIC_DBG (3, "Enqueuing %u at off %u in %u space", len, off, max_enq);
- if (off + len > max_enq)
+ if (off - stream_data->app_rx_data_len + len > max_enq)
{
- /* TODO : can we find a better solution, listening on RX fifo evts ? */
- QUIC_DBG (3, "Ingoring packet, RX fifo is full");
- return QUICLY_ERROR_PACKET_IGNORED;
+ QUIC_DBG (1, "Error RX fifo is full");
+ return 1;
}
- if (off == 0)
+ if (off == stream_data->app_rx_data_len)
{
+ /* Streams live on the same thread so (f, stream_data) should stay consistent */
rlen = svm_fifo_enqueue (f, len, (u8 *) src);
+ stream_data->app_rx_data_len += rlen;
ASSERT (rlen >= len);
-
- quicly_stream_sync_recvbuf (stream, rlen);
app_wrk = app_worker_get_if_valid (stream_session->app_wrk_index);
if (PREDICT_TRUE (app_wrk != 0))
app_worker_lock_and_send_event (app_wrk, stream_session,
SESSION_IO_EVT_RX);
+ quic_ack_rx_data (stream_session);
}
else
{
- rlen = svm_fifo_enqueue_with_offset (f, off, len, (u8 *) src);
+ rlen =
+ svm_fifo_enqueue_with_offset (f, off - stream_data->app_rx_data_len,
+ len, (u8 *) src);
ASSERT (rlen == 0);
}
return 0;
{
session_t *stream_session;
svm_fifo_t *f;
+ int rv;
stream_session = get_stream_session_from_stream (stream);
f = stream_session->tx_fifo;
- ASSERT (svm_fifo_dequeue_drop (f, delta) == delta);
+ rv = svm_fifo_dequeue_drop (f, delta);
+ ASSERT (rv == delta);
quicly_stream_sync_sendbuf (stream, 0);
}
}
else
{
- QUIC_DBG (3, "Wrote ALL");
*wrote_all = 1;
*len = deq_max - off;
+ QUIC_DBG (3, "Wrote ALL, %u", *len);
}
/* TODO, use something like : return svm_fifo_peek (f, off, *len, dst); */
qctx = quic_get_conn_ctx (stream->conn);
stream_session = session_alloc (qctx->c_thread_index);
- QUIC_DBG (2, "Allocated stream_session, id %u, thread %u ctx %u",
- stream_session->session_index, stream_session->thread_index,
- sctx_id);
+ QUIC_DBG (2, "ACCEPTED stream_session 0x%lx ctx %u",
+ session_handle (stream_session), sctx_id);
sctx = quic_ctx_get (sctx_id, qctx->c_thread_index);
- sctx->c_quic_ctx_id.parent_app_wrk_id =
- qctx->c_quic_ctx_id.parent_app_wrk_id;
- sctx->c_quic_ctx_id.parent_app_id = qctx->c_quic_ctx_id.parent_app_id;
+ sctx->parent_app_wrk_id = qctx->parent_app_wrk_id;
+ sctx->parent_app_id = qctx->parent_app_id;
sctx->c_quic_ctx_id.quic_connection_ctx_id = qctx->c_c_index;
sctx->c_c_index = sctx_id;
- sctx->c_quic_ctx_id.is_stream = 1;
sctx->c_s_index = stream_session->session_index;
sctx->c_quic_ctx_id.stream = stream;
+ sctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
+ sctx->flags |= QUIC_F_IS_STREAM;
stream_data = (quic_stream_data_t *) stream->data;
stream_data->ctx_id = sctx_id;
stream_data->thread_index = sctx->c_thread_index;
+ stream_data->app_rx_data_len = 0;
sctx->c_s_index = stream_session->session_index;
stream_session->session_state = SESSION_STATE_CREATED;
- stream_session->flags |= SESSION_F_QUIC_STREAM;
- stream_session->app_wrk_index = sctx->c_quic_ctx_id.parent_app_wrk_id;
+ stream_session->app_wrk_index = sctx->parent_app_wrk_id;
stream_session->connection_index = sctx->c_c_index;
stream_session->session_type =
session_type_from_proto_and_ip (TRANSPORT_PROTO_QUIC,
quicly_reset_stream (stream, QUIC_APP_ALLOCATION_ERROR);
return;
}
+ svm_fifo_add_want_deq_ntf (stream_session->rx_fifo,
+ SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL |
+ SVM_FIFO_WANT_DEQ_NOTIF_IF_EMPTY);
rv = app_worker_accept_notify (app_wrk, stream_session);
if (rv)
quicly_reset_stream (stream, QUIC_APP_ACCEPT_NOTIFY_ERROR);
return;
}
- session_lookup_add_connection (&sctx->connection,
- session_handle (stream_session));
}
static int
return 0;
}
-static quicly_stream_open_t on_stream_open = { &quic_on_stream_open };
-
static void
-quic_on_conn_close (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_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_DBG (2, "connection closed, reason: %.*s", reason, reason_len);
quic_ctx_t *ctx = quic_get_conn_ctx (conn);
+#if QUIC_DEBUG >= 2
+ session_t *quic_session = session_get (ctx->c_s_index, ctx->c_thread_index);
+ clib_warning ("Session 0x%lx closed by peer (%U) %.*s ",
+ session_handle (quic_session), quic_format_err, code,
+ reason_len, reason);
+#endif
+ ctx->c_quic_ctx_id.conn_state = QUIC_CONN_STATE_PASSIVE_CLOSING;
session_transport_closing_notify (&ctx->connection);
}
-static quicly_closed_by_peer_t on_closed_by_peer = { &quic_on_conn_close };
+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 };
/*****************************************************************************
+ *
* END QUICLY CALLBACKS
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * BEGIN TIMERS HANDLING
+ *
+ *****************************************************************************/
+
+static int64_t
+quic_get_thread_time (u8 thread_index)
+{
+ return quic_main.wrk_ctx[thread_index].time_now;
+}
+
+static int64_t
+quic_get_time (quicly_now_t * self)
+{
+ u8 thread_index = vlib_get_thread_index ();
+ return quic_get_thread_time (thread_index);
+}
+
+static quicly_now_t quicly_vpp_now_cb = { quic_get_time };
+
+static u32
+quic_set_time_now (u32 thread_index)
+{
+ vlib_main_t *vlib_main = vlib_get_main ();
+ f64 time = vlib_time_now (vlib_main);
+ quic_main.wrk_ctx[thread_index].time_now = (int64_t) (time * 1000.f);
+ return quic_main.wrk_ctx[thread_index].time_now;
+}
+
+/* Transport proto callback */
+static void
+quic_update_time (f64 now, u8 thread_index)
+{
+ tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
+
+ tw = &quic_main.wrk_ctx[thread_index].timer_wheel;
+ quic_set_time_now (thread_index);
+ tw_timer_expire_timers_1t_3w_1024sl_ov (tw, now);
+}
+
+static void
+quic_timer_expired (u32 conn_index)
+{
+ quic_ctx_t *ctx;
+ QUIC_DBG (4, "Timer expired for conn %u at %ld", conn_index,
+ quic_get_time (NULL));
+ ctx = quic_ctx_get (conn_index, vlib_get_thread_index ());
+ ctx->timer_handle = QUIC_TIMER_HANDLE_INVALID;
+ quic_send_packets (ctx);
+}
+
+static void
+quic_update_timer (quic_ctx_t * ctx)
+{
+ tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
+ int64_t next_timeout, next_interval;
+ session_t *quic_session;
+
+ /* This timeout is in ms which is the unit of our timer */
+ next_timeout = quicly_get_first_timeout (ctx->c_quic_ctx_id.conn);
+ next_interval = next_timeout - quic_get_time (NULL);
+
+ if (next_timeout == 0 || next_interval <= 0)
+ {
+ if (ctx->c_s_index == QUIC_SESSION_INVALID)
+ {
+ next_interval = 1;
+ }
+ else
+ {
+ quic_session = session_get (ctx->c_s_index, ctx->c_thread_index);
+ if (svm_fifo_set_event (quic_session->tx_fifo))
+ session_send_io_evt_to_thread_custom (quic_session,
+ quic_session->thread_index,
+ SESSION_IO_EVT_BUILTIN_TX);
+ return;
+ }
+ }
+
+ tw = &quic_main.wrk_ctx[vlib_get_thread_index ()].timer_wheel;
+
+ QUIC_DBG (4, "Timer set to %ld (int %ld) for ctx %u", next_timeout,
+ next_interval, ctx->c_c_index);
+
+ if (ctx->timer_handle == QUIC_TIMER_HANDLE_INVALID)
+ {
+ if (next_timeout == INT64_MAX)
+ {
+ QUIC_DBG (4, "timer for ctx %u already stopped", ctx->c_c_index);
+ return;
+ }
+ ctx->timer_handle =
+ tw_timer_start_1t_3w_1024sl_ov (tw, ctx->c_c_index, 0, next_interval);
+ }
+ else
+ {
+ if (next_timeout == INT64_MAX)
+ {
+ tw_timer_stop_1t_3w_1024sl_ov (tw, ctx->timer_handle);
+ ctx->timer_handle = QUIC_TIMER_HANDLE_INVALID;
+ QUIC_DBG (4, "Stopping timer for ctx %u", ctx->c_c_index);
+ }
+ else
+ tw_timer_update_1t_3w_1024sl_ov (tw, ctx->timer_handle,
+ next_interval);
+ }
+ return;
+}
+
+static void
+quic_expired_timers_dispatch (u32 * expired_timers)
+{
+ int i;
+
+ for (i = 0; i < vec_len (expired_timers); i++)
+ {
+ quic_timer_expired (expired_timers[i]);
+ }
+}
+
+/*****************************************************************************
+ *
+ * END TIMERS HANDLING
+ *
*****************************************************************************/
/* single-entry session cache */
ctx->sign_certificate = &sc.super;
}
-static inline void
-quic_make_connection_key (clib_bihash_kv_16_8_t * kv,
- const quicly_cid_plaintext_t * id)
-{
- kv->key[0] = ((u64) id->master_id) << 32 | (u64) id->thread_id;
- kv->key[1] = id->node_id;
-}
-
-static void
-quic_connection_closed (u32 ctx_index, u32 thread_index)
-{
- /* TODO : free fifos */
- QUIC_DBG (2, "QUIC connection closed");
- tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
- clib_bihash_kv_16_8_t kv;
- quicly_conn_t *conn;
- quic_ctx_t *ctx;
-
- ctx = quic_ctx_get (ctx_index, thread_index);
-
- ASSERT (!ctx->c_quic_ctx_id.is_stream);
- /* TODO if connection is not established, just delete the session? */
-
- /* Stop the timer */
- if (ctx->timer_handle != QUIC_TIMER_HANDLE_INVALID)
- {
- tw = &quic_main.wrk_ctx[thread_index].timer_wheel;
- tw_timer_stop_1t_3w_1024sl_ov (tw, ctx->timer_handle);
- }
-
- /* Delete the connection from the connection map */
- conn = ctx->c_quic_ctx_id.conn;
- quic_make_connection_key (&kv, quicly_get_master_id (conn));
- QUIC_DBG (2, "Deleting conn with id %lu %lu", kv.key[0], kv.key[1]);
- clib_bihash_add_del_16_8 (&quic_main.connection_hash, &kv, 0 /* is_add */ );
-
- quic_disconnect_transport (ctx);
- session_transport_delete_notify (&ctx->connection);
- /* Do not try to send anything anymore */
- quicly_free (ctx->c_quic_ctx_id.conn);
- ctx->c_quic_ctx_id.conn = NULL;
- quic_ctx_free (ctx);
-}
-
static void
allocate_quicly_ctx (application_t * app, u8 is_client)
{
quicly_ctx->transport_params.max_streams_bidi = QUIC_INT_MAX;
quicly_ctx->transport_params.max_stream_data.bidi_local = (QUIC_FIFO_SIZE - 1); /* max_enq is SIZE - 1 */
quicly_ctx->transport_params.max_stream_data.bidi_remote = (QUIC_FIFO_SIZE - 1); /* max_enq is SIZE - 1 */
- quicly_ctx->transport_params.max_stream_data.uni = QUIC_INT_MAX;
-
- quicly_ctx->tls->random_bytes (ctx_data->cid_key, 16);
- ctx_data->cid_key[16] = 0;
- key_vec = ptls_iovec_init (ctx_data->cid_key, strlen (ctx_data->cid_key));
- quicly_ctx->cid_encryptor =
- quicly_new_default_cid_encryptor (&ptls_openssl_bfecb,
- &ptls_openssl_sha256, key_vec);
- if (!is_client && app->tls_key != NULL && app->tls_cert != NULL)
- {
- load_bio_private_key (quicly_ctx->tls, (char *) app->tls_key);
- load_bio_certificate_chain (quicly_ctx->tls, (char *) app->tls_cert);
- }
-}
-
-
-/*****************************************************************************
- * BEGIN TIMERS HANDLING
- *****************************************************************************/
-
-static int64_t
-quic_get_thread_time (u8 thread_index)
-{
- return quic_main.wrk_ctx[thread_index].time_now;
-}
-
-static int64_t
-quic_get_time (quicly_now_t * self)
-{
- u8 thread_index = vlib_get_thread_index ();
- return quic_get_thread_time (thread_index);
-}
-
-static u32
-quic_set_time_now (u32 thread_index)
-{
- vlib_main_t *vlib_main = vlib_get_main ();
- f64 time = vlib_time_now (vlib_main);
- quic_main.wrk_ctx[thread_index].time_now = (int64_t) (time * 1000.f);
- return quic_main.wrk_ctx[thread_index].time_now;
-}
-
-/* Transport proto callback */
-static void
-quic_update_time (f64 now, u8 thread_index)
-{
- tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
-
- tw = &quic_main.wrk_ctx[thread_index].timer_wheel;
- quic_set_time_now (thread_index);
- tw_timer_expire_timers_1t_3w_1024sl_ov (tw, now);
-}
-
-static void
-quic_timer_expired (u32 conn_index)
-{
- quic_ctx_t *ctx;
- QUIC_DBG (4, "Timer expired for conn %u at %ld", conn_index,
- quic_get_time (NULL));
- ctx = quic_ctx_get (conn_index, vlib_get_thread_index ());
- ctx->timer_handle = QUIC_TIMER_HANDLE_INVALID;
- quic_send_packets (ctx);
-}
-
-static void
-quic_update_timer (quic_ctx_t * ctx)
-{
- tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
- int64_t next_timeout, next_interval;
- session_t *quic_session;
-
- /* This timeout is in ms which is the unit of our timer */
- next_timeout = quicly_get_first_timeout (ctx->c_quic_ctx_id.conn);
- next_interval = next_timeout - quic_get_time (NULL);
-
- if (next_timeout == 0 || next_interval <= 0)
- {
- if (ctx->c_s_index == QUIC_SESSION_INVALID)
- {
- next_interval = 1;
- }
- else
- {
- quic_session = session_get (ctx->c_s_index, ctx->c_thread_index);
- if (svm_fifo_set_event (quic_session->tx_fifo))
- session_send_io_evt_to_thread_custom (quic_session,
- quic_session->thread_index,
- SESSION_IO_EVT_BUILTIN_TX);
- return;
- }
- }
-
- tw = &quic_main.wrk_ctx[vlib_get_thread_index ()].timer_wheel;
-
- QUIC_DBG (4, "Timer set to %ld (int %ld) for ctx %u", next_timeout,
- next_interval, ctx->c_c_index);
-
- if (ctx->timer_handle == QUIC_TIMER_HANDLE_INVALID)
- {
- if (next_timeout == INT64_MAX)
- {
- QUIC_DBG (4, "timer for ctx %u already stopped", ctx->c_c_index);
- return;
- }
- ctx->timer_handle =
- tw_timer_start_1t_3w_1024sl_ov (tw, ctx->c_c_index, 0, next_interval);
- }
- else
- {
- if (next_timeout == INT64_MAX)
- {
- tw_timer_stop_1t_3w_1024sl_ov (tw, ctx->timer_handle);
- ctx->timer_handle = QUIC_TIMER_HANDLE_INVALID;
- QUIC_DBG (4, "Stopping timer for ctx %u", ctx->c_c_index);
- }
- else
- tw_timer_update_1t_3w_1024sl_ov (tw, ctx->timer_handle,
- next_interval);
- }
- return;
-}
-
-static void
-quic_expired_timers_dispatch (u32 * expired_timers)
-{
- int i;
-
- for (i = 0; i < vec_len (expired_timers); i++)
- {
- quic_timer_expired (expired_timers[i]);
- }
-}
-
-
-/*****************************************************************************
- * END TIMERS HANDLING
- *
- * BEGIN TRANSPORT PROTO FUNCTIONS
- *****************************************************************************/
-
-static int
-quic_connect (transport_endpoint_cfg_t * tep)
-{
- QUIC_DBG (2, "Called quic_connect");
- session_endpoint_cfg_t *sep;
- int connect_stream = 0;
-
- sep = (session_endpoint_cfg_t *) tep;
-
- if (sep->port == 0)
- {
- /* TODO: better logic to detect if this is a stream or a connection request */
- connect_stream = 1;
- }
+ quicly_ctx->transport_params.max_stream_data.uni = QUIC_INT_MAX;
- if (connect_stream)
- {
- return quic_connect_new_stream (sep);
- }
- else
+ quicly_ctx->tls->random_bytes (ctx_data->cid_key, 16);
+ ctx_data->cid_key[16] = 0;
+ key_vec = ptls_iovec_init (ctx_data->cid_key, strlen (ctx_data->cid_key));
+ quicly_ctx->cid_encryptor =
+ quicly_new_default_cid_encryptor (&ptls_openssl_bfecb,
+ &ptls_openssl_sha256, key_vec);
+ if (!is_client && app->tls_key != NULL && app->tls_cert != NULL)
{
- return quic_connect_new_connection (sep);
+ load_bio_private_key (quicly_ctx->tls, (char *) app->tls_key);
+ load_bio_certificate_chain (quicly_ctx->tls, (char *) app->tls_cert);
}
}
+/*****************************************************************************
+ *
+ * BEGIN TRANSPORT PROTO FUNCTIONS
+ *
+ *****************************************************************************/
+
static int
-quic_connect_new_stream (session_endpoint_cfg_t * sep)
+quic_connect_new_stream (session_t * quic_session, u32 opaque)
{
uint64_t quic_session_handle;
- session_t *quic_session, *stream_session;
+ session_t *stream_session;
quic_stream_data_t *stream_data;
quicly_stream_t *stream;
quicly_conn_t *conn;
int rv;
/* Find base session to which the user want to attach a stream */
- quic_session_handle = sep->transport_opts;
- QUIC_DBG (2, "Opening new stream (qsession %u)", sep->transport_opts);
- quic_session = session_get_from_handle (quic_session_handle);
+ quic_session_handle = session_handle (quic_session);
+ QUIC_DBG (2, "Opening new stream (qsession %u)", quic_session_handle);
- if (quic_session->session_type !=
- session_type_from_proto_and_ip (TRANSPORT_PROTO_QUIC, sep->is_ip4))
+ if (session_type_transport_proto (quic_session->session_type) !=
+ TRANSPORT_PROTO_QUIC)
{
QUIC_DBG (1, "received incompatible session");
return -1;
sctx = quic_ctx_get (sctx_index, quic_session->thread_index);
qctx =
quic_ctx_get (quic_session->connection_index, quic_session->thread_index);
- if (qctx->c_quic_ctx_id.is_stream)
+ if (quic_ctx_is_stream (qctx))
{
QUIC_DBG (1, "session is a stream");
quic_ctx_free (sctx);
return -1;
}
- sctx->c_quic_ctx_id.parent_app_wrk_id =
- qctx->c_quic_ctx_id.parent_app_wrk_id;
- sctx->c_quic_ctx_id.parent_app_id = qctx->c_quic_ctx_id.parent_app_id;
+ sctx->parent_app_wrk_id = qctx->parent_app_wrk_id;
+ sctx->parent_app_id = qctx->parent_app_id;
sctx->c_quic_ctx_id.quic_connection_ctx_id = qctx->c_c_index;
sctx->c_c_index = sctx_index;
- sctx->c_quic_ctx_id.is_stream = 1;
+ sctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
+ sctx->flags |= QUIC_F_IS_STREAM;
conn = qctx->c_quic_ctx_id.conn;
QUIC_DBG (2, "Opened stream %d, creating session", stream->stream_id);
stream_session = session_alloc (qctx->c_thread_index);
- QUIC_DBG (2, "Allocated stream_session, id %u, thread %u ctx %u",
- stream_session->session_index, stream_session->thread_index,
- sctx_index);
- stream_session->flags |= SESSION_F_QUIC_STREAM;
+ QUIC_DBG (2, "Allocated stream_session 0x%lx ctx %u",
+ session_handle (stream_session), sctx_index);
stream_session->app_wrk_index = app_wrk->wrk_index;
stream_session->connection_index = sctx_index;
stream_session->listener_handle = quic_session_handle;
quicly_reset_stream (stream, QUIC_APP_ALLOCATION_ERROR);
session_free_w_fifos (stream_session);
quic_ctx_free (sctx);
- return app_worker_connect_notify (app_wrk, NULL, sep->opaque);
+ return app_worker_connect_notify (app_wrk, NULL, 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);
+
stream_session->session_state = SESSION_STATE_READY;
- if (app_worker_connect_notify (app_wrk, stream_session, sep->opaque))
+ if (app_worker_connect_notify (app_wrk, stream_session, opaque))
{
QUIC_DBG (1, "failed to notify app");
quicly_reset_stream (stream, QUIC_APP_CONNECT_NOTIFY_ERROR);
quic_ctx_free (sctx);
return -1;
}
- session_lookup_add_connection (&sctx->connection,
- session_handle (stream_session));
stream_data = (quic_stream_data_t *) stream->data;
stream_data->ctx_id = sctx->c_c_index;
stream_data->thread_index = sctx->c_thread_index;
+ stream_data->app_rx_data_len = 0;
return 0;
}
ctx_index = quic_ctx_alloc (vlib_get_thread_index ());
ctx = quic_ctx_get (ctx_index, vlib_get_thread_index ());
- ctx->c_quic_ctx_id.parent_app_wrk_id = sep->app_wrk_index;
+ ctx->parent_app_wrk_id = sep->app_wrk_index;
ctx->c_s_index = QUIC_SESSION_INVALID;
ctx->c_c_index = ctx_index;
ctx->c_quic_ctx_id.udp_is_ip4 = sep->is_ip4;
ctx->timer_handle = QUIC_TIMER_HANDLE_INVALID;
- ctx->conn_state = QUIC_CONN_STATE_HANDSHAKE;
- ctx->client_opaque = sep->opaque;
+ ctx->c_quic_ctx_id.conn_state = QUIC_CONN_STATE_HANDSHAKE;
+ ctx->c_quic_ctx_id.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->c_quic_ctx_id.srv_hostname = format (0, "%v", sep->hostname);
+ vec_terminate_c_string (ctx->c_quic_ctx_id.srv_hostname);
}
else
{
/* needed by quic for crypto + determining client / server */
- ctx->srv_hostname =
+ ctx->c_quic_ctx_id.srv_hostname =
format (0, "%U", format_ip46_address, &sep->ip, sep->is_ip4);
}
app_wrk = app_worker_get (sep->app_wrk_index);
app = application_get (app_wrk->app_index);
- ctx->c_quic_ctx_id.parent_app_id = app_wrk->app_index;
+ ctx->parent_app_id = app_wrk->app_index;
cargs->sep_ext.ns_index = app->ns_index;
allocate_quicly_ctx (app, 1 /* is client */ );
return 0;
}
+static int
+quic_connect (transport_endpoint_cfg_t * tep)
+{
+ QUIC_DBG (2, "Called quic_connect");
+ session_endpoint_cfg_t *sep = (session_endpoint_cfg_t *) tep;
+ session_t *quic_session;
+ sep = (session_endpoint_cfg_t *) tep;
+
+ quic_session = session_get_from_handle_if_valid (sep->parent_handle);
+ if (quic_session)
+ return quic_connect_new_stream (quic_session, sep->opaque);
+ else
+ return quic_connect_new_connection (sep);
+}
+
static void
quic_proto_on_close (u32 ctx_index, u32 thread_index)
{
- quic_ctx_t *ctx = quic_ctx_get (ctx_index, thread_index);
- if (ctx->c_quic_ctx_id.is_stream)
- {
+ 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);
- clib_warning ("Closing Ssession 0x%lx",
- session_handle (stream_session));
+ session_t *stream_session =
+ session_get (ctx->c_s_index, ctx->c_thread_index);
+ clib_warning ("Closing session 0x%lx", session_handle (stream_session));
#endif
+ if (quic_ctx_is_stream (ctx))
+ {
quicly_stream_t *stream = ctx->c_quic_ctx_id.stream;
- quicly_reset_stream (stream, QUIC_APP_ERROR_NONE);
+ quicly_reset_stream (stream, QUIC_APP_ERROR_CLOSE_NOTIFY);
+ quic_send_packets (ctx);
}
+ else if (ctx->c_quic_ctx_id.conn_state == QUIC_CONN_STATE_PASSIVE_CLOSING)
+ quic_connection_closed (ctx->c_c_index, ctx->c_thread_index,
+ 0 /* notify_transport */ );
else
{
-#if QUIC_DEBUG >= 2
- session_t *quic_session =
- session_get (ctx->c_s_index, ctx->c_thread_index);
- clib_warning ("Closing Qsession 0x%lx", session_handle (quic_session));
-#endif
quicly_conn_t *conn = ctx->c_quic_ctx_id.conn;
/* Start connection closing. Keep sending packets until quicly_send
returns QUICLY_ERROR_FREE_CONNECTION */
- quicly_close (conn, 0, "");
+ quicly_close (conn, QUIC_APP_ERROR_CLOSE_NOTIFY, "Closed by peer");
/* This also causes all streams to be closed (and the cb called) */
+ quic_send_packets (ctx);
}
- quic_send_packets (ctx);
}
static u32
if (vnet_listen (args))
return -1;
- lctx_index = quic_ctx_alloc (0); /* listener */
+ lctx_index = quic_ctx_alloc (0);
udp_handle = args->handle;
app_listener = app_listener_get_w_handle (udp_handle);
udp_listen_session = app_listener_get_session (app_listener);
udp_listen_session->opaque = lctx_index;
- lctx = quic_ctx_get (lctx_index, 0); /* listener */
- lctx->is_listener = 1;
- lctx->c_quic_ctx_id.parent_app_wrk_id = sep->app_wrk_index;
- lctx->c_quic_ctx_id.parent_app_id = app_wrk->app_index;
- lctx->c_quic_ctx_id.udp_session_handle = udp_handle;
- lctx->c_quic_ctx_id.udp_is_ip4 = sep->is_ip4;
+ lctx = quic_ctx_get (lctx_index, 0);
+ lctx->flags |= QUIC_F_IS_LISTENER;
+
+ clib_memcpy (&lctx->c_rmt_ip, &args->sep.peer.ip, sizeof (ip46_address_t));
+ clib_memcpy (&lctx->c_lcl_ip, &args->sep.ip, sizeof (ip46_address_t));
+ lctx->c_rmt_port = args->sep.peer.port;
+ lctx->c_lcl_port = args->sep.port;
+ lctx->c_is_ip4 = args->sep.is_ip4;
+ lctx->c_fib_index = args->sep.fib_index;
+ lctx->c_proto = TRANSPORT_PROTO_QUIC;
+ lctx->parent_app_wrk_id = sep->app_wrk_index;
+ lctx->parent_app_id = app_wrk->app_index;
+ lctx->udp_session_handle = udp_handle;
lctx->c_s_index = quic_listen_session_index;
- QUIC_DBG (2, "Started listening %d", lctx_index);
+ QUIC_DBG (2, "Listening UDP session 0x%lx",
+ session_handle (udp_listen_session));
+ QUIC_DBG (2, "Listening QUIC session 0x%lx", quic_listen_session_index);
return lctx_index;
}
{
QUIC_DBG (2, "Called quic_stop_listen");
quic_ctx_t *lctx;
-
lctx = quic_ctx_get (lctx_index, 0);
+ ASSERT (quic_ctx_is_listener (lctx));
vnet_unlisten_args_t a = {
- .handle = lctx->c_quic_ctx_id.udp_session_handle,
+ .handle = lctx->udp_session_handle,
.app_index = quic_main.app_index,
.wrk_map_index = 0 /* default wrk */
};
static transport_connection_t *
quic_connection_get (u32 ctx_index, u32 thread_index)
{
- QUIC_DBG (2, "Called quic_connection_get");
quic_ctx_t *ctx;
ctx = quic_ctx_get (ctx_index, thread_index);
return &ctx->connection;
{
quic_ctx_t *ctx = va_arg (*args, quic_ctx_t *);
u32 verbose = va_arg (*args, u32);
+ u8 *str = 0;
if (!ctx)
return s;
- s = format (s, "[#%d][%s] ", ctx->c_thread_index, "Q");
-
- if (ctx->is_listener)
- {
- s = format (s, "%s Listener: ", ctx->c_quic_ctx_id.is_stream ?
- "Stream" : "QSession");
- if (verbose)
- s = format (s, "app %d wrk %d", ctx->c_quic_ctx_id.parent_app_id,
- ctx->c_quic_ctx_id.parent_app_wrk_id);
- }
+ str = format (str, "[#%d][Q] ", ctx->c_thread_index);
+
+ if (quic_ctx_is_listener (ctx))
+ str = format (str, "Listener, UDP %ld", ctx->udp_session_handle);
+ else if (quic_ctx_is_stream (ctx))
+ str = format (str, "Stream %ld conn %d",
+ ctx->c_quic_ctx_id.stream->stream_id,
+ ctx->c_quic_ctx_id.quic_connection_ctx_id);
+ else /* connection */
+ str = format (str, "Conn %d UDP %d", ctx->c_c_index,
+ ctx->udp_session_handle);
+
+ str = format (str, " app %d wrk %d", ctx->parent_app_id,
+ ctx->parent_app_wrk_id);
+
+ if (verbose == 1)
+ s = format (s, "%-50s%-15d", str, ctx->c_quic_ctx_id.conn_state);
else
- {
- if (ctx->c_is_ip4)
- s = format (s, "%U:%d->%U:%d", format_ip4_address, &ctx->c_lcl_ip4,
- clib_net_to_host_u16 (ctx->c_lcl_port),
- format_ip4_address, &ctx->c_rmt_ip4,
- clib_net_to_host_u16 (ctx->c_rmt_port));
- else
- s = format (s, "%U:%d->%U:%d", format_ip6_address, &ctx->c_lcl_ip6,
- clib_net_to_host_u16 (ctx->c_lcl_port),
- format_ip6_address, &ctx->c_rmt_ip6,
- clib_net_to_host_u16 (ctx->c_rmt_port));
- }
+ s = format (s, "%s\n", str);
+ vec_free (str);
return s;
}
u32 thread_index = va_arg (*args, u32);
u32 verbose = va_arg (*args, u32);
quic_ctx_t *ctx = quic_ctx_get (qc_index, thread_index);
- if (ctx)
- s = format (s, "%-50U", format_quic_ctx, ctx, verbose);
+ s = format (s, "%U", format_quic_ctx, ctx, verbose);
return s;
}
format_quic_half_open (u8 * s, va_list * args)
{
u32 qc_index = va_arg (*args, u32);
- quic_ctx_t *ctx = quic_ctx_get (qc_index, vlib_get_thread_index ());
- s = format (s, "[QUIC] half-open app %u", ctx->c_quic_ctx_id.parent_app_id);
+ u32 thread_index = va_arg (*args, u32);
+ quic_ctx_t *ctx = quic_ctx_get (qc_index, thread_index);
+ s =
+ format (s, "[#%d][Q] half-open app %u", thread_index, ctx->parent_app_id);
return s;
}
format_quic_listener (u8 * s, va_list * args)
{
u32 tci = va_arg (*args, u32);
+ u32 thread_index = va_arg (*args, u32);
u32 verbose = va_arg (*args, u32);
- quic_ctx_t *ctx = quic_ctx_get (tci, vlib_get_thread_index ());
- if (ctx)
- {
- ASSERT (ctx->is_listener);
- s = format (s, "%-50U", format_quic_ctx, ctx, verbose);
- }
+ quic_ctx_t *ctx = quic_ctx_get (tci, thread_index);
+ s = format (s, "%U", format_quic_ctx, ctx, verbose);
return s;
}
}
static int
-quic_notify_app_connected (quic_ctx_t * ctx)
+quic_on_client_connected (quic_ctx_t * ctx)
{
- QUIC_DBG (1, "quic_notify_app_connected");
session_t *quic_session;
app_worker_t *app_wrk;
u32 ctx_id = ctx->c_c_index;
u32 thread_index = ctx->c_thread_index;
- quic_ctx_t *lctx;
- app_wrk = app_worker_get_if_valid (ctx->c_quic_ctx_id.parent_app_wrk_id);
+ app_wrk = app_worker_get_if_valid (ctx->parent_app_wrk_id);
if (!app_wrk)
{
quic_disconnect_transport (ctx);
quic_session = session_alloc (thread_index);
- lctx = quic_ctx_get (ctx->c_quic_ctx_id.listener_ctx_id, 0);
- QUIC_DBG (2, "Allocated quic_session, id %u, thread %u",
- quic_session->session_index, quic_session->thread_index);
+ QUIC_DBG (2, "Allocated quic session 0x%lx", session_handle (quic_session));
ctx->c_s_index = quic_session->session_index;
- quic_session->app_wrk_index = ctx->c_quic_ctx_id.parent_app_wrk_id;
+ quic_session->app_wrk_index = ctx->parent_app_wrk_id;
quic_session->connection_index = ctx->c_c_index;
- quic_session->listener_handle = lctx->c_s_index;
+ quic_session->listener_handle = SESSION_INVALID_HANDLE;
quic_session->session_type =
session_type_from_proto_and_ip (TRANSPORT_PROTO_QUIC,
ctx->c_quic_ctx_id.udp_is_ip4);
{
QUIC_DBG (1, "failed to app_worker_init_connected");
quic_proto_on_close (ctx_id, thread_index);
- return app_worker_connect_notify (app_wrk, NULL, ctx->client_opaque);
+ return app_worker_connect_notify (app_wrk, NULL,
+ ctx->c_quic_ctx_id.client_opaque);
}
quic_session->session_state = SESSION_STATE_CONNECTING;
- if (app_worker_connect_notify (app_wrk, quic_session, ctx->client_opaque))
+ if (app_worker_connect_notify
+ (app_wrk, quic_session, ctx->c_quic_ctx_id.client_opaque))
{
QUIC_DBG (1, "failed to notify app");
quic_proto_on_close (ctx_id, thread_index);
/* If the app opens a stream in its callback it may invalidate ctx */
ctx = quic_ctx_get (ctx_id, thread_index);
quic_session->session_state = SESSION_STATE_LISTENING;
- session_lookup_add_connection (&ctx->connection,
- session_handle (quic_session));
return 0;
}
-static int
-quic_session_connected_callback (u32 quic_app_index, u32 ctx_index,
- session_t * udp_session, u8 is_fail)
-{
- QUIC_DBG (2, "QSession is now connected (id %u)",
- udp_session->session_index);
- /* This should always be called before quic_connect returns since UDP always
- * connects instantly. */
- clib_bihash_kv_16_8_t kv;
- struct sockaddr_in6 sa6;
- struct sockaddr *sa = (struct sockaddr *) &sa6;
- socklen_t salen;
- transport_connection_t *tc;
- app_worker_t *app_wrk;
- quicly_conn_t *conn;
- application_t *app;
- quic_ctx_t *ctx;
- u32 thread_index = vlib_get_thread_index ();
- int ret;
-
- ctx = quic_ctx_get (ctx_index, thread_index);
- if (is_fail)
- {
- u32 api_context;
- int rv = 0;
-
- app_wrk =
- app_worker_get_if_valid (ctx->c_quic_ctx_id.parent_app_wrk_id);
- if (app_wrk)
- {
- api_context = ctx->c_s_index;
- app_worker_connect_notify (app_wrk, 0, api_context);
- }
- return rv;
- }
-
- app_wrk = app_worker_get_if_valid (ctx->c_quic_ctx_id.parent_app_wrk_id);
- if (!app_wrk)
- {
- QUIC_DBG (1, "Appwrk not found");
- return -1;
- }
- app = application_get (app_wrk->app_index);
-
- 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);
-
- ctx->c_quic_ctx_id.udp_session_handle = session_handle (udp_session);
- udp_session->opaque = ctx->c_quic_ctx_id.parent_app_id;
- udp_session->session_state = SESSION_STATE_READY;
-
- /* Init QUIC lib connection
- * Generate required sockaddr & salen */
- tc = session_get_transport (udp_session);
- quic_build_sockaddr (sa, &salen, &tc->rmt_ip, tc->rmt_port, tc->is_ip4);
-
- ret =
- quicly_connect (&ctx->c_quic_ctx_id.conn,
- (quicly_context_t *) app->quicly_ctx,
- (char *) ctx->srv_hostname, sa, salen,
- &quic_main.next_cid, &quic_main.hs_properties, NULL);
- ++quic_main.next_cid.master_id;
- /* Save context handle in quicly connection */
- quic_store_conn_ctx (ctx->c_quic_ctx_id.conn, ctx);
- assert (ret == 0);
-
- /* Register connection in connections map */
- conn = ctx->c_quic_ctx_id.conn;
- quic_make_connection_key (&kv, quicly_get_master_id (conn));
- kv.value = ((u64) thread_index) << 32 | (u64) 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 */ );
-
- quic_send_packets (ctx);
-
- /* 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);
-
- return ret;
-}
-
static void
quic_receive_connection (void *arg)
{
(void *) arg);
}
+static int
+quic_session_connected_callback (u32 quic_app_index, u32 ctx_index,
+ session_t * udp_session, u8 is_fail)
+{
+ QUIC_DBG (2, "QSession is now connected (id %u)",
+ udp_session->session_index);
+ /* This should always be called before quic_connect returns since UDP always
+ * connects instantly. */
+ clib_bihash_kv_16_8_t kv;
+ struct sockaddr_in6 sa6;
+ struct sockaddr *sa = (struct sockaddr *) &sa6;
+ socklen_t salen;
+ transport_connection_t *tc;
+ app_worker_t *app_wrk;
+ quicly_conn_t *conn;
+ application_t *app;
+ quic_ctx_t *ctx;
+ u32 thread_index = vlib_get_thread_index ();
+ int ret;
+
+ ctx = quic_ctx_get (ctx_index, thread_index);
+ if (is_fail)
+ {
+ u32 api_context;
+ int rv = 0;
+
+ 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);
+ }
+ return rv;
+ }
+
+ app_wrk = app_worker_get_if_valid (ctx->parent_app_wrk_id);
+ if (!app_wrk)
+ {
+ QUIC_DBG (1, "Appwrk not found");
+ return -1;
+ }
+ app = application_get (app_wrk->app_index);
+
+ 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);
+
+ ctx->udp_session_handle = session_handle (udp_session);
+ udp_session->opaque = ctx->parent_app_id;
+ udp_session->session_state = SESSION_STATE_READY;
+
+ /* Init QUIC lib connection
+ * Generate required sockaddr & salen */
+ tc = session_get_transport (udp_session);
+ quic_build_sockaddr (sa, &salen, &tc->rmt_ip, tc->rmt_port, tc->is_ip4);
+
+ ret =
+ quicly_connect (&ctx->c_quic_ctx_id.conn,
+ (quicly_context_t *) app->quicly_ctx,
+ (char *) ctx->c_quic_ctx_id.srv_hostname, sa, salen,
+ &quic_main.next_cid, &quic_main.hs_properties, NULL);
+ ++quic_main.next_cid.master_id;
+ /* Save context handle in quicly connection */
+ quic_store_conn_ctx (ctx->c_quic_ctx_id.conn, ctx);
+ assert (ret == 0);
+
+ /* Register connection in connections map */
+ conn = ctx->c_quic_ctx_id.conn;
+ quic_make_connection_key (&kv, quicly_get_master_id (conn));
+ kv.value = ((u64) thread_index) << 32 | (u64) 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 */ );
+
+ quic_send_packets (ctx);
+
+ /* 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);
+
+ return ret;
+}
+
static void
quic_session_disconnect_callback (session_t * s)
{
quic_session_accepted_callback (session_t * udp_session)
{
/* New UDP connection, try to accept it */
- QUIC_DBG (2, "UDP session accepted");
u32 ctx_index;
u32 *pool_index;
quic_ctx_t *ctx, *lctx;
ctx->c_thread_index = udp_session->thread_index;
ctx->c_c_index = ctx_index;
ctx->c_s_index = QUIC_SESSION_INVALID;
- ctx->c_quic_ctx_id.udp_session_handle = session_handle (udp_session);
+ ctx->udp_session_handle = session_handle (udp_session);
+ QUIC_DBG (2, "ACCEPTED UDP 0x%lx", ctx->udp_session_handle);
ctx->c_quic_ctx_id.listener_ctx_id = udp_listen_session->opaque;
lctx = quic_ctx_get (udp_listen_session->opaque,
udp_listen_session->thread_index);
- ctx->c_quic_ctx_id.udp_is_ip4 = lctx->c_quic_ctx_id.udp_is_ip4;
- ctx->c_quic_ctx_id.parent_app_id = lctx->c_quic_ctx_id.parent_app_id;
- ctx->c_quic_ctx_id.parent_app_wrk_id =
- lctx->c_quic_ctx_id.parent_app_wrk_id;
+ ctx->c_quic_ctx_id.udp_is_ip4 = lctx->c_is_ip4;
+ ctx->parent_app_id = lctx->parent_app_id;
+ ctx->parent_app_wrk_id = lctx->parent_app_wrk_id;
ctx->timer_handle = QUIC_TIMER_HANDLE_INVALID;
- ctx->conn_state = QUIC_CONN_STATE_OPENED;
+ ctx->c_quic_ctx_id.conn_state = QUIC_CONN_STATE_OPENED;
+ ctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
- udp_session->opaque = ctx->c_quic_ctx_id.parent_app_id;
+ udp_session->opaque = ctx->parent_app_id;
/* Put this ctx in the "opening" pool */
pool_get (quic_main.wrk_ctx[ctx->c_thread_index].opening_ctx_pool,
return 0;
}
+
+static int
+quic_custom_app_rx_callback (transport_connection_t * tc)
+{
+ quic_ctx_t *ctx;
+ session_t *stream_session = session_get (tc->s_index, tc->thread_index);
+ QUIC_DBG (3, "Received app READ notification");
+ quic_ack_rx_data (stream_session);
+ svm_fifo_reset_has_deq_ntf (stream_session->rx_fifo);
+
+ /* Need to send packets (acks may never be sent otherwise) */
+ ctx = quic_ctx_get (stream_session->connection_index,
+ stream_session->thread_index);
+ quic_send_packets (ctx);
+ return 0;
+}
+
static int
quic_custom_tx_callback (void *s)
{
quic_ctx_t *ctx;
int rv;
- svm_fifo_unset_event (stream_session->tx_fifo);
if (PREDICT_FALSE
(stream_session->session_state >= SESSION_STATE_TRANSPORT_CLOSING))
return 0;
ctx =
quic_ctx_get (stream_session->connection_index,
stream_session->thread_index);
- if (PREDICT_FALSE (!ctx->c_quic_ctx_id.is_stream))
+ if (PREDICT_FALSE (!quic_ctx_is_stream (ctx)))
{
goto tx_end; /* Most probably a reschedule */
}
+ QUIC_DBG (3, "Stream TX event");
+ quic_ack_rx_data (stream_session);
+ if (!svm_fifo_max_dequeue (stream_session->tx_fifo))
+ return 0;
+
stream = ctx->c_quic_ctx_id.stream;
if (!quicly_sendstate_is_open (&stream->sendstate))
{
rv = quicly_receive (conn, &packet);
if (rv)
{
- QUIC_DBG (2, "Quicly receive ignored packet code : %u", 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->c_quic_ctx_id.conn && ctx->conn_state == QUIC_CONN_STATE_HANDSHAKE)
+ if (ctx->c_quic_ctx_id.conn
+ && ctx->c_quic_ctx_id.conn_state == QUIC_CONN_STATE_HANDSHAKE)
{
if (quicly_connection_is_ready (conn))
{
- ctx->conn_state = QUIC_CONN_STATE_READY;
+ ctx->c_quic_ctx_id.conn_state = QUIC_CONN_STATE_READY;
if (quicly_is_client (conn))
{
- quic_notify_app_connected (ctx);
+ quic_on_client_connected (ctx);
ctx = quic_ctx_get (ctx_id, thread_index);
}
}
int rv;
quic_session = session_alloc (ctx->c_thread_index);
- QUIC_DBG (2, "Allocated quic_session, id %u, thread %u ctx %u",
- quic_session->session_index, quic_session->thread_index,
- ctx->c_c_index);
+ QUIC_DBG (2, "Allocated quic_session, 0x%lx ctx %u",
+ session_handle (quic_session), ctx->c_c_index);
quic_session->session_state = SESSION_STATE_LISTENING;
ctx->c_s_index = quic_session->session_index;
lctx = quic_ctx_get (ctx->c_quic_ctx_id.listener_ctx_id, 0);
- quic_session->app_wrk_index = lctx->c_quic_ctx_id.parent_app_wrk_id;
+ quic_session->app_wrk_index = lctx->parent_app_wrk_id;
quic_session->connection_index = ctx->c_c_index;
quic_session->session_type =
session_type_from_proto_and_ip (TRANSPORT_PROTO_QUIC,
ctx->c_quic_ctx_id.udp_is_ip4);
- quic_session->listener_handle = lctx->c_quic_ctx_id.listener_ctx_id;
+ quic_session->listener_handle = lctx->c_s_index;
/* TODO: don't alloc fifos when we don't transfer data on this session
* but we still need fifos for the events? */
session_free (quic_session);
return rv;
}
- session_lookup_add_connection (&ctx->connection,
- session_handle (quic_session));
app_wrk = app_worker_get (quic_session->app_wrk_index);
rv = app_worker_accept_notify (app_wrk, quic_session);
if (rv)
static int
quic_create_connection (quicly_context_t * quicly_ctx,
- u64 udp_session_handle, u32 ctx_index,
- struct sockaddr *sa,
+ u32 ctx_index, struct sockaddr *sa,
socklen_t salen, quicly_decoded_packet_t packet)
{
clib_bihash_kv_16_8_t kv;
/* Save ctx handle in quicly connection */
quic_store_conn_ctx (conn, ctx);
ctx->c_quic_ctx_id.conn = conn;
- ctx->conn_state = QUIC_CONN_STATE_HANDSHAKE;
+ ctx->c_quic_ctx_id.conn_state = QUIC_CONN_STATE_HANDSHAKE;
quic_create_quic_session (ctx);
* reset, then the next CID is highly likely to contain a non-authenticating
* CID, ... */
QUIC_DBG (2, "Sending stateless reset");
+ int rv;
quicly_datagram_t *dgram;
session_t *udp_session;
if (packet.cid.dest.plaintext.node_id == 0
if (dgram == NULL)
return 1;
udp_session = session_get_from_handle (udp_session_handle);
- return quic_send_datagram (udp_session, dgram); /* TODO : set event on fifo */
+ rv = quic_send_datagram (udp_session, dgram);
+ if (svm_fifo_set_event (udp_session->tx_fifo))
+ session_send_io_evt_to_thread (udp_session->tx_fifo,
+ SESSION_IO_EVT_TX);
+ return rv;
}
return 0;
}
struct sockaddr_in6 sa6;
struct sockaddr *sa = (struct sockaddr *) &sa6;
socklen_t salen;
- u32 max_deq, len, full_len, ctx_index = UINT32_MAX, ctx_thread =
- UINT32_MAX, ret;
+ u32 max_deq, full_len, ctx_index = UINT32_MAX, ctx_thread = UINT32_MAX, ret;
u8 *data;
int err;
u32 *opening_ctx_pool, *ctx_index_ptr;
u64 udp_session_handle = session_handle (udp_session);
int rv = 0;
u32 thread_index = vlib_get_thread_index ();
-
app = application_get_if_valid (app_index);
if (!app)
{
{
udp_session = session_get_from_handle (udp_session_handle); /* session alloc might have happened */
f = udp_session->rx_fifo;
- svm_fifo_unset_event (f);
max_deq = svm_fifo_max_dequeue (f);
- if (max_deq < sizeof (session_dgram_hdr_t))
+ if (max_deq == 0)
return 0;
- ret = svm_fifo_peek (f, 0, SESSION_CONN_HDR_LEN, (u8 *) & ph);
- if (ret != SESSION_CONN_HDR_LEN)
+ if (max_deq < SESSION_CONN_HDR_LEN)
{
- QUIC_DBG (1, "Not enough data for header in RX");
+ QUIC_DBG (1, "Not enough data for even a header in RX");
return 1;
}
- if (ph.data_length < ph.data_offset)
+ ret = svm_fifo_peek (f, 0, SESSION_CONN_HDR_LEN, (u8 *) & ph);
+ if (ret != SESSION_CONN_HDR_LEN)
{
- QUIC_DBG (1, "Not enough data vs offset in RX");
+ QUIC_DBG (1, "Not enough data for header in RX");
return 1;
}
- len = ph.data_length - ph.data_offset;
- full_len = ph.data_length + ph.data_offset + SESSION_CONN_HDR_LEN;
+ 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");
/* 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, ph.data_offset + SESSION_CONN_HDR_LEN,
- ph.data_length, data);
+ ret = svm_fifo_peek (f, SESSION_CONN_HDR_LEN, ph.data_length, data);
if (ret != ph.data_length)
{
QUIC_DBG (1, "Not enough data peeked in RX");
return 1;
}
- plen =
- quicly_decode_packet ((quicly_context_t *) app->quicly_ctx, &packet,
- data, len);
-
rv = 0;
quic_build_sockaddr (sa, &salen, &ph.rmt_ip, ph.rmt_port, ph.is_ip4);
- plen =
- quicly_decode_packet ((quicly_context_t *) app->quicly_ctx, &packet,
- data, len);
+ plen = quicly_decode_packet ((quicly_context_t *) app->quicly_ctx,
+ &packet, data, ph.data_length);
if (plen != SIZE_MAX)
{
pool_foreach (ctx_index_ptr, opening_ctx_pool,
({
ctx = quic_ctx_get (*ctx_index_ptr, thread_index);
- if (ctx->c_quic_ctx_id.udp_session_handle == udp_session_handle)
+ if (ctx->udp_session_handle == udp_session_handle)
{
/* Right ctx found, create conn & remove from pool */
quic_create_connection ((quicly_context_t *) app->quicly_ctx,
- udp_session_handle, *ctx_index_ptr,
- sa, salen, packet);
+ *ctx_index_ptr, sa, salen, packet);
pool_put (opening_ctx_pool, ctx_index_ptr);
goto ctx_search_done;
}
}
}
ctx_search_done:
- svm_fifo_dequeue_drop (f,
- ph.data_length + ph.data_offset +
- SESSION_CONN_HDR_LEN);
+ svm_fifo_dequeue_drop (f, full_len);
free (data);
}
while (1);
transport_endpoint_t * tep, u8 is_lcl)
{
session_t *udp_session;
- if (ctx->c_quic_ctx_id.is_stream)
- {
- tep->is_ip4 = 255; /* well this is ugly */
- }
- else
+ if (!quic_ctx_is_stream (ctx))
{
- udp_session =
- session_get_from_handle (ctx->c_quic_ctx_id.udp_session_handle);
+ udp_session = session_get_from_handle (ctx->udp_session_handle);
session_get_endpoint (udp_session, tep, is_lcl);
}
}
app_listener_t *app_listener;
session_t *udp_listen_session;
ctx = quic_ctx_get (listener_index, vlib_get_thread_index ());
- if (ctx->is_listener)
+ if (quic_ctx_is_listener (ctx))
{
- app_listener =
- app_listener_get_w_handle (ctx->c_quic_ctx_id.udp_session_handle);
+ app_listener = app_listener_get_w_handle (ctx->udp_session_handle);
udp_listen_session = app_listener_get_session (app_listener);
return session_get_endpoint (udp_listen_session, tep, is_lcl);
}
.get_connection = quic_connection_get,
.get_listener = quic_listener_get,
.update_time = quic_update_time,
+ .app_rx_evt = quic_custom_app_rx_callback,
.custom_tx = quic_custom_tx_callback,
- .tx_type = TRANSPORT_TX_INTERNAL,
- .service_type = TRANSPORT_SERVICE_APP,
.format_connection = format_quic_connection,
.format_half_open = format_quic_half_open,
.format_listener = format_quic_listener,
.get_transport_endpoint = quic_get_transport_endpoint,
.get_transport_listener_endpoint = quic_get_transport_listener_endpoint,
+ .transport_options = {
+ .tx_type = TRANSPORT_TX_INTERNAL,
+ .service_type = TRANSPORT_SERVICE_APP,
+ },
};
/* *INDENT-ON* */
static clib_error_t *
quic_init (vlib_main_t * vm)
{
- u32 add_segment_size = (4096ULL << 20) - 1, segment_size = 512 << 20;
+ u32 segment_size = 256 << 20;
vlib_thread_main_t *vtm = vlib_get_thread_main ();
tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
vnet_app_attach_args_t _a, *a = &_a;
a->options = options;
a->name = format (0, "quic");
a->options[APP_OPTIONS_SEGMENT_SIZE] = segment_size;
- a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = add_segment_size;
+ a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = segment_size;
a->options[APP_OPTIONS_RX_FIFO_SIZE] = fifo_size;
a->options[APP_OPTIONS_TX_FIFO_SIZE] = fifo_size;
a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
clib_bihash_init_16_8 (&qm->connection_hash, "quic connections", 1024,
4 << 20);
- if (!qm->ca_cert_path)
- qm->ca_cert_path = QUIC_DEFAULT_CA_CERT_PATH;
qm->app_index = a->app_index;
-
qm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock
/ QUIC_TSTAMP_RESOLUTION;
VLIB_INIT_FUNCTION (quic_init);
+static clib_error_t *
+quic_plugin_crypto_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "vpp"))
+ {
+ quic_tlsctx.cipher_suites = vpp_crypto_cipher_suites;
+ return 0;
+ }
+ else if (unformat (input, "picotls"))
+ {
+ quic_tlsctx.cipher_suites = ptls_openssl_cipher_suites;
+ return 0;
+ }
+ else
+ return clib_error_return (0, "unknown input '%U'",
+ format_unformat_error, input);
+ }
+
+ return clib_error_return (0, "unknown input '%U'",
+ format_unformat_error, input);
+}
+
/* *INDENT-OFF* */
+VLIB_CLI_COMMAND(quic_plugin_crypto_command, static)=
+{
+ .path = "quic set crypto api",
+ .short_help = "quic set crypto api [picotls, vpp]",
+ .function = quic_plugin_crypto_command_fn,
+};
+
VLIB_PLUGIN_REGISTER () =
{
.version = VPP_BUILD_VER,
Code Review / vpp.git / blobdiff