blob: bd2153e235b636071ae58c699dbc3110301f79ea [file] [log] [blame]
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001/*
2 * QUIC transport layer over SOCK_DGRAM sockets.
3 *
Willy Tarreau3dfb7da2022-03-02 22:33:39 +01004 * Copyright 2020 HAProxy Technologies, Frederic Lecaille <flecaille@haproxy.com>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#define _GNU_SOURCE
14#include <errno.h>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +010015#include <stdio.h>
16#include <stdlib.h>
17
18#include <sys/socket.h>
19#include <sys/stat.h>
20#include <sys/types.h>
21
22#include <netinet/tcp.h>
23
Amaury Denoyelleeb01f592021-10-07 16:44:05 +020024#include <import/ebmbtree.h>
25
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +010026#include <haproxy/buf-t.h>
27#include <haproxy/compat.h>
28#include <haproxy/api.h>
29#include <haproxy/debug.h>
30#include <haproxy/tools.h>
31#include <haproxy/ticks.h>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +010032
33#include <haproxy/connection.h>
34#include <haproxy/fd.h>
35#include <haproxy/freq_ctr.h>
36#include <haproxy/global.h>
Frédéric Lécailledfbae762021-02-18 09:59:01 +010037#include <haproxy/h3.h>
Amaury Denoyelle154bc7f2021-11-12 16:09:54 +010038#include <haproxy/hq_interop.h>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +010039#include <haproxy/log.h>
Frédéric Lécailledfbae762021-02-18 09:59:01 +010040#include <haproxy/mux_quic.h>
Amaury Denoyelle3db98e92022-05-13 15:41:04 +020041#include <haproxy/ncbuf.h>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +010042#include <haproxy/pipe.h>
43#include <haproxy/proxy.h>
44#include <haproxy/quic_cc.h>
45#include <haproxy/quic_frame.h>
46#include <haproxy/quic_loss.h>
Amaury Denoyellecfa2d562022-01-19 16:01:05 +010047#include <haproxy/quic_sock.h>
Frédéric Lécaille3ccea6d2022-05-23 22:54:54 +020048#include <haproxy/quic_stats.h>
Amaury Denoyelle0cc02a32022-04-19 17:21:11 +020049#include <haproxy/quic_stream.h>
Frédéric Lécaille748ece62022-05-21 23:58:40 +020050#include <haproxy/quic_tp.h>
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +020051#include <haproxy/cbuf.h>
Amaury Denoyelle8524f0f2022-02-08 15:03:40 +010052#include <haproxy/proto_quic.h>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +010053#include <haproxy/quic_tls.h>
54#include <haproxy/ssl_sock.h>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +010055#include <haproxy/task.h>
56#include <haproxy/trace.h>
57#include <haproxy/xprt_quic.h>
58
Amaury Denoyellea22d8602021-11-10 15:17:56 +010059/* list of supported QUIC versions by this implementation */
Frédéric Lécaille301425b2022-06-14 17:40:39 +020060const struct quic_version quic_versions[] = {
Frédéric Lécaille86845c52022-06-08 19:28:36 +020061 {
62 .num = QUIC_PROTOCOL_VERSION_DRAFT_29,
63 .initial_salt = initial_salt_draft_29,
64 .initial_salt_len = sizeof initial_salt_draft_29,
65 .key_label = (const unsigned char *)QUIC_HKDF_KEY_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020066 .key_label_len = sizeof(QUIC_HKDF_KEY_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020067 .iv_label = (const unsigned char *)QUIC_HKDF_IV_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020068 .iv_label_len = sizeof(QUIC_HKDF_IV_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020069 .hp_label = (const unsigned char *)QUIC_HKDF_HP_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020070 .hp_label_len = sizeof(QUIC_HKDF_HP_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020071 .ku_label = (const unsigned char *)QUIC_HKDF_KU_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020072 .ku_label_len = sizeof(QUIC_HKDF_KU_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020073 .retry_tag_key = (const unsigned char *)QUIC_TLS_RETRY_KEY_DRAFT,
74 .retry_tag_nonce = (const unsigned char *)QUIC_TLS_RETRY_NONCE_DRAFT,
75 },
76 {
77 .num = QUIC_PROTOCOL_VERSION_1,
78 .initial_salt = initial_salt_v1,
79 .initial_salt_len = sizeof initial_salt_v1,
80 .key_label = (const unsigned char *)QUIC_HKDF_KEY_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020081 .key_label_len = sizeof(QUIC_HKDF_KEY_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020082 .iv_label = (const unsigned char *)QUIC_HKDF_IV_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020083 .iv_label_len = sizeof(QUIC_HKDF_IV_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020084 .hp_label = (const unsigned char *)QUIC_HKDF_HP_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020085 .hp_label_len = sizeof(QUIC_HKDF_HP_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020086 .ku_label = (const unsigned char *)QUIC_HKDF_KU_LABEL_V1,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020087 .ku_label_len = sizeof(QUIC_HKDF_KU_LABEL_V1) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020088 .retry_tag_key = (const unsigned char *)QUIC_TLS_RETRY_KEY_V1,
89 .retry_tag_nonce = (const unsigned char *)QUIC_TLS_RETRY_NONCE_V1,
90 },
91 {
92 .num = QUIC_PROTOCOL_VERSION_2_DRAFT,
93 .initial_salt = initial_salt_v2_draft,
94 .initial_salt_len = sizeof initial_salt_v2_draft,
95 .key_label = (const unsigned char *)QUIC_HKDF_KEY_LABEL_V2,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020096 .key_label_len = sizeof(QUIC_HKDF_KEY_LABEL_V2) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020097 .iv_label = (const unsigned char *)QUIC_HKDF_IV_LABEL_V2,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +020098 .iv_label_len = sizeof(QUIC_HKDF_IV_LABEL_V2) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +020099 .hp_label = (const unsigned char *)QUIC_HKDF_HP_LABEL_V2,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +0200100 .hp_label_len = sizeof(QUIC_HKDF_HP_LABEL_V2) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +0200101 .ku_label = (const unsigned char *)QUIC_HKDF_KU_LABEL_V2,
Frédéric Lécailleb1cb9582022-06-16 17:53:46 +0200102 .ku_label_len = sizeof(QUIC_HKDF_KU_LABEL_V2) - 1,
Frédéric Lécaille86845c52022-06-08 19:28:36 +0200103 .retry_tag_key = (const unsigned char *)QUIC_TLS_RETRY_KEY_V2_DRAFT,
104 .retry_tag_nonce = (const unsigned char *)QUIC_TLS_RETRY_NONCE_V2_DRAFT,
105 },
Amaury Denoyellea22d8602021-11-10 15:17:56 +0100106};
107
Frédéric Lécaille86845c52022-06-08 19:28:36 +0200108/* The total number of supported versions */
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200109const size_t quic_versions_nb = sizeof quic_versions / sizeof *quic_versions;
110/* Listener only preferred version */
111const struct quic_version *preferred_version;
Frédéric Lécaille86845c52022-06-08 19:28:36 +0200112
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100113/* trace source and events */
114static void quic_trace(enum trace_level level, uint64_t mask, \
115 const struct trace_source *src,
116 const struct ist where, const struct ist func,
117 const void *a1, const void *a2, const void *a3, const void *a4);
118
119static const struct trace_event quic_trace_events[] = {
120 { .mask = QUIC_EV_CONN_NEW, .name = "new_conn", .desc = "new QUIC connection" },
121 { .mask = QUIC_EV_CONN_INIT, .name = "new_conn_init", .desc = "new QUIC connection initialization" },
122 { .mask = QUIC_EV_CONN_ISEC, .name = "init_secs", .desc = "initial secrets derivation" },
123 { .mask = QUIC_EV_CONN_RSEC, .name = "read_secs", .desc = "read secrets derivation" },
124 { .mask = QUIC_EV_CONN_WSEC, .name = "write_secs", .desc = "write secrets derivation" },
125 { .mask = QUIC_EV_CONN_LPKT, .name = "lstnr_packet", .desc = "new listener received packet" },
126 { .mask = QUIC_EV_CONN_SPKT, .name = "srv_packet", .desc = "new server received packet" },
Ilya Shipitsin1e9a6662021-01-05 22:10:46 +0500127 { .mask = QUIC_EV_CONN_ENCPKT, .name = "enc_hdshk_pkt", .desc = "handhshake packet encryption" },
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200128 { .mask = QUIC_EV_CONN_TXPKT, .name = "tx_pkt", .desc = "TX packet" },
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100129 { .mask = QUIC_EV_CONN_PAPKT, .name = "phdshk_apkt", .desc = "post handhshake application packet preparation" },
130 { .mask = QUIC_EV_CONN_PAPKTS, .name = "phdshk_apkts", .desc = "post handhshake application packets preparation" },
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200131 { .mask = QUIC_EV_CONN_IO_CB, .name = "qc_io_cb", .desc = "QUIC conn. I/O processing" },
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100132 { .mask = QUIC_EV_CONN_RMHP, .name = "rm_hp", .desc = "Remove header protection" },
133 { .mask = QUIC_EV_CONN_PRSHPKT, .name = "parse_hpkt", .desc = "parse handshake packet" },
134 { .mask = QUIC_EV_CONN_PRSAPKT, .name = "parse_apkt", .desc = "parse application packet" },
135 { .mask = QUIC_EV_CONN_PRSFRM, .name = "parse_frm", .desc = "parse frame" },
136 { .mask = QUIC_EV_CONN_PRSAFRM, .name = "parse_ack_frm", .desc = "parse ACK frame" },
137 { .mask = QUIC_EV_CONN_BFRM, .name = "build_frm", .desc = "build frame" },
138 { .mask = QUIC_EV_CONN_PHPKTS, .name = "phdshk_pkts", .desc = "handhshake packets preparation" },
139 { .mask = QUIC_EV_CONN_TRMHP, .name = "rm_hp_try", .desc = "header protection removing try" },
140 { .mask = QUIC_EV_CONN_ELRMHP, .name = "el_rm_hp", .desc = "handshake enc. level header protection removing" },
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200141 { .mask = QUIC_EV_CONN_RXPKT, .name = "rx_pkt", .desc = "RX packet" },
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100142 { .mask = QUIC_EV_CONN_SSLDATA, .name = "ssl_provide_data", .desc = "CRYPTO data provision to TLS stack" },
143 { .mask = QUIC_EV_CONN_RXCDATA, .name = "el_treat_rx_cfrms",.desc = "enc. level RX CRYPTO frames processing"},
144 { .mask = QUIC_EV_CONN_ADDDATA, .name = "add_hdshk_data", .desc = "TLS stack ->add_handshake_data() call"},
145 { .mask = QUIC_EV_CONN_FFLIGHT, .name = "flush_flight", .desc = "TLS stack ->flush_flight() call"},
146 { .mask = QUIC_EV_CONN_SSLALERT, .name = "send_alert", .desc = "TLS stack ->send_alert() call"},
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100147 { .mask = QUIC_EV_CONN_RTTUPDT, .name = "rtt_updt", .desc = "RTT sampling" },
148 { .mask = QUIC_EV_CONN_SPPKTS, .name = "sppkts", .desc = "send prepared packets" },
149 { .mask = QUIC_EV_CONN_PKTLOSS, .name = "pktloss", .desc = "detect packet loss" },
150 { .mask = QUIC_EV_CONN_STIMER, .name = "stimer", .desc = "set timer" },
151 { .mask = QUIC_EV_CONN_PTIMER, .name = "ptimer", .desc = "process timer" },
152 { .mask = QUIC_EV_CONN_SPTO, .name = "spto", .desc = "set PTO" },
Frédéric Lécaille6c1e36c2020-12-23 17:17:37 +0100153 { .mask = QUIC_EV_CONN_BCFRMS, .name = "bcfrms", .desc = "build CRYPTO data frames" },
Frédéric Lécaille513b4f22021-09-20 15:23:17 +0200154 { .mask = QUIC_EV_CONN_XPRTSEND, .name = "xprt_send", .desc = "sending XRPT subscription" },
155 { .mask = QUIC_EV_CONN_XPRTRECV, .name = "xprt_recv", .desc = "receiving XRPT subscription" },
Frédéric Lécailleba85acd2022-01-11 14:43:50 +0100156 { .mask = QUIC_EV_CONN_FREED, .name = "conn_freed", .desc = "releasing conn. memory" },
157 { .mask = QUIC_EV_CONN_CLOSE, .name = "conn_close", .desc = "closing conn." },
Frédéric Lécaillece69cbc2022-03-22 12:45:33 +0100158 { .mask = QUIC_EV_CONN_ACKSTRM, .name = "ack_strm", .desc = "STREAM ack."},
Frédéric Lécailleb823bb72022-03-31 20:26:18 +0200159 { .mask = QUIC_EV_CONN_FRMLIST, .name = "frm_list", .desc = "frame list"},
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +0200160 { .mask = QUIC_EV_STATELESS_RST, .name = "stateless_reset", .desc = "stateless reset sent"},
Frédéric Lécaillec7785b52022-05-23 09:08:54 +0200161 { .mask = QUIC_EV_TRANSP_PARAMS, .name = "transport_params", .desc = "transport parameters"},
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200162 { .mask = QUIC_EV_CONN_IDLE_TIMER, .name = "idle_timer", .desc = "idle timer task"},
163 { .mask = QUIC_EV_CONN_SUB, .name = "xprt_sub", .desc = "RX/TX subcription or unsubscription to QUIC xprt"},
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100164 { /* end */ }
165};
166
167static const struct name_desc quic_trace_lockon_args[4] = {
168 /* arg1 */ { /* already used by the connection */ },
169 /* arg2 */ { .name="quic", .desc="QUIC transport" },
170 /* arg3 */ { },
171 /* arg4 */ { }
172};
173
174static const struct name_desc quic_trace_decoding[] = {
175#define QUIC_VERB_CLEAN 1
176 { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" },
177 { /* end */ }
178};
179
180
181struct trace_source trace_quic = {
182 .name = IST("quic"),
183 .desc = "QUIC xprt",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100184 .arg_def = TRC_ARG1_QCON, /* TRACE()'s first argument is always a quic_conn */
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100185 .default_cb = quic_trace,
186 .known_events = quic_trace_events,
187 .lockon_args = quic_trace_lockon_args,
188 .decoding = quic_trace_decoding,
189 .report_events = ~0, /* report everything by default */
190};
191
192#define TRACE_SOURCE &trace_quic
193INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE);
194
195static BIO_METHOD *ha_quic_meth;
196
Willy Tarreaub8dec4a2022-06-23 11:02:08 +0200197DECLARE_POOL(pool_head_quic_tx_ring, "quic_tx_ring", QUIC_TX_RING_BUFSZ);
Frédéric Lécaille324ecda2021-11-02 10:14:44 +0100198DECLARE_POOL(pool_head_quic_conn_rxbuf, "quic_conn_rxbuf", QUIC_CONN_RX_BUFSZ);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100199DECLARE_STATIC_POOL(pool_head_quic_conn_ctx,
Willy Tarreaub8dec4a2022-06-23 11:02:08 +0200200 "quic_conn_ctx", sizeof(struct ssl_sock_ctx));
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100201DECLARE_STATIC_POOL(pool_head_quic_conn, "quic_conn", sizeof(struct quic_conn));
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100202DECLARE_POOL(pool_head_quic_connection_id,
Willy Tarreaub8dec4a2022-06-23 11:02:08 +0200203 "quic_connnection_id", sizeof(struct quic_connection_id));
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +0100204DECLARE_POOL(pool_head_quic_dgram, "quic_dgram", sizeof(struct quic_dgram));
Willy Tarreaub8dec4a2022-06-23 11:02:08 +0200205DECLARE_POOL(pool_head_quic_rx_packet, "quic_rx_packet", sizeof(struct quic_rx_packet));
206DECLARE_POOL(pool_head_quic_tx_packet, "quic_tx_packet", sizeof(struct quic_tx_packet));
207DECLARE_STATIC_POOL(pool_head_quic_rx_crypto_frm, "quic_rx_crypto_frm", sizeof(struct quic_rx_crypto_frm));
208DECLARE_STATIC_POOL(pool_head_quic_crypto_buf, "quic_crypto_buf", sizeof(struct quic_crypto_buf));
209DECLARE_POOL(pool_head_quic_frame, "quic_frame", sizeof(struct quic_frame));
210DECLARE_STATIC_POOL(pool_head_quic_arng, "quic_arng", sizeof(struct quic_arng_node));
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100211
Frédéric Lécaille9445abc2021-08-04 10:49:51 +0200212static struct quic_tx_packet *qc_build_pkt(unsigned char **pos, const unsigned char *buf_end,
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200213 struct quic_enc_level *qel, struct quic_tls_ctx *ctx,
214 struct list *frms, struct quic_conn *qc,
215 const struct quic_version *ver, size_t dglen, int pkt_type,
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +0200216 int force_ack, int padding, int probe, int cc, int *err);
Frédéric Lécaille00e24002022-02-18 17:13:45 +0100217static struct task *quic_conn_app_io_cb(struct task *t, void *context, unsigned int state);
Frédéric Lécaille47756802022-03-25 09:12:16 +0100218static void qc_idle_timer_do_rearm(struct quic_conn *qc);
Frédéric Lécaille530601c2022-03-10 15:11:57 +0100219static void qc_idle_timer_rearm(struct quic_conn *qc, int read);
Frédéric Lécaille3fd92f62022-05-19 14:35:20 +0200220static int qc_conn_alloc_ssl_ctx(struct quic_conn *qc);
221static int quic_conn_init_timer(struct quic_conn *qc);
222static int quic_conn_init_idle_timer_task(struct quic_conn *qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100223
Frédéric Lécaillef63921f2020-12-18 09:48:20 +0100224/* Only for debug purpose */
225struct enc_debug_info {
226 unsigned char *payload;
227 size_t payload_len;
228 unsigned char *aad;
229 size_t aad_len;
230 uint64_t pn;
231};
232
233/* Initializes a enc_debug_info struct (only for debug purpose) */
234static inline void enc_debug_info_init(struct enc_debug_info *edi,
235 unsigned char *payload, size_t payload_len,
236 unsigned char *aad, size_t aad_len, uint64_t pn)
237{
238 edi->payload = payload;
239 edi->payload_len = payload_len;
240 edi->aad = aad;
241 edi->aad_len = aad_len;
242 edi->pn = pn;
243}
244
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100245/* Trace callback for QUIC.
246 * These traces always expect that arg1, if non-null, is of type connection.
247 */
248static void quic_trace(enum trace_level level, uint64_t mask, const struct trace_source *src,
249 const struct ist where, const struct ist func,
250 const void *a1, const void *a2, const void *a3, const void *a4)
251{
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100252 const struct quic_conn *qc = a1;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100253
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100254 if (qc) {
Frédéric Lécaillebd242082022-02-25 17:17:59 +0100255 const struct quic_tls_ctx *tls_ctx;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100256
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100257 chunk_appendf(&trace_buf, " : qc@%p", qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200258 if (mask & QUIC_EV_CONN_INIT) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100259 chunk_appendf(&trace_buf, "\n odcid");
260 quic_cid_dump(&trace_buf, &qc->odcid);
Frédéric Lécaillec5e72b92020-12-02 16:11:40 +0100261 chunk_appendf(&trace_buf, "\n dcid");
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100262 quic_cid_dump(&trace_buf, &qc->dcid);
Frédéric Lécaillec5e72b92020-12-02 16:11:40 +0100263 chunk_appendf(&trace_buf, "\n scid");
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100264 quic_cid_dump(&trace_buf, &qc->scid);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100265 }
266
Frédéric Lécaillec7785b52022-05-23 09:08:54 +0200267 if (mask & QUIC_EV_TRANSP_PARAMS) {
268 const struct quic_transport_params *p = a2;
Frédéric Lécaille4f5777a2022-06-20 19:39:26 +0200269 quic_transport_params_dump(&trace_buf, qc, p);
Frédéric Lécaillec7785b52022-05-23 09:08:54 +0200270 }
271
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100272 if (mask & QUIC_EV_CONN_ADDDATA) {
273 const enum ssl_encryption_level_t *level = a2;
274 const size_t *len = a3;
275
276 if (level) {
277 enum quic_tls_enc_level lvl = ssl_to_quic_enc_level(*level);
278
279 chunk_appendf(&trace_buf, " el=%c(%d)", quic_enc_level_char(lvl), lvl);
280 }
281 if (len)
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100282 chunk_appendf(&trace_buf, " len=%llu", (unsigned long long)*len);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100283 }
284 if ((mask & QUIC_EV_CONN_ISEC) && qc) {
285 /* Initial read & write secrets. */
286 enum quic_tls_enc_level level = QUIC_TLS_ENC_LEVEL_INITIAL;
287 const unsigned char *rx_sec = a2;
288 const unsigned char *tx_sec = a3;
289
Frédéric Lécaillebd242082022-02-25 17:17:59 +0100290 tls_ctx = &qc->els[level].tls_ctx;
291 if (tls_ctx->flags & QUIC_FL_TLS_SECRETS_SET) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100292 chunk_appendf(&trace_buf, "\n RX el=%c", quic_enc_level_char(level));
293 if (rx_sec)
294 quic_tls_secret_hexdump(&trace_buf, rx_sec, 32);
Frédéric Lécaillebd242082022-02-25 17:17:59 +0100295 quic_tls_keys_hexdump(&trace_buf, &tls_ctx->rx);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100296 chunk_appendf(&trace_buf, "\n TX el=%c", quic_enc_level_char(level));
297 if (tx_sec)
298 quic_tls_secret_hexdump(&trace_buf, tx_sec, 32);
Frédéric Lécaillebd242082022-02-25 17:17:59 +0100299 quic_tls_keys_hexdump(&trace_buf, &tls_ctx->tx);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100300 }
301 }
302 if (mask & (QUIC_EV_CONN_RSEC|QUIC_EV_CONN_RWSEC)) {
303 const enum ssl_encryption_level_t *level = a2;
304 const unsigned char *secret = a3;
305 const size_t *secret_len = a4;
306
307 if (level) {
308 enum quic_tls_enc_level lvl = ssl_to_quic_enc_level(*level);
309
310 chunk_appendf(&trace_buf, "\n RX el=%c", quic_enc_level_char(lvl));
311 if (secret && secret_len)
312 quic_tls_secret_hexdump(&trace_buf, secret, *secret_len);
Frédéric Lécaillebd242082022-02-25 17:17:59 +0100313 tls_ctx = &qc->els[lvl].tls_ctx;
314 if (tls_ctx->flags & QUIC_FL_TLS_SECRETS_SET)
315 quic_tls_keys_hexdump(&trace_buf, &tls_ctx->rx);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100316 }
317 }
318
319 if (mask & (QUIC_EV_CONN_WSEC|QUIC_EV_CONN_RWSEC)) {
320 const enum ssl_encryption_level_t *level = a2;
321 const unsigned char *secret = a3;
322 const size_t *secret_len = a4;
323
324 if (level) {
325 enum quic_tls_enc_level lvl = ssl_to_quic_enc_level(*level);
326
327 chunk_appendf(&trace_buf, "\n TX el=%c", quic_enc_level_char(lvl));
328 if (secret && secret_len)
329 quic_tls_secret_hexdump(&trace_buf, secret, *secret_len);
Frédéric Lécaillebd242082022-02-25 17:17:59 +0100330 tls_ctx = &qc->els[lvl].tls_ctx;
331 if (tls_ctx->flags & QUIC_FL_TLS_SECRETS_SET)
332 quic_tls_keys_hexdump(&trace_buf, &tls_ctx->tx);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100333 }
334
335 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100336
Frédéric Lécailleb823bb72022-03-31 20:26:18 +0200337 if (mask & QUIC_EV_CONN_FRMLIST) {
338 const struct list *l = a2;
339
340 if (l) {
341 const struct quic_frame *frm;
342 list_for_each_entry(frm, l, list)
343 chunk_frm_appendf(&trace_buf, frm);
344 }
345 }
346
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200347 if (mask & (QUIC_EV_CONN_TXPKT|QUIC_EV_CONN_PAPKT)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100348 const struct quic_tx_packet *pkt = a2;
349 const struct quic_enc_level *qel = a3;
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100350 const ssize_t *room = a4;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100351
352 if (qel) {
Amaury Denoyelle4fd53d72021-12-21 14:28:26 +0100353 const struct quic_pktns *pktns = qc->pktns;
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100354 chunk_appendf(&trace_buf, " qel=%c cwnd=%llu ppif=%lld pif=%llu "
Frédéric Lécaille466e9da2021-12-29 12:04:13 +0100355 "if=%llu pp=%u",
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100356 quic_enc_level_char_from_qel(qel, qc),
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100357 (unsigned long long)qc->path->cwnd,
358 (unsigned long long)qc->path->prep_in_flight,
359 (unsigned long long)qc->path->in_flight,
360 (unsigned long long)pktns->tx.in_flight,
Frédéric Lécaille466e9da2021-12-29 12:04:13 +0100361 pktns->tx.pto_probe);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100362 }
363 if (pkt) {
Frédéric Lécaille0ad04582021-07-27 14:51:54 +0200364 const struct quic_frame *frm;
Frédéric Lécaille0371cd52021-12-13 12:30:54 +0100365 if (pkt->pn_node.key != (uint64_t)-1)
366 chunk_appendf(&trace_buf, " pn=%llu",(ull)pkt->pn_node.key);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100367 list_for_each_entry(frm, &pkt->frms, list)
Frédéric Lécaille1ede8232021-12-23 14:11:25 +0100368 chunk_frm_appendf(&trace_buf, frm);
Frédéric Lécaille8b6ea172022-01-17 10:51:43 +0100369 chunk_appendf(&trace_buf, " rx.bytes=%llu tx.bytes=%llu",
370 (unsigned long long)qc->rx.bytes,
371 (unsigned long long)qc->tx.bytes);
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100372 }
373
374 if (room) {
375 chunk_appendf(&trace_buf, " room=%lld", (long long)*room);
376 chunk_appendf(&trace_buf, " dcid.len=%llu scid.len=%llu",
377 (unsigned long long)qc->dcid.len, (unsigned long long)qc->scid.len);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100378 }
379 }
380
Frédéric Lécaille00e24002022-02-18 17:13:45 +0100381 if (mask & QUIC_EV_CONN_IO_CB) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100382 const enum quic_handshake_state *state = a2;
383 const int *err = a3;
384
385 if (state)
386 chunk_appendf(&trace_buf, " state=%s", quic_hdshk_state_str(*state));
387 if (err)
388 chunk_appendf(&trace_buf, " err=%s", ssl_error_str(*err));
389 }
390
Frédéric Lécaille6c1e36c2020-12-23 17:17:37 +0100391 if (mask & (QUIC_EV_CONN_TRMHP|QUIC_EV_CONN_ELRMHP|QUIC_EV_CONN_SPKT)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100392 const struct quic_rx_packet *pkt = a2;
393 const unsigned long *pktlen = a3;
394 const SSL *ssl = a4;
395
396 if (pkt) {
Frédéric Lécaille3dfd4c42022-04-05 15:29:14 +0200397 chunk_appendf(&trace_buf, " pkt@%p", pkt);
398 if (pkt->type == QUIC_PACKET_TYPE_SHORT && pkt->data)
399 chunk_appendf(&trace_buf, " kp=%d",
400 !!(*pkt->data & QUIC_PACKET_KEY_PHASE_BIT));
401 chunk_appendf(&trace_buf, " el=%c",
402 quic_packet_type_enc_level_char(pkt->type));
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100403 if (pkt->pnl)
404 chunk_appendf(&trace_buf, " pnl=%u pn=%llu", pkt->pnl,
405 (unsigned long long)pkt->pn);
406 if (pkt->token_len)
407 chunk_appendf(&trace_buf, " toklen=%llu",
408 (unsigned long long)pkt->token_len);
409 if (pkt->aad_len)
410 chunk_appendf(&trace_buf, " aadlen=%llu",
411 (unsigned long long)pkt->aad_len);
412 chunk_appendf(&trace_buf, " flags=0x%x len=%llu",
413 pkt->flags, (unsigned long long)pkt->len);
414 }
415 if (pktlen)
416 chunk_appendf(&trace_buf, " (%ld)", *pktlen);
417 if (ssl) {
418 enum ssl_encryption_level_t level = SSL_quic_read_level(ssl);
419 chunk_appendf(&trace_buf, " el=%c",
420 quic_enc_level_char(ssl_to_quic_enc_level(level)));
421 }
422 }
423
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200424 if (mask & (QUIC_EV_CONN_RXPKT|QUIC_EV_CONN_PRSHPKT|QUIC_EV_CONN_SSLDATA)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100425 const struct quic_rx_packet *pkt = a2;
426 const struct quic_rx_crypto_frm *cf = a3;
427 const SSL *ssl = a4;
428
429 if (pkt)
430 chunk_appendf(&trace_buf, " pkt@%p el=%c pn=%llu", pkt,
431 quic_packet_type_enc_level_char(pkt->type),
432 (unsigned long long)pkt->pn);
433 if (cf)
434 chunk_appendf(&trace_buf, " cfoff=%llu cflen=%llu",
435 (unsigned long long)cf->offset_node.key,
436 (unsigned long long)cf->len);
437 if (ssl) {
438 enum ssl_encryption_level_t level = SSL_quic_read_level(ssl);
Frédéric Lécaille57e6e9e2021-09-23 18:10:56 +0200439 chunk_appendf(&trace_buf, " rel=%c",
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100440 quic_enc_level_char(ssl_to_quic_enc_level(level)));
441 }
Frédéric Lécaille1fc5e162021-11-22 14:25:57 +0100442
Amaury Denoyelle57e6db72022-07-13 15:07:56 +0200443 if (qc->err.code)
444 chunk_appendf(&trace_buf, " err_code=0x%llx", (ull)qc->err.code);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100445 }
446
447 if (mask & (QUIC_EV_CONN_PRSFRM|QUIC_EV_CONN_BFRM)) {
448 const struct quic_frame *frm = a2;
449
450 if (frm)
451 chunk_appendf(&trace_buf, " %s", quic_frame_type_string(frm->type));
452 }
453
454 if (mask & QUIC_EV_CONN_PHPKTS) {
455 const struct quic_enc_level *qel = a2;
456
457 if (qel) {
Frédéric Lécailledd51da52021-12-29 15:36:25 +0100458 const struct quic_pktns *pktns = qel->pktns;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100459 chunk_appendf(&trace_buf,
Frédéric Lécaille466e9da2021-12-29 12:04:13 +0100460 " qel=%c state=%s ack?%d cwnd=%llu ppif=%lld pif=%llu if=%llu pp=%u",
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100461 quic_enc_level_char_from_qel(qel, qc),
Frédéric Lécaillefc790062022-03-28 17:10:31 +0200462 quic_hdshk_state_str(qc->state),
Frédéric Lécaille205e4f32022-03-28 17:38:27 +0200463 !!(qel->pktns->flags & QUIC_FL_PKTNS_ACK_REQUIRED),
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100464 (unsigned long long)qc->path->cwnd,
465 (unsigned long long)qc->path->prep_in_flight,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100466 (unsigned long long)qc->path->in_flight,
Frédéric Lécaille466e9da2021-12-29 12:04:13 +0100467 (unsigned long long)pktns->tx.in_flight,
468 pktns->tx.pto_probe);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100469 }
470 }
471
Frédéric Lécaillef63921f2020-12-18 09:48:20 +0100472 if (mask & QUIC_EV_CONN_ENCPKT) {
473 const struct enc_debug_info *edi = a2;
474
475 if (edi)
476 chunk_appendf(&trace_buf,
477 " payload=@%p payload_len=%llu"
478 " aad=@%p aad_len=%llu pn=%llu",
479 edi->payload, (unsigned long long)edi->payload_len,
480 edi->aad, (unsigned long long)edi->aad_len,
481 (unsigned long long)edi->pn);
482 }
483
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100484 if (mask & QUIC_EV_CONN_RMHP) {
485 const struct quic_rx_packet *pkt = a2;
486
487 if (pkt) {
488 const int *ret = a3;
489
490 chunk_appendf(&trace_buf, " pkt@%p", pkt);
491 if (ret && *ret)
492 chunk_appendf(&trace_buf, " pnl=%u pn=%llu",
493 pkt->pnl, (unsigned long long)pkt->pn);
494 }
495 }
496
497 if (mask & QUIC_EV_CONN_PRSAFRM) {
Frédéric Lécaille0ad04582021-07-27 14:51:54 +0200498 const struct quic_frame *frm = a2;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100499 const unsigned long *val1 = a3;
500 const unsigned long *val2 = a4;
501
Frédéric Lécaille2f163482022-08-19 09:23:15 +0200502 if (frm) {
503 chunk_appendf(&trace_buf, " frm@%p", frm);
Frédéric Lécaille1ede8232021-12-23 14:11:25 +0100504 chunk_frm_appendf(&trace_buf, frm);
Frédéric Lécaille2f163482022-08-19 09:23:15 +0200505 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100506 if (val1)
507 chunk_appendf(&trace_buf, " %lu", *val1);
508 if (val2)
509 chunk_appendf(&trace_buf, "..%lu", *val2);
510 }
511
Frédéric Lécaillece69cbc2022-03-22 12:45:33 +0100512 if (mask & QUIC_EV_CONN_ACKSTRM) {
513 const struct quic_stream *s = a2;
Amaury Denoyelle7272cd72022-03-29 15:15:54 +0200514 const struct qc_stream_desc *stream = a3;
Frédéric Lécaillece69cbc2022-03-22 12:45:33 +0100515
516 if (s)
517 chunk_appendf(&trace_buf, " off=%llu len=%llu", (ull)s->offset.key, (ull)s->len);
Amaury Denoyelle7272cd72022-03-29 15:15:54 +0200518 if (stream)
519 chunk_appendf(&trace_buf, " ack_offset=%llu", (ull)stream->ack_offset);
Frédéric Lécaillece69cbc2022-03-22 12:45:33 +0100520 }
521
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100522 if (mask & QUIC_EV_CONN_RTTUPDT) {
523 const unsigned int *rtt_sample = a2;
524 const unsigned int *ack_delay = a3;
525 const struct quic_loss *ql = a4;
526
527 if (rtt_sample)
528 chunk_appendf(&trace_buf, " rtt_sample=%ums", *rtt_sample);
529 if (ack_delay)
530 chunk_appendf(&trace_buf, " ack_delay=%ums", *ack_delay);
531 if (ql)
532 chunk_appendf(&trace_buf,
533 " srtt=%ums rttvar=%ums min_rtt=%ums",
534 ql->srtt >> 3, ql->rtt_var >> 2, ql->rtt_min);
535 }
536 if (mask & QUIC_EV_CONN_CC) {
537 const struct quic_cc_event *ev = a2;
538 const struct quic_cc *cc = a3;
539
540 if (a2)
541 quic_cc_event_trace(&trace_buf, ev);
542 if (a3)
543 quic_cc_state_trace(&trace_buf, cc);
544 }
545
546 if (mask & QUIC_EV_CONN_PKTLOSS) {
547 const struct quic_pktns *pktns = a2;
548 const struct list *lost_pkts = a3;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100549
550 if (pktns) {
551 chunk_appendf(&trace_buf, " pktns=%s",
552 pktns == &qc->pktns[QUIC_TLS_PKTNS_INITIAL] ? "I" :
553 pktns == &qc->pktns[QUIC_TLS_PKTNS_01RTT] ? "01RTT": "H");
554 if (pktns->tx.loss_time)
555 chunk_appendf(&trace_buf, " loss_time=%dms",
Frédéric Lécaillef7e0b8d2020-12-16 17:33:11 +0100556 TICKS_TO_MS(tick_remain(now_ms, pktns->tx.loss_time)));
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100557 }
558 if (lost_pkts && !LIST_ISEMPTY(lost_pkts)) {
559 struct quic_tx_packet *pkt;
560
561 chunk_appendf(&trace_buf, " lost_pkts:");
562 list_for_each_entry(pkt, lost_pkts, list)
563 chunk_appendf(&trace_buf, " %lu", (unsigned long)pkt->pn_node.key);
564 }
565 }
566
567 if (mask & (QUIC_EV_CONN_STIMER|QUIC_EV_CONN_PTIMER|QUIC_EV_CONN_SPTO)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100568 const struct quic_pktns *pktns = a2;
569 const int *duration = a3;
Frédéric Lécaillef7e0b8d2020-12-16 17:33:11 +0100570 const uint64_t *ifae_pkts = a4;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100571
Frédéric Lécaillef7e0b8d2020-12-16 17:33:11 +0100572 if (ifae_pkts)
573 chunk_appendf(&trace_buf, " ifae_pkts=%llu",
574 (unsigned long long)*ifae_pkts);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100575 if (pktns) {
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100576 chunk_appendf(&trace_buf, " pktns=%s pp=%d",
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100577 pktns == &qc->pktns[QUIC_TLS_PKTNS_INITIAL] ? "I" :
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100578 pktns == &qc->pktns[QUIC_TLS_PKTNS_01RTT] ? "01RTT": "H",
579 pktns->tx.pto_probe);
Frédéric Lécaille22cfd832021-12-27 17:42:51 +0100580 if (mask & (QUIC_EV_CONN_STIMER|QUIC_EV_CONN_SPTO)) {
581 if (pktns->tx.in_flight)
582 chunk_appendf(&trace_buf, " if=%llu", (ull)pktns->tx.in_flight);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100583 if (pktns->tx.loss_time)
584 chunk_appendf(&trace_buf, " loss_time=%dms",
585 TICKS_TO_MS(pktns->tx.loss_time - now_ms));
586 }
587 if (mask & QUIC_EV_CONN_SPTO) {
588 if (pktns->tx.time_of_last_eliciting)
589 chunk_appendf(&trace_buf, " tole=%dms",
590 TICKS_TO_MS(pktns->tx.time_of_last_eliciting - now_ms));
591 if (duration)
Frédéric Lécaillec5e72b92020-12-02 16:11:40 +0100592 chunk_appendf(&trace_buf, " dur=%dms", TICKS_TO_MS(*duration));
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100593 }
594 }
595
Frédéric Lécaille03235d72022-03-30 14:36:40 +0200596 if (!(mask & (QUIC_EV_CONN_SPTO|QUIC_EV_CONN_PTIMER)) && qc->timer_task) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100597 chunk_appendf(&trace_buf,
598 " expire=%dms", TICKS_TO_MS(qc->timer - now_ms));
599 }
600 }
601
602 if (mask & QUIC_EV_CONN_SPPKTS) {
603 const struct quic_tx_packet *pkt = a2;
604
Frédéric Lécaille8ecb7362022-08-04 12:00:00 +0200605 chunk_appendf(&trace_buf, " cwnd=%llu ppif=%llu pif=%llu",
Frédéric Lécaille04ffb662020-12-08 15:58:39 +0100606 (unsigned long long)qc->path->cwnd,
607 (unsigned long long)qc->path->prep_in_flight,
608 (unsigned long long)qc->path->in_flight);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100609 if (pkt) {
Frédéric Lécaille0371cd52021-12-13 12:30:54 +0100610 chunk_appendf(&trace_buf, " pn=%lu(%s) iflen=%llu",
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100611 (unsigned long)pkt->pn_node.key,
612 pkt->pktns == &qc->pktns[QUIC_TLS_PKTNS_INITIAL] ? "I" :
613 pkt->pktns == &qc->pktns[QUIC_TLS_PKTNS_01RTT] ? "01RTT": "H",
Frédéric Lécaille0371cd52021-12-13 12:30:54 +0100614 (unsigned long long)pkt->in_flight_len);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100615 }
616 }
Frédéric Lécaille47c433f2020-12-10 17:03:11 +0100617
618 if (mask & QUIC_EV_CONN_SSLALERT) {
619 const uint8_t *alert = a2;
620 const enum ssl_encryption_level_t *level = a3;
621
622 if (alert)
623 chunk_appendf(&trace_buf, " alert=0x%02x", *alert);
624 if (level)
625 chunk_appendf(&trace_buf, " el=%c",
626 quic_enc_level_char(ssl_to_quic_enc_level(*level)));
627 }
Frédéric Lécailleea604992020-12-24 13:01:37 +0100628
629 if (mask & QUIC_EV_CONN_BCFRMS) {
630 const size_t *sz1 = a2;
631 const size_t *sz2 = a3;
632 const size_t *sz3 = a4;
633
634 if (sz1)
635 chunk_appendf(&trace_buf, " %llu", (unsigned long long)*sz1);
636 if (sz2)
637 chunk_appendf(&trace_buf, " %llu", (unsigned long long)*sz2);
638 if (sz3)
639 chunk_appendf(&trace_buf, " %llu", (unsigned long long)*sz3);
640 }
Frédéric Lécaille242fb1b2020-12-31 12:45:38 +0100641
642 if (mask & QUIC_EV_CONN_PSTRM) {
643 const struct quic_frame *frm = a2;
Frédéric Lécaille577fe482021-01-11 15:10:06 +0100644
Frédéric Lécailled8b84432021-12-10 15:18:36 +0100645 if (frm)
Frédéric Lécaille1ede8232021-12-23 14:11:25 +0100646 chunk_frm_appendf(&trace_buf, frm);
Frédéric Lécaille242fb1b2020-12-31 12:45:38 +0100647 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100648 }
649 if (mask & QUIC_EV_CONN_LPKT) {
650 const struct quic_rx_packet *pkt = a2;
Frédéric Lécaille865b0782021-09-23 07:33:20 +0200651 const uint64_t *len = a3;
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200652 const struct quic_version *ver = a4;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100653
Frédéric Lécaille8678eb02021-12-16 18:03:52 +0100654 if (pkt) {
655 chunk_appendf(&trace_buf, " pkt@%p type=0x%02x %s",
656 pkt, pkt->type, qc_pkt_long(pkt) ? "long" : "short");
657 if (pkt->pn_node.key != (uint64_t)-1)
658 chunk_appendf(&trace_buf, " pn=%llu", pkt->pn_node.key);
659 }
660
Frédéric Lécaille865b0782021-09-23 07:33:20 +0200661 if (len)
662 chunk_appendf(&trace_buf, " len=%llu", (ull)*len);
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200663
664 if (ver)
665 chunk_appendf(&trace_buf, " ver=0x%08x", ver->num);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100666 }
667
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +0200668 if (mask & QUIC_EV_STATELESS_RST) {
669 const struct quic_cid *cid = a2;
670
671 if (cid)
672 quic_cid_dump(&trace_buf, cid);
673 }
674
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100675}
676
677/* Returns 1 if the peer has validated <qc> QUIC connection address, 0 if not. */
Amaury Denoyellee81fed92021-12-22 11:06:34 +0100678static inline int quic_peer_validated_addr(struct quic_conn *qc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100679{
Frédéric Lécaille67f47d02021-08-19 15:19:09 +0200680 struct quic_pktns *hdshk_pktns, *app_pktns;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100681
Frédéric Lécaille1aa57d32022-01-12 09:46:02 +0100682 if (!qc_is_listener(qc))
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100683 return 1;
684
Frédéric Lécaille67f47d02021-08-19 15:19:09 +0200685 hdshk_pktns = qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE].pktns;
686 app_pktns = qc->els[QUIC_TLS_ENC_LEVEL_APP].pktns;
Frédéric Lécaille205e4f32022-03-28 17:38:27 +0200687 if ((hdshk_pktns->flags & QUIC_FL_PKTNS_PKT_RECEIVED) ||
688 (app_pktns->flags & QUIC_FL_PKTNS_PKT_RECEIVED) ||
Frédéric Lécaillefc790062022-03-28 17:10:31 +0200689 qc->state >= QUIC_HS_ST_COMPLETE)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100690 return 1;
691
692 return 0;
693}
694
695/* Set the timer attached to the QUIC connection with <ctx> as I/O handler and used for
696 * both loss detection and PTO and schedule the task assiated to this timer if needed.
697 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +0100698static inline void qc_set_timer(struct quic_conn *qc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100699{
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100700 struct quic_pktns *pktns;
701 unsigned int pto;
Frédéric Lécailleeed7a7d2021-08-18 09:16:01 +0200702 int handshake_complete;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100703
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100704 TRACE_ENTER(QUIC_EV_CONN_STIMER, qc,
Amaury Denoyellee81fed92021-12-22 11:06:34 +0100705 NULL, NULL, &qc->path->ifae_pkts);
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100706
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100707 pktns = quic_loss_pktns(qc);
708 if (tick_isset(pktns->tx.loss_time)) {
709 qc->timer = pktns->tx.loss_time;
710 goto out;
711 }
712
Frédéric Lécailleca98a7f2021-11-10 17:30:15 +0100713 /* anti-amplification: the timer must be
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100714 * cancelled for a server which reached the anti-amplification limit.
715 */
Frédéric Lécaille078634d2022-01-04 16:59:42 +0100716 if (!quic_peer_validated_addr(qc) &&
Frédéric Lécaillefc790062022-03-28 17:10:31 +0200717 (qc->flags & QUIC_FL_CONN_ANTI_AMPLIFICATION_REACHED)) {
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100718 TRACE_PROTO("anti-amplification reached", QUIC_EV_CONN_STIMER, qc);
Frédéric Lécailleca98a7f2021-11-10 17:30:15 +0100719 qc->timer = TICK_ETERNITY;
720 goto out;
721 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100722
Amaury Denoyellee81fed92021-12-22 11:06:34 +0100723 if (!qc->path->ifae_pkts && quic_peer_validated_addr(qc)) {
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100724 TRACE_PROTO("timer cancellation", QUIC_EV_CONN_STIMER, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100725 /* Timer cancellation. */
726 qc->timer = TICK_ETERNITY;
727 goto out;
728 }
729
Frédéric Lécaillefc790062022-03-28 17:10:31 +0200730 handshake_complete = qc->state >= QUIC_HS_ST_COMPLETE;
Frédéric Lécailleeed7a7d2021-08-18 09:16:01 +0200731 pktns = quic_pto_pktns(qc, handshake_complete, &pto);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100732 if (tick_isset(pto))
733 qc->timer = pto;
734 out:
Frédéric Lécaille5757b4a2022-02-16 14:46:17 +0100735 if (qc->timer_task && qc->timer != TICK_ETERNITY) {
Frédéric Lécailleaaf1f192022-03-22 15:37:41 +0100736 if (tick_is_expired(qc->timer, now_ms)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200737 TRACE_DEVEL("wakeup asap timer task", QUIC_EV_CONN_STIMER, qc);
Frédéric Lécaille5757b4a2022-02-16 14:46:17 +0100738 task_wakeup(qc->timer_task, TASK_WOKEN_MSG);
Frédéric Lécailleaaf1f192022-03-22 15:37:41 +0100739 }
740 else {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200741 TRACE_DEVEL("timer task scheduling", QUIC_EV_CONN_STIMER, qc);
Frédéric Lécaille5757b4a2022-02-16 14:46:17 +0100742 task_schedule(qc->timer_task, qc->timer);
Frédéric Lécailleaaf1f192022-03-22 15:37:41 +0100743 }
Frédéric Lécaille5757b4a2022-02-16 14:46:17 +0100744 }
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +0100745 TRACE_LEAVE(QUIC_EV_CONN_STIMER, qc, pktns);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100746}
747
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100748/* Derive new keys and ivs required for Key Update feature for <qc> QUIC
749 * connection.
750 * Return 1 if succeeded, 0 if not.
751 */
752static int quic_tls_key_update(struct quic_conn *qc)
753{
754 struct quic_tls_ctx *tls_ctx = &qc->els[QUIC_TLS_ENC_LEVEL_APP].tls_ctx;
755 struct quic_tls_secrets *rx, *tx;
756 struct quic_tls_kp *nxt_rx = &qc->ku.nxt_rx;
757 struct quic_tls_kp *nxt_tx = &qc->ku.nxt_tx;
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200758 const struct quic_version *ver =
759 qc->negotiated_version ? qc->negotiated_version : qc->original_version;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200760 int ret = 0;
761
762 TRACE_ENTER(QUIC_EV_CONN_RWSEC, qc);
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100763
764 tls_ctx = &qc->els[QUIC_TLS_ENC_LEVEL_APP].tls_ctx;
765 rx = &tls_ctx->rx;
766 tx = &tls_ctx->tx;
767 nxt_rx = &qc->ku.nxt_rx;
768 nxt_tx = &qc->ku.nxt_tx;
769
770 /* Prepare new RX secrets */
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200771 if (!quic_tls_sec_update(rx->md, ver, nxt_rx->secret, nxt_rx->secretlen,
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100772 rx->secret, rx->secretlen)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200773 TRACE_ERROR("New RX secret update failed", QUIC_EV_CONN_RWSEC, qc);
774 goto leave;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100775 }
776
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200777 if (!quic_tls_derive_keys(rx->aead, NULL, rx->md, ver,
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100778 nxt_rx->key, nxt_rx->keylen,
779 nxt_rx->iv, nxt_rx->ivlen, NULL, 0,
780 nxt_rx->secret, nxt_rx->secretlen)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200781 TRACE_ERROR("New RX key derivation failed", QUIC_EV_CONN_RWSEC, qc);
782 goto leave;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100783 }
784
785 /* Prepare new TX secrets */
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200786 if (!quic_tls_sec_update(tx->md, ver, nxt_tx->secret, nxt_tx->secretlen,
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100787 tx->secret, tx->secretlen)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200788 TRACE_ERROR("New TX secret update failed", QUIC_EV_CONN_RWSEC, qc);
789 goto leave;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100790 }
791
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200792 if (!quic_tls_derive_keys(tx->aead, NULL, tx->md, ver,
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100793 nxt_tx->key, nxt_tx->keylen,
794 nxt_tx->iv, nxt_tx->ivlen, NULL, 0,
795 nxt_tx->secret, nxt_tx->secretlen)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200796 TRACE_ERROR("New TX key derivation failed", QUIC_EV_CONN_RWSEC, qc);
797 goto leave;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100798 }
799
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200800 if (nxt_rx->ctx) {
801 EVP_CIPHER_CTX_free(nxt_rx->ctx);
802 nxt_rx->ctx = NULL;
803 }
804
805 if (!quic_tls_rx_ctx_init(&nxt_rx->ctx, tls_ctx->rx.aead, nxt_rx->key)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200806 TRACE_ERROR("could not initial RX TLS cipher context", QUIC_EV_CONN_RWSEC, qc);
807 goto leave;
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200808 }
809
810 if (nxt_tx->ctx) {
811 EVP_CIPHER_CTX_free(nxt_tx->ctx);
812 nxt_tx->ctx = NULL;
813 }
814
815 if (!quic_tls_rx_ctx_init(&nxt_tx->ctx, tls_ctx->tx.aead, nxt_tx->key)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200816 TRACE_ERROR("could not initial RX TLS cipher context", QUIC_EV_CONN_RWSEC, qc);
817 goto leave;
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200818 }
819
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200820 ret = 1;
821 leave:
822 TRACE_LEAVE(QUIC_EV_CONN_RWSEC, qc);
823 return ret;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100824}
825
826/* Rotate the Key Update information for <qc> QUIC connection.
827 * Must be used after having updated them.
828 * Always succeeds.
829 */
830static void quic_tls_rotate_keys(struct quic_conn *qc)
831{
832 struct quic_tls_ctx *tls_ctx = &qc->els[QUIC_TLS_ENC_LEVEL_APP].tls_ctx;
833 unsigned char *curr_secret, *curr_iv, *curr_key;
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200834 EVP_CIPHER_CTX *curr_ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100835
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200836 TRACE_ENTER(QUIC_EV_CONN_RXPKT, qc);
837
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100838 /* Rotate the RX secrets */
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200839 curr_ctx = tls_ctx->rx.ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100840 curr_secret = tls_ctx->rx.secret;
841 curr_iv = tls_ctx->rx.iv;
842 curr_key = tls_ctx->rx.key;
843
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200844 tls_ctx->rx.ctx = qc->ku.nxt_rx.ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100845 tls_ctx->rx.secret = qc->ku.nxt_rx.secret;
846 tls_ctx->rx.iv = qc->ku.nxt_rx.iv;
847 tls_ctx->rx.key = qc->ku.nxt_rx.key;
848
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200849 qc->ku.nxt_rx.ctx = qc->ku.prv_rx.ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100850 qc->ku.nxt_rx.secret = qc->ku.prv_rx.secret;
851 qc->ku.nxt_rx.iv = qc->ku.prv_rx.iv;
852 qc->ku.nxt_rx.key = qc->ku.prv_rx.key;
853
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200854 qc->ku.prv_rx.ctx = curr_ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100855 qc->ku.prv_rx.secret = curr_secret;
856 qc->ku.prv_rx.iv = curr_iv;
857 qc->ku.prv_rx.key = curr_key;
858 qc->ku.prv_rx.pn = tls_ctx->rx.pn;
859
860 /* Update the TX secrets */
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200861 curr_ctx = tls_ctx->tx.ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100862 curr_secret = tls_ctx->tx.secret;
863 curr_iv = tls_ctx->tx.iv;
864 curr_key = tls_ctx->tx.key;
865
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200866 tls_ctx->tx.ctx = qc->ku.nxt_tx.ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100867 tls_ctx->tx.secret = qc->ku.nxt_tx.secret;
868 tls_ctx->tx.iv = qc->ku.nxt_tx.iv;
869 tls_ctx->tx.key = qc->ku.nxt_tx.key;
870
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +0200871 qc->ku.nxt_tx.ctx = curr_ctx;
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100872 qc->ku.nxt_tx.secret = curr_secret;
873 qc->ku.nxt_tx.iv = curr_iv;
874 qc->ku.nxt_tx.key = curr_key;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200875
876 TRACE_LEAVE(QUIC_EV_CONN_RXPKT, qc);
Frédéric Lécaillea7973a62021-11-30 11:10:36 +0100877}
878
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200879/* returns 0 on error, 1 on success */
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100880int ha_quic_set_encryption_secrets(SSL *ssl, enum ssl_encryption_level_t level,
881 const uint8_t *read_secret,
882 const uint8_t *write_secret, size_t secret_len)
883{
Amaury Denoyelle9320dd52022-01-19 10:03:30 +0100884 struct quic_conn *qc = SSL_get_ex_data(ssl, ssl_qc_app_data_index);
885 struct quic_tls_ctx *tls_ctx = &qc->els[ssl_to_quic_enc_level(level)].tls_ctx;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100886 const SSL_CIPHER *cipher = SSL_get_current_cipher(ssl);
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +0100887 struct quic_tls_secrets *rx, *tx;
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200888 const struct quic_version *ver =
889 qc->negotiated_version ? qc->negotiated_version : qc->original_version;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200890 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100891
Amaury Denoyelle9320dd52022-01-19 10:03:30 +0100892 TRACE_ENTER(QUIC_EV_CONN_RWSEC, qc);
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +0100893 BUG_ON(secret_len > QUIC_TLS_SECRET_LEN);
Frédéric Lécaillefc790062022-03-28 17:10:31 +0200894 if (qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE) {
Amaury Denoyelle9320dd52022-01-19 10:03:30 +0100895 TRACE_PROTO("CC required", QUIC_EV_CONN_RWSEC, qc);
Frédéric Lécaillef44d19e2022-03-26 12:22:41 +0100896 goto no_secret;
Frédéric Lécaille1fc5e162021-11-22 14:25:57 +0100897 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100898
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +0100899 if (!quic_tls_ctx_keys_alloc(tls_ctx)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200900 TRACE_ERROR("keys allocation failed", QUIC_EV_CONN_RWSEC, qc);
901 goto leave;
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +0100902 }
903
904 rx = &tls_ctx->rx;
905 tx = &tls_ctx->tx;
906
907 rx->aead = tx->aead = tls_aead(cipher);
908 rx->md = tx->md = tls_md(cipher);
909 rx->hp = tx->hp = tls_hp(cipher);
910
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200911 if (!quic_tls_derive_keys(rx->aead, rx->hp, rx->md, ver, rx->key, rx->keylen,
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +0100912 rx->iv, rx->ivlen, rx->hp_key, sizeof rx->hp_key,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100913 read_secret, secret_len)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200914 TRACE_ERROR("RX key derivation failed", QUIC_EV_CONN_RWSEC, qc);
915 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100916 }
917
Frédéric Lécaillef4605742022-04-05 10:28:29 +0200918 if (!quic_tls_rx_ctx_init(&rx->ctx, rx->aead, rx->key)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200919 TRACE_ERROR("could not initial RX TLS cipher context", QUIC_EV_CONN_RWSEC, qc);
920 goto leave;
Frédéric Lécaillef4605742022-04-05 10:28:29 +0200921 }
922
Frédéric Lécaille86a53c52022-08-19 18:18:13 +0200923 if (!quic_tls_dec_aes_ctx_init(&rx->hp_ctx, rx->hp, rx->hp_key)) {
924 TRACE_ERROR("could not initial RX TLS cipher context for HP", QUIC_EV_CONN_RWSEC, qc);
925 goto leave;
926 }
927
Frédéric Lécaille61b851d2022-01-28 21:38:45 +0100928 /* Enqueue this connection asap if we could derive O-RTT secrets as
929 * listener. Note that a listener derives only RX secrets for this
930 * level.
931 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200932 if (qc_is_listener(qc) && level == ssl_encryption_early_data) {
933 TRACE_DEVEL("pushing connection into accept queue", QUIC_EV_CONN_RWSEC, qc);
Frédéric Lécaille61b851d2022-01-28 21:38:45 +0100934 quic_accept_push_qc(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200935 }
Frédéric Lécaille4015cbb2021-12-14 19:29:34 +0100936
937 if (!write_secret)
Frédéric Lécailleee4508d2022-02-14 17:54:04 +0100938 goto out;
Frédéric Lécaille4015cbb2021-12-14 19:29:34 +0100939
Frédéric Lécaille301425b2022-06-14 17:40:39 +0200940 if (!quic_tls_derive_keys(tx->aead, tx->hp, tx->md, ver, tx->key, tx->keylen,
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +0100941 tx->iv, tx->ivlen, tx->hp_key, sizeof tx->hp_key,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100942 write_secret, secret_len)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200943 TRACE_ERROR("TX key derivation failed", QUIC_EV_CONN_RWSEC, qc);
944 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100945 }
946
Frédéric Lécaillef4605742022-04-05 10:28:29 +0200947 if (!quic_tls_tx_ctx_init(&tx->ctx, tx->aead, tx->key)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200948 TRACE_ERROR("could not initial RX TLS cipher context", QUIC_EV_CONN_RWSEC, qc);
949 goto leave;
Frédéric Lécaillef4605742022-04-05 10:28:29 +0200950 }
951
Frédéric Lécaille86a53c52022-08-19 18:18:13 +0200952 if (!quic_tls_enc_aes_ctx_init(&tx->hp_ctx, tx->hp, tx->hp_key)) {
953 TRACE_ERROR("could not initial TX TLS cipher context for HP", QUIC_EV_CONN_RWSEC, qc);
954 goto leave;
955 }
956
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +0100957 if (level == ssl_encryption_application) {
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +0100958 struct quic_tls_kp *prv_rx = &qc->ku.prv_rx;
959 struct quic_tls_kp *nxt_rx = &qc->ku.nxt_rx;
960 struct quic_tls_kp *nxt_tx = &qc->ku.nxt_tx;
961
Frédéric Lécaille96fd1632022-04-01 11:21:47 +0200962 /* These secrets must be stored only for Application encryption level */
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +0100963 if (!(rx->secret = pool_alloc(pool_head_quic_tls_secret)) ||
964 !(tx->secret = pool_alloc(pool_head_quic_tls_secret))) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200965 TRACE_ERROR("Could not allocate secrete keys", QUIC_EV_CONN_RWSEC, qc);
966 goto leave;
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +0100967 }
968
969 memcpy(rx->secret, read_secret, secret_len);
970 rx->secretlen = secret_len;
971 memcpy(tx->secret, write_secret, secret_len);
972 tx->secretlen = secret_len;
973 /* Initialize all the secret keys lengths */
974 prv_rx->secretlen = nxt_rx->secretlen = nxt_tx->secretlen = secret_len;
975 /* Prepare the next key update */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200976 if (!quic_tls_key_update(qc)) {
977 // trace already emitted by function above
978 goto leave;
979 }
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +0100980 }
Frédéric Lécailleee4508d2022-02-14 17:54:04 +0100981
Frédéric Lécaille1fc5e162021-11-22 14:25:57 +0100982 out:
Frédéric Lécaillebd242082022-02-25 17:17:59 +0100983 tls_ctx->flags |= QUIC_FL_TLS_SECRETS_SET;
Frédéric Lécaillef44d19e2022-03-26 12:22:41 +0100984 no_secret:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200985 ret = 1;
986 leave:
Amaury Denoyelle9320dd52022-01-19 10:03:30 +0100987 TRACE_LEAVE(QUIC_EV_CONN_RWSEC, qc, &level);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200988 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100989}
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100990
991/* This function copies the CRYPTO data provided by the TLS stack found at <data>
992 * with <len> as size in CRYPTO buffers dedicated to store the information about
993 * outgoing CRYPTO frames so that to be able to replay the CRYPTO data streams.
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200994 * It fails (returns 0) only if it could not managed to allocate enough CRYPTO
995 * buffers to store all the data.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100996 * Note that CRYPTO data may exist at any encryption level except at 0-RTT.
997 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +0200998static int quic_crypto_data_cpy(struct quic_conn *qc, struct quic_enc_level *qel,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +0100999 const unsigned char *data, size_t len)
1000{
1001 struct quic_crypto_buf **qcb;
1002 /* The remaining byte to store in CRYPTO buffers. */
1003 size_t cf_offset, cf_len, *nb_buf;
1004 unsigned char *pos;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001005 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001006
1007 nb_buf = &qel->tx.crypto.nb_buf;
1008 qcb = &qel->tx.crypto.bufs[*nb_buf - 1];
1009 cf_offset = (*nb_buf - 1) * QUIC_CRYPTO_BUF_SZ + (*qcb)->sz;
1010 cf_len = len;
1011
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001012 TRACE_ENTER(QUIC_EV_CONN_ADDDATA, qc);
1013
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001014 while (len) {
1015 size_t to_copy, room;
1016
1017 pos = (*qcb)->data + (*qcb)->sz;
1018 room = QUIC_CRYPTO_BUF_SZ - (*qcb)->sz;
1019 to_copy = len > room ? room : len;
1020 if (to_copy) {
1021 memcpy(pos, data, to_copy);
1022 /* Increment the total size of this CRYPTO buffers by <to_copy>. */
1023 qel->tx.crypto.sz += to_copy;
1024 (*qcb)->sz += to_copy;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001025 len -= to_copy;
1026 data += to_copy;
1027 }
1028 else {
1029 struct quic_crypto_buf **tmp;
1030
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001031 // FIXME: realloc!
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001032 tmp = realloc(qel->tx.crypto.bufs,
1033 (*nb_buf + 1) * sizeof *qel->tx.crypto.bufs);
1034 if (tmp) {
1035 qel->tx.crypto.bufs = tmp;
1036 qcb = &qel->tx.crypto.bufs[*nb_buf];
1037 *qcb = pool_alloc(pool_head_quic_crypto_buf);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001038 if (!*qcb) {
1039 TRACE_ERROR("Could not allocate crypto buf", QUIC_EV_CONN_ADDDATA, qc);
1040 goto leave;
1041 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001042
1043 (*qcb)->sz = 0;
1044 ++*nb_buf;
1045 }
1046 else {
1047 break;
1048 }
1049 }
1050 }
1051
1052 /* Allocate a TX CRYPTO frame only if all the CRYPTO data
1053 * have been buffered.
1054 */
1055 if (!len) {
Frédéric Lécaille0ad04582021-07-27 14:51:54 +02001056 struct quic_frame *frm;
Frédéric Lécaille81cd3c82022-01-10 18:31:07 +01001057 struct quic_frame *found = NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001058
Frédéric Lécaille81cd3c82022-01-10 18:31:07 +01001059 /* There is at most one CRYPTO frame in this packet number
1060 * space. Let's look for it.
1061 */
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01001062 list_for_each_entry(frm, &qel->pktns->tx.frms, list) {
Frédéric Lécaille81cd3c82022-01-10 18:31:07 +01001063 if (frm->type != QUIC_FT_CRYPTO)
1064 continue;
1065
1066 /* Found */
1067 found = frm;
1068 break;
1069 }
1070
1071 if (found) {
1072 found->crypto.len += cf_len;
1073 }
1074 else {
Frédéric Lécailleb9171912022-04-21 17:32:10 +02001075 frm = pool_zalloc(pool_head_quic_frame);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001076 if (!frm) {
1077 TRACE_ERROR("Could not allocate quic frame", QUIC_EV_CONN_ADDDATA, qc);
1078 goto leave;
1079 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001080
Frédéric Lécailleb9171912022-04-21 17:32:10 +02001081 LIST_INIT(&frm->reflist);
Frédéric Lécailled4ecf942022-01-04 23:15:40 +01001082 frm->type = QUIC_FT_CRYPTO;
1083 frm->crypto.offset = cf_offset;
1084 frm->crypto.len = cf_len;
1085 frm->crypto.qel = qel;
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01001086 LIST_APPEND(&qel->pktns->tx.frms, &frm->list);
Frédéric Lécailled4ecf942022-01-04 23:15:40 +01001087 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001088 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001089 ret = len == 0;
1090 leave:
1091 TRACE_LEAVE(QUIC_EV_CONN_ADDDATA, qc);
1092 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001093}
1094
Amaury Denoyelle9fab9fd2022-05-20 15:04:38 +02001095/* Prepare the emission of CONNECTION_CLOSE with error <err>. All send/receive
1096 * activity for <qc> will be interrupted.
1097 */
Amaury Denoyelle57e6db72022-07-13 15:07:56 +02001098void quic_set_connection_close(struct quic_conn *qc, const struct quic_err err)
Amaury Denoyelle9fab9fd2022-05-20 15:04:38 +02001099{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001100 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
Amaury Denoyelle9fab9fd2022-05-20 15:04:38 +02001101 if (qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001102 goto leave;
Amaury Denoyelle9fab9fd2022-05-20 15:04:38 +02001103
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001104 TRACE_STATE("setting immediate close", QUIC_EV_CONN_CLOSE, qc);
Amaury Denoyelle9fab9fd2022-05-20 15:04:38 +02001105 qc->flags |= QUIC_FL_CONN_IMMEDIATE_CLOSE;
Amaury Denoyelle57e6db72022-07-13 15:07:56 +02001106 qc->err.code = err.code;
1107 qc->err.app = err.app;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001108 leave:
1109 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Amaury Denoyelle9fab9fd2022-05-20 15:04:38 +02001110}
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001111
Frédéric Lécaille067a82b2021-11-19 17:02:20 +01001112/* Set <alert> TLS alert as QUIC CRYPTO_ERROR error */
1113void quic_set_tls_alert(struct quic_conn *qc, int alert)
1114{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001115 TRACE_ENTER(QUIC_EV_CONN_SSLALERT, qc);
1116
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02001117 if (!(qc->flags & QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED)) {
1118 qc->flags |= QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001119 TRACE_DEVEL("dec half open counter", QUIC_EV_CONN_SSLALERT, qc);
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02001120 HA_ATOMIC_DEC(&qc->prx_counters->half_open_conn);
1121 }
Amaury Denoyelle57e6db72022-07-13 15:07:56 +02001122 quic_set_connection_close(qc, quic_err_tls(alert));
Amaury Denoyelle9fab9fd2022-05-20 15:04:38 +02001123 qc->flags |= QUIC_FL_CONN_TLS_ALERT;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001124 TRACE_STATE("Alert set", QUIC_EV_CONN_SSLALERT, qc);
1125
1126 TRACE_LEAVE(QUIC_EV_CONN_SSLALERT, qc);
Frédéric Lécaille067a82b2021-11-19 17:02:20 +01001127}
1128
Frédéric Lécailleb0bd62d2021-12-14 19:34:08 +01001129/* Set the application for <qc> QUIC connection.
1130 * Return 1 if succeeded, 0 if not.
1131 */
1132int quic_set_app_ops(struct quic_conn *qc, const unsigned char *alpn, size_t alpn_len)
1133{
Amaury Denoyelle4b40f192022-01-19 11:29:25 +01001134 if (alpn_len >= 2 && memcmp(alpn, "h3", 2) == 0)
1135 qc->app_ops = &h3_ops;
1136 else if (alpn_len >= 10 && memcmp(alpn, "hq-interop", 10) == 0)
1137 qc->app_ops = &hq_interop_ops;
Frédéric Lécailleb0bd62d2021-12-14 19:34:08 +01001138 else
1139 return 0;
1140
Frédéric Lécailleb0bd62d2021-12-14 19:34:08 +01001141 return 1;
1142}
1143
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001144/* ->add_handshake_data QUIC TLS callback used by the QUIC TLS stack when it
1145 * wants to provide the QUIC layer with CRYPTO data.
1146 * Returns 1 if succeeded, 0 if not.
1147 */
1148int ha_quic_add_handshake_data(SSL *ssl, enum ssl_encryption_level_t level,
1149 const uint8_t *data, size_t len)
1150{
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001151 struct quic_conn *qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001152 enum quic_tls_enc_level tel;
1153 struct quic_enc_level *qel;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001154 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001155
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001156 qc = SSL_get_ex_data(ssl, ssl_qc_app_data_index);
1157 TRACE_ENTER(QUIC_EV_CONN_ADDDATA, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001158
Frédéric Lécaillefc790062022-03-28 17:10:31 +02001159 if (qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE) {
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001160 TRACE_PROTO("CC required", QUIC_EV_CONN_ADDDATA, qc);
Frédéric Lécaille1fc5e162021-11-22 14:25:57 +01001161 goto out;
1162 }
1163
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001164 tel = ssl_to_quic_enc_level(level);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001165 if (tel == -1) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001166 TRACE_ERROR("Wrong encryption level", QUIC_EV_CONN_ADDDATA, qc);
1167 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001168 }
1169
Frédéric Lécaille3916ca12022-02-02 14:09:05 +01001170 qel = &qc->els[tel];
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001171 if (!quic_crypto_data_cpy(qc, qel, data, len)) {
1172 TRACE_ERROR("Could not bufferize", QUIC_EV_CONN_ADDDATA, qc);
1173 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001174 }
1175
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001176 TRACE_DEVEL("CRYPTO data buffered", QUIC_EV_CONN_ADDDATA,
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001177 qc, &level, &len);
Frédéric Lécaille1fc5e162021-11-22 14:25:57 +01001178 out:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001179 ret = 1;
1180 leave:
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001181 TRACE_LEAVE(QUIC_EV_CONN_ADDDATA, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001182 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001183}
1184
1185int ha_quic_flush_flight(SSL *ssl)
1186{
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001187 struct quic_conn *qc = SSL_get_ex_data(ssl, ssl_qc_app_data_index);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001188
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001189 TRACE_ENTER(QUIC_EV_CONN_FFLIGHT, qc);
1190 TRACE_LEAVE(QUIC_EV_CONN_FFLIGHT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001191
1192 return 1;
1193}
1194
1195int ha_quic_send_alert(SSL *ssl, enum ssl_encryption_level_t level, uint8_t alert)
1196{
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001197 struct quic_conn *qc = SSL_get_ex_data(ssl, ssl_qc_app_data_index);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001198
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001199 TRACE_ENTER(QUIC_EV_CONN_SSLALERT, qc);
1200
1201 TRACE_PROTO("Received TLS alert", QUIC_EV_CONN_SSLALERT, qc, &alert, &level);
1202
Amaury Denoyelle9320dd52022-01-19 10:03:30 +01001203 quic_set_tls_alert(qc, alert);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001204 TRACE_LEAVE(QUIC_EV_CONN_SSLALERT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001205 return 1;
1206}
1207
1208/* QUIC TLS methods */
1209static SSL_QUIC_METHOD ha_quic_method = {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001210 .set_encryption_secrets = ha_quic_set_encryption_secrets,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001211 .add_handshake_data = ha_quic_add_handshake_data,
1212 .flush_flight = ha_quic_flush_flight,
1213 .send_alert = ha_quic_send_alert,
1214};
1215
1216/* Initialize the TLS context of a listener with <bind_conf> as configuration.
1217 * Returns an error count.
1218 */
1219int ssl_quic_initial_ctx(struct bind_conf *bind_conf)
1220{
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001221 struct ssl_bind_conf __maybe_unused *ssl_conf_cur;
1222 int cfgerr = 0;
1223
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001224 long options =
1225 (SSL_OP_ALL & ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) |
1226 SSL_OP_SINGLE_ECDH_USE |
1227 SSL_OP_CIPHER_SERVER_PREFERENCE;
1228 SSL_CTX *ctx;
1229
1230 ctx = SSL_CTX_new(TLS_server_method());
1231 bind_conf->initial_ctx = ctx;
1232
1233 SSL_CTX_set_options(ctx, options);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001234 SSL_CTX_set_mode(ctx, SSL_MODE_RELEASE_BUFFERS);
1235 SSL_CTX_set_min_proto_version(ctx, TLS1_3_VERSION);
1236 SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001237
1238#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaillee06f7452022-06-16 15:06:44 +02001239#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001240 if (bind_conf->ssl_conf.early_data) {
1241 SSL_CTX_set_options(ctx, SSL_OP_NO_ANTI_REPLAY);
Frédéric Lécaillead3c07a2021-12-14 19:23:43 +01001242 SSL_CTX_set_max_early_data(ctx, 0xffffffff);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001243 }
1244 SSL_CTX_set_client_hello_cb(ctx, ssl_sock_switchctx_cbk, NULL);
1245 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_err_cbk);
1246#else
1247 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_cbk);
1248#endif
1249 SSL_CTX_set_tlsext_servername_arg(ctx, bind_conf);
1250#endif
1251 SSL_CTX_set_quic_method(ctx, &ha_quic_method);
1252
1253 return cfgerr;
1254}
1255
1256/* Decode an expected packet number from <truncated_on> its truncated value,
1257 * depending on <largest_pn> the largest received packet number, and <pn_nbits>
1258 * the number of bits used to encode this packet number (its length in bytes * 8).
1259 * See https://quicwg.org/base-drafts/draft-ietf-quic-transport.html#packet-encoding
1260 */
1261static uint64_t decode_packet_number(uint64_t largest_pn,
1262 uint32_t truncated_pn, unsigned int pn_nbits)
1263{
1264 uint64_t expected_pn = largest_pn + 1;
1265 uint64_t pn_win = (uint64_t)1 << pn_nbits;
1266 uint64_t pn_hwin = pn_win / 2;
1267 uint64_t pn_mask = pn_win - 1;
1268 uint64_t candidate_pn;
1269
1270
1271 candidate_pn = (expected_pn & ~pn_mask) | truncated_pn;
1272 /* Note that <pn_win> > <pn_hwin>. */
1273 if (candidate_pn < QUIC_MAX_PACKET_NUM - pn_win &&
1274 candidate_pn + pn_hwin <= expected_pn)
1275 return candidate_pn + pn_win;
1276
1277 if (candidate_pn > expected_pn + pn_hwin && candidate_pn >= pn_win)
1278 return candidate_pn - pn_win;
1279
1280 return candidate_pn;
1281}
1282
1283/* Remove the header protection of <pkt> QUIC packet using <tls_ctx> as QUIC TLS
1284 * cryptographic context.
1285 * <largest_pn> is the largest received packet number and <pn> the address of
1286 * the packet number field for this packet with <byte0> address of its first byte.
1287 * <end> points to one byte past the end of this packet.
1288 * Returns 1 if succeeded, 0 if not.
1289 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01001290static int qc_do_rm_hp(struct quic_conn *qc,
1291 struct quic_rx_packet *pkt, struct quic_tls_ctx *tls_ctx,
Frédéric Lécaille99897d12022-08-08 10:28:07 +02001292 int64_t largest_pn, unsigned char *pn, unsigned char *byte0)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001293{
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02001294 int ret, i, pnlen;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001295 uint64_t packet_number;
1296 uint32_t truncated_pn = 0;
1297 unsigned char mask[5] = {0};
1298 unsigned char *sample;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001299 EVP_CIPHER_CTX *cctx = NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001300
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001301 TRACE_ENTER(QUIC_EV_CONN_RMHP, qc);
1302
1303 ret = 0;
1304
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001305 /* Check there is enough data in this packet. */
Frédéric Lécaille99897d12022-08-08 10:28:07 +02001306 if (pkt->len - (pn - byte0) < QUIC_PACKET_PN_MAXLEN + sizeof mask) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001307 TRACE_PROTO("too short packet", QUIC_EV_CONN_RMHP, qc, pkt);
1308 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001309 }
1310
1311 cctx = EVP_CIPHER_CTX_new();
1312 if (!cctx) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001313 TRACE_ERROR("memory allocation failed", QUIC_EV_CONN_RMHP, qc, pkt);
1314 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001315 }
1316
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001317 sample = pn + QUIC_PACKET_PN_MAXLEN;
1318
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02001319 if (!quic_tls_aes_decrypt(mask, sample, sizeof mask, tls_ctx->rx.hp_ctx)) {
1320 TRACE_ERROR("HP removing failed", QUIC_EV_CONN_RMHP, qc, pkt);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001321 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001322 }
1323
1324 *byte0 ^= mask[0] & (*byte0 & QUIC_PACKET_LONG_HEADER_BIT ? 0xf : 0x1f);
1325 pnlen = (*byte0 & QUIC_PACKET_PNL_BITMASK) + 1;
1326 for (i = 0; i < pnlen; i++) {
1327 pn[i] ^= mask[i + 1];
1328 truncated_pn = (truncated_pn << 8) | pn[i];
1329 }
1330
1331 packet_number = decode_packet_number(largest_pn, truncated_pn, pnlen * 8);
1332 /* Store remaining information for this unprotected header */
1333 pkt->pn = packet_number;
1334 pkt->pnl = pnlen;
1335
1336 ret = 1;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001337 leave:
1338 if (cctx)
1339 EVP_CIPHER_CTX_free(cctx);
1340 TRACE_LEAVE(QUIC_EV_CONN_RMHP, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001341 return ret;
1342}
1343
1344/* Encrypt the payload of a QUIC packet with <pn> as number found at <payload>
1345 * address, with <payload_len> as payload length, <aad> as address of
1346 * the ADD and <aad_len> as AAD length depending on the <tls_ctx> QUIC TLS
1347 * context.
1348 * Returns 1 if succeeded, 0 if not.
1349 */
1350static int quic_packet_encrypt(unsigned char *payload, size_t payload_len,
1351 unsigned char *aad, size_t aad_len, uint64_t pn,
Frédéric Lécaille5f7f1182022-01-10 11:00:16 +01001352 struct quic_tls_ctx *tls_ctx, struct quic_conn *qc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001353{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001354 int ret = 0;
Frédéric Lécaillef2f4a4e2022-04-05 12:18:46 +02001355 unsigned char iv[QUIC_TLS_IV_LEN];
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001356 unsigned char *tx_iv = tls_ctx->tx.iv;
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +01001357 size_t tx_iv_sz = tls_ctx->tx.ivlen;
Frédéric Lécaillef63921f2020-12-18 09:48:20 +01001358 struct enc_debug_info edi;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001359
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001360 TRACE_ENTER(QUIC_EV_CONN_ENCPKT, qc);
1361
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001362 if (!quic_aead_iv_build(iv, sizeof iv, tx_iv, tx_iv_sz, pn)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001363 TRACE_ERROR("AEAD IV building for encryption failed", QUIC_EV_CONN_ENCPKT, qc);
Frédéric Lécaillef63921f2020-12-18 09:48:20 +01001364 goto err;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001365 }
1366
1367 if (!quic_tls_encrypt(payload, payload_len, aad, aad_len,
Frédéric Lécaillef4605742022-04-05 10:28:29 +02001368 tls_ctx->tx.ctx, tls_ctx->tx.aead, tls_ctx->tx.key, iv)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001369 TRACE_ERROR("QUIC packet encryption failed", QUIC_EV_CONN_ENCPKT, qc);
Frédéric Lécaillef63921f2020-12-18 09:48:20 +01001370 goto err;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001371 }
1372
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001373 ret = 1;
1374 leave:
1375 TRACE_LEAVE(QUIC_EV_CONN_ENCPKT, qc);
1376 return ret;
Frédéric Lécaillef63921f2020-12-18 09:48:20 +01001377
1378 err:
1379 enc_debug_info_init(&edi, payload, payload_len, aad, aad_len, pn);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001380 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001381}
1382
1383/* Decrypt <pkt> QUIC packet with <tls_ctx> as QUIC TLS cryptographic context.
1384 * Returns 1 if succeeded, 0 if not.
1385 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001386static int qc_pkt_decrypt(struct quic_rx_packet *pkt, struct quic_enc_level *qel,
1387 struct quic_conn *qc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001388{
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001389 int ret, kp_changed;
Frédéric Lécaillef2f4a4e2022-04-05 12:18:46 +02001390 unsigned char iv[QUIC_TLS_IV_LEN];
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001391 struct quic_tls_ctx *tls_ctx = &qel->tls_ctx;
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +02001392 EVP_CIPHER_CTX *rx_ctx = tls_ctx->rx.ctx;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001393 unsigned char *rx_iv = tls_ctx->rx.iv;
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001394 size_t rx_iv_sz = tls_ctx->rx.ivlen;
1395 unsigned char *rx_key = tls_ctx->rx.key;
1396
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001397 TRACE_ENTER(QUIC_EV_CONN_RXPKT, qc);
1398
1399 ret = 0;
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001400 kp_changed = 0;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001401
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001402 if (pkt->type == QUIC_PACKET_TYPE_SHORT) {
1403 /* The two tested bits are not at the same position,
1404 * this is why they are first both inversed.
1405 */
1406 if (!(*pkt->data & QUIC_PACKET_KEY_PHASE_BIT) ^ !(tls_ctx->flags & QUIC_FL_TLS_KP_BIT_SET)) {
1407 if (pkt->pn < tls_ctx->rx.pn) {
1408 /* The lowest packet number of a previous key phase
1409 * cannot be null if it really stores previous key phase
1410 * secrets.
1411 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001412 // TODO: check if BUG_ON() more suitable
1413 if (!pkt->qc->ku.prv_rx.pn) {
1414 TRACE_ERROR("null previous packet number", QUIC_EV_CONN_RXPKT, qc);
1415 goto leave;
1416 }
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001417
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +02001418 rx_ctx = pkt->qc->ku.prv_rx.ctx;
1419 rx_iv = pkt->qc->ku.prv_rx.iv;
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001420 rx_key = pkt->qc->ku.prv_rx.key;
1421 }
1422 else if (pkt->pn > qel->pktns->rx.largest_pn) {
1423 /* Next key phase */
1424 kp_changed = 1;
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +02001425 rx_ctx = pkt->qc->ku.nxt_rx.ctx;
1426 rx_iv = pkt->qc->ku.nxt_rx.iv;
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001427 rx_key = pkt->qc->ku.nxt_rx.key;
1428 }
1429 }
1430 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001431
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001432 if (!quic_aead_iv_build(iv, sizeof iv, rx_iv, rx_iv_sz, pkt->pn)) {
1433 TRACE_ERROR("quic_aead_iv_build() failed", QUIC_EV_CONN_RXPKT, qc);
1434 goto leave;
1435 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001436
1437 ret = quic_tls_decrypt(pkt->data + pkt->aad_len, pkt->len - pkt->aad_len,
1438 pkt->data, pkt->aad_len,
Frédéric Lécaille8c7927c2022-04-05 16:28:38 +02001439 rx_ctx, tls_ctx->rx.aead, rx_key, iv);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001440 if (!ret) {
1441 TRACE_ERROR("quic_tls_decrypt() failed", QUIC_EV_CONN_RXPKT, qc);
1442 goto leave;
1443 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001444
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001445 /* Update the keys only if the packet decryption succeeded. */
1446 if (kp_changed) {
1447 quic_tls_rotate_keys(pkt->qc);
1448 /* Toggle the Key Phase bit */
1449 tls_ctx->flags ^= QUIC_FL_TLS_KP_BIT_SET;
1450 /* Store the lowest packet number received for the current key phase */
1451 tls_ctx->rx.pn = pkt->pn;
1452 /* Prepare the next key update */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001453 if (!quic_tls_key_update(pkt->qc)) {
1454 TRACE_ERROR("quic_tls_key_update() failed", QUIC_EV_CONN_RXPKT, qc);
1455 goto leave;
1456 }
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01001457 }
1458
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001459 /* Update the packet length (required to parse the frames). */
Frédéric Lécaillef4605742022-04-05 10:28:29 +02001460 pkt->len -= QUIC_TLS_TAG_LEN;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001461 ret = 1;
1462 leave:
1463 TRACE_LEAVE(QUIC_EV_CONN_RXPKT, qc);
Frédéric Lécaille11a6f402022-08-16 14:48:59 +02001464 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001465}
1466
Frédéric Lécaille96367152022-04-25 09:40:19 +02001467
1468/* Remove references to <frm> frame */
1469static void qc_frm_unref(struct quic_conn *qc, struct quic_frame *frm)
1470{
Frédéric Lécaille96367152022-04-25 09:40:19 +02001471 struct quic_frame *f, *tmp;
1472
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001473 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
1474
Frédéric Lécaille96367152022-04-25 09:40:19 +02001475 list_for_each_entry_safe(f, tmp, &frm->reflist, ref) {
Frédéric Lécaille96367152022-04-25 09:40:19 +02001476 f->origin = NULL;
1477 LIST_DELETE(&f->ref);
Frédéric Lécailleeba90882022-08-25 16:06:48 +02001478 if (f->pkt) {
1479 TRACE_DEVEL("remove frame reference",
1480 QUIC_EV_CONN_PRSAFRM, qc, f, &f->pkt->pn_node.key);
1481 }
1482 else {
1483 TRACE_DEVEL("remove frame reference for unsent frame",
1484 QUIC_EV_CONN_PRSAFRM, qc, f);
1485 }
Frédéric Lécaille96367152022-04-25 09:40:19 +02001486 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001487
1488 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille96367152022-04-25 09:40:19 +02001489}
1490
Frédéric Lécaillea9568412022-04-25 08:58:04 +02001491/* Release <frm> frame and mark its copies as acknowledged */
Frédéric Lécailleda342552022-04-25 10:28:49 +02001492void qc_release_frm(struct quic_conn *qc, struct quic_frame *frm)
Frédéric Lécaillea9568412022-04-25 08:58:04 +02001493{
1494 uint64_t pn;
1495 struct quic_frame *origin, *f, *tmp;
1496
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001497 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
1498
Frédéric Lécaillea9568412022-04-25 08:58:04 +02001499 /* Identify this frame: a frame copy or one of its copies */
1500 origin = frm->origin ? frm->origin : frm;
1501 /* Ensure the source of the copies is flagged as acked, <frm> being
1502 * possibly a copy of <origin>
1503 */
1504 origin->flags |= QUIC_FL_TX_FRAME_ACKED;
1505 /* Mark all the copy of <origin> as acknowledged. We must
1506 * not release the packets (releasing the frames) at this time as
1507 * they are possibly also to be acknowledged alongside the
1508 * the current one.
1509 */
1510 list_for_each_entry_safe(f, tmp, &origin->reflist, ref) {
Frédéric Lécailleeba90882022-08-25 16:06:48 +02001511 if (f->pkt) {
1512 pn = f->pkt->pn_node.key;
1513 TRACE_DEVEL("mark frame as acked from packet",
1514 QUIC_EV_CONN_PRSAFRM, qc, f, &pn);
1515 }
1516 else {
1517 TRACE_DEVEL("mark unsend frame as acked",
1518 QUIC_EV_CONN_PRSAFRM, qc, f);
1519 }
Frédéric Lécaillea9568412022-04-25 08:58:04 +02001520 f->flags |= QUIC_FL_TX_FRAME_ACKED;
1521 f->origin = NULL;
1522 LIST_DELETE(&f->ref);
1523 }
1524 LIST_DELETE(&frm->list);
1525 pn = frm->pkt->pn_node.key;
1526 quic_tx_packet_refdec(frm->pkt);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001527 TRACE_DEVEL("freeing frame from packet",
Frédéric Lécaillea9568412022-04-25 08:58:04 +02001528 QUIC_EV_CONN_PRSAFRM, qc, frm, &pn);
1529 pool_free(pool_head_quic_frame, frm);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001530
1531 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02001532}
1533
Amaury Denoyelle240b1b12022-07-13 15:18:16 +02001534/* Schedule a CONNECTION_CLOSE emission on <qc> if the MUX has been released
1535 * and all STREAM data are acknowledged. The MUX is responsible to have set
1536 * <qc.err> before as it is reused for the CONNECTION_CLOSE frame.
1537 *
1538 * TODO this should also be called on lost packet detection
1539 */
1540static void qc_check_close_on_released_mux(struct quic_conn *qc)
1541{
1542 struct ssl_sock_ctx *ctx = qc->xprt_ctx;
1543
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001544 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
1545
Amaury Denoyelle240b1b12022-07-13 15:18:16 +02001546 if (qc->mux_state == QC_MUX_RELEASED && eb_is_empty(&qc->streams_by_id)) {
1547 /* Reuse errcode which should have been previously set by the MUX on release. */
1548 quic_set_connection_close(qc, qc->err);
1549 tasklet_wakeup(ctx->wait_event.tasklet);
1550 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001551
1552 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Amaury Denoyelle240b1b12022-07-13 15:18:16 +02001553}
1554
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001555/* Remove from <stream> the acknowledged frames.
Amaury Denoyelle95e50fb2022-03-29 14:50:25 +02001556 *
1557 * Returns 1 if at least one frame was removed else 0.
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001558 */
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001559static int quic_stream_try_to_consume(struct quic_conn *qc,
1560 struct qc_stream_desc *stream)
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001561{
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001562 int ret;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001563 struct eb64_node *frm_node;
1564
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001565 TRACE_ENTER(QUIC_EV_CONN_ACKSTRM, qc);
1566
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001567 ret = 0;
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001568 frm_node = eb64_first(&stream->acked_frms);
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001569 while (frm_node) {
1570 struct quic_stream *strm;
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001571 struct quic_frame *frm;
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001572 size_t offset, len;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001573
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02001574 strm = eb64_entry(frm_node, struct quic_stream, offset);
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001575 offset = strm->offset.key;
1576 len = strm->len;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001577
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001578 if (offset > stream->ack_offset)
1579 break;
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001580
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001581 if (qc_stream_desc_ack(&stream, offset, len)) {
Amaury Denoyelle7586bef2022-04-25 14:26:54 +02001582 /* cf. next comment : frame may be freed at this stage. */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001583 TRACE_DEVEL("stream consumed", QUIC_EV_CONN_ACKSTRM,
Amaury Denoyelle7586bef2022-04-25 14:26:54 +02001584 qc, stream ? strm : NULL, stream);
Amaury Denoyelle119965f2022-02-24 17:39:57 +01001585 ret = 1;
1586 }
1587
Amaury Denoyelle7586bef2022-04-25 14:26:54 +02001588 /* If stream is NULL after qc_stream_desc_ack(), it means frame
1589 * has been freed. with the stream frames tree. Nothing to do
1590 * anymore in here.
1591 */
Amaury Denoyelle240b1b12022-07-13 15:18:16 +02001592 if (!stream) {
1593 qc_check_close_on_released_mux(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001594 ret = 1;
1595 goto leave;
Amaury Denoyelle240b1b12022-07-13 15:18:16 +02001596 }
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001597
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001598 frm_node = eb64_next(frm_node);
1599 eb64_delete(&strm->offset);
Amaury Denoyelle7b4c9d62022-02-24 10:50:58 +01001600
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001601 frm = container_of(strm, struct quic_frame, stream);
Frédéric Lécailleda342552022-04-25 10:28:49 +02001602 qc_release_frm(qc, frm);
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001603 }
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001604
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001605 leave:
1606 TRACE_LEAVE(QUIC_EV_CONN_ACKSTRM, qc);
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001607 return ret;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001608}
1609
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001610/* Treat <frm> frame whose packet it is attached to has just been acknowledged. */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01001611static inline void qc_treat_acked_tx_frm(struct quic_conn *qc,
1612 struct quic_frame *frm)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001613{
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001614 int stream_acked;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001615
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001616 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc, frm);
1617
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001618 stream_acked = 0;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001619 switch (frm->type) {
1620 case QUIC_FT_STREAM_8 ... QUIC_FT_STREAM_F:
1621 {
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001622 struct quic_stream *strm_frm = &frm->stream;
Amaury Denoyelle8d5def02022-03-29 11:51:17 +02001623 struct eb64_node *node = NULL;
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001624 struct qc_stream_desc *stream = NULL;
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001625 const size_t offset = strm_frm->offset.key;
1626 const size_t len = strm_frm->len;
Amaury Denoyelle8d5def02022-03-29 11:51:17 +02001627
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001628 /* do not use strm_frm->stream as the qc_stream_desc instance
1629 * might be freed at this stage. Use the id to do a proper
Amaury Denoyellee4301da2022-04-19 17:59:50 +02001630 * lookup.
Amaury Denoyelle8d5def02022-03-29 11:51:17 +02001631 *
1632 * TODO if lookup operation impact on the perf is noticeable,
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001633 * implement a refcount on qc_stream_desc instances.
Amaury Denoyelle8d5def02022-03-29 11:51:17 +02001634 */
Amaury Denoyellee4301da2022-04-19 17:59:50 +02001635 node = eb64_lookup(&qc->streams_by_id, strm_frm->id);
1636 if (!node) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001637 TRACE_DEVEL("acked stream for released stream", QUIC_EV_CONN_ACKSTRM, qc, strm_frm);
Frédéric Lécailleda342552022-04-25 10:28:49 +02001638 qc_release_frm(qc, frm);
Amaury Denoyelle8d5def02022-03-29 11:51:17 +02001639 /* early return */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001640 goto leave;
Amaury Denoyelle8d5def02022-03-29 11:51:17 +02001641 }
Amaury Denoyellee4301da2022-04-19 17:59:50 +02001642 stream = eb64_entry(node, struct qc_stream_desc, by_id);
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001643
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001644 TRACE_DEVEL("acked stream", QUIC_EV_CONN_ACKSTRM, qc, strm_frm, stream);
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001645 if (offset <= stream->ack_offset) {
1646 if (qc_stream_desc_ack(&stream, offset, len)) {
Amaury Denoyelle119965f2022-02-24 17:39:57 +01001647 stream_acked = 1;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001648 TRACE_DEVEL("stream consumed", QUIC_EV_CONN_ACKSTRM,
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001649 qc, strm_frm, stream);
1650 }
Amaury Denoyelle0c7679d2022-02-24 10:56:33 +01001651
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001652 if (!stream) {
1653 /* no need to continue if stream freed. */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001654 TRACE_DEVEL("stream released and freed", QUIC_EV_CONN_ACKSTRM, qc);
Frédéric Lécailleda342552022-04-25 10:28:49 +02001655 qc_release_frm(qc, frm);
Amaury Denoyelle240b1b12022-07-13 15:18:16 +02001656 qc_check_close_on_released_mux(qc);
Amaury Denoyelle1b81dda2022-04-21 09:32:53 +02001657 break;
Amaury Denoyelle119965f2022-02-24 17:39:57 +01001658 }
1659
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001660 TRACE_DEVEL("stream consumed", QUIC_EV_CONN_ACKSTRM,
Frédéric Lécailleda342552022-04-25 10:28:49 +02001661 qc, strm_frm, stream);
1662 qc_release_frm(qc, frm);
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001663 }
1664 else {
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001665 eb64_insert(&stream->acked_frms, &strm_frm->offset);
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001666 }
Amaury Denoyelle119965f2022-02-24 17:39:57 +01001667
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02001668 stream_acked |= quic_stream_try_to_consume(qc, stream);
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001669 }
1670 break;
1671 default:
Frédéric Lécailleda342552022-04-25 10:28:49 +02001672 qc_release_frm(qc, frm);
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02001673 }
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001674
Frédéric Lécaille89a2ceb2022-04-20 15:59:07 +02001675 if (stream_acked && qc->mux_state == QC_MUX_READY) {
Frédéric Lécaille1c482c62021-09-20 16:59:51 +02001676 struct qcc *qcc = qc->qcc;
1677
1678 if (qcc->subs && qcc->subs->events & SUB_RETRY_SEND) {
1679 tasklet_wakeup(qcc->subs->tasklet);
1680 qcc->subs->events &= ~SUB_RETRY_SEND;
1681 if (!qcc->subs->events)
1682 qcc->subs = NULL;
1683 }
1684 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001685 leave:
1686 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001687}
1688
1689/* Remove <largest> down to <smallest> node entries from <pkts> tree of TX packet,
1690 * deallocating them, and their TX frames.
1691 * Returns the last node reached to be used for the next range.
1692 * May be NULL if <largest> node could not be found.
1693 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01001694static inline struct eb64_node *qc_ackrng_pkts(struct quic_conn *qc,
1695 struct eb_root *pkts,
1696 unsigned int *pkt_flags,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001697 struct list *newly_acked_pkts,
1698 struct eb64_node *largest_node,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01001699 uint64_t largest, uint64_t smallest)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001700{
1701 struct eb64_node *node;
1702 struct quic_tx_packet *pkt;
1703
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001704 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
1705
Frédéric Lécaille843399f2022-07-22 16:27:44 +02001706 node = largest_node ? largest_node : eb64_lookup_le(pkts, largest);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001707 while (node && node->key >= smallest) {
Frédéric Lécaille0ad04582021-07-27 14:51:54 +02001708 struct quic_frame *frm, *frmbak;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001709
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02001710 pkt = eb64_entry(node, struct quic_tx_packet, pn_node);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001711 *pkt_flags |= pkt->flags;
Willy Tarreau2b718102021-04-21 07:32:39 +02001712 LIST_INSERT(newly_acked_pkts, &pkt->list);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001713 TRACE_DEVEL("Removing packet #", QUIC_EV_CONN_PRSAFRM, qc, NULL, &pkt->pn_node.key);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001714 list_for_each_entry_safe(frm, frmbak, &pkt->frms, list)
Amaury Denoyellee81fed92021-12-22 11:06:34 +01001715 qc_treat_acked_tx_frm(qc, frm);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001716 node = eb64_prev(node);
1717 eb64_delete(&pkt->pn_node);
1718 }
1719
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001720 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001721 return node;
1722}
1723
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001724/* Remove all frames from <pkt_frm_list> and reinsert them in the
1725 * same order they have been sent into <pktns_frm_list>.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001726 */
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001727static inline void qc_requeue_nacked_pkt_tx_frms(struct quic_conn *qc,
Frédéric Lécaille96367152022-04-25 09:40:19 +02001728 struct quic_tx_packet *pkt,
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01001729 struct list *pktns_frm_list)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001730{
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001731 struct quic_frame *frm, *frmbak;
1732 struct list tmp = LIST_HEAD_INIT(tmp);
Frédéric Lécaille96367152022-04-25 09:40:19 +02001733 struct list *pkt_frm_list = &pkt->frms;
Frédéric Lécaille1ba25c22022-08-18 17:21:19 +02001734 uint64_t pn = pkt->pn_node.key;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001735
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001736 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
1737
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001738 list_for_each_entry_safe(frm, frmbak, pkt_frm_list, list) {
Frédéric Lécaille96367152022-04-25 09:40:19 +02001739 /* First remove this frame from the packet it was attached to */
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001740 LIST_DELETE(&frm->list);
Frédéric Lécaille1ba25c22022-08-18 17:21:19 +02001741 quic_tx_packet_refdec(pkt);
Frédéric Lécaille96367152022-04-25 09:40:19 +02001742 /* At this time, this frame is not freed but removed from its packet */
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001743 frm->pkt = NULL;
Frédéric Lécaille96367152022-04-25 09:40:19 +02001744 /* Remove any reference to this frame */
1745 qc_frm_unref(qc, frm);
1746 switch (frm->type) {
1747 case QUIC_FT_STREAM_8 ... QUIC_FT_STREAM_F:
1748 {
1749 struct quic_stream *strm_frm = &frm->stream;
1750 struct eb64_node *node = NULL;
1751 struct qc_stream_desc *stream_desc;
1752
1753 node = eb64_lookup(&qc->streams_by_id, strm_frm->id);
1754 if (!node) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001755 TRACE_DEVEL("released stream", QUIC_EV_CONN_PRSAFRM, qc, frm);
1756 TRACE_DEVEL("freeing frame from packet", QUIC_EV_CONN_PRSAFRM,
Frédéric Lécaille96367152022-04-25 09:40:19 +02001757 qc, frm, &pn);
1758 pool_free(pool_head_quic_frame, frm);
1759 continue;
1760 }
1761
1762 stream_desc = eb64_entry(node, struct qc_stream_desc, by_id);
1763 /* Do not resend this frame if in the "already acked range" */
1764 if (strm_frm->offset.key + strm_frm->len <= stream_desc->ack_offset) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001765 TRACE_DEVEL("ignored frame in already acked range",
Frédéric Lécaille96367152022-04-25 09:40:19 +02001766 QUIC_EV_CONN_PRSAFRM, qc, frm);
1767 continue;
1768 }
1769 else if (strm_frm->offset.key < stream_desc->ack_offset) {
1770 strm_frm->offset.key = stream_desc->ack_offset;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001771 TRACE_DEVEL("updated partially acked frame",
Frédéric Lécaille96367152022-04-25 09:40:19 +02001772 QUIC_EV_CONN_PRSAFRM, qc, frm);
1773 }
Frédéric Lécaille96367152022-04-25 09:40:19 +02001774 break;
1775 }
1776
1777 default:
1778 break;
1779 }
1780
1781 /* Do not resend probing packet with old data */
1782 if (pkt->flags & QUIC_FL_TX_PACKET_PROBE_WITH_OLD_DATA) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001783 TRACE_DEVEL("ignored frame with old data from packet", QUIC_EV_CONN_PRSAFRM,
1784 qc, frm, &pn);
Frédéric Lécaille96367152022-04-25 09:40:19 +02001785 if (frm->origin)
1786 LIST_DELETE(&frm->ref);
1787 pool_free(pool_head_quic_frame, frm);
1788 continue;
1789 }
1790
1791 if (frm->flags & QUIC_FL_TX_FRAME_ACKED) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001792 TRACE_DEVEL("already acked frame", QUIC_EV_CONN_PRSAFRM, qc, frm);
1793 TRACE_DEVEL("freeing frame from packet", QUIC_EV_CONN_PRSAFRM,
Frédéric Lécaille96367152022-04-25 09:40:19 +02001794 qc, frm, &pn);
1795 pool_free(pool_head_quic_frame, frm);
1796 }
1797 else {
Frédéric Lécaille77cb38d2022-04-27 07:17:56 +02001798 if (QUIC_FT_STREAM_8 <= frm->type && frm->type <= QUIC_FT_STREAM_F) {
1799 /* Mark this STREAM frame as lost. A look up their stream descriptor
1800 * will be performed to check the stream is not consumed or released.
1801 */
Amaury Denoyellef372e742022-08-16 14:41:57 +02001802 frm->flags |= QUIC_FL_TX_FRAME_LOST;
Frédéric Lécaille77cb38d2022-04-27 07:17:56 +02001803 }
Frédéric Lécaille96367152022-04-25 09:40:19 +02001804 LIST_APPEND(&tmp, &frm->list);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001805 TRACE_DEVEL("frame requeued", QUIC_EV_CONN_PRSAFRM, qc, frm);
Frédéric Lécaille96367152022-04-25 09:40:19 +02001806 }
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001807 }
1808
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01001809 LIST_SPLICE(pktns_frm_list, &tmp);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001810
1811 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001812}
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001813
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001814/* Free <pkt> TX packet and its attached frames.
Ilya Shipitsin3b64a282022-07-29 22:26:53 +05001815 * This is the responsibility of the caller to remove this packet of
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001816 * any data structure it was possibly attached to.
1817 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001818static inline void free_quic_tx_packet(struct quic_conn *qc,
1819 struct quic_tx_packet *pkt)
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001820{
1821 struct quic_frame *frm, *frmbak;
1822
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001823 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
1824
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001825 if (!pkt)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001826 goto leave;
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001827
1828 list_for_each_entry_safe(frm, frmbak, &pkt->frms, list) {
1829 LIST_DELETE(&frm->list);
1830 pool_free(pool_head_quic_frame, frm);
1831 }
1832 pool_free(pool_head_quic_tx_packet, pkt);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001833
1834 leave:
1835 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01001836}
1837
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001838/* Free the TX packets of <pkts> list */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001839static inline void free_quic_tx_pkts(struct quic_conn *qc, struct list *pkts)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001840{
1841 struct quic_tx_packet *pkt, *tmp;
1842
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001843 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
1844
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001845 list_for_each_entry_safe(pkt, tmp, pkts, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02001846 LIST_DELETE(&pkt->list);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001847 eb64_delete(&pkt->pn_node);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001848 free_quic_tx_packet(qc, pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001849 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001850
1851 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001852}
1853
Frédéric Lécaille141982a2022-03-15 18:44:20 +01001854/* Remove already sent ranges of acknowledged packet numbers from
1855 * <pktns> packet number space tree below <largest_acked_pn> possibly
1856 * updating the range which contains <largest_acked_pn>.
1857 * Never fails.
1858 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001859static void qc_treat_ack_of_ack(struct quic_conn *qc,
1860 struct quic_pktns *pktns,
Frédéric Lécaille141982a2022-03-15 18:44:20 +01001861 int64_t largest_acked_pn)
1862{
1863 struct eb64_node *ar, *next_ar;
1864 struct quic_arngs *arngs = &pktns->rx.arngs;
1865
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001866 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
1867
Frédéric Lécaille141982a2022-03-15 18:44:20 +01001868 ar = eb64_first(&arngs->root);
1869 while (ar) {
1870 struct quic_arng_node *ar_node;
1871
1872 next_ar = eb64_next(ar);
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02001873 ar_node = eb64_entry(ar, struct quic_arng_node, first);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001874
1875 if ((int64_t)ar_node->first.key > largest_acked_pn) {
1876 TRACE_DEVEL("first.key > largest", QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille141982a2022-03-15 18:44:20 +01001877 break;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001878 }
Frédéric Lécaille141982a2022-03-15 18:44:20 +01001879
1880 if (largest_acked_pn < ar_node->last) {
1881 eb64_delete(ar);
1882 ar_node->first.key = largest_acked_pn + 1;
1883 eb64_insert(&arngs->root, ar);
1884 break;
1885 }
1886
1887 eb64_delete(ar);
1888 pool_free(pool_head_quic_arng, ar_node);
1889 arngs->sz--;
1890 ar = next_ar;
1891 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001892
1893 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille141982a2022-03-15 18:44:20 +01001894}
1895
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001896/* Send a packet ack event nofication for each newly acked packet of
1897 * <newly_acked_pkts> list and free them.
1898 * Always succeeds.
1899 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01001900static inline void qc_treat_newly_acked_pkts(struct quic_conn *qc,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001901 struct list *newly_acked_pkts)
1902{
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001903 struct quic_tx_packet *pkt, *tmp;
1904 struct quic_cc_event ev = { .type = QUIC_CC_EVT_ACK, };
1905
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001906 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
1907
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001908 list_for_each_entry_safe(pkt, tmp, newly_acked_pkts, list) {
1909 pkt->pktns->tx.in_flight -= pkt->in_flight_len;
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01001910 qc->path->prep_in_flight -= pkt->in_flight_len;
Frédéric Lécailleba9db402022-03-01 17:06:50 +01001911 qc->path->in_flight -= pkt->in_flight_len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001912 if (pkt->flags & QUIC_FL_TX_PACKET_ACK_ELICITING)
Frédéric Lécaillef7e0b8d2020-12-16 17:33:11 +01001913 qc->path->ifae_pkts--;
Frédéric Lécaille141982a2022-03-15 18:44:20 +01001914 /* If this packet contained an ACK frame, proceed to the
1915 * acknowledging of range of acks from the largest acknowledged
1916 * packet number which was sent in an ACK frame by this packet.
1917 */
1918 if (pkt->largest_acked_pn != -1)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001919 qc_treat_ack_of_ack(qc, pkt->pktns, pkt->largest_acked_pn);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001920 ev.ack.acked = pkt->in_flight_len;
1921 ev.ack.time_sent = pkt->time_sent;
1922 quic_cc_event(&qc->path->cc, &ev);
Willy Tarreau2b718102021-04-21 07:32:39 +02001923 LIST_DELETE(&pkt->list);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001924 eb64_delete(&pkt->pn_node);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02001925 quic_tx_packet_refdec(pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001926 }
1927
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001928 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
1929
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001930}
1931
Frédéric Lécaillee87524d2022-01-19 17:48:40 +01001932/* Release all the frames attached to <pktns> packet number space */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001933static inline void qc_release_pktns_frms(struct quic_conn *qc,
1934 struct quic_pktns *pktns)
Frédéric Lécaillee87524d2022-01-19 17:48:40 +01001935{
1936 struct quic_frame *frm, *frmbak;
1937
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001938 TRACE_ENTER(QUIC_EV_CONN_PHPKTS, qc);
1939
Frédéric Lécaillee87524d2022-01-19 17:48:40 +01001940 list_for_each_entry_safe(frm, frmbak, &pktns->tx.frms, list) {
1941 LIST_DELETE(&frm->list);
1942 pool_free(pool_head_quic_frame, frm);
1943 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001944
1945 TRACE_LEAVE(QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaillee87524d2022-01-19 17:48:40 +01001946}
1947
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001948/* Handle <pkts> list of lost packets detected at <now_us> handling
1949 * their TX frames.
1950 * Send a packet loss event to the congestion controller if
1951 * in flight packet have been lost.
1952 * Also frees the packet in <pkts> list.
1953 * Never fails.
1954 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01001955static inline void qc_release_lost_pkts(struct quic_conn *qc,
1956 struct quic_pktns *pktns,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001957 struct list *pkts,
1958 uint64_t now_us)
1959{
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001960 struct quic_tx_packet *pkt, *tmp, *oldest_lost, *newest_lost;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001961
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02001962 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
1963
Frédéric Lécaille277c4622022-08-24 17:06:04 +02001964 if (LIST_ISEMPTY(pkts))
1965 goto leave;
1966
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001967 oldest_lost = newest_lost = NULL;
1968 list_for_each_entry_safe(pkt, tmp, pkts, list) {
Frédéric Lécaille7065dd02022-01-14 15:51:52 +01001969 struct list tmp = LIST_HEAD_INIT(tmp);
1970
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001971 pkt->pktns->tx.in_flight -= pkt->in_flight_len;
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01001972 qc->path->prep_in_flight -= pkt->in_flight_len;
Frédéric Lécailleba9db402022-03-01 17:06:50 +01001973 qc->path->in_flight -= pkt->in_flight_len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001974 if (pkt->flags & QUIC_FL_TX_PACKET_ACK_ELICITING)
Frédéric Lécaillef7e0b8d2020-12-16 17:33:11 +01001975 qc->path->ifae_pkts--;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001976 /* Treat the frames of this lost packet. */
Frédéric Lécaille96367152022-04-25 09:40:19 +02001977 qc_requeue_nacked_pkt_tx_frms(qc, pkt, &pktns->tx.frms);
Willy Tarreau2b718102021-04-21 07:32:39 +02001978 LIST_DELETE(&pkt->list);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001979 if (!oldest_lost) {
1980 oldest_lost = newest_lost = pkt;
1981 }
1982 else {
1983 if (newest_lost != oldest_lost)
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02001984 quic_tx_packet_refdec(newest_lost);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01001985 newest_lost = pkt;
1986 }
1987 }
1988
Frédéric Lécaillea5ee0ae2022-03-02 14:52:56 +01001989 if (newest_lost) {
1990 /* Sent a congestion event to the controller */
Benoit DOLEZ69e3f052022-06-08 09:28:56 +02001991 struct quic_cc_event ev = { };
1992
1993 ev.type = QUIC_CC_EVT_LOSS;
1994 ev.loss.time_sent = newest_lost->time_sent;
Frédéric Lécaillea5ee0ae2022-03-02 14:52:56 +01001995
1996 quic_cc_event(&qc->path->cc, &ev);
1997 }
1998
1999 /* If an RTT have been already sampled, <rtt_min> has been set.
2000 * We must check if we are experiencing a persistent congestion.
2001 * If this is the case, the congestion controller must re-enter
2002 * slow start state.
2003 */
2004 if (qc->path->loss.rtt_min && newest_lost != oldest_lost) {
2005 unsigned int period = newest_lost->time_sent - oldest_lost->time_sent;
2006
2007 if (quic_loss_persistent_congestion(&qc->path->loss, period,
2008 now_ms, qc->max_ack_delay))
2009 qc->path->cc.algo->slow_start(&qc->path->cc);
2010 }
2011
Frédéric Lécaille277c4622022-08-24 17:06:04 +02002012 quic_tx_packet_refdec(oldest_lost);
2013 if (newest_lost != oldest_lost)
2014 quic_tx_packet_refdec(newest_lost);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002015
Frédéric Lécaille277c4622022-08-24 17:06:04 +02002016 leave:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002017 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002018}
2019
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002020/* Parse ACK frame into <frm> from a buffer at <buf> address with <end> being at
2021 * one byte past the end of this buffer. Also update <rtt_sample> if needed, i.e.
Ilya Shipitsin1e9a6662021-01-05 22:10:46 +05002022 * if the largest acked packet was newly acked and if there was at least one newly
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002023 * acked ack-eliciting packet.
2024 * Return 1, if succeeded, 0 if not.
2025 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002026static inline int qc_parse_ack_frm(struct quic_conn *qc,
2027 struct quic_frame *frm,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002028 struct quic_enc_level *qel,
2029 unsigned int *rtt_sample,
2030 const unsigned char **pos, const unsigned char *end)
2031{
2032 struct quic_ack *ack = &frm->ack;
2033 uint64_t smallest, largest;
2034 struct eb_root *pkts;
2035 struct eb64_node *largest_node;
2036 unsigned int time_sent, pkt_flags;
2037 struct list newly_acked_pkts = LIST_HEAD_INIT(newly_acked_pkts);
2038 struct list lost_pkts = LIST_HEAD_INIT(lost_pkts);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002039 int ret = 0;
2040
2041 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002042
2043 if (ack->largest_ack > qel->pktns->tx.next_pn) {
2044 TRACE_DEVEL("ACK for not sent packet", QUIC_EV_CONN_PRSAFRM,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002045 qc, NULL, &ack->largest_ack);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002046 goto err;
2047 }
2048
2049 if (ack->first_ack_range > ack->largest_ack) {
2050 TRACE_DEVEL("too big first ACK range", QUIC_EV_CONN_PRSAFRM,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002051 qc, NULL, &ack->first_ack_range);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002052 goto err;
2053 }
2054
2055 largest = ack->largest_ack;
2056 smallest = largest - ack->first_ack_range;
2057 pkts = &qel->pktns->tx.pkts;
2058 pkt_flags = 0;
2059 largest_node = NULL;
2060 time_sent = 0;
2061
Frédéric Lécaille205e4f32022-03-28 17:38:27 +02002062 if ((int64_t)ack->largest_ack > qel->pktns->rx.largest_acked_pn) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002063 largest_node = eb64_lookup(pkts, largest);
2064 if (!largest_node) {
2065 TRACE_DEVEL("Largest acked packet not found",
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002066 QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille83b7a5b2021-11-17 16:16:04 +01002067 }
2068 else {
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02002069 time_sent = eb64_entry(largest_node,
Frédéric Lécaille83b7a5b2021-11-17 16:16:04 +01002070 struct quic_tx_packet, pn_node)->time_sent;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002071 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002072 }
2073
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002074 TRACE_PROTO("rcvd ack range", QUIC_EV_CONN_PRSAFRM,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002075 qc, NULL, &largest, &smallest);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002076 do {
2077 uint64_t gap, ack_range;
2078
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002079 qc_ackrng_pkts(qc, pkts, &pkt_flags, &newly_acked_pkts,
2080 largest_node, largest, smallest);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002081 if (!ack->ack_range_num--)
2082 break;
2083
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002084 if (!quic_dec_int(&gap, pos, end)) {
2085 TRACE_ERROR("quic_dec_int(gap) failed", QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002086 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002087 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002088
2089 if (smallest < gap + 2) {
2090 TRACE_DEVEL("wrong gap value", QUIC_EV_CONN_PRSAFRM,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002091 qc, NULL, &gap, &smallest);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002092 goto err;
2093 }
2094
2095 largest = smallest - gap - 2;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002096 if (!quic_dec_int(&ack_range, pos, end)) {
2097 TRACE_ERROR("quic_dec_int(ack_range) failed", QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002098 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002099 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002100
2101 if (largest < ack_range) {
2102 TRACE_DEVEL("wrong ack range value", QUIC_EV_CONN_PRSAFRM,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002103 qc, NULL, &largest, &ack_range);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002104 goto err;
2105 }
2106
2107 /* Do not use this node anymore. */
2108 largest_node = NULL;
2109 /* Next range */
2110 smallest = largest - ack_range;
2111
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002112 TRACE_PROTO("rcvd next ack range", QUIC_EV_CONN_PRSAFRM,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002113 qc, NULL, &largest, &smallest);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002114 } while (1);
2115
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002116 if (time_sent && (pkt_flags & QUIC_FL_TX_PACKET_ACK_ELICITING)) {
2117 *rtt_sample = tick_remain(time_sent, now_ms);
Frédéric Lécaille205e4f32022-03-28 17:38:27 +02002118 qel->pktns->rx.largest_acked_pn = ack->largest_ack;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002119 }
2120
2121 if (!LIST_ISEMPTY(&newly_acked_pkts)) {
2122 if (!eb_is_empty(&qel->pktns->tx.pkts)) {
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002123 qc_packet_loss_lookup(qel->pktns, qc, &lost_pkts);
Frédéric Lécaille277c4622022-08-24 17:06:04 +02002124 qc_release_lost_pkts(qc, qel->pktns, &lost_pkts, now_ms);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002125 }
Amaury Denoyellee81fed92021-12-22 11:06:34 +01002126 qc_treat_newly_acked_pkts(qc, &newly_acked_pkts);
2127 if (quic_peer_validated_addr(qc))
2128 qc->path->loss.pto_count = 0;
2129 qc_set_timer(qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002130 }
2131
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002132 ret = 1;
2133 leave:
2134 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
2135 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002136
2137 err:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002138 free_quic_tx_pkts(qc, &newly_acked_pkts);
2139 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002140}
2141
Frédéric Lécaille6f0fadb2021-09-28 09:04:12 +02002142/* This function gives the detail of the SSL error. It is used only
2143 * if the debug mode and the verbose mode are activated. It dump all
2144 * the SSL error until the stack was empty.
2145 */
2146static forceinline void qc_ssl_dump_errors(struct connection *conn)
2147{
2148 if (unlikely(global.mode & MODE_DEBUG)) {
2149 while (1) {
Willy Tarreau325fc632022-04-11 18:47:38 +02002150 const char *func = NULL;
Frédéric Lécaille6f0fadb2021-09-28 09:04:12 +02002151 unsigned long ret;
2152
Willy Tarreau325fc632022-04-11 18:47:38 +02002153 ERR_peek_error_func(&func);
Frédéric Lécaille6f0fadb2021-09-28 09:04:12 +02002154 ret = ERR_get_error();
2155 if (!ret)
2156 return;
2157
2158 fprintf(stderr, "conn. @%p OpenSSL error[0x%lx] %s: %s\n", conn, ret,
Willy Tarreau325fc632022-04-11 18:47:38 +02002159 func, ERR_reason_error_string(ret));
Frédéric Lécaille6f0fadb2021-09-28 09:04:12 +02002160 }
2161 }
2162}
2163
Amaury Denoyelle71e588c2021-11-12 11:23:29 +01002164int ssl_sock_get_alpn(const struct connection *conn, void *xprt_ctx,
2165 const char **str, int *len);
2166
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002167/* Provide CRYPTO data to the TLS stack found at <data> with <len> as length
2168 * from <qel> encryption level with <ctx> as QUIC connection context.
Ilya Shipitsin1e9a6662021-01-05 22:10:46 +05002169 * Remaining parameter are there for debugging purposes.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002170 * Return 1 if succeeded, 0 if not.
2171 */
2172static inline int qc_provide_cdata(struct quic_enc_level *el,
Frédéric Lécaille1eaec332021-06-04 14:59:59 +02002173 struct ssl_sock_ctx *ctx,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002174 const unsigned char *data, size_t len,
2175 struct quic_rx_packet *pkt,
2176 struct quic_rx_crypto_frm *cf)
2177{
Frédéric Lécailleeed7a7d2021-08-18 09:16:01 +02002178 int ssl_err, state;
Frédéric Lécaillea5fe49f2021-06-04 11:52:35 +02002179 struct quic_conn *qc;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002180 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002181
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002182 ssl_err = SSL_ERROR_NONE;
Amaury Denoyellec15dd922021-12-21 11:41:52 +01002183 qc = ctx->qc;
2184
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01002185 TRACE_ENTER(QUIC_EV_CONN_SSLDATA, qc);
2186
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002187 if (SSL_provide_quic_data(ctx->ssl, el->level, data, len) != 1) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002188 TRACE_ERROR("SSL_provide_quic_data() error",
Frédéric Lécaillefde2a982021-12-27 15:12:09 +01002189 QUIC_EV_CONN_SSLDATA, qc, pkt, cf, ctx->ssl);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002190 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002191 }
2192
2193 el->rx.crypto.offset += len;
2194 TRACE_PROTO("in order CRYPTO data",
Frédéric Lécaillee7ff2b22021-12-22 17:40:38 +01002195 QUIC_EV_CONN_SSLDATA, qc, NULL, cf, ctx->ssl);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002196
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002197 state = qc->state;
Frédéric Lécailleeed7a7d2021-08-18 09:16:01 +02002198 if (state < QUIC_HS_ST_COMPLETE) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002199 ssl_err = SSL_do_handshake(ctx->ssl);
2200 if (ssl_err != 1) {
2201 ssl_err = SSL_get_error(ctx->ssl, ssl_err);
2202 if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002203 TRACE_PROTO("SSL handshake in progress",
Frédéric Lécaille00e24002022-02-18 17:13:45 +01002204 QUIC_EV_CONN_IO_CB, qc, &state, &ssl_err);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002205 goto out;
2206 }
2207
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02002208 /* TODO: Should close the connection asap */
2209 if (!(qc->flags & QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED)) {
2210 qc->flags |= QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED;
2211 HA_ATOMIC_DEC(&qc->prx_counters->half_open_conn);
2212 HA_ATOMIC_INC(&qc->prx_counters->hdshk_fail);
2213 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002214 TRACE_ERROR("SSL handshake error", QUIC_EV_CONN_IO_CB, qc, &state, &ssl_err);
Frédéric Lécaille7c881bd2021-09-28 09:05:59 +02002215 qc_ssl_dump_errors(ctx->conn);
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01002216 ERR_clear_error();
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002217 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002218 }
2219
Frédéric Lécaille00e24002022-02-18 17:13:45 +01002220 TRACE_PROTO("SSL handshake OK", QUIC_EV_CONN_IO_CB, qc, &state);
Frédéric Lécaillebc964bd2022-04-13 16:20:09 +02002221
2222 /* Check the alpn could be negotiated */
2223 if (!qc->app_ops) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002224 TRACE_ERROR("No negotiated ALPN", QUIC_EV_CONN_IO_CB, qc, &state);
Frédéric Lécaillebc964bd2022-04-13 16:20:09 +02002225 quic_set_tls_alert(qc, SSL_AD_NO_APPLICATION_PROTOCOL);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002226 goto leave;
Frédéric Lécaillebc964bd2022-04-13 16:20:09 +02002227 }
2228
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02002229 if (!(qc->flags & QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002230 TRACE_DEVEL("dec half open counter", QUIC_EV_CONN_IO_CB, qc, &state);
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02002231 qc->flags |= QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED;
2232 HA_ATOMIC_DEC(&qc->prx_counters->half_open_conn);
2233 }
Frédéric Lécaille00e24002022-02-18 17:13:45 +01002234 /* I/O callback switch */
2235 ctx->wait_event.tasklet->process = quic_conn_app_io_cb;
Amaury Denoyellecfa2d562022-01-19 16:01:05 +01002236 if (qc_is_listener(ctx->qc)) {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002237 qc->state = QUIC_HS_ST_CONFIRMED;
Amaury Denoyellecfa2d562022-01-19 16:01:05 +01002238 /* The connection is ready to be accepted. */
2239 quic_accept_push_qc(qc);
2240 }
2241 else {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002242 qc->state = QUIC_HS_ST_COMPLETE;
Amaury Denoyellecfa2d562022-01-19 16:01:05 +01002243 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002244 } else {
2245 ssl_err = SSL_process_quic_post_handshake(ctx->ssl);
2246 if (ssl_err != 1) {
2247 ssl_err = SSL_get_error(ctx->ssl, ssl_err);
2248 if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002249 TRACE_PROTO("SSL post handshake in progress",
Frédéric Lécaille00e24002022-02-18 17:13:45 +01002250 QUIC_EV_CONN_IO_CB, qc, &state, &ssl_err);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002251 goto out;
2252 }
2253
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002254 TRACE_ERROR("SSL post handshake error",
Frédéric Lécaille00e24002022-02-18 17:13:45 +01002255 QUIC_EV_CONN_IO_CB, qc, &state, &ssl_err);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002256 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002257 }
2258
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002259 TRACE_STATE("SSL post handshake succeeded", QUIC_EV_CONN_IO_CB, qc, &state);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002260 }
Amaury Denoyellee2288c32021-12-03 14:44:21 +01002261
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002262 out:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002263 ret = 1;
2264 leave:
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01002265 TRACE_LEAVE(QUIC_EV_CONN_SSLDATA, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002266 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002267}
2268
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +02002269/* Parse a STREAM frame <strm_frm>
2270 *
2271 * Return 1 on success. On error, 0 is returned. In this case, the packet
2272 * containing the frame must not be acknowledged.
Amaury Denoyelle74cf2372022-04-29 15:58:22 +02002273 */
Frédéric Lécailledfbae762021-02-18 09:59:01 +01002274static inline int qc_handle_strm_frm(struct quic_rx_packet *pkt,
2275 struct quic_stream *strm_frm,
2276 struct quic_conn *qc)
2277{
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +02002278 int ret;
2279
Amaury Denoyelle74cf2372022-04-29 15:58:22 +02002280 /* RFC9000 13.1. Packet Processing
2281 *
2282 * A packet MUST NOT be acknowledged until packet protection has been
2283 * successfully removed and all frames contained in the packet have
2284 * been processed. For STREAM frames, this means the data has been
2285 * enqueued in preparation to be received by the application protocol,
2286 * but it does not require that data be delivered and consumed.
2287 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002288 TRACE_ENTER(QUIC_EV_CONN_PRSFRM, qc);
2289
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +02002290 ret = qcc_recv(qc->qcc, strm_frm->id, strm_frm->len,
2291 strm_frm->offset.key, strm_frm->fin,
2292 (char *)strm_frm->data);
Amaury Denoyelle74cf2372022-04-29 15:58:22 +02002293
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +02002294 /* frame rejected - packet must not be acknowledeged */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002295 TRACE_LEAVE(QUIC_EV_CONN_PRSFRM, qc);
2296 return !ret;
Frédéric Lécailledfbae762021-02-18 09:59:01 +01002297}
2298
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002299/* Duplicate all frames from <pkt_frm_list> list into <out_frm_list> list
2300 * for <qc> QUIC connection.
2301 * This is a best effort function which never fails even if no memory could be
2302 * allocated to duplicate these frames.
2303 */
2304static void qc_dup_pkt_frms(struct quic_conn *qc,
2305 struct list *pkt_frm_list, struct list *out_frm_list)
2306{
2307 struct quic_frame *frm, *frmbak;
2308 struct list tmp = LIST_HEAD_INIT(tmp);
2309
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002310 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
2311
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002312 list_for_each_entry_safe(frm, frmbak, pkt_frm_list, list) {
2313 struct quic_frame *dup_frm, *origin;
2314
2315 switch (frm->type) {
2316 case QUIC_FT_STREAM_8 ... QUIC_FT_STREAM_F:
2317 {
2318 struct quic_stream *strm_frm = &frm->stream;
2319 struct eb64_node *node = NULL;
2320 struct qc_stream_desc *stream_desc;
2321
2322 node = eb64_lookup(&qc->streams_by_id, strm_frm->id);
2323 if (!node) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002324 TRACE_DEVEL("ignored frame for a released stream", QUIC_EV_CONN_PRSAFRM, qc, frm);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002325 continue;
2326 }
2327
2328 stream_desc = eb64_entry(node, struct qc_stream_desc, by_id);
2329 /* Do not resend this frame if in the "already acked range" */
2330 if (strm_frm->offset.key + strm_frm->len <= stream_desc->ack_offset) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002331 TRACE_DEVEL("ignored frame in already acked range",
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002332 QUIC_EV_CONN_PRSAFRM, qc, frm);
2333 continue;
2334 }
2335 else if (strm_frm->offset.key < stream_desc->ack_offset) {
2336 strm_frm->offset.key = stream_desc->ack_offset;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002337 TRACE_DEVEL("updated partially acked frame",
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002338 QUIC_EV_CONN_PRSAFRM, qc, frm);
2339 }
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002340 break;
2341 }
2342
2343 default:
2344 break;
2345 }
2346
Frédéric Lécaille4173a392022-08-18 08:20:47 +02002347 dup_frm = pool_alloc(pool_head_quic_frame);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002348 if (!dup_frm) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002349 TRACE_ERROR("could not duplicate frame", QUIC_EV_CONN_PRSAFRM, qc, frm);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002350 break;
2351 }
2352
2353 /* If <frm> is already a copy of another frame, we must take
2354 * its original frame as source for the copy.
2355 */
2356 origin = frm->origin ? frm->origin : frm;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002357 TRACE_DEVEL("built probing frame", QUIC_EV_CONN_PRSAFRM, qc, origin);
Frédéric Lécaillee35463c2022-08-27 10:19:42 +02002358 if (origin->pkt)
2359 TRACE_DEVEL("duplicated from packet", QUIC_EV_CONN_PRSAFRM,
2360 qc, NULL, &origin->pkt->pn_node.key);
2361 else {
2362 /* <origin> is a frame which was sent from a packet detected as lost. */
2363 TRACE_DEVEL("duplicated from lost packet", QUIC_EV_CONN_PRSAFRM, qc);
2364 }
Frédéric Lécaille4173a392022-08-18 08:20:47 +02002365 *dup_frm = *origin;
2366 dup_frm->pkt = NULL;
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002367 dup_frm->origin = origin;
Frédéric Lécaille4173a392022-08-18 08:20:47 +02002368 dup_frm->flags = 0;
2369 LIST_INIT(&dup_frm->reflist);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002370 LIST_APPEND(&origin->reflist, &dup_frm->ref);
2371 LIST_APPEND(&tmp, &dup_frm->list);
2372 }
2373
2374 LIST_SPLICE(out_frm_list, &tmp);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002375
2376 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02002377}
2378
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002379/* Prepare a fast retransmission from <qel> encryption level */
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002380static void qc_prep_fast_retrans(struct quic_conn *qc,
2381 struct quic_enc_level *qel,
2382 struct list *frms1, struct list *frms2)
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002383{
2384 struct eb_root *pkts = &qel->pktns->tx.pkts;
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002385 struct list *frms = frms1;
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002386 struct eb64_node *node;
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002387 struct quic_tx_packet *pkt;
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002388
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002389 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
2390
2391 BUG_ON(frms1 == frms2);
2392
Frédéric Lécaillef010f0a2022-01-06 17:28:05 +01002393 pkt = NULL;
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002394 node = eb64_first(pkts);
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002395 start:
Frédéric Lécaillef010f0a2022-01-06 17:28:05 +01002396 while (node) {
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002397 pkt = eb64_entry(node, struct quic_tx_packet, pn_node);
2398 node = eb64_next(node);
2399 /* Skip the empty and coalesced packets */
Frédéric Lécailleb44cbc62022-04-21 17:58:46 +02002400 if (!LIST_ISEMPTY(&pkt->frms) && !(pkt->flags & QUIC_FL_TX_PACKET_COALESCED))
Frédéric Lécaillef010f0a2022-01-06 17:28:05 +01002401 break;
Frédéric Lécaillef010f0a2022-01-06 17:28:05 +01002402 }
2403
2404 if (!pkt)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002405 goto leave;
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002406
Frédéric Lécaille12fd2592022-03-31 08:42:06 +02002407 /* When building a packet from another one, the field which may increase the
2408 * packet size is the packet number. And the maximum increase is 4 bytes.
2409 */
2410 if (!quic_peer_validated_addr(qc) && qc_is_listener(qc) &&
2411 pkt->len + 4 > 3 * qc->rx.bytes - qc->tx.prep_bytes) {
2412 TRACE_PROTO("anti-amplification limit would be reached", QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002413 goto leave;
Frédéric Lécaille12fd2592022-03-31 08:42:06 +02002414 }
2415
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002416 TRACE_DEVEL("duplicating packet", QUIC_EV_CONN_PRSAFRM, qc, NULL, &pkt->pn_node.key);
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002417 qc_dup_pkt_frms(qc, &pkt->frms, frms);
2418 if (frms == frms1 && frms2) {
2419 frms = frms2;
2420 goto start;
2421 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002422 leave:
2423 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002424}
2425
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002426/* Prepare a fast retransmission during a handshake after a client
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002427 * has resent Initial packets. According to the RFC a server may retransmit
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002428 * Initial packets send them coalescing with others (Handshake here).
2429 * (Listener only function).
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002430 */
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002431static void qc_prep_hdshk_fast_retrans(struct quic_conn *qc,
2432 struct list *ifrms, struct list *hfrms)
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002433{
2434 struct list itmp = LIST_HEAD_INIT(itmp);
2435 struct list htmp = LIST_HEAD_INIT(htmp);
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002436
2437 struct quic_enc_level *iqel = &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL];
2438 struct quic_enc_level *hqel = &qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE];
2439 struct quic_enc_level *qel = iqel;
2440 struct eb_root *pkts;
2441 struct eb64_node *node;
2442 struct quic_tx_packet *pkt;
2443 struct list *tmp = &itmp;
2444
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002445 TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002446 start:
2447 pkt = NULL;
2448 pkts = &qel->pktns->tx.pkts;
2449 node = eb64_first(pkts);
2450 /* Skip the empty packet (they have already been retransmitted) */
2451 while (node) {
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02002452 pkt = eb64_entry(node, struct quic_tx_packet, pn_node);
Frédéric Lécailleb44cbc62022-04-21 17:58:46 +02002453 if (!LIST_ISEMPTY(&pkt->frms) && !(pkt->flags & QUIC_FL_TX_PACKET_COALESCED))
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002454 break;
2455 node = eb64_next(node);
2456 }
2457
2458 if (!pkt)
2459 goto end;
2460
Frédéric Lécaille12fd2592022-03-31 08:42:06 +02002461 /* When building a packet from another one, the field which may increase the
2462 * packet size is the packet number. And the maximum increase is 4 bytes.
2463 */
2464 if (!quic_peer_validated_addr(qc) && qc_is_listener(qc) &&
2465 pkt->len + 4 > 3 * qc->rx.bytes - qc->tx.prep_bytes) {
2466 TRACE_PROTO("anti-amplification limit would be reached", QUIC_EV_CONN_PRSAFRM, qc);
2467 goto end;
2468 }
2469
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002470 qel->pktns->tx.pto_probe += 1;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002471
2472 /* No risk to loop here, #packet per datagram is bounded */
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002473 requeue:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002474 TRACE_DEVEL("duplicating packet", QUIC_EV_CONN_PRSAFRM, qc, NULL, &pkt->pn_node.key);
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002475 qc_dup_pkt_frms(qc, &pkt->frms, tmp);
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002476 if (qel == iqel) {
2477 if (pkt->next && pkt->next->type == QUIC_PACKET_TYPE_HANDSHAKE) {
2478 pkt = pkt->next;
2479 tmp = &htmp;
2480 hqel->pktns->tx.pto_probe += 1;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002481 TRACE_DEVEL("looping for next packet", QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002482 goto requeue;
2483 }
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002484 }
Frédéric Lécaille04e63aa2022-01-17 18:16:27 +01002485
2486 end:
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002487 LIST_SPLICE(ifrms, &itmp);
2488 LIST_SPLICE(hfrms, &htmp);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002489
2490 TRACE_LEAVE(QUIC_EV_CONN_PRSAFRM, qc);
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002491}
2492
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02002493static void qc_cc_err_count_inc(struct quic_conn *qc, struct quic_frame *frm)
Frédéric Lécaille3ccea6d2022-05-23 22:54:54 +02002494{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002495 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
2496
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02002497 if (frm->type == QUIC_FT_CONNECTION_CLOSE)
2498 quic_stats_transp_err_count_inc(qc->prx_counters, frm->connection_close.error_code);
2499 else if (frm->type == QUIC_FT_CONNECTION_CLOSE_APP) {
2500 if (qc->mux_state != QC_MUX_READY || !qc->qcc->app_ops->inc_err_cnt)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002501 goto out;
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02002502
2503 qc->qcc->app_ops->inc_err_cnt(qc->qcc->ctx, frm->connection_close_app.error_code);
2504 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002505
2506 out:
2507 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Frédéric Lécaille3ccea6d2022-05-23 22:54:54 +02002508}
2509
Frédéric Lécaille4df2fe92022-05-29 11:36:03 +02002510/* Enqueue a STOP_SENDING frame to send into 1RTT packet number space
2511 * frame list to send.
2512 * Return 1 if succeeded, 0 if not.
2513 */
2514static int qc_stop_sending_frm_enqueue(struct quic_conn *qc, uint64_t id)
2515{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002516 int ret = 0;
Frédéric Lécaille4df2fe92022-05-29 11:36:03 +02002517 struct quic_frame *frm;
2518 struct quic_enc_level *qel = &qc->els[QUIC_TLS_ENC_LEVEL_APP];
2519 uint64_t app_error_code;
2520
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002521 TRACE_ENTER(QUIC_EV_CONN_PRSHPKT, qc);
2522
Frédéric Lécaille4df2fe92022-05-29 11:36:03 +02002523 /* TODO: the mux may be released, we cannot have more
2524 * information about the application error code to send
2525 * at this time.
2526 */
2527 app_error_code = H3_REQUEST_REJECTED;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002528 // fixme: zalloc
Frédéric Lécaille4df2fe92022-05-29 11:36:03 +02002529 frm = pool_zalloc(pool_head_quic_frame);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002530 if (!frm) {
2531 TRACE_ERROR("failed to allocate quic_frame", QUIC_EV_CONN_PRSHPKT, qc);
2532 goto out;
2533 }
Frédéric Lécaille4df2fe92022-05-29 11:36:03 +02002534
2535 frm->type = QUIC_FT_STOP_SENDING;
2536 frm->stop_sending.id = id;
2537 frm->stop_sending.app_error_code = app_error_code;
2538 LIST_INIT(&frm->reflist);
2539 LIST_APPEND(&qel->pktns->tx.frms, &frm->list);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002540 ret = 1;
2541 out:
2542 TRACE_LEAVE(QUIC_EV_CONN_PRSHPKT, qc);
2543 return ret;
Frédéric Lécaille4df2fe92022-05-29 11:36:03 +02002544}
2545
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002546/* Parse all the frames of <pkt> QUIC packet for QUIC connection with <ctx>
2547 * as I/O handler context and <qel> as encryption level.
2548 * Returns 1 if succeeded, 0 if failed.
2549 */
Frédéric Lécaille1eaec332021-06-04 14:59:59 +02002550static int qc_parse_pkt_frms(struct quic_rx_packet *pkt, struct ssl_sock_ctx *ctx,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002551 struct quic_enc_level *qel)
2552{
2553 struct quic_frame frm;
2554 const unsigned char *pos, *end;
Amaury Denoyellec15dd922021-12-21 11:41:52 +01002555 struct quic_conn *qc = ctx->qc;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002556 int fast_retrans = 0, ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002557
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01002558 TRACE_ENTER(QUIC_EV_CONN_PRSHPKT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002559 /* Skip the AAD */
2560 pos = pkt->data + pkt->aad_len;
2561 end = pkt->data + pkt->len;
2562
2563 while (pos < end) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002564 if (!qc_parse_frm(&frm, pkt, &pos, end, qc)) {
2565 // trace already emitted by function above
2566 goto leave;
2567 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002568
Frédéric Lécaille1ede8232021-12-23 14:11:25 +01002569 TRACE_PROTO("RX frame", QUIC_EV_CONN_PSTRM, qc, &frm);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002570 switch (frm.type) {
Frédéric Lécaille0c140202020-12-09 15:56:48 +01002571 case QUIC_FT_PADDING:
Frédéric Lécaille0c140202020-12-09 15:56:48 +01002572 break;
2573 case QUIC_FT_PING:
2574 break;
2575 case QUIC_FT_ACK:
2576 {
2577 unsigned int rtt_sample;
2578
2579 rtt_sample = 0;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002580 if (!qc_parse_ack_frm(qc, &frm, qel, &rtt_sample, &pos, end)) {
2581 // trace already emitted by function above
2582 goto leave;
2583 }
Frédéric Lécaille0c140202020-12-09 15:56:48 +01002584
2585 if (rtt_sample) {
2586 unsigned int ack_delay;
2587
Amaury Denoyelle17a74162021-12-21 14:45:39 +01002588 ack_delay = !quic_application_pktns(qel->pktns, qc) ? 0 :
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002589 qc->state >= QUIC_HS_ST_CONFIRMED ?
Frédéric Lécaille22576a22021-12-28 14:27:43 +01002590 MS_TO_TICKS(QUIC_MIN(quic_ack_delay_ms(&frm.ack, qc), qc->max_ack_delay)) :
2591 MS_TO_TICKS(quic_ack_delay_ms(&frm.ack, qc));
Amaury Denoyelle17a74162021-12-21 14:45:39 +01002592 quic_loss_srtt_update(&qc->path->loss, rtt_sample, ack_delay, qc);
Frédéric Lécaille0c140202020-12-09 15:56:48 +01002593 }
Frédéric Lécaille0c140202020-12-09 15:56:48 +01002594 break;
2595 }
Frédéric Lécaillee06ca652022-05-29 11:48:58 +02002596 case QUIC_FT_RESET_STREAM:
2597 /* TODO: handle this frame at STREAM level */
2598 break;
Frédéric Lécailled8b84432021-12-10 15:18:36 +01002599 case QUIC_FT_STOP_SENDING:
Amaury Denoyellea5b50752022-07-04 11:44:53 +02002600 {
2601 struct quic_stop_sending *stop_sending = &frm.stop_sending;
2602 if (qc->mux_state == QC_MUX_READY) {
2603 if (qcc_recv_stop_sending(qc->qcc, stop_sending->id,
2604 stop_sending->app_error_code)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002605 TRACE_ERROR("qcc_recv_stop_sending() failed", QUIC_EV_CONN_PRSHPKT, qc);
2606 goto leave;
Amaury Denoyellea5b50752022-07-04 11:44:53 +02002607 }
2608 }
Frédéric Lécailled8b84432021-12-10 15:18:36 +01002609 break;
Amaury Denoyellea5b50752022-07-04 11:44:53 +02002610 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002611 case QUIC_FT_CRYPTO:
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002612 {
2613 struct quic_rx_crypto_frm *cf;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002614
Frédéric Lécaillebd242082022-02-25 17:17:59 +01002615 if (unlikely(qel->tls_ctx.flags & QUIC_FL_TLS_SECRETS_DCD)) {
Frédéric Lécaille917a7db2022-01-03 17:00:35 +01002616 /* XXX TO DO: <cfdebug> is used only for the traces. */
2617 struct quic_rx_crypto_frm cfdebug = { };
2618
2619 cfdebug.offset_node.key = frm.crypto.offset;
2620 cfdebug.len = frm.crypto.len;
2621 TRACE_PROTO("CRYPTO data discarded",
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002622 QUIC_EV_CONN_RXPKT, qc, pkt, &cfdebug);
Frédéric Lécaille917a7db2022-01-03 17:00:35 +01002623 break;
2624 }
2625
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002626 if (unlikely(frm.crypto.offset < qel->rx.crypto.offset)) {
2627 if (frm.crypto.offset + frm.crypto.len <= qel->rx.crypto.offset) {
2628 /* XXX TO DO: <cfdebug> is used only for the traces. */
2629 struct quic_rx_crypto_frm cfdebug = { };
2630
2631 cfdebug.offset_node.key = frm.crypto.offset;
2632 cfdebug.len = frm.crypto.len;
2633 /* Nothing to do */
2634 TRACE_PROTO("Already received CRYPTO data",
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002635 QUIC_EV_CONN_RXPKT, qc, pkt, &cfdebug);
Frédéric Lécaille2fe8b3b2022-01-10 12:10:10 +01002636 if (qc_is_listener(ctx->qc) &&
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002637 qel == &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL])
2638 fast_retrans = 1;
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002639 break;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002640 }
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002641 else {
2642 size_t diff = qel->rx.crypto.offset - frm.crypto.offset;
2643 /* XXX TO DO: <cfdebug> is used only for the traces. */
2644 struct quic_rx_crypto_frm cfdebug = { };
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002645
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002646 cfdebug.offset_node.key = frm.crypto.offset;
2647 cfdebug.len = frm.crypto.len;
2648 TRACE_PROTO("Partially already received CRYPTO data",
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002649 QUIC_EV_CONN_RXPKT, qc, pkt, &cfdebug);
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002650 frm.crypto.len -= diff;
2651 frm.crypto.data += diff;
2652 frm.crypto.offset = qel->rx.crypto.offset;
2653 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002654 }
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002655
2656 if (frm.crypto.offset == qel->rx.crypto.offset) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002657 /* XXX TO DO: <cf> is used only for the traces. */
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002658 struct quic_rx_crypto_frm cfdebug = { };
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002659
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002660 cfdebug.offset_node.key = frm.crypto.offset;
2661 cfdebug.len = frm.crypto.len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002662 if (!qc_provide_cdata(qel, ctx,
2663 frm.crypto.data, frm.crypto.len,
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002664 pkt, &cfdebug)) {
2665 // trace already emitted by function above
2666 goto leave;
2667 }
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002668
2669 break;
2670 }
2671
2672 /* frm.crypto.offset > qel->rx.crypto.offset */
2673 cf = pool_alloc(pool_head_quic_rx_crypto_frm);
2674 if (!cf) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002675 TRACE_ERROR("CRYPTO frame allocation failed",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01002676 QUIC_EV_CONN_PRSHPKT, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002677 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002678 }
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002679
2680 cf->offset_node.key = frm.crypto.offset;
2681 cf->len = frm.crypto.len;
2682 cf->data = frm.crypto.data;
2683 cf->pkt = pkt;
2684 eb64_insert(&qel->rx.crypto.frms, &cf->offset_node);
2685 quic_rx_packet_refinc(pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002686 break;
Frédéric Lécaillef9cb3a92021-12-02 11:25:58 +01002687 }
Frédéric Lécailled8b84432021-12-10 15:18:36 +01002688 case QUIC_FT_STREAM_8 ... QUIC_FT_STREAM_F:
Frédéric Lécaille242fb1b2020-12-31 12:45:38 +01002689 {
2690 struct quic_stream *stream = &frm.stream;
Frédéric Lécailled62240c2022-05-02 18:52:58 +02002691 unsigned nb_streams = qc->rx.strms[qcs_id_type(stream->id)].nb_streams;
Frédéric Lécaille242fb1b2020-12-31 12:45:38 +01002692
Frédéric Lécailled62240c2022-05-02 18:52:58 +02002693 /* The upper layer may not be allocated. */
2694 if (qc->mux_state != QC_MUX_READY) {
2695 if ((stream->id >> QCS_ID_TYPE_SHIFT) < nb_streams) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002696 TRACE_DATA("Already closed stream", QUIC_EV_CONN_PRSHPKT, qc);
Frédéric Lécailled62240c2022-05-02 18:52:58 +02002697 break;
2698 }
2699 else {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002700 TRACE_DEVEL("No mux for new stream", QUIC_EV_CONN_PRSHPKT, qc);
Frédéric Lécaille4df2fe92022-05-29 11:36:03 +02002701 if (!qc_stop_sending_frm_enqueue(qc, stream->id))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002702 TRACE_ERROR("could not enqueue STOP_SENDING frame", QUIC_EV_CONN_PRSHPKT, qc);
2703 /* This packet will not be acknowledged */
2704 goto leave;
Frédéric Lécailled62240c2022-05-02 18:52:58 +02002705 }
2706 }
Frédéric Lécaille12aa26b2022-03-21 11:37:13 +01002707
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002708 if (!qc_handle_strm_frm(pkt, stream, qc)) {
2709 TRACE_ERROR("qc_handle_strm_frm() failed", QUIC_EV_CONN_PRSHPKT, qc);
2710 goto leave;
2711 }
Frédéric Lécailledfbae762021-02-18 09:59:01 +01002712
Frédéric Lécaille242fb1b2020-12-31 12:45:38 +01002713 break;
2714 }
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002715 case QUIC_FT_MAX_DATA:
Amaury Denoyelle1e5e5132022-03-08 16:23:03 +01002716 if (qc->mux_state == QC_MUX_READY) {
2717 struct quic_max_data *data = &frm.max_data;
2718 qcc_recv_max_data(qc->qcc, data->max_data);
2719 }
2720 break;
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002721 case QUIC_FT_MAX_STREAM_DATA:
Amaury Denoyelle8727ff42022-03-08 10:39:55 +01002722 if (qc->mux_state == QC_MUX_READY) {
2723 struct quic_max_stream_data *data = &frm.max_stream_data;
Amaury Denoyelleb68559a2022-07-06 15:45:20 +02002724 if (qcc_recv_max_stream_data(qc->qcc, data->id,
2725 data->max_stream_data)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002726 TRACE_ERROR("qcc_recv_max_stream_data() failed", QUIC_EV_CONN_PRSHPKT, qc);
2727 goto leave;
Amaury Denoyelleb68559a2022-07-06 15:45:20 +02002728 }
Amaury Denoyelle8727ff42022-03-08 10:39:55 +01002729 }
2730 break;
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002731 case QUIC_FT_MAX_STREAMS_BIDI:
2732 case QUIC_FT_MAX_STREAMS_UNI:
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02002733 break;
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002734 case QUIC_FT_DATA_BLOCKED:
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02002735 HA_ATOMIC_INC(&qc->prx_counters->data_blocked);
2736 break;
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002737 case QUIC_FT_STREAM_DATA_BLOCKED:
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02002738 HA_ATOMIC_INC(&qc->prx_counters->stream_data_blocked);
2739 break;
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002740 case QUIC_FT_STREAMS_BLOCKED_BIDI:
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02002741 HA_ATOMIC_INC(&qc->prx_counters->streams_data_blocked_bidi);
2742 break;
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002743 case QUIC_FT_STREAMS_BLOCKED_UNI:
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02002744 HA_ATOMIC_INC(&qc->prx_counters->streams_data_blocked_uni);
Frédéric Lécaillef366cb72021-11-18 10:57:18 +01002745 break;
Frédéric Lécaille0c140202020-12-09 15:56:48 +01002746 case QUIC_FT_NEW_CONNECTION_ID:
Frédéric Lécaille2cca2412022-01-21 13:55:03 +01002747 case QUIC_FT_RETIRE_CONNECTION_ID:
2748 /* XXX TO DO XXX */
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002749 break;
2750 case QUIC_FT_CONNECTION_CLOSE:
2751 case QUIC_FT_CONNECTION_CLOSE_APP:
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02002752 /* Increment the error counters */
2753 qc_cc_err_count_inc(qc, &frm);
Frédéric Lécaille47756802022-03-25 09:12:16 +01002754 if (!(qc->flags & QUIC_FL_CONN_DRAINING)) {
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02002755 if (!(qc->flags & QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED)) {
2756 qc->flags |= QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED;
Frédéric Lécailleeb791452022-05-24 16:01:39 +02002757 HA_ATOMIC_DEC(&qc->prx_counters->half_open_conn);
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02002758 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002759 TRACE_STATE("Entering draining state", QUIC_EV_CONN_PRSHPKT, qc);
Frédéric Lécaille47756802022-03-25 09:12:16 +01002760 /* RFC 9000 10.2. Immediate Close:
2761 * The closing and draining connection states exist to ensure
2762 * that connections close cleanly and that delayed or reordered
2763 * packets are properly discarded. These states SHOULD persist
2764 * for at least three times the current PTO interval...
2765 *
2766 * Rearm the idle timeout only one time when entering draining
2767 * state.
2768 */
2769 qc_idle_timer_do_rearm(qc);
2770 qc->flags |= QUIC_FL_CONN_DRAINING|QUIC_FL_CONN_IMMEDIATE_CLOSE;
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02002771 qc_notify_close(qc);
Frédéric Lécaille47756802022-03-25 09:12:16 +01002772 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002773 break;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002774 case QUIC_FT_HANDSHAKE_DONE:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002775 if (qc_is_listener(ctx->qc)) {
2776 TRACE_ERROR("non accepted QUIC_FT_HANDSHAKE_DONE frame",
2777 QUIC_EV_CONN_PRSHPKT, qc);
2778 goto leave;
2779 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002780
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002781 qc->state = QUIC_HS_ST_CONFIRMED;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002782 break;
2783 default:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002784 TRACE_ERROR("unknosw frame type", QUIC_EV_CONN_PRSHPKT, qc);
2785 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002786 }
2787 }
2788
Frédéric Lécaille44ae7522022-03-21 12:18:00 +01002789 /* Flag this packet number space as having received a packet. */
Frédéric Lécaille205e4f32022-03-28 17:38:27 +02002790 qel->pktns->flags |= QUIC_FL_PKTNS_PKT_RECEIVED;
Frédéric Lécaille44ae7522022-03-21 12:18:00 +01002791
Frédéric Lécaillee248e372022-04-25 09:25:56 +02002792 if (fast_retrans) {
2793 struct quic_enc_level *iqel = &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL];
2794 struct quic_enc_level *hqel = &qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE];
2795
2796 qc_prep_hdshk_fast_retrans(qc, &iqel->pktns->tx.frms, &hqel->pktns->tx.frms);
2797 }
Frédéric Lécaille3bb457c2021-12-30 16:14:20 +01002798
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002799 /* The server must switch from INITIAL to HANDSHAKE handshake state when it
2800 * has successfully parse a Handshake packet. The Initial encryption must also
2801 * be discarded.
2802 */
Frédéric Lécaille2fe8b3b2022-01-10 12:10:10 +01002803 if (pkt->type == QUIC_PACKET_TYPE_HANDSHAKE && qc_is_listener(ctx->qc)) {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002804 if (qc->state >= QUIC_HS_ST_SERVER_INITIAL) {
Frédéric Lécaille05bd92b2022-03-29 19:09:46 +02002805 if (!(qc->els[QUIC_TLS_ENC_LEVEL_INITIAL].tls_ctx.flags &
2806 QUIC_FL_TLS_SECRETS_DCD)) {
2807 quic_tls_discard_keys(&qc->els[QUIC_TLS_ENC_LEVEL_INITIAL]);
2808 TRACE_PROTO("discarding Initial pktns", QUIC_EV_CONN_PRSHPKT, qc);
2809 quic_pktns_discard(qc->els[QUIC_TLS_ENC_LEVEL_INITIAL].pktns, qc);
2810 qc_set_timer(ctx->qc);
2811 qc_el_rx_pkts_del(&qc->els[QUIC_TLS_ENC_LEVEL_INITIAL]);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002812 qc_release_pktns_frms(qc, qc->els[QUIC_TLS_ENC_LEVEL_INITIAL].pktns);
Frédéric Lécaille05bd92b2022-03-29 19:09:46 +02002813 }
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002814 if (qc->state < QUIC_HS_ST_SERVER_HANDSHAKE)
2815 qc->state = QUIC_HS_ST_SERVER_HANDSHAKE;
Frédéric Lécaille8c27de72021-09-20 11:00:46 +02002816 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002817 }
2818
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002819 ret = 1;
2820 leave:
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01002821 TRACE_LEAVE(QUIC_EV_CONN_PRSHPKT, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002822 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002823}
2824
Amaury Denoyelle5b689862022-08-08 16:07:30 +02002825/* Allocate Tx buffer from <qc> quic-conn if needed.
2826 *
2827 * Returns allocated buffer or NULL on error.
2828 */
2829static struct buffer *qc_txb_alloc(struct quic_conn *qc)
2830{
2831 struct buffer *buf = &qc->tx.buf;
2832 if (!b_alloc(buf))
2833 return NULL;
2834
2835 return buf;
2836}
2837
2838/* Free Tx buffer from <qc> if it is empty. */
2839static void qc_txb_release(struct quic_conn *qc)
2840{
2841 struct buffer *buf = &qc->tx.buf;
2842
2843 /* For the moment sending function is responsible to purge the buffer
2844 * entirely. It may change in the future but this requires to be able
2845 * to reuse old data.
2846 */
Amaury Denoyelle654269c2022-08-08 15:38:57 +02002847 BUG_ON_HOT(buf && b_data(buf));
Amaury Denoyelle5b689862022-08-08 16:07:30 +02002848
2849 if (!b_data(buf)) {
2850 b_free(buf);
2851 offer_buffers(NULL, 1);
2852 }
2853}
2854
Amaury Denoyelle654269c2022-08-08 15:38:57 +02002855/* Commit a datagram payload written into <buf> of length <length>. <first_pkt>
2856 * must contains the address of the first packet stored in the payload.
2857 *
2858 * Caller is responsible that there is enough space in the buffer.
2859 */
2860static void qc_txb_store(struct buffer *buf, uint16_t length,
2861 struct quic_tx_packet *first_pkt)
2862{
2863 const size_t hdlen = sizeof(uint16_t) + sizeof(void *);
2864 BUG_ON_HOT(b_contig_space(buf) < hdlen); /* this must not happen */
2865
2866 write_u16(b_tail(buf), length);
2867 write_ptr(b_tail(buf) + sizeof(length), first_pkt);
2868 b_add(buf, hdlen + length);
2869}
2870
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002871/* Returns 1 if a packet may be built for <qc> from <qel> encryption level
2872 * with <frms> as ack-eliciting frame list to send, 0 if not.
2873 * <cc> must equal to 1 if an immediate close was asked, 0 if not.
2874 * <probe> must equalt to 1 if a probing packet is required, 0 if not.
Frédéric Lécaille57bddbc2022-06-20 17:51:24 +02002875 * <force_ack> may be set to 1 if you want to force an ack.
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002876 */
2877static int qc_may_build_pkt(struct quic_conn *qc, struct list *frms,
Frédéric Lécaille57bddbc2022-06-20 17:51:24 +02002878 struct quic_enc_level *qel, int cc, int probe, int force_ack)
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002879{
Frédéric Lécaille57bddbc2022-06-20 17:51:24 +02002880 unsigned int must_ack = force_ack ||
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02002881 (LIST_ISEMPTY(frms) && (qel->pktns->flags & QUIC_FL_PKTNS_ACK_REQUIRED));
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002882
2883 /* Do not build any more packet if the TX secrets are not available or
2884 * if there is nothing to send, i.e. if no CONNECTION_CLOSE or ACK are required
2885 * and if there is no more packets to send upon PTO expiration
2886 * and if there is no more ack-eliciting frames to send or in flight
2887 * congestion control limit is reached for prepared data
2888 */
2889 if (!(qel->tls_ctx.flags & QUIC_FL_TLS_SECRETS_SET) ||
2890 (!cc && !probe && !must_ack &&
2891 (LIST_ISEMPTY(frms) || qc->path->prep_in_flight >= qc->path->cwnd))) {
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002892 return 0;
2893 }
2894
2895 return 1;
2896}
2897
Amaury Denoyellef2476052022-08-04 16:19:57 +02002898/* Prepare as much as possible QUIC packets for sending from prebuilt frames
2899 * <frms>. Each packet is stored in a distinct datagram written to <buf>.
2900 *
2901 * Each datagram is prepended by a two fields header : the datagram length and
2902 * the address of the packet contained in the datagram.
2903 *
2904 * Returns the number of bytes prepared in packets if succeeded (may be 0), or
2905 * -1 if something wrong happened.
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002906 */
Amaury Denoyellef2476052022-08-04 16:19:57 +02002907static int qc_prep_app_pkts(struct quic_conn *qc, struct buffer *buf,
Frédéric Lécaille28c7ea32022-02-25 17:41:39 +01002908 struct list *frms)
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002909{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002910 int ret = -1;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002911 struct quic_enc_level *qel;
Amaury Denoyelle654269c2022-08-08 15:38:57 +02002912 unsigned char *end, *pos;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002913 struct quic_tx_packet *pkt;
2914 size_t total;
Amaury Denoyellef2476052022-08-04 16:19:57 +02002915 /* Each datagram is prepended with its length followed by the address
2916 * of the first packet in the datagram.
2917 */
2918 const size_t dg_headlen = sizeof(uint16_t) + sizeof(pkt);
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002919
2920 TRACE_ENTER(QUIC_EV_CONN_PHPKTS, qc);
Amaury Denoyellef2476052022-08-04 16:19:57 +02002921
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002922 qel = &qc->els[QUIC_TLS_ENC_LEVEL_APP];
2923 total = 0;
Amaury Denoyelle654269c2022-08-08 15:38:57 +02002924 pos = (unsigned char *)b_tail(buf);
Amaury Denoyellef2476052022-08-04 16:19:57 +02002925 while (b_contig_space(buf) >= (int)qc->path->mtu + dg_headlen) {
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002926 int err, probe, cc;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002927
2928 TRACE_POINT(QUIC_EV_CONN_PHPKTS, qc, qel);
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002929 probe = 0;
Frédéric Lécaillefc790062022-03-28 17:10:31 +02002930 cc = qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE;
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002931 /* We do not probe if an immediate close was asked */
2932 if (!cc)
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002933 probe = qel->pktns->tx.pto_probe;
Frédéric Lécailleb0021452022-03-29 11:42:03 +02002934
Frédéric Lécaille57bddbc2022-06-20 17:51:24 +02002935 if (!qc_may_build_pkt(qc, frms, qel, cc, probe, 0))
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002936 break;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002937
2938 /* Leave room for the datagram header */
2939 pos += dg_headlen;
2940 if (!quic_peer_validated_addr(qc) && qc_is_listener(qc)) {
Frédéric Lécaille628e89c2022-06-24 12:13:53 +02002941 end = pos + QUIC_MIN((uint64_t)qc->path->mtu, 3 * qc->rx.bytes - qc->tx.prep_bytes);
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002942 }
2943 else {
2944 end = pos + qc->path->mtu;
2945 }
2946
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02002947 pkt = qc_build_pkt(&pos, end, qel, &qel->tls_ctx, frms, qc, NULL, 0,
2948 QUIC_PACKET_TYPE_SHORT, 0, 0, probe, cc, &err);
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002949 switch (err) {
2950 case -2:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002951 // trace already emitted by function above
2952 goto leave;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002953 case -1:
Frédéric Lécaillee9a974a2022-03-13 19:19:12 +01002954 /* As we provide qc_build_pkt() with an enough big buffer to fulfill an
2955 * MTU, we are here because of the congestion control window. There is
2956 * no need to try to reuse this buffer.
2957 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002958 TRACE_DEVEL("could not prepare anymore packet", QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaillee9a974a2022-03-13 19:19:12 +01002959 goto out;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002960 default:
2961 break;
2962 }
2963
2964 /* This is to please to GCC. We cannot have (err >= 0 && !pkt) */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002965 BUG_ON(!pkt);
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002966
Frédéric Lécaille1809c332022-04-25 10:24:12 +02002967 if (qc->flags & QUIC_FL_CONN_RETRANS_OLD_DATA)
2968 pkt->flags |= QUIC_FL_TX_PACKET_PROBE_WITH_OLD_DATA;
2969
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002970 total += pkt->len;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002971
Amaury Denoyellef2476052022-08-04 16:19:57 +02002972 /* Write datagram header. */
Amaury Denoyelle654269c2022-08-08 15:38:57 +02002973 qc_txb_store(buf, pkt->len, pkt);
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002974 }
2975
2976 out:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002977 ret = total;
2978 leave:
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002979 TRACE_LEAVE(QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02002980 return ret;
Frédéric Lécaille1c5968b2022-02-25 17:15:21 +01002981}
2982
Amaury Denoyellef2476052022-08-04 16:19:57 +02002983/* Prepare as much as possible QUIC packets for sending from prebuilt frames
2984 * <frms>. Several packets can be regrouped in a single datagram. The result is
2985 * written into <buf>.
2986 *
2987 * Each datagram is prepended by a two fields header : the datagram length and
2988 * the address of first packet in the datagram.
2989 *
2990 * Returns the number of bytes prepared in packets if succeeded (may be 0), or
2991 * -1 if something wrong happened.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002992 */
Amaury Denoyellef2476052022-08-04 16:19:57 +02002993static int qc_prep_pkts(struct quic_conn *qc, struct buffer *buf,
Frédéric Lécaillefc888442022-04-11 15:39:34 +02002994 enum quic_tls_enc_level tel, struct list *tel_frms,
2995 enum quic_tls_enc_level next_tel, struct list *next_tel_frms)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002996{
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01002997 struct quic_enc_level *qel;
Amaury Denoyelle654269c2022-08-08 15:38:57 +02002998 unsigned char *end, *pos;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02002999 struct quic_tx_packet *first_pkt, *cur_pkt, *prv_pkt;
3000 /* length of datagrams */
3001 uint16_t dglen;
3002 size_t total;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003003 int ret = -1, padding;
Amaury Denoyellef2476052022-08-04 16:19:57 +02003004 /* Each datagram is prepended with its length followed by the address
3005 * of the first packet in the datagram.
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003006 */
Amaury Denoyellef2476052022-08-04 16:19:57 +02003007 const size_t dg_headlen = sizeof(uint16_t) + sizeof(first_pkt);
Frédéric Lécaillefc888442022-04-11 15:39:34 +02003008 struct list *frms;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003009
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01003010 TRACE_ENTER(QUIC_EV_CONN_PHPKTS, qc);
3011
Amaury Denoyellef2476052022-08-04 16:19:57 +02003012 /* Currently qc_prep_pkts() does not handle buffer wrapping so the
3013 * caller must ensure that buf is resetted.
3014 */
3015 BUG_ON_HOT(buf->head || buf->data);
3016
Frédéric Lécaille99942d62022-01-07 14:32:31 +01003017 total = 0;
Frédéric Lécaillefc888442022-04-11 15:39:34 +02003018 qel = &qc->els[tel];
3019 frms = tel_frms;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003020 dglen = 0;
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01003021 padding = 0;
Amaury Denoyelle654269c2022-08-08 15:38:57 +02003022 pos = (unsigned char *)b_head(buf);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003023 first_pkt = prv_pkt = NULL;
Amaury Denoyellef2476052022-08-04 16:19:57 +02003024 while (b_contig_space(buf) >= (int)qc->path->mtu + dg_headlen || prv_pkt) {
Frédéric Lécailleb0021452022-03-29 11:42:03 +02003025 int err, probe, cc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003026 enum quic_pkt_type pkt_type;
Frédéric Lécaille301425b2022-06-14 17:40:39 +02003027 struct quic_tls_ctx *tls_ctx;
3028 const struct quic_version *ver;
Frédéric Lécaille57bddbc2022-06-20 17:51:24 +02003029 int force_ack = (qel->pktns->flags & QUIC_FL_PKTNS_ACK_REQUIRED) &&
3030 (qel == &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL] ||
3031 qel == &qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE]);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003032
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01003033 TRACE_POINT(QUIC_EV_CONN_PHPKTS, qc, qel);
Frédéric Lécailleb0021452022-03-29 11:42:03 +02003034 probe = 0;
Frédéric Lécaillefc790062022-03-28 17:10:31 +02003035 cc = qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE;
Frédéric Lécailleb0021452022-03-29 11:42:03 +02003036 /* We do not probe if an immediate close was asked */
3037 if (!cc)
Frédéric Lécaille94fca872022-01-19 18:54:18 +01003038 probe = qel->pktns->tx.pto_probe;
Frédéric Lécailleb0021452022-03-29 11:42:03 +02003039
Frédéric Lécaille57bddbc2022-06-20 17:51:24 +02003040 if (!qc_may_build_pkt(qc, frms, qel, cc, probe, force_ack)) {
Amaury Denoyelle654269c2022-08-08 15:38:57 +02003041 if (prv_pkt)
3042 qc_txb_store(buf, dglen, first_pkt);
Frédéric Lécaille39ba1c32022-01-21 16:52:56 +01003043 /* Let's select the next encryption level */
3044 if (tel != next_tel && next_tel != QUIC_TLS_ENC_LEVEL_NONE) {
3045 tel = next_tel;
Frédéric Lécaillefc888442022-04-11 15:39:34 +02003046 frms = next_tel_frms;
Frédéric Lécaille39ba1c32022-01-21 16:52:56 +01003047 qel = &qc->els[tel];
3048 /* Build a new datagram */
3049 prv_pkt = NULL;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003050 TRACE_DEVEL("next encryption level selected", QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaille39ba1c32022-01-21 16:52:56 +01003051 continue;
3052 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003053 break;
3054 }
3055
3056 pkt_type = quic_tls_level_pkt_type(tel);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003057 if (!prv_pkt) {
3058 /* Leave room for the datagram header */
3059 pos += dg_headlen;
Frédéric Lécaille2fe8b3b2022-01-10 12:10:10 +01003060 if (!quic_peer_validated_addr(qc) && qc_is_listener(qc)) {
Frédéric Lécaille628e89c2022-06-24 12:13:53 +02003061 end = pos + QUIC_MIN((uint64_t)qc->path->mtu, 3 * qc->rx.bytes - qc->tx.prep_bytes);
Frédéric Lécailleca98a7f2021-11-10 17:30:15 +01003062 }
3063 else {
3064 end = pos + qc->path->mtu;
3065 }
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003066 }
3067
Frédéric Lécaille301425b2022-06-14 17:40:39 +02003068 if (qc->negotiated_version) {
3069 ver = qc->negotiated_version;
3070 if (qel == &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL])
3071 tls_ctx = &qc->negotiated_ictx;
3072 else
3073 tls_ctx = &qel->tls_ctx;
3074 }
3075 else {
3076 ver = qc->original_version;
3077 tls_ctx = &qel->tls_ctx;
3078 }
3079
3080 cur_pkt = qc_build_pkt(&pos, end, qel, tls_ctx, frms,
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02003081 qc, ver, dglen, pkt_type,
3082 force_ack, padding, probe, cc, &err);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003083 switch (err) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003084 case -2:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003085 // trace already emitted by function above
3086 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003087 case -1:
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003088 /* If there was already a correct packet present, set the
3089 * current datagram as prepared into <cbuf>.
3090 */
Amaury Denoyelle654269c2022-08-08 15:38:57 +02003091 if (prv_pkt)
3092 qc_txb_store(buf, dglen, first_pkt);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003093 TRACE_DEVEL("could not prepare anymore packet", QUIC_EV_CONN_PHPKTS, qc);
Amaury Denoyellef2476052022-08-04 16:19:57 +02003094 goto out;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003095 default:
Frédéric Lécaille63556772021-12-29 17:18:21 +01003096 break;
3097 }
Frédéric Lécaille67f47d02021-08-19 15:19:09 +02003098
Frédéric Lécaille63556772021-12-29 17:18:21 +01003099 /* This is to please to GCC. We cannot have (err >= 0 && !cur_pkt) */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003100 BUG_ON(!cur_pkt);
Frédéric Lécaille63556772021-12-29 17:18:21 +01003101
Frédéric Lécaille1809c332022-04-25 10:24:12 +02003102 if (qc->flags & QUIC_FL_CONN_RETRANS_OLD_DATA)
3103 cur_pkt->flags |= QUIC_FL_TX_PACKET_PROBE_WITH_OLD_DATA;
3104
Frédéric Lécaille63556772021-12-29 17:18:21 +01003105 total += cur_pkt->len;
3106 /* keep trace of the first packet in the datagram */
3107 if (!first_pkt)
3108 first_pkt = cur_pkt;
3109 /* Attach the current one to the previous one */
Frédéric Lécailleb44cbc62022-04-21 17:58:46 +02003110 if (prv_pkt) {
Frédéric Lécaille63556772021-12-29 17:18:21 +01003111 prv_pkt->next = cur_pkt;
Frédéric Lécailleb44cbc62022-04-21 17:58:46 +02003112 cur_pkt->flags |= QUIC_FL_TX_PACKET_COALESCED;
3113 }
Frédéric Lécaille63556772021-12-29 17:18:21 +01003114 /* Let's say we have to build a new dgram */
3115 prv_pkt = NULL;
3116 dglen += cur_pkt->len;
3117 /* Client: discard the Initial encryption keys as soon as
3118 * a handshake packet could be built.
3119 */
Frédéric Lécaillefc790062022-03-28 17:10:31 +02003120 if (qc->state == QUIC_HS_ST_CLIENT_INITIAL &&
Frédéric Lécaille63556772021-12-29 17:18:21 +01003121 pkt_type == QUIC_PACKET_TYPE_HANDSHAKE) {
3122 quic_tls_discard_keys(&qc->els[QUIC_TLS_ENC_LEVEL_INITIAL]);
3123 TRACE_PROTO("discarding Initial pktns", QUIC_EV_CONN_PHPKTS, qc);
3124 quic_pktns_discard(qc->els[QUIC_TLS_ENC_LEVEL_INITIAL].pktns, qc);
3125 qc_set_timer(qc);
Frédéric Lécaillea6255f52022-01-19 17:29:48 +01003126 qc_el_rx_pkts_del(&qc->els[QUIC_TLS_ENC_LEVEL_INITIAL]);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003127 qc_release_pktns_frms(qc, qc->els[QUIC_TLS_ENC_LEVEL_INITIAL].pktns);
Frédéric Lécaillefc790062022-03-28 17:10:31 +02003128 qc->state = QUIC_HS_ST_CLIENT_HANDSHAKE;
Frédéric Lécaille63556772021-12-29 17:18:21 +01003129 }
3130 /* If the data for the current encryption level have all been sent,
3131 * select the next level.
3132 */
3133 if ((tel == QUIC_TLS_ENC_LEVEL_INITIAL || tel == QUIC_TLS_ENC_LEVEL_HANDSHAKE) &&
Frédéric Lécaille7aef5f42022-04-25 10:33:12 +02003134 next_tel != QUIC_TLS_ENC_LEVEL_NONE && (LIST_ISEMPTY(frms) && !qel->pktns->tx.pto_probe)) {
Frédéric Lécaille63556772021-12-29 17:18:21 +01003135 /* If QUIC_TLS_ENC_LEVEL_HANDSHAKE was already reached let's try QUIC_TLS_ENC_LEVEL_APP */
3136 if (tel == QUIC_TLS_ENC_LEVEL_HANDSHAKE && next_tel == tel)
3137 next_tel = QUIC_TLS_ENC_LEVEL_APP;
3138 tel = next_tel;
Frédéric Lécaillefc888442022-04-11 15:39:34 +02003139 if (tel == QUIC_TLS_ENC_LEVEL_APP)
3140 frms = &qc->els[tel].pktns->tx.frms;
3141 else
3142 frms = next_tel_frms;
Frédéric Lécaille63556772021-12-29 17:18:21 +01003143 qel = &qc->els[tel];
Frédéric Lécaillefc888442022-04-11 15:39:34 +02003144 if (!LIST_ISEMPTY(frms)) {
Frédéric Lécaille63556772021-12-29 17:18:21 +01003145 /* If there is data for the next level, do not
3146 * consume a datagram.
3147 */
3148 prv_pkt = cur_pkt;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003149 }
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003150 }
Amaury Denoyellef2476052022-08-04 16:19:57 +02003151
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003152 /* If we have to build a new datagram, set the current datagram as
3153 * prepared into <cbuf>.
3154 */
3155 if (!prv_pkt) {
Amaury Denoyelle654269c2022-08-08 15:38:57 +02003156 qc_txb_store(buf, dglen, first_pkt);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003157 first_pkt = NULL;
3158 dglen = 0;
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01003159 padding = 0;
3160 }
3161 else if (prv_pkt->type == QUIC_TLS_ENC_LEVEL_INITIAL &&
Frédéric Lécaille1aa57d32022-01-12 09:46:02 +01003162 (!qc_is_listener(qc) ||
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01003163 prv_pkt->flags & QUIC_FL_TX_PACKET_ACK_ELICITING)) {
3164 padding = 1;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003165 }
3166 }
3167
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003168 out:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003169 ret = total;
3170 leave:
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01003171 TRACE_LEAVE(QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003172 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003173}
3174
Amaury Denoyellef2476052022-08-04 16:19:57 +02003175/* Send datagrams stored in <buf>.
3176 *
3177 * This function always returns 1 for success. Even if sendto() syscall failed,
3178 * buffer is drained and packets are considered as emitted. QUIC loss detection
3179 * mechanism is used as a back door way to retry sending.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003180 */
Amaury Denoyellef2476052022-08-04 16:19:57 +02003181int qc_send_ppkts(struct buffer *buf, struct ssl_sock_ctx *ctx)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003182{
3183 struct quic_conn *qc;
Amaury Denoyelle906b0582022-08-05 15:22:28 +02003184 char skip_sendto = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003185
Amaury Denoyellec15dd922021-12-21 11:41:52 +01003186 qc = ctx->qc;
Frédéric Lécaille8726d632022-05-03 10:32:21 +02003187 TRACE_ENTER(QUIC_EV_CONN_SPPKTS, qc);
Amaury Denoyellef2476052022-08-04 16:19:57 +02003188 while (b_contig_data(buf, 0)) {
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003189 unsigned char *pos;
3190 struct buffer tmpbuf = { };
3191 struct quic_tx_packet *first_pkt, *pkt, *next_pkt;
3192 uint16_t dglen;
3193 size_t headlen = sizeof dglen + sizeof first_pkt;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003194 unsigned int time_sent;
3195
Amaury Denoyellef2476052022-08-04 16:19:57 +02003196 pos = (unsigned char *)b_head(buf);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003197 dglen = read_u16(pos);
Amaury Denoyellef2476052022-08-04 16:19:57 +02003198 BUG_ON_HOT(!dglen); /* this should not happen */
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003199
3200 pos += sizeof dglen;
3201 first_pkt = read_ptr(pos);
3202 pos += sizeof first_pkt;
3203 tmpbuf.area = (char *)pos;
3204 tmpbuf.size = tmpbuf.data = dglen;
3205
Frédéric Lécaille3a561372022-08-29 18:05:44 +02003206 TRACE_DATA("send dgram", QUIC_EV_CONN_SPPKTS, qc);
Amaury Denoyelle906b0582022-08-05 15:22:28 +02003207 /* If sendto is on error just skip the call to it for the rest
3208 * of the loop but continue to purge the buffer. Data will be
3209 * transmitted when QUIC packets are detected as lost on our
3210 * side.
3211 *
3212 * TODO use fd-monitoring to detect when send operation can be
3213 * retry. This should improve the bandwidth without relying on
3214 * retransmission timer. However, it requires a major rework on
3215 * quic-conn fd management.
3216 */
Amaury Denoyelle906b0582022-08-05 15:22:28 +02003217 if (!skip_sendto) {
3218 if (qc_snd_buf(qc, &tmpbuf, tmpbuf.data, 0)) {
3219 skip_sendto = 1;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003220 TRACE_ERROR("sendto error, simulate sending for the rest of data", QUIC_EV_CONN_SPPKTS, qc);
Amaury Denoyelle906b0582022-08-05 15:22:28 +02003221 }
3222 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003223
Amaury Denoyellef2476052022-08-04 16:19:57 +02003224 b_del(buf, dglen + headlen);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003225 qc->tx.bytes += tmpbuf.data;
3226 time_sent = now_ms;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003227
3228 for (pkt = first_pkt; pkt; pkt = next_pkt) {
3229 pkt->time_sent = time_sent;
3230 if (pkt->flags & QUIC_FL_TX_PACKET_ACK_ELICITING) {
3231 pkt->pktns->tx.time_of_last_eliciting = time_sent;
Frédéric Lécaillef7e0b8d2020-12-16 17:33:11 +01003232 qc->path->ifae_pkts++;
Frédéric Lécaille530601c2022-03-10 15:11:57 +01003233 if (qc->flags & QUIC_FL_CONN_IDLE_TIMER_RESTARTED_AFTER_READ)
3234 qc_idle_timer_rearm(qc, 0);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003235 }
Frédéric Lécaille59bf2552022-03-28 12:13:09 +02003236 if (!(qc->flags & QUIC_FL_CONN_CLOSING) &&
3237 (pkt->flags & QUIC_FL_TX_PACKET_CC)) {
3238 qc->flags |= QUIC_FL_CONN_CLOSING;
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02003239 qc_notify_close(qc);
3240
Frédéric Lécaille59bf2552022-03-28 12:13:09 +02003241 /* RFC 9000 10.2. Immediate Close:
3242 * The closing and draining connection states exist to ensure
3243 * that connections close cleanly and that delayed or reordered
3244 * packets are properly discarded. These states SHOULD persist
3245 * for at least three times the current PTO interval...
3246 *
3247 * Rearm the idle timeout only one time when entering closing
3248 * state.
3249 */
3250 qc_idle_timer_do_rearm(qc);
3251 if (qc->timer_task) {
3252 task_destroy(qc->timer_task);
3253 qc->timer_task = NULL;
3254 }
3255 }
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02003256 qc->path->in_flight += pkt->in_flight_len;
3257 pkt->pktns->tx.in_flight += pkt->in_flight_len;
Frédéric Lécaille5f6c25e2022-08-24 16:23:44 +02003258 if (pkt->in_flight_len)
Frédéric Lécailleda9c4412022-08-22 18:47:51 +02003259 qc_set_timer(qc);
Frédéric Lécaille5f6c25e2022-08-24 16:23:44 +02003260 TRACE_DATA("sent pkt", QUIC_EV_CONN_SPPKTS, qc, pkt);
3261 next_pkt = pkt->next;
3262 quic_tx_packet_refinc(pkt);
3263 eb64_insert(&pkt->pktns->tx.pkts, &pkt->pn_node);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003264 }
3265 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003266
Frédéric Lécaille8726d632022-05-03 10:32:21 +02003267 TRACE_LEAVE(QUIC_EV_CONN_SPPKTS, qc);
3268
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003269 return 1;
3270}
3271
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003272/* Copy into <buf> buffer a stateless reset token depending on the
3273 * <salt> salt input. This is the cluster secret which will be derived
3274 * as HKDF input secret to generate this token.
3275 * Return 1 if succeeded, 0 if not.
3276 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003277static int quic_stateless_reset_token_cpy(struct quic_conn *qc,
3278 unsigned char *buf, size_t len,
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003279 const unsigned char *salt, size_t saltlen)
3280{
3281 /* Input secret */
3282 const unsigned char *key = (const unsigned char *)global.cluster_secret;
3283 size_t keylen = strlen(global.cluster_secret);
3284 /* Info */
3285 const unsigned char label[] = "stateless token";
3286 size_t labellen = sizeof label - 1;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003287 int ret;
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003288
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003289 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
3290
3291 ret = quic_hkdf_extract_and_expand(EVP_sha256(), buf, len,
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003292 key, keylen, salt, saltlen, label, labellen);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003293 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
3294 return ret;
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003295}
3296
3297/* Initialize the stateless reset token attached to <cid> connection ID.
3298 * Returns 1 if succeeded, 0 if not.
3299 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003300static int quic_stateless_reset_token_init(struct quic_conn *qc,
3301 struct quic_connection_id *quic_cid)
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003302{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003303 int ret;
3304
3305 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
3306
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003307 if (global.cluster_secret) {
3308 /* Output secret */
3309 unsigned char *token = quic_cid->stateless_reset_token;
3310 size_t tokenlen = sizeof quic_cid->stateless_reset_token;
3311 /* Salt */
3312 const unsigned char *cid = quic_cid->cid.data;
3313 size_t cidlen = quic_cid->cid.len;
3314
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003315 ret = quic_stateless_reset_token_cpy(qc, token, tokenlen, cid, cidlen);
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003316 }
3317 else {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003318 /* TODO: RAND_bytes() should be replaced */
3319 ret = RAND_bytes(quic_cid->stateless_reset_token,
3320 sizeof quic_cid->stateless_reset_token) == 1;
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003321 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003322
3323 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
3324 return ret;
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003325}
3326
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003327/* Allocate a new CID with <seq_num> as sequence number and attach it to <root>
3328 * ebtree.
3329 *
3330 * The CID is randomly generated in part with the result altered to be
3331 * associated with the current thread ID. This means this function must only
3332 * be called by the quic_conn thread.
3333 *
3334 * Returns the new CID if succeeded, NULL if not.
3335 */
3336static struct quic_connection_id *new_quic_cid(struct eb_root *root,
3337 struct quic_conn *qc,
3338 int seq_num)
3339{
3340 struct quic_connection_id *cid;
3341
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003342 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
3343
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003344 cid = pool_alloc(pool_head_quic_connection_id);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003345 if (!cid) {
3346 TRACE_ERROR("cid allocation failed", QUIC_EV_CONN_TXPKT, qc);
3347 goto err;
3348 }
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003349
3350 cid->cid.len = QUIC_HAP_CID_LEN;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003351 /* TODO: RAND_bytes() should be replaced */
3352 if (RAND_bytes(cid->cid.data, cid->cid.len) != 1) {
3353 TRACE_ERROR("RAND_bytes() failed", QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003354 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003355 }
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003356
3357 quic_pin_cid_to_tid(cid->cid.data, tid);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003358 if (quic_stateless_reset_token_init(qc, cid) != 1) {
3359 TRACE_ERROR("quic_stateless_reset_token_init() failed", QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaille28a17952022-05-06 15:07:20 +02003360 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003361 }
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003362
3363 cid->qc = qc;
3364
3365 cid->seq_num.key = seq_num;
3366 cid->retire_prior_to = 0;
3367 /* insert the allocated CID in the quic_conn tree */
3368 eb64_insert(root, &cid->seq_num);
3369
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003370 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003371 return cid;
3372
3373 err:
3374 pool_free(pool_head_quic_connection_id, cid);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003375 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaille0226c522022-05-06 14:18:53 +02003376 return NULL;
3377}
3378
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003379/* Build all the frames which must be sent just after the handshake have succeeded.
3380 * This is essentially NEW_CONNECTION_ID frames. A QUIC server must also send
3381 * a HANDSHAKE_DONE frame.
3382 * Return 1 if succeeded, 0 if not.
3383 */
Frédéric Lécaille522c65c2021-08-03 14:29:03 +02003384static int quic_build_post_handshake_frames(struct quic_conn *qc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003385{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003386 int ret = 0, i, first, max;
Frédéric Lécaille522c65c2021-08-03 14:29:03 +02003387 struct quic_enc_level *qel;
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003388 struct quic_frame *frm, *frmbak;
3389 struct list frm_list = LIST_HEAD_INIT(frm_list);
3390 struct eb64_node *node;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003391
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003392 TRACE_ENTER(QUIC_EV_CONN_IO_CB, qc);
3393
Frédéric Lécaille522c65c2021-08-03 14:29:03 +02003394 qel = &qc->els[QUIC_TLS_ENC_LEVEL_APP];
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003395 /* Only servers must send a HANDSHAKE_DONE frame. */
Frédéric Lécaille1aa57d32022-01-12 09:46:02 +01003396 if (qc_is_listener(qc)) {
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003397 frm = pool_zalloc(pool_head_quic_frame);
Frédéric Lécaille96d08d32022-08-11 12:04:07 +02003398 if (!frm) {
3399 TRACE_ERROR("frame allocation error", QUIC_EV_CONN_IO_CB, qc);
3400 goto leave;
3401 }
Frédéric Lécaille153d4a82021-01-06 12:12:39 +01003402
Frédéric Lécailleb9171912022-04-21 17:32:10 +02003403 LIST_INIT(&frm->reflist);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003404 frm->type = QUIC_FT_HANDSHAKE_DONE;
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003405 LIST_APPEND(&frm_list, &frm->list);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003406 }
3407
Frédéric Lécaille96d08d32022-08-11 12:04:07 +02003408 /* Initialize <max> connection IDs minus one: there is
3409 * already one connection ID used for the current connection.
3410 */
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003411 first = 1;
3412 max = qc->tx.params.active_connection_id_limit;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003413
3414 /* TODO: check limit */
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003415 for (i = first; i < max; i++) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003416 struct quic_connection_id *cid;
3417
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003418 frm = pool_zalloc(pool_head_quic_frame);
Frédéric Lécaille96d08d32022-08-11 12:04:07 +02003419 if (!frm) {
3420 TRACE_ERROR("frame allocation error", QUIC_EV_CONN_IO_CB, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003421 goto err;
Frédéric Lécaille96d08d32022-08-11 12:04:07 +02003422 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003423
Frédéric Lécailleb9171912022-04-21 17:32:10 +02003424 LIST_INIT(&frm->reflist);
Amaury Denoyelle0442efd2022-01-28 16:02:13 +01003425 cid = new_quic_cid(&qc->cids, qc, i);
Frédéric Lécaille96d08d32022-08-11 12:04:07 +02003426 if (!cid) {
3427 TRACE_ERROR("CID allocation error", QUIC_EV_CONN_IO_CB, qc);
Amaury Denoyelled6a352a2021-11-24 15:32:46 +01003428 goto err;
Frédéric Lécaille96d08d32022-08-11 12:04:07 +02003429 }
Amaury Denoyelled6a352a2021-11-24 15:32:46 +01003430
Frédéric Lécaille74904a42022-01-27 15:35:56 +01003431 /* insert the allocated CID in the receiver datagram handler tree */
Amaury Denoyelle8524f0f2022-02-08 15:03:40 +01003432 ebmb_insert(&quic_dghdlrs[tid].cids, &cid->node, cid->cid.len);
Amaury Denoyelled6a352a2021-11-24 15:32:46 +01003433
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003434 quic_connection_id_to_frm_cpy(frm, cid);
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003435 LIST_APPEND(&frm_list, &frm->list);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003436 }
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003437
3438 LIST_SPLICE(&qel->pktns->tx.frms, &frm_list);
Frédéric Lécaillefc790062022-03-28 17:10:31 +02003439 qc->flags |= QUIC_FL_CONN_POST_HANDSHAKE_FRAMES_BUILT;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003440
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003441 ret = 1;
3442 leave:
3443 TRACE_LEAVE(QUIC_EV_CONN_IO_CB, qc);
3444 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003445
3446 err:
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003447 /* free the frames */
3448 list_for_each_entry_safe(frm, frmbak, &frm_list, list)
3449 pool_free(pool_head_quic_frame, frm);
3450
Frédéric Lécaille96d08d32022-08-11 12:04:07 +02003451 node = eb64_lookup_ge(&qc->cids, first);
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003452 while (node) {
3453 struct quic_connection_id *cid;
3454
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003455 cid = eb64_entry(node, struct quic_connection_id, seq_num);
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003456 if (cid->seq_num.key >= max)
3457 break;
3458
Frédéric Lécaille411aa6d2022-03-21 12:01:22 +01003459 node = eb64_next(node);
Frédéric Lécailled64f68f2022-03-18 17:45:28 +01003460 ebmb_delete(&cid->node);
3461 eb64_delete(&cid->seq_num);
3462 pool_free(pool_head_quic_connection_id, cid);
3463 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003464 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003465}
3466
3467/* Deallocate <l> list of ACK ranges. */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003468void quic_free_arngs(struct quic_conn *qc, struct quic_arngs *arngs)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003469{
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003470 struct eb64_node *n;
3471 struct quic_arng_node *ar;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003472
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003473 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
3474
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003475 n = eb64_first(&arngs->root);
3476 while (n) {
3477 struct eb64_node *next;
3478
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003479 ar = eb64_entry(n, struct quic_arng_node, first);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003480 next = eb64_next(n);
3481 eb64_delete(n);
Frédéric Lécaille82851bd2022-04-04 13:43:58 +02003482 pool_free(pool_head_quic_arng, ar);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003483 n = next;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003484 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003485
3486 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003487}
3488
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003489/* Return the gap value between <p> and <q> ACK ranges where <q> follows <p> in
3490 * descending order.
3491 */
3492static inline size_t sack_gap(struct quic_arng_node *p,
3493 struct quic_arng_node *q)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003494{
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003495 return p->first.key - q->last - 2;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003496}
3497
3498
3499/* Remove the last elements of <ack_ranges> list of ack range updating its
3500 * encoded size until it goes below <limit>.
Ilya Shipitsin1e9a6662021-01-05 22:10:46 +05003501 * Returns 1 if succeeded, 0 if not (no more element to remove).
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003502 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003503static int quic_rm_last_ack_ranges(struct quic_conn *qc,
3504 struct quic_arngs *arngs, size_t limit)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003505{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003506 int ret = 0;
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003507 struct eb64_node *last, *prev;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003508
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003509 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
3510
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003511 last = eb64_last(&arngs->root);
3512 while (last && arngs->enc_sz > limit) {
3513 struct quic_arng_node *last_node, *prev_node;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003514
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003515 prev = eb64_prev(last);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003516 if (!prev) {
3517 TRACE_DEVEL("<last> not found", QUIC_EV_CONN_TXPKT, qc);
3518 goto out;
3519 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003520
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003521 last_node = eb64_entry(last, struct quic_arng_node, first);
3522 prev_node = eb64_entry(prev, struct quic_arng_node, first);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003523 arngs->enc_sz -= quic_int_getsize(last_node->last - last_node->first.key);
3524 arngs->enc_sz -= quic_int_getsize(sack_gap(prev_node, last_node));
3525 arngs->enc_sz -= quic_decint_size_diff(arngs->sz);
3526 --arngs->sz;
3527 eb64_delete(last);
3528 pool_free(pool_head_quic_arng, last);
3529 last = prev;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003530 }
3531
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003532 ret = 1;
3533 out:
3534 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
3535 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003536}
3537
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003538/* Set the encoded size of <arngs> QUIC ack ranges. */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003539static void quic_arngs_set_enc_sz(struct quic_conn *qc, struct quic_arngs *arngs)
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003540{
3541 struct eb64_node *node, *next;
3542 struct quic_arng_node *ar, *ar_next;
3543
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003544 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
3545
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003546 node = eb64_last(&arngs->root);
3547 if (!node)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003548 goto leave;
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003549
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003550 ar = eb64_entry(node, struct quic_arng_node, first);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003551 arngs->enc_sz = quic_int_getsize(ar->last) +
3552 quic_int_getsize(ar->last - ar->first.key) + quic_int_getsize(arngs->sz - 1);
3553
3554 while ((next = eb64_prev(node))) {
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003555 ar_next = eb64_entry(next, struct quic_arng_node, first);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003556 arngs->enc_sz += quic_int_getsize(sack_gap(ar, ar_next)) +
3557 quic_int_getsize(ar_next->last - ar_next->first.key);
3558 node = next;
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003559 ar = eb64_entry(node, struct quic_arng_node, first);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003560 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003561
3562 leave:
3563 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003564}
3565
Frédéric Lécaille9ef64cd2021-06-02 15:27:34 +02003566/* Insert <ar> ack range into <argns> tree of ack ranges.
3567 * Returns the ack range node which has been inserted if succeeded, NULL if not.
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003568 */
3569static inline
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003570struct quic_arng_node *quic_insert_new_range(struct quic_conn *qc,
3571 struct quic_arngs *arngs,
Frédéric Lécaille9ef64cd2021-06-02 15:27:34 +02003572 struct quic_arng *ar)
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003573{
Frédéric Lécaille9ef64cd2021-06-02 15:27:34 +02003574 struct quic_arng_node *new_ar;
3575
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003576 TRACE_ENTER(QUIC_EV_CONN_RXPKT, qc);
3577
Frédéric Lécaille9ef64cd2021-06-02 15:27:34 +02003578 new_ar = pool_alloc(pool_head_quic_arng);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003579 if (!new_ar) {
3580 TRACE_ERROR("ack range allocation failed", QUIC_EV_CONN_RXPKT, qc);
3581 goto leave;
Frédéric Lécaille9ef64cd2021-06-02 15:27:34 +02003582 }
3583
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003584 new_ar->first.key = ar->first;
3585 new_ar->last = ar->last;
3586 eb64_insert(&arngs->root, &new_ar->first);
3587 arngs->sz++;
3588
3589 leave:
3590 TRACE_LEAVE(QUIC_EV_CONN_RXPKT, qc);
Frédéric Lécaille9ef64cd2021-06-02 15:27:34 +02003591 return new_ar;
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003592}
3593
3594/* Update <arngs> tree of ACK ranges with <ar> as new ACK range value.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003595 * Note that this function computes the number of bytes required to encode
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003596 * this tree of ACK ranges in descending order.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003597 *
3598 * Descending order
3599 * ------------->
3600 * range1 range2
3601 * ..........|--------|..............|--------|
3602 * ^ ^ ^ ^
3603 * | | | |
3604 * last1 first1 last2 first2
3605 * ..........+--------+--------------+--------+......
3606 * diff1 gap12 diff2
3607 *
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003608 * To encode the previous list of ranges we must encode integers as follows in
3609 * descending order:
3610 * enc(last2),enc(diff2),enc(gap12),enc(diff1)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003611 * with diff1 = last1 - first1
3612 * diff2 = last2 - first2
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003613 * gap12 = first1 - last2 - 2 (>= 0)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003614 *
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003615
3616returns 0 on error
3617
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003618 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003619int quic_update_ack_ranges_list(struct quic_conn *qc,
3620 struct quic_arngs *arngs,
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003621 struct quic_arng *ar)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003622{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003623 int ret = 0;
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003624 struct eb64_node *le;
3625 struct quic_arng_node *new_node;
3626 struct eb64_node *new;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003627
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003628 TRACE_ENTER(QUIC_EV_CONN_RXPKT, qc);
3629
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003630 new = NULL;
3631 if (eb_is_empty(&arngs->root)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003632 new_node = quic_insert_new_range(qc, arngs, ar);
3633 if (new_node)
3634 ret = 1;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003635
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003636 goto leave;
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003637 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003638
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003639 le = eb64_lookup_le(&arngs->root, ar->first);
3640 if (!le) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003641 new_node = quic_insert_new_range(qc, arngs, ar);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003642 if (!new_node)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003643 goto leave;
Frédéric Lécaille0e257832021-11-16 10:54:19 +01003644
3645 new = &new_node->first;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003646 }
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003647 else {
3648 struct quic_arng_node *le_ar =
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003649 eb64_entry(le, struct quic_arng_node, first);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003650
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003651 /* Already existing range */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003652 if (le_ar->last >= ar->last) {
3653 ret = 1;
3654 }
3655 else if (le_ar->last + 1 >= ar->first) {
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003656 le_ar->last = ar->last;
3657 new = le;
3658 new_node = le_ar;
3659 }
3660 else {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003661 new_node = quic_insert_new_range(qc, arngs, ar);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003662 if (!new_node)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003663 goto leave;
Frédéric Lécaille8ba42762021-06-02 17:40:09 +02003664
3665 new = &new_node->first;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003666 }
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003667 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003668
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003669 /* Verify that the new inserted node does not overlap the nodes
3670 * which follow it.
3671 */
3672 if (new) {
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003673 struct eb64_node *next;
3674 struct quic_arng_node *next_node;
3675
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003676 while ((next = eb64_next(new))) {
3677 next_node =
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003678 eb64_entry(next, struct quic_arng_node, first);
Frédéric Lécaillec825eba2021-06-02 17:38:13 +02003679 if (new_node->last + 1 < next_node->first.key)
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003680 break;
3681
3682 if (next_node->last > new_node->last)
3683 new_node->last = next_node->last;
3684 eb64_delete(next);
Frédéric Lécaillebaea2842021-06-02 15:04:03 +02003685 pool_free(pool_head_quic_arng, next_node);
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003686 /* Decrement the size of these ranges. */
3687 arngs->sz--;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003688 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003689 }
3690
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003691 ret = 1;
3692 leave:
3693 quic_arngs_set_enc_sz(qc, arngs);
3694 TRACE_LEAVE(QUIC_EV_CONN_RXPKT, qc);
3695 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003696}
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003697/* Remove the header protection of packets at <el> encryption level.
3698 * Always succeeds.
3699 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01003700static inline void qc_rm_hp_pkts(struct quic_conn *qc, struct quic_enc_level *el)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003701{
3702 struct quic_tls_ctx *tls_ctx;
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02003703 struct quic_rx_packet *pqpkt, *pkttmp;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003704 struct quic_enc_level *app_qel;
3705
Amaury Denoyellee81fed92021-12-22 11:06:34 +01003706 TRACE_ENTER(QUIC_EV_CONN_ELRMHP, qc);
3707 app_qel = &qc->els[QUIC_TLS_ENC_LEVEL_APP];
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003708 /* A server must not process incoming 1-RTT packets before the handshake is complete. */
Frédéric Lécaillefc790062022-03-28 17:10:31 +02003709 if (el == app_qel && qc_is_listener(qc) && qc->state < QUIC_HS_ST_COMPLETE) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003710 TRACE_DEVEL("hp not removed (handshake not completed)",
Amaury Denoyellee81fed92021-12-22 11:06:34 +01003711 QUIC_EV_CONN_ELRMHP, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003712 goto out;
3713 }
3714 tls_ctx = &el->tls_ctx;
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02003715 list_for_each_entry_safe(pqpkt, pkttmp, &el->rx.pqpkts, list) {
Amaury Denoyellee81fed92021-12-22 11:06:34 +01003716 if (!qc_do_rm_hp(qc, pqpkt, tls_ctx, el->pktns->rx.largest_pn,
Frédéric Lécaille99897d12022-08-08 10:28:07 +02003717 pqpkt->data + pqpkt->pn_offset, pqpkt->data)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003718 TRACE_ERROR("hp removing error", QUIC_EV_CONN_ELRMHP, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003719 }
3720 else {
3721 /* The AAD includes the packet number field */
3722 pqpkt->aad_len = pqpkt->pn_offset + pqpkt->pnl;
3723 /* Store the packet into the tree of packets to decrypt. */
3724 pqpkt->pn_node.key = pqpkt->pn;
Frédéric Lécailleebc3fc12021-09-22 08:34:21 +02003725 eb64_insert(&el->rx.pkts, &pqpkt->pn_node);
3726 quic_rx_packet_refinc(pqpkt);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003727 TRACE_DEVEL("hp removed", QUIC_EV_CONN_ELRMHP, qc, pqpkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003728 }
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02003729 LIST_DELETE(&pqpkt->list);
Frédéric Lécaillea11d0e22021-06-07 14:38:18 +02003730 quic_rx_packet_refdec(pqpkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003731 }
3732
3733 out:
Amaury Denoyellee81fed92021-12-22 11:06:34 +01003734 TRACE_LEAVE(QUIC_EV_CONN_ELRMHP, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003735}
3736
3737/* Process all the CRYPTO frame at <el> encryption level.
3738 * Return 1 if succeeded, 0 if not.
3739 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003740static inline int qc_treat_rx_crypto_frms(struct quic_conn *qc,
3741 struct quic_enc_level *el,
Frédéric Lécaille1eaec332021-06-04 14:59:59 +02003742 struct ssl_sock_ctx *ctx)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003743{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003744 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003745 struct eb64_node *node;
3746
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003747 TRACE_ENTER(QUIC_EV_CONN_TRMHP, qc);
3748
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003749 node = eb64_first(&el->rx.crypto.frms);
3750 while (node) {
3751 struct quic_rx_crypto_frm *cf;
3752
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003753 cf = eb64_entry(node, struct quic_rx_crypto_frm, offset_node);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003754 if (cf->offset_node.key != el->rx.crypto.offset)
3755 break;
3756
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003757 if (!qc_provide_cdata(el, ctx, cf->data, cf->len, cf->pkt, cf)) {
3758 TRACE_ERROR("qc_provide_cdata() failed", QUIC_EV_CONN_TRMHP);
3759 goto leave;
3760 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003761
3762 node = eb64_next(node);
3763 quic_rx_packet_refdec(cf->pkt);
3764 eb64_delete(&cf->offset_node);
3765 pool_free(pool_head_quic_rx_crypto_frm, cf);
3766 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003767
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003768 ret = 1;
3769 leave:
3770 TRACE_LEAVE(QUIC_EV_CONN_TRMHP, qc);
3771 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003772}
3773
Frédéric Lécaille3230bcf2021-09-22 15:15:46 +02003774/* Process all the packets at <el> and <next_el> encryption level.
Ilya Shipitsinbd6b4be2021-10-15 16:18:21 +05003775 * This is the caller responsibility to check that <cur_el> is different of <next_el>
Frédéric Lécaille3230bcf2021-09-22 15:15:46 +02003776 * as pointer value.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003777 * Return 1 if succeeded, 0 if not.
3778 */
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003779int qc_treat_rx_pkts(struct quic_enc_level *cur_el, struct quic_enc_level *next_el,
3780 struct ssl_sock_ctx *ctx, int force_ack)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003781{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003782 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003783 struct eb64_node *node;
Frédéric Lécaille120ea6f2021-07-26 16:42:56 +02003784 int64_t largest_pn = -1;
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02003785 unsigned int largest_pn_time_received = 0;
Amaury Denoyelle29632b82022-01-18 16:50:58 +01003786 struct quic_conn *qc = ctx->qc;
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003787 struct quic_enc_level *qel = cur_el;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003788
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003789 TRACE_ENTER(QUIC_EV_CONN_RXPKT, ctx->qc);
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003790 qel = cur_el;
3791 next_tel:
3792 if (!qel)
3793 goto out;
3794
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003795 node = eb64_first(&qel->rx.pkts);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003796 while (node) {
3797 struct quic_rx_packet *pkt;
3798
Frédéric Lécaillea54e49d2022-05-10 15:15:24 +02003799 pkt = eb64_entry(node, struct quic_rx_packet, pn_node);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003800 TRACE_DATA("new packet", QUIC_EV_CONN_RXPKT,
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01003801 ctx->qc, pkt, NULL, ctx->ssl);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003802 if (!qc_pkt_decrypt(pkt, qel, qc)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003803 /* Drop the packet */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003804 TRACE_ERROR("packet decryption failed -> dropped",
3805 QUIC_EV_CONN_RXPKT, ctx->qc, pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003806 }
3807 else {
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003808 if (!qc_parse_pkt_frms(pkt, ctx, qel)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003809 /* Drop the packet */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003810 TRACE_ERROR("packet parsing failed -> dropped",
3811 QUIC_EV_CONN_RXPKT, ctx->qc, pkt);
Frédéric Lécailleeb791452022-05-24 16:01:39 +02003812 HA_ATOMIC_INC(&qc->prx_counters->dropped_parsing);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003813 }
3814 else {
Frédéric Lécaille8090b512020-11-30 16:19:22 +01003815 struct quic_arng ar = { .first = pkt->pn, .last = pkt->pn };
3816
Frédéric Lécailleb0021452022-03-29 11:42:03 +02003817 if (pkt->flags & QUIC_FL_RX_PACKET_ACK_ELICITING || force_ack) {
3818 qel->pktns->flags |= QUIC_FL_PKTNS_ACK_REQUIRED;
3819 qel->pktns->rx.nb_aepkts_since_last_ack++;
Frédéric Lécaille530601c2022-03-10 15:11:57 +01003820 qc_idle_timer_rearm(qc, 1);
3821 }
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02003822 if (pkt->pn > largest_pn) {
Frédéric Lécaille120ea6f2021-07-26 16:42:56 +02003823 largest_pn = pkt->pn;
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02003824 largest_pn_time_received = pkt->time_received;
3825 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003826 /* Update the list of ranges to acknowledge. */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003827 if (!quic_update_ack_ranges_list(qc, &qel->pktns->rx.arngs, &ar))
3828 TRACE_ERROR("Could not update ack range list",
3829 QUIC_EV_CONN_RXPKT, ctx->qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003830 }
3831 }
3832 node = eb64_next(node);
Frédéric Lécailleebc3fc12021-09-22 08:34:21 +02003833 eb64_delete(&pkt->pn_node);
3834 quic_rx_packet_refdec(pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003835 }
3836
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02003837 if (largest_pn != -1 && largest_pn > qel->pktns->rx.largest_pn) {
3838 /* Update the largest packet number. */
Frédéric Lécaille205e4f32022-03-28 17:38:27 +02003839 qel->pktns->rx.largest_pn = largest_pn;
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02003840 /* Update the largest acknowledged packet timestamps */
3841 qel->pktns->rx.largest_time_received = largest_pn_time_received;
3842 qel->pktns->flags |= QUIC_FL_PKTNS_NEW_LARGEST_PN;
3843 }
3844
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003845 if (!qc_treat_rx_crypto_frms(qc, qel, ctx)) {
3846 // trace already emitted by function above
3847 goto leave;
3848 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003849
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003850 if (qel == cur_el) {
Frédéric Lécaille3230bcf2021-09-22 15:15:46 +02003851 BUG_ON(qel == next_el);
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003852 qel = next_el;
Frédéric Lécaille91a211f2022-05-24 10:54:42 +02003853 largest_pn = -1;
Frédéric Lécaille2766e782021-08-30 17:16:07 +02003854 goto next_tel;
3855 }
3856
3857 out:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003858 ret = 1;
3859 leave:
3860 TRACE_LEAVE(QUIC_EV_CONN_RXPKT, ctx->qc);
3861 return ret;
3862}
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01003863
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003864/* Check if it's possible to remove header protection for packets related to
3865 * encryption level <qel>. If <qel> is NULL, assume it's false.
3866 *
3867 * Return true if the operation is possible else false.
3868 */
3869static int qc_qel_may_rm_hp(struct quic_conn *qc, struct quic_enc_level *qel)
3870{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003871 int ret = 0;
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003872 enum quic_tls_enc_level tel;
3873
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003874 TRACE_ENTER(QUIC_EV_CONN_TRMHP, qc);
3875
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003876 if (!qel)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003877 goto cant_rm_hp;
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003878
3879 tel = ssl_to_quic_enc_level(qel->level);
3880
3881 /* check if tls secrets are available */
Frédéric Lécaillebd242082022-02-25 17:17:59 +01003882 if (qel->tls_ctx.flags & QUIC_FL_TLS_SECRETS_DCD) {
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003883 TRACE_DEVEL("Discarded keys", QUIC_EV_CONN_TRMHP, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003884 goto cant_rm_hp;
Frédéric Lécaille51c90652022-02-22 11:39:14 +01003885 }
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003886
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003887 if (!(qel->tls_ctx.flags & QUIC_FL_TLS_SECRETS_SET)) {
3888 TRACE_DEVEL("non available secrets", QUIC_EV_CONN_TRMHP, qc);
3889 goto cant_rm_hp;
3890 }
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003891
Amaury Denoyelle0b1f9312022-01-26 09:51:28 +01003892 /* check if the connection layer is ready before using app level */
Frédéric Lécaille298931d2022-01-28 21:41:06 +01003893 if ((tel == QUIC_TLS_ENC_LEVEL_APP || tel == QUIC_TLS_ENC_LEVEL_EARLY_DATA) &&
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003894 qc->mux_state == QC_MUX_NULL) {
3895 TRACE_DEVEL("connection layer not ready", QUIC_EV_CONN_TRMHP, qc);
3896 goto cant_rm_hp;
3897 }
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003898
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003899 ret = 1;
3900 cant_rm_hp:
3901 TRACE_LEAVE(QUIC_EV_CONN_TRMHP, qc);
3902 return ret;
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01003903}
3904
Amaury Denoyellecc130472022-08-17 10:08:16 +02003905/* Try to send application frames from list <frms> on connection <qc>.
3906 *
Amaury Denoyelle70467562022-08-17 16:33:13 +02003907 * Use qc_send_app_probing wrapper when probing with old data.
Amaury Denoyellecc130472022-08-17 10:08:16 +02003908 *
3909 * Returns 1 on success. Some data might not have been sent due to congestion,
3910 * in this case they are left in <frms> input list. The caller may subscribe on
3911 * quic-conn to retry later.
3912 *
3913 * Returns 0 on critical error.
3914 * TODO review and classify more distinctly transient from definitive errors to
3915 * allow callers to properly handle it.
3916 */
Amaury Denoyelle70467562022-08-17 16:33:13 +02003917static int qc_send_app_pkts(struct quic_conn *qc, struct list *frms)
Frédéric Lécaille00e24002022-02-18 17:13:45 +01003918{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003919 int status = 0;
3920 struct buffer *buf;
3921
3922 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
3923
3924 buf = qc_txb_alloc(qc);
3925 if (!buf) {
3926 TRACE_ERROR("buffer allocation failed", QUIC_EV_CONN_TXPKT, qc);
3927 goto leave;
3928 }
3929
Frédéric Lécailledc077512022-07-26 09:17:19 +02003930 /* Prepare and send packets until we could not further prepare packets. */
3931 while (1) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003932 int ret;
Amaury Denoyellef2476052022-08-04 16:19:57 +02003933 /* Currently buf cannot be non-empty at this stage. Even if a
3934 * previous sendto() has failed it is emptied to simulate
3935 * packet emission and rely on QUIC lost detection to try to
3936 * emit it.
3937 */
3938 BUG_ON_HOT(b_data(buf));
3939 b_reset(buf);
3940
Amaury Denoyellef2476052022-08-04 16:19:57 +02003941 ret = qc_prep_app_pkts(qc, buf, frms);
Frédéric Lécailledc077512022-07-26 09:17:19 +02003942 if (ret == -1)
3943 goto err;
3944 else if (ret == 0)
3945 goto out;
Frédéric Lécaille00e24002022-02-18 17:13:45 +01003946
Amaury Denoyellef2476052022-08-04 16:19:57 +02003947 if (!qc_send_ppkts(buf, qc->xprt_ctx))
Frédéric Lécailledc077512022-07-26 09:17:19 +02003948 goto err;
3949 }
Frédéric Lécaille00e24002022-02-18 17:13:45 +01003950
3951 out:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003952 status = 1;
Amaury Denoyelle5b689862022-08-08 16:07:30 +02003953 qc_txb_release(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003954 leave:
3955 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
3956 return status;
Frédéric Lécaille00e24002022-02-18 17:13:45 +01003957
3958 err:
Amaury Denoyelle5b689862022-08-08 16:07:30 +02003959 qc_txb_release(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02003960 goto leave;
Frédéric Lécaille00e24002022-02-18 17:13:45 +01003961}
3962
Amaury Denoyellecc130472022-08-17 10:08:16 +02003963/* Try to send application frames from list <frms> on connection <qc>. Use this
Amaury Denoyelle70467562022-08-17 16:33:13 +02003964 * function when probing is required.
Amaury Denoyelleb29a1dc2022-08-12 14:30:04 +02003965 *
3966 * Returns the result from qc_send_app_pkts function.
3967 */
Amaury Denoyelle70467562022-08-17 16:33:13 +02003968static forceinline int qc_send_app_probing(struct quic_conn *qc,
3969 struct list *frms)
Amaury Denoyelleb29a1dc2022-08-12 14:30:04 +02003970{
3971 int ret;
3972
3973 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
3974
Amaury Denoyelle70467562022-08-17 16:33:13 +02003975 TRACE_STATE("preparing old data (probing)", QUIC_EV_CONN_TXPKT, qc);
3976 qc->flags |= QUIC_FL_CONN_RETRANS_OLD_DATA;
Amaury Denoyelleb29a1dc2022-08-12 14:30:04 +02003977 ret = qc_send_app_pkts(qc, frms);
Amaury Denoyelle70467562022-08-17 16:33:13 +02003978 qc->flags &= ~QUIC_FL_CONN_RETRANS_OLD_DATA;
Amaury Denoyelleb29a1dc2022-08-12 14:30:04 +02003979
3980 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
3981 return ret;
3982}
3983
Amaury Denoyelle70467562022-08-17 16:33:13 +02003984/* Try to send application frames from list <frms> on connection <qc>. This
3985 * function is provided for MUX upper layer usage only.
Amaury Denoyellecc130472022-08-17 10:08:16 +02003986 *
3987 * Returns the result from qc_send_app_pkts function.
3988 */
Amaury Denoyelle70467562022-08-17 16:33:13 +02003989int qc_send_mux(struct quic_conn *qc, struct list *frms)
Amaury Denoyellecc130472022-08-17 10:08:16 +02003990{
3991 int ret;
3992
3993 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
Amaury Denoyelle70467562022-08-17 16:33:13 +02003994 BUG_ON(qc->mux_state != QC_MUX_READY); /* Only MUX can uses this function so it must be ready. */
Amaury Denoyellecc130472022-08-17 10:08:16 +02003995
Amaury Denoyelle70467562022-08-17 16:33:13 +02003996 TRACE_STATE("preparing data (from MUX)", QUIC_EV_CONN_TXPKT, qc);
3997 qc->flags |= QUIC_FL_CONN_TX_MUX_CONTEXT;
Amaury Denoyellecc130472022-08-17 10:08:16 +02003998 ret = qc_send_app_pkts(qc, frms);
Amaury Denoyelle70467562022-08-17 16:33:13 +02003999 qc->flags &= ~QUIC_FL_CONN_TX_MUX_CONTEXT;
Amaury Denoyellecc130472022-08-17 10:08:16 +02004000
4001 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
4002 return ret;
4003}
4004
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004005/* Sends handshake packets from up to two encryption levels <tel> and <next_te>
4006 * with <tel_frms> and <next_tel_frms> as frame list respectively for <qc>
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004007 * QUIC connection. <old_data> is used as boolean to send data already sent but
4008 * not already acknowledged (in flight).
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004009 * Returns 1 if succeeded, 0 if not.
4010 */
4011int qc_send_hdshk_pkts(struct quic_conn *qc, int old_data,
4012 enum quic_tls_enc_level tel, struct list *tel_frms,
4013 enum quic_tls_enc_level next_tel, struct list *next_tel_frms)
4014{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004015 int ret, status = 0;
Amaury Denoyelle5b689862022-08-08 16:07:30 +02004016 struct buffer *buf = qc_txb_alloc(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004017
4018 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
4019
4020 if (!buf) {
4021 TRACE_ERROR("buffer allocation failed", QUIC_EV_CONN_TXPKT, qc);
4022 goto leave;
4023 }
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004024
Amaury Denoyellef2476052022-08-04 16:19:57 +02004025 /* Currently buf cannot be non-empty at this stage. Even if a previous
4026 * sendto() has failed it is emptied to simulate packet emission and
4027 * rely on QUIC lost detection to try to emit it.
4028 */
4029 BUG_ON_HOT(b_data(buf));
4030 b_reset(buf);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004031
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004032 if (old_data) {
4033 TRACE_STATE("old data for probing asked", QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004034 qc->flags |= QUIC_FL_CONN_RETRANS_OLD_DATA;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004035 }
Amaury Denoyellef2476052022-08-04 16:19:57 +02004036
4037 ret = qc_prep_pkts(qc, buf, tel, tel_frms, next_tel, next_tel_frms);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004038 if (ret == -1)
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004039 goto out;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004040 else if (ret == 0)
4041 goto skip_send;
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004042
Amaury Denoyellef2476052022-08-04 16:19:57 +02004043 if (!qc_send_ppkts(buf, qc->xprt_ctx))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004044 goto out;
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004045
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004046 skip_send:
4047 status = 1;
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004048 out:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004049 TRACE_STATE("no more need old data for probing", QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004050 qc->flags &= ~QUIC_FL_CONN_RETRANS_OLD_DATA;
Amaury Denoyelle5b689862022-08-08 16:07:30 +02004051 qc_txb_release(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004052 leave:
4053 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
4054 return status;
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004055}
4056
4057/* Retransmit up to two datagrams depending on packet number space */
4058static void qc_dgrams_retransmit(struct quic_conn *qc)
4059{
4060 struct quic_enc_level *iqel = &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL];
4061 struct quic_enc_level *hqel = &qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE];
4062 struct quic_enc_level *aqel = &qc->els[QUIC_TLS_ENC_LEVEL_APP];
4063
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004064 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
4065
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004066 if (iqel->pktns->flags & QUIC_FL_PKTNS_PROBE_NEEDED) {
4067 struct list ifrms = LIST_HEAD_INIT(ifrms);
4068 struct list hfrms = LIST_HEAD_INIT(hfrms);
4069
4070 qc_prep_hdshk_fast_retrans(qc, &ifrms, &hfrms);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004071 TRACE_DEVEL("Avail. ack eliciting frames", QUIC_EV_CONN_FRMLIST, qc, &ifrms);
4072 TRACE_DEVEL("Avail. ack eliciting frames", QUIC_EV_CONN_FRMLIST, qc, &hfrms);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004073 if (!LIST_ISEMPTY(&ifrms)) {
4074 iqel->pktns->tx.pto_probe = 1;
4075 if (!LIST_ISEMPTY(&hfrms)) {
4076 hqel->pktns->tx.pto_probe = 1;
4077 qc_send_hdshk_pkts(qc, 1, QUIC_TLS_ENC_LEVEL_INITIAL, &ifrms,
4078 QUIC_TLS_ENC_LEVEL_HANDSHAKE, &hfrms);
4079 }
4080 }
4081 if (hqel->pktns->flags & QUIC_FL_PKTNS_PROBE_NEEDED) {
4082 qc_prep_fast_retrans(qc, hqel, &hfrms, NULL);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004083 TRACE_DEVEL("Avail. ack eliciting frames", QUIC_EV_CONN_FRMLIST, qc, &hfrms);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004084 if (!LIST_ISEMPTY(&hfrms)) {
4085 hqel->pktns->tx.pto_probe = 1;
4086 qc_send_hdshk_pkts(qc, 1, QUIC_TLS_ENC_LEVEL_HANDSHAKE, &hfrms,
4087 QUIC_TLS_ENC_LEVEL_NONE, NULL);
4088 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004089 TRACE_STATE("no more need to probe Handshake packet number space",
4090 QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004091 hqel->pktns->flags &= ~QUIC_FL_PKTNS_PROBE_NEEDED;
4092 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004093 TRACE_STATE("no more need to probe Initial packet number space",
4094 QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004095 iqel->pktns->flags &= ~QUIC_FL_PKTNS_PROBE_NEEDED;
4096 }
4097 else {
4098 int i;
4099 struct list frms1 = LIST_HEAD_INIT(frms1);
4100 struct list frms2 = LIST_HEAD_INIT(frms2);
4101
4102 if (hqel->pktns->flags & QUIC_FL_PKTNS_PROBE_NEEDED) {
4103 hqel->pktns->tx.pto_probe = 0;
4104 for (i = 0; i < QUIC_MAX_NB_PTO_DGRAMS; i++) {
4105 qc_prep_fast_retrans(qc, hqel, &frms1, NULL);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004106 TRACE_DEVEL("Avail. ack eliciting frames", QUIC_EV_CONN_FRMLIST, qc, &frms1);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004107 if (!LIST_ISEMPTY(&frms1)) {
4108 hqel->pktns->tx.pto_probe = 1;
4109 qc_send_hdshk_pkts(qc, 1, QUIC_TLS_ENC_LEVEL_HANDSHAKE, &frms1,
4110 QUIC_TLS_ENC_LEVEL_NONE, NULL);
4111 }
4112 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004113 TRACE_STATE("no more need to probe Handshake packet number space",
4114 QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004115 hqel->pktns->flags &= ~QUIC_FL_PKTNS_PROBE_NEEDED;
4116 }
4117 else if (aqel->pktns->flags & QUIC_FL_PKTNS_PROBE_NEEDED) {
4118 aqel->pktns->tx.pto_probe = 0;
4119 qc_prep_fast_retrans(qc, aqel, &frms1, &frms2);
4120 TRACE_PROTO("Avail. ack eliciting frames", QUIC_EV_CONN_FRMLIST, qc, &frms1);
4121 TRACE_PROTO("Avail. ack eliciting frames", QUIC_EV_CONN_FRMLIST, qc, &frms2);
4122 if (!LIST_ISEMPTY(&frms1)) {
4123 aqel->pktns->tx.pto_probe = 1;
Amaury Denoyellecc130472022-08-17 10:08:16 +02004124 qc_send_app_probing(qc, &frms1);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004125 }
4126 if (!LIST_ISEMPTY(&frms2)) {
4127 aqel->pktns->tx.pto_probe = 1;
Amaury Denoyellecc130472022-08-17 10:08:16 +02004128 qc_send_app_probing(qc, &frms2);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004129 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004130 TRACE_STATE("no more need to probe 01RTT packet number space",
4131 QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004132 aqel->pktns->flags &= ~QUIC_FL_PKTNS_PROBE_NEEDED;
4133 }
4134 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004135 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea9568412022-04-25 08:58:04 +02004136}
4137
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004138/* QUIC connection packet handler task (post handshake) */
4139static struct task *quic_conn_app_io_cb(struct task *t, void *context, unsigned int state)
4140{
4141 struct ssl_sock_ctx *ctx;
4142 struct quic_conn *qc;
4143 struct quic_enc_level *qel;
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004144
4145
4146 ctx = context;
4147 qc = ctx->qc;
4148 qel = &qc->els[QUIC_TLS_ENC_LEVEL_APP];
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004149
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004150 TRACE_ENTER(QUIC_EV_CONN_IO_CB, qc);
4151 TRACE_STATE("connection handshake state", QUIC_EV_CONN_IO_CB, qc, &qc->state);
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004152
Frédéric Lécaille7aef5f42022-04-25 10:33:12 +02004153 /* Retranmissions */
4154 if (qc->flags & QUIC_FL_CONN_RETRANS_NEEDED) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004155 TRACE_STATE("retransmission needed", QUIC_EV_CONN_IO_CB, qc);
Frédéric Lécaille7aef5f42022-04-25 10:33:12 +02004156 qc->flags &= ~QUIC_FL_CONN_RETRANS_NEEDED;
4157 qc_dgrams_retransmit(qc);
4158 }
4159
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004160 if (!LIST_ISEMPTY(&qel->rx.pqpkts) && qc_qel_may_rm_hp(qc, qel))
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004161 qc_rm_hp_pkts(qc, qel);
4162
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004163 if (!qc_treat_rx_pkts(qel, NULL, ctx, 0)) {
4164 TRACE_DEVEL("qc_treat_rx_pkts() failed", QUIC_EV_CONN_IO_CB, qc);
4165 goto out;
4166 }
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004167
Frédéric Lécaille47756802022-03-25 09:12:16 +01004168 if ((qc->flags & QUIC_FL_CONN_DRAINING) &&
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004169 !(qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE)) {
4170 TRACE_STATE("draining connection (must not send packets)", QUIC_EV_CONN_IO_CB, qc);
Frédéric Lécaille47756802022-03-25 09:12:16 +01004171 goto out;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004172 }
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004173
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004174 /* XXX TODO: how to limit the list frames to send */
Amaury Denoyelle70467562022-08-17 16:33:13 +02004175 if (!qc_send_app_pkts(qc, &qel->pktns->tx.frms)) {
4176 TRACE_DEVEL("qc_send_app_pkts() failed", QUIC_EV_CONN_IO_CB, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004177 goto out;
4178 }
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004179
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004180 out:
4181 TRACE_LEAVE(QUIC_EV_CONN_IO_CB, qc);
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004182 return t;
4183}
4184
Amaury Denoyellec09ef0c2022-08-08 18:15:24 +02004185/* Returns a boolean if <qc> needs to emit frames for <qel> encryption level. */
4186static int qc_need_sending(struct quic_conn *qc, struct quic_enc_level *qel)
4187{
4188 return (qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE) ||
4189 (qel->pktns->flags & QUIC_FL_PKTNS_ACK_REQUIRED) ||
4190 qel->pktns->tx.pto_probe ||
4191 !LIST_ISEMPTY(&qel->pktns->tx.frms);
4192}
4193
Frédéric Lécaille91ae7aa2021-08-03 16:45:39 +02004194/* QUIC connection packet handler task. */
4195struct task *quic_conn_io_cb(struct task *t, void *context, unsigned int state)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004196{
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02004197 int ret, ssl_err;
Frédéric Lécaille91ae7aa2021-08-03 16:45:39 +02004198 struct ssl_sock_ctx *ctx;
Frédéric Lécaillea5fe49f2021-06-04 11:52:35 +02004199 struct quic_conn *qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004200 enum quic_tls_enc_level tel, next_tel;
4201 struct quic_enc_level *qel, *next_qel;
Amaury Denoyellef2476052022-08-04 16:19:57 +02004202 struct buffer *buf = NULL;
Frédéric Lécaillede6f7c52022-01-03 17:25:53 +01004203 int st, force_ack, zero_rtt;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004204
Frédéric Lécaille91ae7aa2021-08-03 16:45:39 +02004205 ctx = context;
Amaury Denoyellec15dd922021-12-21 11:41:52 +01004206 qc = ctx->qc;
Frédéric Lécaille00e24002022-02-18 17:13:45 +01004207 TRACE_ENTER(QUIC_EV_CONN_IO_CB, qc);
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004208 st = qc->state;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004209 TRACE_PROTO("connection state", QUIC_EV_CONN_IO_CB, qc, &st);
Frédéric Lécaille7aef5f42022-04-25 10:33:12 +02004210
4211 /* Retranmissions */
4212 if (qc->flags & QUIC_FL_CONN_RETRANS_NEEDED) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004213 TRACE_DEVEL("retransmission needed", QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaille7aef5f42022-04-25 10:33:12 +02004214 qc->flags &= ~QUIC_FL_CONN_RETRANS_NEEDED;
4215 qc_dgrams_retransmit(qc);
4216 }
4217
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004218 if (qc->flags & QUIC_FL_CONN_IO_CB_WAKEUP) {
4219 qc->flags &= ~QUIC_FL_CONN_IO_CB_WAKEUP;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004220 TRACE_DEVEL("needs to wakeup the timer task after the anti-amplicaiton limit was reached",
4221 QUIC_EV_CONN_IO_CB, qc);
4222 /* The I/O handler has been woken up by the dgram parser (qc_lstnr_pkt_rcv())
Frédéric Lécaille6b663152022-01-04 17:03:11 +01004223 * after the anti-amplification was reached.
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004224 *
4225 * TODO: this part should be removed. This was there because the
4226 * datagram parser was not executed by only one thread.
Frédéric Lécaille59507de2022-08-11 12:14:07 +02004227 */
Frédéric Lécaille6b663152022-01-04 17:03:11 +01004228 qc_set_timer(qc);
4229 if (tick_isset(qc->timer) && tick_is_lt(qc->timer, now_ms))
4230 task_wakeup(qc->timer_task, TASK_WOKEN_MSG);
4231 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004232 ssl_err = SSL_ERROR_NONE;
Frédéric Lécaille4137b2d2021-12-17 18:24:16 +01004233 zero_rtt = st < QUIC_HS_ST_COMPLETE &&
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004234 (!LIST_ISEMPTY(&qc->els[QUIC_TLS_ENC_LEVEL_EARLY_DATA].rx.pqpkts) ||
Frédéric Lécaille4137b2d2021-12-17 18:24:16 +01004235 qc_el_rx_pkts(&qc->els[QUIC_TLS_ENC_LEVEL_EARLY_DATA]));
Frédéric Lécaille2766e782021-08-30 17:16:07 +02004236 start:
Frédéric Lécaille917a7db2022-01-03 17:00:35 +01004237 if (st >= QUIC_HS_ST_COMPLETE &&
4238 qc_el_rx_pkts(&qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE])) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004239 TRACE_DEVEL("remaining Handshake packets", QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaille917a7db2022-01-03 17:00:35 +01004240 /* There may be remaining Handshake packets to treat and acknowledge. */
4241 tel = QUIC_TLS_ENC_LEVEL_HANDSHAKE;
4242 next_tel = QUIC_TLS_ENC_LEVEL_APP;
4243 }
4244 else if (!quic_get_tls_enc_levels(&tel, &next_tel, st, zero_rtt))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004245 goto out;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004246
Frédéric Lécaillea5fe49f2021-06-04 11:52:35 +02004247 qel = &qc->els[tel];
Frédéric Lécaillef7980962021-08-19 17:35:21 +02004248 next_qel = next_tel == QUIC_TLS_ENC_LEVEL_NONE ? NULL : &qc->els[next_tel];
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004249
4250 next_level:
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01004251 /* Treat packets waiting for header packet protection decryption */
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004252 if (!LIST_ISEMPTY(&qel->rx.pqpkts) && qc_qel_may_rm_hp(qc, qel))
Amaury Denoyellee81fed92021-12-22 11:06:34 +01004253 qc_rm_hp_pkts(qc, qel);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004254
Frédéric Lécaille2766e782021-08-30 17:16:07 +02004255 force_ack = qel == &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL] ||
4256 qel == &qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE];
4257 if (!qc_treat_rx_pkts(qel, next_qel, ctx, force_ack))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004258 goto out;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004259
Frédéric Lécaille47756802022-03-25 09:12:16 +01004260 if ((qc->flags & QUIC_FL_CONN_DRAINING) &&
4261 !(qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE))
4262 goto out;
4263
Frédéric Lécaille1231d3c2022-04-28 15:43:46 +02004264 if (next_qel && next_qel == &qc->els[QUIC_TLS_ENC_LEVEL_EARLY_DATA] &&
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004265 !LIST_ISEMPTY(&next_qel->rx.pqpkts)) {
Frédéric Lécaille1231d3c2022-04-28 15:43:46 +02004266 if ((next_qel->tls_ctx.flags & QUIC_FL_TLS_SECRETS_SET)) {
4267 qel = next_qel;
4268 next_qel = NULL;
4269 goto next_level;
4270 }
4271 else {
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004272 struct quic_rx_packet *pkt, *pkttmp;
Frédéric Lécaille1231d3c2022-04-28 15:43:46 +02004273 struct quic_enc_level *aqel = &qc->els[QUIC_TLS_ENC_LEVEL_EARLY_DATA];
4274
4275 /* Drop these 0-RTT packets */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004276 TRACE_DEVEL("drop all 0-RTT packets", QUIC_EV_CONN_PHPKTS, qc);
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004277 list_for_each_entry_safe(pkt, pkttmp, &aqel->rx.pqpkts, list) {
4278 LIST_DELETE(&pkt->list);
Frédéric Lécaille1231d3c2022-04-28 15:43:46 +02004279 quic_rx_packet_refdec(pkt);
4280 }
4281 }
Frédéric Lécaillea5da31d2021-12-14 19:44:14 +01004282 }
4283
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004284 st = qc->state;
Frédéric Lécaillede6f7c52022-01-03 17:25:53 +01004285 if (st >= QUIC_HS_ST_COMPLETE) {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004286 if (!(qc->flags & QUIC_FL_CONN_POST_HANDSHAKE_FRAMES_BUILT) &&
Frédéric Lécaillede6f7c52022-01-03 17:25:53 +01004287 !quic_build_post_handshake_frames(qc))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004288 goto out;
Frédéric Lécaillefee7ba62021-12-06 12:09:08 +01004289
Frédéric Lécaillebd242082022-02-25 17:17:59 +01004290 if (!(qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE].tls_ctx.flags &
Frédéric Lécaillede6f7c52022-01-03 17:25:53 +01004291 QUIC_FL_TLS_SECRETS_DCD)) {
4292 /* Discard the Handshake keys. */
4293 quic_tls_discard_keys(&qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE]);
4294 TRACE_PROTO("discarding Handshake pktns", QUIC_EV_CONN_PHPKTS, qc);
4295 quic_pktns_discard(qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE].pktns, qc);
4296 qc_set_timer(qc);
Frédéric Lécaillede6f7c52022-01-03 17:25:53 +01004297 qc_el_rx_pkts_del(&qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE]);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004298 qc_release_pktns_frms(qc, qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE].pktns);
Frédéric Lécaillede6f7c52022-01-03 17:25:53 +01004299 }
4300
4301 if (qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE].pktns->flags & QUIC_FL_PKTNS_ACK_REQUIRED) {
4302 /* There may be remaining handshake to build (acks) */
4303 st = QUIC_HS_ST_SERVER_HANDSHAKE;
4304 }
Frédéric Lécaille91ae7aa2021-08-03 16:45:39 +02004305 }
4306
Frédéric Lécaillebec186d2022-01-12 15:32:55 +01004307 /* A listener does not send any O-RTT packet. O-RTT packet number space must not
4308 * be considered.
4309 */
4310 if (!quic_get_tls_enc_levels(&tel, &next_tel, st, 0))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004311 goto out;
Amaury Denoyellef2476052022-08-04 16:19:57 +02004312
Amaury Denoyellef0f92b22022-08-09 17:52:52 +02004313 if (!qc_need_sending(qc, qel) &&
4314 (!next_qel || !qc_need_sending(qc, next_qel))) {
Amaury Denoyellec09ef0c2022-08-08 18:15:24 +02004315 goto skip_send;
Amaury Denoyellef0f92b22022-08-09 17:52:52 +02004316 }
Amaury Denoyellec09ef0c2022-08-08 18:15:24 +02004317
Amaury Denoyelle5b689862022-08-08 16:07:30 +02004318 buf = qc_txb_alloc(qc);
Amaury Denoyellef2476052022-08-04 16:19:57 +02004319 if (!buf)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004320 goto out;
Amaury Denoyellef2476052022-08-04 16:19:57 +02004321
4322 /* Currently buf cannot be non-empty at this stage. Even if a previous
4323 * sendto() has failed it is emptied to simulate packet emission and
4324 * rely on QUIC lost detection to try to emit it.
4325 */
4326 BUG_ON_HOT(b_data(buf));
4327 b_reset(buf);
4328
4329 ret = qc_prep_pkts(qc, buf, tel, &qc->els[tel].pktns->tx.frms,
Frédéric Lécaillefc888442022-04-11 15:39:34 +02004330 next_tel, &qc->els[next_tel].pktns->tx.frms);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02004331 if (ret == -1)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004332 goto out;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02004333 else if (ret == 0)
4334 goto skip_send;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004335
Amaury Denoyellef2476052022-08-04 16:19:57 +02004336 if (!qc_send_ppkts(buf, ctx))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004337 goto out;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004338
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02004339 skip_send:
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004340 /* Check if there is something to do for the next level.
4341 */
Frédéric Lécaille3230bcf2021-09-22 15:15:46 +02004342 if (next_qel && next_qel != qel &&
Frédéric Lécaillebd242082022-02-25 17:17:59 +01004343 (next_qel->tls_ctx.flags & QUIC_FL_TLS_SECRETS_SET) &&
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004344 (!LIST_ISEMPTY(&next_qel->rx.pqpkts) || qc_el_rx_pkts(next_qel))) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004345 qel = next_qel;
Frédéric Lécaille3230bcf2021-09-22 15:15:46 +02004346 next_qel = NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004347 goto next_level;
4348 }
4349
Frédéric Lécaille47756802022-03-25 09:12:16 +01004350 out:
Amaury Denoyelle5b689862022-08-08 16:07:30 +02004351 qc_txb_release(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004352 TRACE_LEAVE(QUIC_EV_CONN_IO_CB, qc, &st, &ssl_err);
Frédéric Lécaille91ae7aa2021-08-03 16:45:39 +02004353 return t;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004354}
4355
Ilya Shipitsin1e9a6662021-01-05 22:10:46 +05004356/* Uninitialize <qel> QUIC encryption level. Never fails. */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004357static void quic_conn_enc_level_uninit(struct quic_conn *qc, struct quic_enc_level *qel)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004358{
4359 int i;
4360
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004361 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
4362
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004363 for (i = 0; i < qel->tx.crypto.nb_buf; i++) {
4364 if (qel->tx.crypto.bufs[i]) {
4365 pool_free(pool_head_quic_crypto_buf, qel->tx.crypto.bufs[i]);
4366 qel->tx.crypto.bufs[i] = NULL;
4367 }
4368 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01004369 ha_free(&qel->tx.crypto.bufs);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004370
4371 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004372}
4373
4374/* Initialize QUIC TLS encryption level with <level<> as level for <qc> QUIC
Ilya Shipitsin1e9a6662021-01-05 22:10:46 +05004375 * connection allocating everything needed.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004376 * Returns 1 if succeeded, 0 if not.
4377 */
4378static int quic_conn_enc_level_init(struct quic_conn *qc,
4379 enum quic_tls_enc_level level)
4380{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004381 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004382 struct quic_enc_level *qel;
4383
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004384 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
4385
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004386 qel = &qc->els[level];
4387 qel->level = quic_to_ssl_enc_level(level);
4388 qel->tls_ctx.rx.aead = qel->tls_ctx.tx.aead = NULL;
4389 qel->tls_ctx.rx.md = qel->tls_ctx.tx.md = NULL;
4390 qel->tls_ctx.rx.hp = qel->tls_ctx.tx.hp = NULL;
Frédéric Lécaillefc768ec2021-11-23 21:02:04 +01004391 qel->tls_ctx.flags = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004392
4393 qel->rx.pkts = EB_ROOT;
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02004394 LIST_INIT(&qel->rx.pqpkts);
Frédéric Lécaille9054d1b2021-07-26 16:23:53 +02004395 qel->rx.crypto.offset = 0;
4396 qel->rx.crypto.frms = EB_ROOT_UNIQUE;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004397
4398 /* Allocate only one buffer. */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004399 /* TODO: use a pool */
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004400 qel->tx.crypto.bufs = malloc(sizeof *qel->tx.crypto.bufs);
4401 if (!qel->tx.crypto.bufs)
4402 goto err;
4403
4404 qel->tx.crypto.bufs[0] = pool_alloc(pool_head_quic_crypto_buf);
4405 if (!qel->tx.crypto.bufs[0])
4406 goto err;
4407
4408 qel->tx.crypto.bufs[0]->sz = 0;
4409 qel->tx.crypto.nb_buf = 1;
4410
4411 qel->tx.crypto.sz = 0;
4412 qel->tx.crypto.offset = 0;
4413
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004414 ret = 1;
4415 leave:
4416 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
4417 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004418
4419 err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01004420 ha_free(&qel->tx.crypto.bufs);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004421 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004422}
4423
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004424/* Release the quic_conn <qc>. The connection is removed from the CIDs tree.
4425 * The connection tasklet is killed.
Amaury Denoyelle76f47ca2021-12-23 10:02:50 +01004426 *
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004427 * This function must only be called by the thread responsible of the quic_conn
4428 * tasklet.
Amaury Denoyelle76f47ca2021-12-23 10:02:50 +01004429 */
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004430static void quic_conn_release(struct quic_conn *qc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004431{
4432 int i;
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004433 struct ssl_sock_ctx *conn_ctx;
Amaury Denoyelle5c3859c2022-03-29 14:49:35 +02004434 struct eb64_node *node;
Frédéric Lécaille96fd1632022-04-01 11:21:47 +02004435 struct quic_tls_ctx *app_tls_ctx;
Amaury Denoyelle2c31e122022-06-20 10:52:55 +02004436 struct quic_rx_packet *pkt, *pktback;
Amaury Denoyelle5c3859c2022-03-29 14:49:35 +02004437
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004438 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
4439
Amaury Denoyelledb71e3b2022-04-06 17:22:12 +02004440 /* We must not free the quic-conn if the MUX is still allocated. */
4441 BUG_ON(qc->mux_state == QC_MUX_READY);
4442
Willy Tarreau54bc7862022-08-10 07:26:27 +02004443 /* in the unlikely (but possible) case the connection was just added to
4444 * the accept_list we must delete it from there.
4445 */
4446 MT_LIST_DELETE(&qc->accept_list);
4447
Amaury Denoyelle5c3859c2022-03-29 14:49:35 +02004448 /* free remaining stream descriptors */
4449 node = eb64_first(&qc->streams_by_id);
4450 while (node) {
4451 struct qc_stream_desc *stream;
4452
4453 stream = eb64_entry(node, struct qc_stream_desc, by_id);
4454 node = eb64_next(node);
4455
Amaury Denoyellec9acc312022-04-01 16:41:21 +02004456 /* all streams attached to the quic-conn are released, so
4457 * qc_stream_desc_free will liberate the stream instance.
4458 */
4459 BUG_ON(!stream->release);
Frédéric Lécailleea4a5cb2022-08-20 18:59:36 +02004460 qc_stream_desc_free(stream, 1);
Amaury Denoyelle5c3859c2022-03-29 14:49:35 +02004461 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004462
Amaury Denoyelle2c31e122022-06-20 10:52:55 +02004463 /* Purge Rx packet list. */
4464 list_for_each_entry_safe(pkt, pktback, &qc->rx.pkt_list, qc_rx_pkt_list) {
4465 LIST_DELETE(&pkt->qc_rx_pkt_list);
4466 pool_free(pool_head_quic_rx_packet, pkt);
4467 }
4468
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004469 if (qc->idle_timer_task) {
4470 task_destroy(qc->idle_timer_task);
4471 qc->idle_timer_task = NULL;
4472 }
4473
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004474 if (qc->timer_task) {
4475 task_destroy(qc->timer_task);
4476 qc->timer_task = NULL;
4477 }
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004478
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004479 /* remove the connection from receiver cids trees */
4480 ebmb_delete(&qc->odcid_node);
4481 ebmb_delete(&qc->scid_node);
4482 free_quic_conn_cids(qc);
Amaury Denoyelle2af19852021-09-30 11:03:28 +02004483
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004484 conn_ctx = qc->xprt_ctx;
Amaury Denoyelle2d9794b2022-01-20 17:43:20 +01004485 if (conn_ctx) {
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004486 tasklet_free(conn_ctx->wait_event.tasklet);
Amaury Denoyelle2d9794b2022-01-20 17:43:20 +01004487 SSL_free(conn_ctx->ssl);
Amaury Denoyelle76f47ca2021-12-23 10:02:50 +01004488 pool_free(pool_head_quic_conn_ctx, conn_ctx);
Amaury Denoyelle2d9794b2022-01-20 17:43:20 +01004489 }
Amaury Denoyelle76f47ca2021-12-23 10:02:50 +01004490
Frédéric Lécaille96fd1632022-04-01 11:21:47 +02004491 quic_tls_ku_free(qc);
4492 for (i = 0; i < QUIC_TLS_ENC_LEVEL_MAX; i++) {
4493 quic_tls_ctx_secs_free(&qc->els[i].tls_ctx);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004494 quic_conn_enc_level_uninit(qc, &qc->els[i]);
Frédéric Lécaille96fd1632022-04-01 11:21:47 +02004495 }
Frédéric Lécaille301425b2022-06-14 17:40:39 +02004496 quic_tls_ctx_secs_free(&qc->negotiated_ictx);
Frédéric Lécaille96fd1632022-04-01 11:21:47 +02004497
4498 app_tls_ctx = &qc->els[QUIC_TLS_ENC_LEVEL_APP].tls_ctx;
4499 pool_free(pool_head_quic_tls_secret, app_tls_ctx->rx.secret);
4500 pool_free(pool_head_quic_tls_secret, app_tls_ctx->tx.secret);
Amaury Denoyelle0a29e132021-12-23 15:06:56 +01004501
Frédéric Lécailleeb2a2da2022-04-01 12:15:24 +02004502 for (i = 0; i < QUIC_TLS_PKTNS_MAX; i++) {
Frédéric Lécaille8ddde4f2022-08-01 14:07:50 +02004503 quic_pktns_tx_pkts_release(&qc->pktns[i], qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004504 quic_free_arngs(qc, &qc->pktns[i].rx.arngs);
Frédéric Lécailleeb2a2da2022-04-01 12:15:24 +02004505 }
Frédéric Lécaille64670882022-04-01 11:57:19 +02004506
Amaury Denoyelle67e6cd52021-12-13 17:07:03 +01004507 pool_free(pool_head_quic_conn_rxbuf, qc->rx.buf.area);
4508 pool_free(pool_head_quic_conn, qc);
Frédéric Lécailleba85acd2022-01-11 14:43:50 +01004509 TRACE_PROTO("QUIC conn. freed", QUIC_EV_CONN_FREED, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004510
4511 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004512}
4513
Amaury Denoyellee0be5732022-04-05 17:34:18 +02004514static void quic_close(struct connection *conn, void *xprt_ctx)
Amaury Denoyelle414cac52021-09-22 11:14:37 +02004515{
4516 struct ssl_sock_ctx *conn_ctx = xprt_ctx;
Amaury Denoyelle29632b82022-01-18 16:50:58 +01004517 struct quic_conn *qc = conn_ctx->qc;
Amaury Denoyelle0a29e132021-12-23 15:06:56 +01004518
Frédéric Lécailleba85acd2022-01-11 14:43:50 +01004519 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
Amaury Denoyelle0a29e132021-12-23 15:06:56 +01004520
Amaury Denoyelle0b1f9312022-01-26 09:51:28 +01004521 /* Next application data can be dropped. */
4522 qc->mux_state = QC_MUX_RELEASED;
4523
Amaury Denoyelledb71e3b2022-04-06 17:22:12 +02004524 /* If the quic-conn timer has already expired free the quic-conn. */
4525 if (qc->flags & QUIC_FL_CONN_EXP_TIMER) {
4526 quic_conn_release(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004527 goto leave;
Amaury Denoyelledb71e3b2022-04-06 17:22:12 +02004528 }
4529
Amaury Denoyelle240b1b12022-07-13 15:18:16 +02004530 qc_check_close_on_released_mux(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004531 leave:
Frédéric Lécailleba85acd2022-01-11 14:43:50 +01004532 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Amaury Denoyelle414cac52021-09-22 11:14:37 +02004533}
4534
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004535/* Callback called upon loss detection and PTO timer expirations. */
Willy Tarreau144f84a2021-03-02 16:09:26 +01004536static struct task *process_timer(struct task *task, void *ctx, unsigned int state)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004537{
Frédéric Lécaille1eaec332021-06-04 14:59:59 +02004538 struct ssl_sock_ctx *conn_ctx;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004539 struct quic_conn *qc;
4540 struct quic_pktns *pktns;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004541
4542 conn_ctx = task->context;
Amaury Denoyellec15dd922021-12-21 11:41:52 +01004543 qc = conn_ctx->qc;
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01004544 TRACE_ENTER(QUIC_EV_CONN_PTIMER, qc,
Frédéric Lécaillef7e0b8d2020-12-16 17:33:11 +01004545 NULL, NULL, &qc->path->ifae_pkts);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004546 task->expire = TICK_ETERNITY;
4547 pktns = quic_loss_pktns(qc);
4548 if (tick_isset(pktns->tx.loss_time)) {
4549 struct list lost_pkts = LIST_HEAD_INIT(lost_pkts);
4550
4551 qc_packet_loss_lookup(pktns, qc, &lost_pkts);
Frédéric Lécaille15773f22022-08-24 17:57:09 +02004552 if (!LIST_ISEMPTY(&lost_pkts))
4553 tasklet_wakeup(conn_ctx->wait_event.tasklet);
Frédéric Lécaille277c4622022-08-24 17:06:04 +02004554 qc_release_lost_pkts(qc, pktns, &lost_pkts, now_ms);
Amaury Denoyellee81fed92021-12-22 11:06:34 +01004555 qc_set_timer(qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004556 goto out;
4557 }
4558
4559 if (qc->path->in_flight) {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004560 pktns = quic_pto_pktns(qc, qc->state >= QUIC_HS_ST_COMPLETE, NULL);
Frédéric Lécailledafbde62022-04-26 13:54:28 +02004561 if (qc->mux_state == QC_MUX_READY && qc->qcc->subs &&
4562 qc->qcc->subs->events & SUB_RETRY_SEND) {
4563 struct qcc *qcc = qc->qcc;
4564
4565 pktns->tx.pto_probe = QUIC_MAX_NB_PTO_DGRAMS;
4566 tasklet_wakeup(qcc->subs->tasklet);
4567 qcc->subs->events &= ~SUB_RETRY_SEND;
4568 if (!qcc->subs->events)
4569 qcc->subs = NULL;
4570 }
4571 else {
4572 qc->flags |= QUIC_FL_CONN_RETRANS_NEEDED;
4573 pktns->flags |= QUIC_FL_PKTNS_PROBE_NEEDED;
4574 if (pktns == &qc->pktns[QUIC_TLS_PKTNS_INITIAL]) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004575 TRACE_STATE("needs to probe Initial packet number space", QUIC_EV_CONN_TXPKT, qc);
4576 if (qc->pktns[QUIC_TLS_PKTNS_HANDSHAKE].tx.in_flight) {
Frédéric Lécailledafbde62022-04-26 13:54:28 +02004577 qc->pktns[QUIC_TLS_PKTNS_HANDSHAKE].flags |= QUIC_FL_PKTNS_PROBE_NEEDED;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004578 TRACE_STATE("needs to probe Handshake packet number space", QUIC_EV_CONN_TXPKT, qc);
4579 }
4580 }
4581 else if (pktns == &qc->pktns[QUIC_TLS_PKTNS_HANDSHAKE]) {
4582 TRACE_STATE("needs to probe Handshake packet number space", QUIC_EV_CONN_TXPKT, qc);
4583 }
4584 else if (pktns == &qc->pktns[QUIC_TLS_PKTNS_01RTT]) {
4585 TRACE_STATE("needs to probe 01RTT packet number space", QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécailledafbde62022-04-26 13:54:28 +02004586 }
Frédéric Lécaille0fa553d2022-01-17 14:26:12 +01004587 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004588 }
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004589 else if (!qc_is_listener(qc) && qc->state <= QUIC_HS_ST_COMPLETE) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004590 struct quic_enc_level *iel = &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL];
4591 struct quic_enc_level *hel = &qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE];
4592
Frédéric Lécaillebd242082022-02-25 17:17:59 +01004593 if (hel->tls_ctx.flags == QUIC_FL_TLS_SECRETS_SET)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004594 hel->pktns->tx.pto_probe = 1;
Frédéric Lécaillebd242082022-02-25 17:17:59 +01004595 if (iel->tls_ctx.flags == QUIC_FL_TLS_SECRETS_SET)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004596 iel->pktns->tx.pto_probe = 1;
4597 }
Frédéric Lécaillea56054e2021-12-31 16:35:28 +01004598
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004599 tasklet_wakeup(conn_ctx->wait_event.tasklet);
4600 qc->path->loss.pto_count++;
4601
4602 out:
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01004603 TRACE_LEAVE(QUIC_EV_CONN_PTIMER, qc, pktns);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004604
4605 return task;
4606}
4607
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02004608/* Parse the Retry token from buffer <token> with <end> a pointer to
4609 * one byte past the end of this buffer. This will extract the ODCID
4610 * which will be stored into <odcid>
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004611 *
4612 * Returns 0 on success else non-zero.
4613 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004614static int parse_retry_token(struct quic_conn *qc,
4615 const unsigned char *token, const unsigned char *end,
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004616 struct quic_cid *odcid)
4617{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004618 int ret = 0;
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004619 uint64_t odcid_len;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02004620 uint32_t timestamp;
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004621
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004622 TRACE_ENTER(QUIC_EV_CONN_LPKT, qc);
4623
4624 if (!quic_dec_int(&odcid_len, &token, end)) {
4625 TRACE_ERROR("quic_dec_int() error", QUIC_EV_CONN_LPKT, qc);
4626 goto leave;
4627 }
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004628
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02004629 /* RFC 9000 7.2. Negotiating Connection IDs:
4630 * When an Initial packet is sent by a client that has not previously
4631 * received an Initial or Retry packet from the server, the client
4632 * populates the Destination Connection ID field with an unpredictable
4633 * value. This Destination Connection ID MUST be at least 8 bytes in length.
4634 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004635 if (odcid_len < QUIC_ODCID_MINLEN || odcid_len > QUIC_CID_MAXLEN) {
4636 TRACE_ERROR("wrong ODCID length", QUIC_EV_CONN_LPKT, qc);
4637 goto leave;
4638 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02004639
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004640 if (end - token < odcid_len + sizeof timestamp) {
4641 TRACE_ERROR("too long ODCID length", QUIC_EV_CONN_LPKT, qc);
4642 goto leave;
4643 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02004644
4645 timestamp = ntohl(read_u32(token + odcid_len));
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004646 if (timestamp + MS_TO_TICKS(QUIC_RETRY_DURATION_MS) <= now_ms) {
4647 TRACE_ERROR("token has expired", QUIC_EV_CONN_LPKT, qc);
4648 goto leave;
4649 }
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004650
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004651 ret = 1;
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004652 memcpy(odcid->data, token, odcid_len);
4653 odcid->len = odcid_len;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004654 leave:
4655 TRACE_LEAVE(QUIC_EV_CONN_LPKT, qc);
4656 return !ret;
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004657}
4658
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004659/* Allocate a new QUIC connection with <version> as QUIC version. <ipv4>
4660 * boolean is set to 1 for IPv4 connection, 0 for IPv6. <server> is set to 1
4661 * for QUIC servers (or haproxy listeners).
4662 * <dcid> is the destination connection ID, <scid> is the source connection ID,
4663 * <token> the token found to be used for this connection with <token_len> as
4664 * length. <saddr> is the source address.
4665 * Returns the connection if succeeded, NULL if not.
4666 */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02004667static struct quic_conn *qc_new_conn(const struct quic_version *qv, int ipv4,
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004668 struct quic_cid *dcid, struct quic_cid *scid,
Frédéric Lécaillee9325e92022-08-11 17:24:38 +02004669 const struct quic_cid *token_odcid,
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004670 struct sockaddr_storage *saddr,
Frédéric Lécaille748ece62022-05-21 23:58:40 +02004671 int server, int token, void *owner)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004672{
4673 int i;
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004674 struct quic_conn *qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004675 /* Initial CID. */
4676 struct quic_connection_id *icid;
Frédéric Lécaillec0b481f2022-02-02 15:39:55 +01004677 char *buf_area = NULL;
Amaury Denoyelled6a352a2021-11-24 15:32:46 +01004678 struct listener *l = NULL;
Frédéric Lécaille43910a92022-07-11 10:24:21 +02004679 struct quic_cc_algo *cc_algo = NULL;
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02004680 struct quic_tls_ctx *ictx;
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02004681 TRACE_ENTER(QUIC_EV_CONN_INIT);
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004682 qc = pool_zalloc(pool_head_quic_conn);
4683 if (!qc) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004684 TRACE_ERROR("Could not allocate a new connection", QUIC_EV_CONN_INIT);
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004685 goto err;
4686 }
4687
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004688 buf_area = pool_alloc(pool_head_quic_conn_rxbuf);
4689 if (!buf_area) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004690 TRACE_ERROR("Could not allocate a new RX buffer", QUIC_EV_CONN_INIT, qc);
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004691 goto err;
4692 }
4693
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004694 qc->cids = EB_ROOT;
4695 /* QUIC Server (or listener). */
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02004696 if (server) {
Frédéric Lécaillea89659a2022-05-19 11:58:53 +02004697 struct proxy *prx;
4698
Amaury Denoyelled6a352a2021-11-24 15:32:46 +01004699 l = owner;
Frédéric Lécaillea89659a2022-05-19 11:58:53 +02004700 prx = l->bind_conf->frontend;
Frédéric Lécaille43910a92022-07-11 10:24:21 +02004701 cc_algo = l->bind_conf->quic_cc_algo;
Frédéric Lécaille6b197642021-07-06 16:25:08 +02004702
Frédéric Lécaillea89659a2022-05-19 11:58:53 +02004703 qc->prx_counters = EXTRA_COUNTERS_GET(prx->extra_counters_fe,
4704 &quic_stats_module);
Frédéric Lécaille2fe8b3b2022-01-10 12:10:10 +01004705 qc->flags |= QUIC_FL_CONN_LISTENER;
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004706 qc->state = QUIC_HS_ST_SERVER_INITIAL;
Amaury Denoyellec92cbfc2021-12-14 17:20:59 +01004707 /* Copy the initial DCID with the address. */
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004708 qc->odcid.len = dcid->len;
4709 qc->odcid.addrlen = dcid->addrlen;
4710 memcpy(qc->odcid.data, dcid->data, dcid->len + dcid->addrlen);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004711
Amaury Denoyelle42b9f1c2021-11-24 15:29:53 +01004712 /* copy the packet SCID to reuse it as DCID for sending */
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004713 if (scid->len)
4714 memcpy(qc->dcid.data, scid->data, scid->len);
4715 qc->dcid.len = scid->len;
Amaury Denoyellef2476052022-08-04 16:19:57 +02004716 qc->tx.buf = BUF_NULL;
Amaury Denoyelle2af19852021-09-30 11:03:28 +02004717 qc->li = l;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004718 }
4719 /* QUIC Client (outgoing connection to servers) */
4720 else {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02004721 qc->state = QUIC_HS_ST_CLIENT_INITIAL;
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004722 if (dcid->len)
4723 memcpy(qc->dcid.data, dcid->data, dcid->len);
4724 qc->dcid.len = dcid->len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004725 }
Amaury Denoyelle0b1f9312022-01-26 09:51:28 +01004726 qc->mux_state = QC_MUX_NULL;
Amaury Denoyelle57e6db72022-07-13 15:07:56 +02004727 qc->err = quic_err_transport(QC_ERR_NO_ERROR);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004728
Amaury Denoyelle0442efd2022-01-28 16:02:13 +01004729 icid = new_quic_cid(&qc->cids, qc, 0);
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004730 if (!icid) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004731 TRACE_ERROR("Could not allocate a new connection ID", QUIC_EV_CONN_INIT, qc);
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004732 goto err;
4733 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004734
Frédéric Lécaille74904a42022-01-27 15:35:56 +01004735 /* insert the allocated CID in the receiver datagram handler tree */
4736 if (server)
Amaury Denoyelle8524f0f2022-02-08 15:03:40 +01004737 ebmb_insert(&quic_dghdlrs[tid].cids, &icid->node, icid->cid.len);
Amaury Denoyelled6a352a2021-11-24 15:32:46 +01004738
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004739 /* Select our SCID which is the first CID with 0 as sequence number. */
4740 qc->scid = icid->cid;
4741
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004742 /* Packet number spaces initialization. */
4743 for (i = 0; i < QUIC_TLS_PKTNS_MAX; i++)
4744 quic_pktns_init(&qc->pktns[i]);
4745 /* QUIC encryption level context initialization. */
4746 for (i = 0; i < QUIC_TLS_ENC_LEVEL_MAX; i++) {
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004747 if (!quic_conn_enc_level_init(qc, i)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004748 TRACE_ERROR("Could not initialize an encryption level", QUIC_EV_CONN_INIT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004749 goto err;
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004750 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004751 /* Initialize the packet number space. */
4752 qc->els[i].pktns = &qc->pktns[quic_tls_pktns(i)];
4753 }
4754
Frédéric Lécaille301425b2022-06-14 17:40:39 +02004755 qc->original_version = qv;
4756 qc->tps_tls_ext = (qc->original_version->num & 0xff000000) == 0xff000000 ?
Frédéric Lécaillea956d152021-11-10 09:24:22 +01004757 TLS_EXTENSION_QUIC_TRANSPORT_PARAMETERS_DRAFT:
4758 TLS_EXTENSION_QUIC_TRANSPORT_PARAMETERS;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004759 /* TX part. */
4760 LIST_INIT(&qc->tx.frms_to_send);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004761 qc->tx.nb_buf = QUIC_CONN_TX_BUFS_NB;
4762 qc->tx.wbuf = qc->tx.rbuf = 0;
4763 qc->tx.bytes = 0;
Amaury Denoyellef2476052022-08-04 16:19:57 +02004764 qc->tx.buf = BUF_NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004765 /* RX part. */
4766 qc->rx.bytes = 0;
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004767 qc->rx.buf = b_make(buf_area, QUIC_CONN_RX_BUFSZ, 0, 0);
Frédéric Lécaille664741e2022-05-02 18:46:58 +02004768 for (i = 0; i < QCS_MAX_TYPES; i++)
4769 qc->rx.strms[i].nb_streams = 0;
Frédéric Lécaille59bf2552022-03-28 12:13:09 +02004770
4771 qc->nb_pkt_for_cc = 1;
4772 qc->nb_pkt_since_cc = 0;
4773
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004774 LIST_INIT(&qc->rx.pkt_list);
Frédéric Lécaille40df78f2021-11-30 10:59:37 +01004775 if (!quic_tls_ku_init(qc)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004776 TRACE_ERROR("Key update initialization failed", QUIC_EV_CONN_INIT, qc);
Frédéric Lécaille40df78f2021-11-30 10:59:37 +01004777 goto err;
4778 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004779
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004780 /* XXX TO DO: Only one path at this time. */
4781 qc->path = &qc->paths[0];
Frédéric Lécaille43910a92022-07-11 10:24:21 +02004782 quic_path_init(qc->path, ipv4, cc_algo ? cc_algo : default_quic_cc_algo, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004783
Amaury Denoyellecfa2d562022-01-19 16:01:05 +01004784 /* required to use MTLIST_IN_LIST */
4785 MT_LIST_INIT(&qc->accept_list);
4786
Amaury Denoyelle5c3859c2022-03-29 14:49:35 +02004787 qc->streams_by_id = EB_ROOT_UNIQUE;
Amaury Denoyelled2f80a22022-04-15 17:30:49 +02004788 qc->stream_buf_count = 0;
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004789 memcpy(&qc->peer_addr, saddr, sizeof qc->peer_addr);
4790
Frédéric Lécaille748ece62022-05-21 23:58:40 +02004791 if (server && !qc_lstnr_params_init(qc, &l->bind_conf->quic_params,
4792 icid->stateless_reset_token,
4793 dcid->data, dcid->len,
Frédéric Lécaille7629f5d2022-08-11 18:54:26 +02004794 qc->scid.data, qc->scid.len, token_odcid))
Frédéric Lécaille395a64d2022-05-09 15:42:26 +02004795 goto err;
Amaury Denoyelle5c3859c2022-03-29 14:49:35 +02004796
Frédéric Lécaille3fd92f62022-05-19 14:35:20 +02004797 if (qc_conn_alloc_ssl_ctx(qc) ||
4798 !quic_conn_init_timer(qc) ||
4799 !quic_conn_init_idle_timer_task(qc))
4800 goto err;
4801
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02004802 ictx = &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL].tls_ctx;
4803 if (!qc_new_isecs(qc, ictx,qc->original_version, dcid->data, dcid->len, 1))
Frédéric Lécaille3fd92f62022-05-19 14:35:20 +02004804 goto err;
4805
Amaury Denoyellee770ce32021-12-21 14:51:56 +01004806 TRACE_LEAVE(QUIC_EV_CONN_INIT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004807
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004808 return qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004809
4810 err:
Frédéric Lécaillec0b481f2022-02-02 15:39:55 +01004811 pool_free(pool_head_quic_conn_rxbuf, buf_area);
4812 if (qc)
4813 qc->rx.buf.area = NULL;
Frédéric Lécaillef293b692022-03-08 16:59:54 +01004814 quic_conn_release(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004815 TRACE_LEAVE(QUIC_EV_CONN_INIT, qc);
Frédéric Lécaille6de72872021-06-11 15:44:24 +02004816 return NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004817}
4818
4819/* Initialize the timer task of <qc> QUIC connection.
4820 * Returns 1 if succeeded, 0 if not.
4821 */
4822static int quic_conn_init_timer(struct quic_conn *qc)
4823{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004824 int ret = 0;
Frédéric Lécaillef57c3332021-12-09 10:06:21 +01004825 /* Attach this task to the same thread ID used for the connection */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004826 TRACE_ENTER(QUIC_EV_CONN_NEW, qc);
4827
Willy Tarreau87168752022-06-13 16:31:53 +02004828 qc->timer_task = task_new_on(qc->tid);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004829 if (!qc->timer_task) {
4830 TRACE_ERROR("timer task allocation failed", QUIC_EV_CONN_NEW, qc);
4831 goto leave;
4832 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004833
4834 qc->timer = TICK_ETERNITY;
4835 qc->timer_task->process = process_timer;
Frédéric Lécaille7fbb94d2022-01-31 10:37:07 +01004836 qc->timer_task->context = qc->xprt_ctx;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004837
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004838 ret = 1;
4839 leave:
4840 TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
4841 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004842}
4843
Frédéric Lécaille47756802022-03-25 09:12:16 +01004844/* Rearm the idle timer for <qc> QUIC connection. */
4845static void qc_idle_timer_do_rearm(struct quic_conn *qc)
4846{
4847 unsigned int expire;
4848
4849 expire = QUIC_MAX(3 * quic_pto(qc), qc->max_idle_timeout);
4850 qc->idle_timer_task->expire = tick_add(now_ms, MS_TO_TICKS(expire));
4851}
4852
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004853/* Rearm the idle timer for <qc> QUIC connection depending on <read> boolean
4854 * which is set to 1 when receiving a packet , and 0 when sending packet
4855 */
4856static void qc_idle_timer_rearm(struct quic_conn *qc, int read)
4857{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004858 TRACE_ENTER(QUIC_EV_CONN_IDLE_TIMER, qc);
4859
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004860 if (read) {
4861 qc->flags |= QUIC_FL_CONN_IDLE_TIMER_RESTARTED_AFTER_READ;
4862 }
4863 else {
4864 qc->flags &= ~QUIC_FL_CONN_IDLE_TIMER_RESTARTED_AFTER_READ;
4865 }
Frédéric Lécaille47756802022-03-25 09:12:16 +01004866 qc_idle_timer_do_rearm(qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004867
4868 TRACE_LEAVE(QUIC_EV_CONN_IDLE_TIMER, qc);
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004869}
4870
4871/* The task handling the idle timeout */
4872static struct task *qc_idle_timer_task(struct task *t, void *ctx, unsigned int state)
4873{
4874 struct quic_conn *qc = ctx;
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02004875 struct quic_counters *prx_counters = qc->prx_counters;
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02004876 unsigned int qc_flags = qc->flags;
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004877
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004878 TRACE_ENTER(QUIC_EV_CONN_IDLE_TIMER, qc);
4879
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02004880 /* Notify the MUX before settings QUIC_FL_CONN_EXP_TIMER or the MUX
4881 * might free the quic-conn too early via quic_close().
4882 */
4883 qc_notify_close(qc);
4884
Amaury Denoyelledb71e3b2022-04-06 17:22:12 +02004885 /* If the MUX is still alive, keep the quic-conn. The MUX is
4886 * responsible to call quic_close to release it.
4887 */
4888 qc->flags |= QUIC_FL_CONN_EXP_TIMER;
4889 if (qc->mux_state != QC_MUX_READY)
4890 quic_conn_release(qc);
4891
4892 /* TODO if the quic-conn cannot be freed because of the MUX, we may at
4893 * least clean some parts of it such as the tasklet.
4894 */
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02004895
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02004896 if (!(qc_flags & QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED)) {
4897 qc_flags |= QUIC_FL_CONN_HALF_OPEN_CNT_DECREMENTED;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004898 TRACE_DEVEL("dec half open counter", QUIC_EV_CONN_SSLALERT, qc);
Frédéric Lécailleeb791452022-05-24 16:01:39 +02004899 HA_ATOMIC_DEC(&prx_counters->half_open_conn);
Frédéric Lécaille2aebaa42022-06-17 15:11:32 +02004900 }
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004901
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004902 TRACE_LEAVE(QUIC_EV_CONN_IDLE_TIMER, qc);
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004903 return NULL;
4904}
4905
4906/* Initialize the idle timeout task for <qc>.
4907 * Returns 1 if succeeded, 0 if not.
4908 */
4909static int quic_conn_init_idle_timer_task(struct quic_conn *qc)
4910{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004911 int ret = 0;
4912
4913 TRACE_ENTER(QUIC_EV_CONN_NEW, qc);
4914
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004915 qc->idle_timer_task = task_new_here();
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004916 if (!qc->idle_timer_task) {
4917 TRACE_ERROR("Idle timer task allocation failed", QUIC_EV_CONN_NEW, qc);
4918 goto leave;
4919 }
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004920
4921 qc->idle_timer_task->process = qc_idle_timer_task;
4922 qc->idle_timer_task->context = qc;
4923 qc_idle_timer_rearm(qc, 1);
4924 task_queue(qc->idle_timer_task);
4925
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004926 ret = 1;
4927 leave:
4928 TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
4929 return ret;
Frédéric Lécaille530601c2022-03-10 15:11:57 +01004930}
4931
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004932/* Parse into <pkt> a long header located at <*buf> buffer, <end> begin a pointer to the end
4933 * past one byte of this buffer.
4934 */
4935static inline int quic_packet_read_long_header(unsigned char **buf, const unsigned char *end,
4936 struct quic_rx_packet *pkt)
4937{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004938 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004939 unsigned char dcid_len, scid_len;
4940
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004941 TRACE_ENTER(QUIC_EV_CONN_RXPKT);
4942
4943 if (end == *buf) {
4944 TRACE_ERROR("buffer data consumed", QUIC_EV_CONN_RXPKT);
4945 goto leave;
4946 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004947
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004948 /* Destination Connection ID Length */
4949 dcid_len = *(*buf)++;
4950 /* We want to be sure we can read <dcid_len> bytes and one more for <scid_len> value */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004951 if (dcid_len > QUIC_CID_MAXLEN || end - *buf < dcid_len + 1) {
4952 TRACE_ERROR("too long DCID", QUIC_EV_CONN_RXPKT);
4953 goto leave;
4954 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004955
4956 if (dcid_len) {
4957 /* Check that the length of this received DCID matches the CID lengths
4958 * of our implementation for non Initials packets only.
4959 */
Frédéric Lécaillea5da31d2021-12-14 19:44:14 +01004960 if (pkt->type != QUIC_PACKET_TYPE_INITIAL &&
4961 pkt->type != QUIC_PACKET_TYPE_0RTT &&
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004962 dcid_len != QUIC_HAP_CID_LEN) {
4963 TRACE_ERROR("wrong DCID length", QUIC_EV_CONN_RXPKT);
4964 goto leave;
4965 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004966
4967 memcpy(pkt->dcid.data, *buf, dcid_len);
4968 }
4969
4970 pkt->dcid.len = dcid_len;
4971 *buf += dcid_len;
4972
4973 /* Source Connection ID Length */
4974 scid_len = *(*buf)++;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004975 if (scid_len > QUIC_CID_MAXLEN || end - *buf < scid_len) {
4976 TRACE_ERROR("too long SCID", QUIC_EV_CONN_RXPKT);
4977 goto leave;
4978 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004979
4980 if (scid_len)
4981 memcpy(pkt->scid.data, *buf, scid_len);
4982 pkt->scid.len = scid_len;
4983 *buf += scid_len;
4984
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004985 ret = 1;
4986 leave:
4987 TRACE_LEAVE(QUIC_EV_CONN_RXPKT);
4988 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01004989}
4990
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004991/* Insert <pkt> RX packet in its <qel> RX packets tree */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004992static void qc_pkt_insert(struct quic_conn *qc,
4993 struct quic_rx_packet *pkt, struct quic_enc_level *qel)
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004994{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02004995 TRACE_ENTER(QUIC_EV_CONN_RXPKT, qc);
4996
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004997 pkt->pn_node.key = pkt->pn;
Frédéric Lécaille2ce5acf2021-12-20 14:41:19 +01004998 quic_rx_packet_refinc(pkt);
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01004999 eb64_insert(&qel->rx.pkts, &pkt->pn_node);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005000
5001 TRACE_LEAVE(QUIC_EV_CONN_RXPKT, qc);
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01005002}
5003
5004/* Try to remove the header protection of <pkt> QUIC packet attached to <qc>
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005005 * QUIC connection with <buf> as packet number field address, <end> a pointer to one
5006 * byte past the end of the buffer containing this packet and <beg> the address of
5007 * the packet first byte.
5008 * If succeeded, this function updates <*buf> to point to the next packet in the buffer.
5009 * Returns 1 if succeeded, 0 if not.
5010 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005011static inline int qc_try_rm_hp(struct quic_conn *qc,
5012 struct quic_rx_packet *pkt,
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005013 unsigned char *buf, unsigned char *beg,
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005014 struct quic_enc_level **el)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005015{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005016 int ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005017 unsigned char *pn = NULL; /* Packet number field */
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01005018 enum quic_tls_enc_level tel;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005019 struct quic_enc_level *qel;
5020 /* Only for traces. */
5021 struct quic_rx_packet *qpkt_trace;
5022
5023 qpkt_trace = NULL;
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005024 TRACE_ENTER(QUIC_EV_CONN_TRMHP, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005025 /* The packet number is here. This is also the start minus
5026 * QUIC_PACKET_PN_MAXLEN of the sample used to add/remove the header
5027 * protection.
5028 */
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005029 pn = buf;
Amaury Denoyelle8ae28072022-01-24 18:34:52 +01005030
5031 tel = quic_packet_type_enc_level(pkt->type);
5032 qel = &qc->els[tel];
5033
5034 if (qc_qel_may_rm_hp(qc, qel)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005035 /* Note that the following function enables us to unprotect the packet
5036 * number and its length subsequently used to decrypt the entire
5037 * packets.
5038 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005039 if (!qc_do_rm_hp(qc, pkt, &qel->tls_ctx,
Frédéric Lécaille99897d12022-08-08 10:28:07 +02005040 qel->pktns->rx.largest_pn, pn, beg)) {
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005041 TRACE_PROTO("hp error", QUIC_EV_CONN_TRMHP, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005042 goto out;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005043 }
5044
5045 /* The AAD includes the packet number field found at <pn>. */
5046 pkt->aad_len = pn - beg + pkt->pnl;
Frédéric Lécailleffde3162022-08-08 18:41:16 +02005047 if (pkt->len - pkt->aad_len < QUIC_TLS_TAG_LEN) {
5048 TRACE_PROTO("Too short packet", QUIC_EV_CONN_TRMHP, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005049 goto out;
Frédéric Lécailleffde3162022-08-08 18:41:16 +02005050 }
5051
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005052 qpkt_trace = pkt;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005053 }
Frédéric Lécaille7d845f12022-02-21 19:22:09 +01005054 else {
Frédéric Lécaillebd242082022-02-25 17:17:59 +01005055 if (qel->tls_ctx.flags & QUIC_FL_TLS_SECRETS_DCD) {
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01005056 /* If the packet number space has been discarded, this packet
5057 * will be not parsed.
5058 */
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005059 TRACE_PROTO("Discarded pktns", QUIC_EV_CONN_TRMHP, qc, pkt);
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01005060 goto out;
5061 }
5062
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005063 TRACE_PROTO("hp not removed", QUIC_EV_CONN_TRMHP, qc, pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005064 pkt->pn_offset = pn - beg;
Frédéric Lécaillea2d8ad22022-08-23 17:45:52 +02005065 LIST_APPEND(&qel->rx.pqpkts, &pkt->list);
Frédéric Lécailleebc3fc12021-09-22 08:34:21 +02005066 quic_rx_packet_refinc(pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005067 }
5068
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01005069 *el = qel;
5070 /* No reference counter incrementation here!!! */
5071 LIST_APPEND(&qc->rx.pkt_list, &pkt->qc_rx_pkt_list);
5072 memcpy(b_tail(&qc->rx.buf), beg, pkt->len);
5073 pkt->data = (unsigned char *)b_tail(&qc->rx.buf);
5074 b_add(&qc->rx.buf, pkt->len);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005075
5076 ret = 1;
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01005077 out:
Amaury Denoyellee81fed92021-12-22 11:06:34 +01005078 TRACE_LEAVE(QUIC_EV_CONN_TRMHP, qc, qpkt_trace);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005079 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005080}
5081
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005082/* Parse the header form from <byte0> first byte of <pkt> packet to set its type.
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005083 * Also set <*long_header> to 1 if this form is long, 0 if not and the version
5084 * of this packet into <*version>.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005085 */
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005086static inline int qc_parse_hd_form(struct quic_rx_packet *pkt,
5087 unsigned char **buf, const unsigned char *end,
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005088 int *long_header, uint32_t *version)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005089{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005090 int ret = 0;
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005091 const unsigned char byte0 = **buf;
5092
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005093 TRACE_ENTER(QUIC_EV_CONN_RXPKT);
5094
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005095 (*buf)++;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005096 if (byte0 & QUIC_PACKET_LONG_HEADER_BIT) {
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005097 unsigned char type =
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005098 (byte0 >> QUIC_PACKET_TYPE_SHIFT) & QUIC_PACKET_TYPE_BITMASK;
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005099
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005100 *long_header = 1;
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005101 /* Version */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005102 if (!quic_read_uint32(version, (const unsigned char **)buf, end)) {
5103 TRACE_ERROR("could not read the packet version", QUIC_EV_CONN_RXPKT);
5104 goto out;
5105 }
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005106
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005107 if (*version != QUIC_PROTOCOL_VERSION_2_DRAFT) {
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005108 pkt->type = type;
5109 }
5110 else {
5111 switch (type) {
5112 case 0:
5113 pkt->type = QUIC_PACKET_TYPE_RETRY;
5114 break;
5115 case 1:
5116 pkt->type = QUIC_PACKET_TYPE_INITIAL;
5117 break;
5118 case 2:
5119 pkt->type = QUIC_PACKET_TYPE_0RTT;
5120 break;
5121 case 3:
5122 pkt->type = QUIC_PACKET_TYPE_HANDSHAKE;
5123 break;
5124 }
5125 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005126 }
5127 else {
5128 pkt->type = QUIC_PACKET_TYPE_SHORT;
5129 *long_header = 0;
5130 }
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005131
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005132 ret = 1;
5133 out:
5134 TRACE_LEAVE(QUIC_EV_CONN_RXPKT);
Frédéric Lécaille59507de2022-08-11 12:14:07 +02005135 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005136}
5137
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005138/* Return the QUIC version (quic_version struct) with <version> as version number
5139 * if supported or NULL if not.
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005140 */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005141static inline const struct quic_version *qc_supported_version(uint32_t version)
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005142{
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005143 int i;
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005144
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005145 for (i = 0; i < quic_versions_nb; i++)
5146 if (quic_versions[i].num == version)
5147 return &quic_versions[i];
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005148
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005149 return NULL;
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005150}
5151
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005152/*
5153 * Send a Version Negotiation packet on response to <pkt> on socket <fd> to
5154 * address <addr>.
5155 * Implementation of RFC9000 6. Version Negotiation
5156 *
5157 * TODO implement a rate-limiting sending of Version Negotiation packets
5158 *
5159 * Returns 0 on success else non-zero
5160 */
Amaury Denoyelled6b16672021-12-23 10:37:19 +01005161static int send_version_negotiation(int fd, struct sockaddr_storage *addr,
5162 struct quic_rx_packet *pkt)
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005163{
5164 char buf[256];
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005165 int ret = 0, i = 0, j;
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005166 uint32_t version;
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005167 const socklen_t addrlen = get_addr_len(addr);
5168
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005169 TRACE_ENTER(QUIC_EV_CONN_TXPKT);
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005170 /*
5171 * header form
5172 * long header, fixed bit to 0 for Version Negotiation
5173 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005174 /* TODO: RAND_bytes() should be replaced? */
5175 if (RAND_bytes((unsigned char *)buf, 1) != 1) {
5176 TRACE_ERROR("RAND_bytes() error", QUIC_EV_CONN_TXPKT);
5177 goto out;
5178 }
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005179
Frédéric Lécailleea78ee12021-11-18 13:54:43 +01005180 buf[i++] |= '\x80';
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005181 /* null version for Version Negotiation */
5182 buf[i++] = '\x00';
5183 buf[i++] = '\x00';
5184 buf[i++] = '\x00';
5185 buf[i++] = '\x00';
5186
5187 /* source connection id */
5188 buf[i++] = pkt->scid.len;
Amaury Denoyelle10eed8e2021-11-18 13:48:57 +01005189 memcpy(&buf[i], pkt->scid.data, pkt->scid.len);
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005190 i += pkt->scid.len;
5191
5192 /* destination connection id */
5193 buf[i++] = pkt->dcid.len;
Amaury Denoyelle10eed8e2021-11-18 13:48:57 +01005194 memcpy(&buf[i], pkt->dcid.data, pkt->dcid.len);
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005195 i += pkt->dcid.len;
5196
5197 /* supported version */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005198 for (j = 0; j < quic_versions_nb; j++) {
5199 version = htonl(quic_versions[j].num);
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005200 memcpy(&buf[i], &version, sizeof(version));
5201 i += sizeof(version);
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005202 }
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005203
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005204 if (sendto(fd, buf, i, 0, (struct sockaddr *)addr, addrlen) < 0)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005205 goto out;
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005206
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005207 ret = 1;
5208 out:
5209 TRACE_LEAVE(QUIC_EV_CONN_TXPKT);
5210 return !ret;
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005211}
5212
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005213/* Send a stateless reset packet depending on <pkt> RX packet information
5214 * from <fd> UDP socket to <dst>
5215 * Return 1 if succeeded, 0 if not.
5216 */
Frédéric Lécailleeb791452022-05-24 16:01:39 +02005217static int send_stateless_reset(struct listener *l, struct sockaddr_storage *dstaddr,
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005218 struct quic_rx_packet *rxpkt)
5219{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005220 int ret = 0, pktlen, rndlen;
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005221 unsigned char pkt[64];
5222 const socklen_t addrlen = get_addr_len(dstaddr);
Frédéric Lécailleeb791452022-05-24 16:01:39 +02005223 struct proxy *prx;
5224 struct quic_counters *prx_counters;
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005225
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005226 TRACE_ENTER(QUIC_EV_STATELESS_RST);
5227
Frédéric Lécailleeb791452022-05-24 16:01:39 +02005228 prx = l->bind_conf->frontend;
5229 prx_counters = EXTRA_COUNTERS_GET(prx->extra_counters_fe, &quic_stats_module);
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005230 /* 10.3 Stateless Reset (https://www.rfc-editor.org/rfc/rfc9000.html#section-10.3)
5231 * The resulting minimum size of 21 bytes does not guarantee that a Stateless
5232 * Reset is difficult to distinguish from other packets if the recipient requires
5233 * the use of a connection ID. To achieve that end, the endpoint SHOULD ensure
5234 * that all packets it sends are at least 22 bytes longer than the minimum
5235 * connection ID length that it requests the peer to include in its packets,
5236 * adding PADDING frames as necessary. This ensures that any Stateless Reset
5237 * sent by the peer is indistinguishable from a valid packet sent to the endpoint.
5238 * An endpoint that sends a Stateless Reset in response to a packet that is
5239 * 43 bytes or shorter SHOULD send a Stateless Reset that is one byte shorter
5240 * than the packet it responds to.
5241 */
5242
5243 /* Note that we build at most a 42 bytes QUIC packet to mimic a short packet */
5244 pktlen = rxpkt->len <= 43 ? rxpkt->len - 1 : 0;
5245 pktlen = QUIC_MAX(QUIC_STATELESS_RESET_PACKET_MINLEN, pktlen);
5246 rndlen = pktlen - QUIC_STATELESS_RESET_TOKEN_LEN;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005247
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005248 /* Put a header of random bytes */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005249 /* TODO: RAND_bytes() should be replaced */
5250 if (RAND_bytes(pkt, rndlen) != 1) {
5251 TRACE_ERROR("RAND_bytes() failed", QUIC_EV_STATELESS_RST);
5252 goto leave;
5253 }
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005254
5255 /* Clear the most significant bit, and set the second one */
5256 *pkt = (*pkt & ~0x80) | 0x40;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005257 if (!quic_stateless_reset_token_cpy(NULL, pkt + rndlen, QUIC_STATELESS_RESET_TOKEN_LEN,
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005258 rxpkt->dcid.data, rxpkt->dcid.len))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005259 goto leave;
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005260
Frédéric Lécailleeb791452022-05-24 16:01:39 +02005261 if (sendto(l->rx.fd, pkt, pktlen, 0, (struct sockaddr *)dstaddr, addrlen) < 0)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005262 goto leave;
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005263
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005264 ret = 1;
Frédéric Lécailleeb791452022-05-24 16:01:39 +02005265 HA_ATOMIC_INC(&prx_counters->stateless_reset_sent);
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005266 TRACE_PROTO("stateless reset sent", QUIC_EV_STATELESS_RST, NULL, &rxpkt->dcid);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005267 leave:
5268 TRACE_LEAVE(QUIC_EV_STATELESS_RST);
5269 return ret;
Frédéric Lécaillee2fb1bf2022-05-09 16:30:55 +02005270}
5271
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005272/* QUIC server only function.
5273 * Add AAD to <add> buffer from <cid> connection ID and <addr> socket address.
Ilya Shipitsin3b64a282022-07-29 22:26:53 +05005274 * This is the responsibility of the caller to check <aad> size is big enough
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005275 * to contain these data.
5276 * Return the number of bytes copied to <aad>.
5277 */
5278static int quic_generate_retry_token_aad(unsigned char *aad,
5279 uint32_t version,
5280 const struct quic_cid *cid,
5281 const struct sockaddr_storage *addr)
5282{
5283 unsigned char *p;
5284
5285 p = aad;
5286 memcpy(p, &version, sizeof version);
5287 p += sizeof version;
5288 p += quic_saddr_cpy(p, addr);
5289 memcpy(p, cid->data, cid->len);
5290 p += cid->len;
5291
5292 return p - aad;
5293}
5294
5295/* QUIC server only function.
5296 * Generate the token to be used in Retry packets. The token is written to
5297 * <buf> whith <len> as length. <odcid> is the original destination connection
5298 * ID and <dcid> is our side destination connection ID (or client source
5299 * connection ID).
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005300 * Returns the length of the encoded token or 0 on error.
5301 */
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005302static int quic_generate_retry_token(unsigned char *buf, size_t len,
5303 const uint32_t version,
5304 const struct quic_cid *odcid,
5305 const struct quic_cid *dcid,
5306 struct sockaddr_storage *addr)
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005307{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005308 int ret = 0;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005309 unsigned char *p;
5310 unsigned char aad[sizeof(uint32_t) + sizeof(in_port_t) +
5311 sizeof(struct in6_addr) + QUIC_HAP_CID_LEN];
5312 size_t aadlen;
5313 unsigned char salt[QUIC_RETRY_TOKEN_SALTLEN];
5314 unsigned char key[QUIC_TLS_KEY_LEN];
5315 unsigned char iv[QUIC_TLS_IV_LEN];
5316 const unsigned char *sec = (const unsigned char *)global.cluster_secret;
5317 size_t seclen = strlen(global.cluster_secret);
5318 EVP_CIPHER_CTX *ctx = NULL;
5319 const EVP_CIPHER *aead = EVP_aes_128_gcm();
5320 uint32_t timestamp = now_ms;
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005321
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005322 TRACE_ENTER(QUIC_EV_CONN_TXPKT);
5323
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005324 /* We copy the odcid into the token, prefixed by its one byte
5325 * length, the format token byte. It is followed by an AEAD TAG, and finally
5326 * the random bytes used to derive the secret to encrypt the token.
5327 */
5328 if (1 + dcid->len + 1 + QUIC_TLS_TAG_LEN + sizeof salt > len)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005329 goto err;
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005330
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005331 aadlen = quic_generate_retry_token_aad(aad, version, dcid, addr);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005332 /* TODO: RAND_bytes() should be replaced */
5333 if (RAND_bytes(salt, sizeof salt) != 1) {
5334 TRACE_ERROR("RAND_bytes()", QUIC_EV_CONN_TXPKT);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005335 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005336 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005337
5338 if (!quic_tls_derive_retry_token_secret(EVP_sha256(), key, sizeof key, iv, sizeof iv,
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005339 salt, sizeof salt, sec, seclen)) {
5340 TRACE_ERROR("quic_tls_derive_retry_token_secret() failed", QUIC_EV_CONN_TXPKT);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005341 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005342 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005343
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005344 if (!quic_tls_tx_ctx_init(&ctx, aead, key)) {
5345 TRACE_ERROR("quic_tls_tx_ctx_init() failed", QUIC_EV_CONN_TXPKT);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005346 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005347 }
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005348
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005349 /* Token build */
5350 p = buf;
5351 *p++ = QUIC_TOKEN_FMT_RETRY,
5352 *p++ = odcid->len;
5353 memcpy(p, odcid->data, odcid->len);
5354 p += odcid->len;
5355 write_u32(p, htonl(timestamp));
5356 p += sizeof timestamp;
5357
5358 /* Do not encrypt the QUIC_TOKEN_FMT_RETRY byte */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005359 if (!quic_tls_encrypt(buf + 1, p - buf - 1, aad, aadlen, ctx, aead, key, iv)) {
5360 TRACE_ERROR("quic_tls_encrypt() failed", QUIC_EV_CONN_TXPKT);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005361 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005362 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005363
5364 p += QUIC_TLS_TAG_LEN;
5365 memcpy(p, salt, sizeof salt);
5366 p += sizeof salt;
5367 EVP_CIPHER_CTX_free(ctx);
5368
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005369 ret = p - buf;
5370 leave:
5371 TRACE_LEAVE(QUIC_EV_CONN_TXPKT);
5372 return ret;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005373
5374 err:
5375 if (ctx)
5376 EVP_CIPHER_CTX_free(ctx);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005377 goto leave;
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005378}
5379
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005380/* QUIC server only function.
5381 * Check the validity of the Retry token from <token> buffer with <tokenlen>
5382 * as length. If valid, the ODCID of <qc> QUIC connection will be put
5383 * into <odcid> connection ID. <dcid> is our side destination connection ID
5384 * of client source connection ID.
5385 * Return 1 if succeeded, 0 if not.
5386 */
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005387static int quic_retry_token_check(const unsigned char *token, size_t tokenlen,
5388 const struct quic_version *qv,
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005389 struct quic_cid *odcid,
5390 const struct quic_cid *dcid,
5391 struct quic_conn *qc,
5392 struct sockaddr_storage *addr)
5393{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005394 int ret = 0;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005395 unsigned char buf[128];
5396 unsigned char aad[sizeof(uint32_t) + sizeof(in_port_t) +
5397 sizeof(struct in6_addr) + QUIC_HAP_CID_LEN];
5398 size_t aadlen;
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005399 const unsigned char *salt;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005400 unsigned char key[QUIC_TLS_KEY_LEN];
5401 unsigned char iv[QUIC_TLS_IV_LEN];
5402 const unsigned char *sec = (const unsigned char *)global.cluster_secret;
5403 size_t seclen = strlen(global.cluster_secret);
5404 EVP_CIPHER_CTX *ctx = NULL;
5405 const EVP_CIPHER *aead = EVP_aes_128_gcm();
5406
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005407 TRACE_ENTER(QUIC_EV_CONN_LPKT, qc);
5408
5409 if (sizeof buf < tokenlen) {
5410 TRACE_ERROR("too short buffer", QUIC_EV_CONN_LPKT, qc);
5411 goto err;
5412 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005413
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005414 aadlen = quic_generate_retry_token_aad(aad, qv->num, dcid, addr);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005415 salt = token + tokenlen - QUIC_RETRY_TOKEN_SALTLEN;
5416 if (!quic_tls_derive_retry_token_secret(EVP_sha256(), key, sizeof key, iv, sizeof iv,
Frédéric Lécaille01d515e2022-06-07 11:39:00 +02005417 salt, QUIC_RETRY_TOKEN_SALTLEN, sec, seclen)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005418 TRACE_ERROR("Could not derive retry secret", QUIC_EV_CONN_LPKT, qc);
5419 goto err;
Frédéric Lécaille01d515e2022-06-07 11:39:00 +02005420 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005421
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005422 if (!quic_tls_rx_ctx_init(&ctx, aead, key)) {
5423 TRACE_ERROR("quic_tls_rx_ctx_init() failed", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005424 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005425 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005426
5427 /* Do not decrypt the QUIC_TOKEN_FMT_RETRY byte */
5428 if (!quic_tls_decrypt2(buf, token + 1, tokenlen - QUIC_RETRY_TOKEN_SALTLEN - 1, aad, aadlen,
Frédéric Lécaille01d515e2022-06-07 11:39:00 +02005429 ctx, aead, key, iv)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005430 TRACE_ERROR("Could not decrypt retry token", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005431 goto err;
Frédéric Lécaille01d515e2022-06-07 11:39:00 +02005432 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005433
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005434 if (parse_retry_token(qc, buf, buf + tokenlen - QUIC_RETRY_TOKEN_SALTLEN - 1, odcid)) {
5435 TRACE_ERROR("Error during Initial token parsing", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005436 goto err;
5437 }
5438
5439 EVP_CIPHER_CTX_free(ctx);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005440
5441 ret = 1;
5442 leave:
5443 TRACE_LEAVE(QUIC_EV_CONN_LPKT, qc);
5444 return ret;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005445
5446 err:
5447 if (ctx)
5448 EVP_CIPHER_CTX_free(ctx);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005449 goto leave;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005450}
5451
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005452/* Generate a Retry packet and send it on <fd> socket to <addr> in response to
5453 * the Initial <pkt> packet.
5454 *
5455 * Returns 0 on success else non-zero.
5456 */
5457static int send_retry(int fd, struct sockaddr_storage *addr,
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005458 struct quic_rx_packet *pkt, const struct quic_version *qv)
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005459{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005460 int ret = 0;
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005461 unsigned char buf[128];
5462 int i = 0, token_len;
5463 const socklen_t addrlen = get_addr_len(addr);
5464 struct quic_cid scid;
5465
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005466 TRACE_ENTER(QUIC_EV_CONN_TXPKT);
5467
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005468 /* long header + fixed bit + packet type QUIC_PACKET_TYPE_RETRY */
5469 buf[i++] = (QUIC_PACKET_LONG_HEADER_BIT | QUIC_PACKET_FIXED_BIT) |
5470 (quic_pkt_type(QUIC_PACKET_TYPE_RETRY, qv->num) << QUIC_PACKET_TYPE_SHIFT);
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005471 /* version */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005472 buf[i++] = *((unsigned char *)&qv->num + 3);
5473 buf[i++] = *((unsigned char *)&qv->num + 2);
5474 buf[i++] = *((unsigned char *)&qv->num + 1);
5475 buf[i++] = *(unsigned char *)&qv->num;
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005476
5477 /* Use the SCID from <pkt> for Retry DCID. */
5478 buf[i++] = pkt->scid.len;
5479 memcpy(&buf[i], pkt->scid.data, pkt->scid.len);
5480 i += pkt->scid.len;
5481
5482 /* Generate a new CID to be used as SCID for the Retry packet. */
5483 scid.len = QUIC_HAP_CID_LEN;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005484 /* TODO: RAND_bytes() should be replaced */
5485 if (RAND_bytes(scid.data, scid.len) != 1) {
5486 TRACE_ERROR("RAND_bytes() failed", QUIC_EV_CONN_TXPKT);
5487 goto out;
5488 }
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005489
5490 buf[i++] = scid.len;
5491 memcpy(&buf[i], scid.data, scid.len);
5492 i += scid.len;
5493
5494 /* token */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005495 if (!(token_len = quic_generate_retry_token(&buf[i], sizeof(buf) - i, qv->num,
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005496 &pkt->dcid, &pkt->scid, addr))) {
5497 TRACE_ERROR("quic_generate_retry_token() failed", QUIC_EV_CONN_TXPKT);
5498 goto out;
5499 }
Frédéric Lécaillecc2764e2022-03-23 14:09:09 +01005500
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005501 i += token_len;
5502
5503 /* token integrity tag */
5504 if ((&buf[i] - buf < QUIC_TLS_TAG_LEN) ||
5505 !quic_tls_generate_retry_integrity_tag(pkt->dcid.data,
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005506 pkt->dcid.len, buf, i, qv)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005507 TRACE_ERROR("quic_tls_generate_retry_integrity_tag() failed", QUIC_EV_CONN_TXPKT);
5508 goto out;
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005509 }
5510
5511 i += QUIC_TLS_TAG_LEN;
5512
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005513 if (sendto(fd, buf, i, 0, (struct sockaddr *)addr, addrlen) < 0) {
5514 TRACE_ERROR("quic_tls_generate_retry_integrity_tag() failed", QUIC_EV_CONN_TXPKT);
5515 goto out;
5516 }
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005517
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005518 ret = 1;
5519 out:
5520 TRACE_LEAVE(QUIC_EV_CONN_TXPKT);
5521 return !ret;
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005522}
5523
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005524/* Retrieve a quic_conn instance from the <pkt> DCID field. If the packet is of
5525 * type INITIAL, the ODCID tree is first used. In this case, <saddr> is
5526 * concatenated to the <pkt> DCID field.
5527 *
5528 * Returns the instance or NULL if not found.
5529 */
Amaury Denoyelled6b16672021-12-23 10:37:19 +01005530static struct quic_conn *retrieve_qc_conn_from_cid(struct quic_rx_packet *pkt,
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005531 struct listener *l,
5532 struct sockaddr_storage *saddr)
5533{
5534 struct quic_conn *qc = NULL;
5535 struct ebmb_node *node;
5536 struct quic_connection_id *id;
Amaury Denoyelle250ac422021-12-22 11:29:05 +01005537 /* set if the quic_conn is found in the second DCID tree */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005538
5539 TRACE_ENTER(QUIC_EV_CONN_RXPKT);
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005540
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005541 /* Look first into ODCIDs tree for INITIAL/0-RTT packets. */
5542 if (pkt->type == QUIC_PACKET_TYPE_INITIAL ||
5543 pkt->type == QUIC_PACKET_TYPE_0RTT) {
5544 /* DCIDs of first packets coming from multiple clients may have
5545 * the same values. Let's distinguish them by concatenating the
5546 * socket addresses.
5547 */
5548 quic_cid_saddr_cat(&pkt->dcid, saddr);
Amaury Denoyelle8524f0f2022-02-08 15:03:40 +01005549 node = ebmb_lookup(&quic_dghdlrs[tid].odcids, pkt->dcid.data,
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005550 pkt->dcid.len + pkt->dcid.addrlen);
5551 if (node) {
5552 qc = ebmb_entry(node, struct quic_conn, odcid_node);
5553 goto end;
5554 }
5555 }
5556
5557 /* Look into DCIDs tree for non-INITIAL/0-RTT packets. This may be used
5558 * also for INITIAL/0-RTT non-first packets with the final DCID in
5559 * used.
5560 */
Amaury Denoyelle8524f0f2022-02-08 15:03:40 +01005561 node = ebmb_lookup(&quic_dghdlrs[tid].cids, pkt->dcid.data, pkt->dcid.len);
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005562 if (!node)
5563 goto end;
5564
5565 id = ebmb_entry(node, struct quic_connection_id, node);
5566 qc = id->qc;
Amaury Denoyelle250ac422021-12-22 11:29:05 +01005567
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005568 /* If found in DCIDs tree, remove the quic_conn from the ODCIDs tree.
5569 * If already done, this is a noop.
5570 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005571 if (qc)
Amaury Denoyelle250ac422021-12-22 11:29:05 +01005572 ebmb_delete(&qc->odcid_node);
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005573
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005574 end:
5575 TRACE_ENTER(QUIC_EV_CONN_RXPKT, qc);
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005576 return qc;
5577}
5578
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005579/* Try to allocate the <*ssl> SSL session object for <qc> QUIC connection
5580 * with <ssl_ctx> as SSL context inherited settings. Also set the transport
5581 * parameters of this session.
5582 * This is the responsibility of the caller to check the validity of all the
5583 * pointers passed as parameter to this function.
5584 * Return 0 if succeeded, -1 if not. If failed, sets the ->err_code member of <qc->conn> to
5585 * CO_ER_SSL_NO_MEM.
5586 */
5587static int qc_ssl_sess_init(struct quic_conn *qc, SSL_CTX *ssl_ctx, SSL **ssl,
5588 unsigned char *params, size_t params_len)
5589{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005590 int retry, ret = -1;
5591
5592 TRACE_ENTER(QUIC_EV_CONN_NEW, qc);
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005593
5594 retry = 1;
5595 retry:
5596 *ssl = SSL_new(ssl_ctx);
5597 if (!*ssl) {
5598 if (!retry--)
5599 goto err;
5600
5601 pool_gc(NULL);
5602 goto retry;
5603 }
5604
5605 if (!SSL_set_quic_method(*ssl, &ha_quic_method) ||
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005606 !SSL_set_ex_data(*ssl, ssl_qc_app_data_index, qc)) {
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005607 SSL_free(*ssl);
5608 *ssl = NULL;
5609 if (!retry--)
5610 goto err;
5611
5612 pool_gc(NULL);
5613 goto retry;
5614 }
5615
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005616 ret = 0;
5617 leave:
5618 TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
5619 return ret;
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005620
5621 err:
5622 qc->conn->err_code = CO_ER_SSL_NO_MEM;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005623 goto leave;
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005624}
5625
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005626/* Finalize <qc> QUIC connection:
5627 * - initialize the Initial QUIC TLS context for negotiated version,
5628 * - derive the secrets for this context,
5629 * - encode the transport parameters to be sent,
5630 * - set them into the TLS stack,
5631 * - initialize ->max_ack_delay and max_idle_timeout,
5632 *
5633 * MUST be called after having received the remote transport parameters.
5634 * Return 1 if succeeded, 0 if not.
5635 */
5636int qc_conn_finalize(struct quic_conn *qc, int server)
5637{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005638 int ret = 0;
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005639 struct quic_transport_params *tx_tp = &qc->tx.params;
5640 struct quic_transport_params *rx_tp = &qc->rx.params;
5641 const struct quic_version *ver;
5642
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005643 TRACE_ENTER(QUIC_EV_CONN_NEW, qc);
5644
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005645 if (tx_tp->version_information.negotiated_version &&
5646 tx_tp->version_information.negotiated_version != qc->original_version) {
5647 qc->negotiated_version =
5648 qc->tx.params.version_information.negotiated_version;
5649 if (!qc_new_isecs(qc, &qc->negotiated_ictx, qc->negotiated_version,
5650 qc->odcid.data, qc->odcid.len, !server))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005651 goto out;
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005652
5653 ver = qc->negotiated_version;
5654 }
5655 else {
5656 ver = qc->original_version;
5657 }
5658
5659 qc->enc_params_len =
5660 quic_transport_params_encode(qc->enc_params,
5661 qc->enc_params + sizeof qc->enc_params,
5662 &qc->rx.params, ver, 1);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005663 if (!qc->enc_params_len) {
5664 TRACE_ERROR("quic_transport_params_encode() failed", QUIC_EV_CONN_TXPKT);
5665 goto out;
5666 }
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005667
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005668 if (!SSL_set_quic_transport_params(qc->xprt_ctx->ssl, qc->enc_params, qc->enc_params_len)) {
5669 TRACE_ERROR("SSL_set_quic_transport_params() failed", QUIC_EV_CONN_TXPKT);
5670 goto out;
5671 }
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005672
5673 if (tx_tp->max_ack_delay)
5674 qc->max_ack_delay = tx_tp->max_ack_delay;
5675
5676 if (tx_tp->max_idle_timeout && rx_tp->max_idle_timeout)
5677 qc->max_idle_timeout =
5678 QUIC_MIN(tx_tp->max_idle_timeout, rx_tp->max_idle_timeout);
5679 else
5680 qc->max_idle_timeout =
5681 QUIC_MAX(tx_tp->max_idle_timeout, rx_tp->max_idle_timeout);
5682
5683 TRACE_PROTO("\nTX(remote) transp. params.", QUIC_EV_TRANSP_PARAMS, qc, tx_tp);
5684
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005685 ret = 1;
5686 out:
5687 TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
5688 return ret;
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005689}
5690
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005691/* Allocate the ssl_sock_ctx from connection <qc>. This creates the tasklet
5692 * used to process <qc> received packets. The allocated context is stored in
5693 * <qc.xprt_ctx>.
5694 *
5695 * Returns 0 on success else non-zero.
5696 */
Frédéric Lécaille3fd92f62022-05-19 14:35:20 +02005697static int qc_conn_alloc_ssl_ctx(struct quic_conn *qc)
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005698{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005699 int ret = 0;
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005700 struct bind_conf *bc = qc->li->bind_conf;
5701 struct ssl_sock_ctx *ctx = NULL;
5702
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005703 TRACE_ENTER(QUIC_EV_CONN_NEW, qc);
5704
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005705 ctx = pool_zalloc(pool_head_quic_conn_ctx);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005706 if (!ctx) {
5707 TRACE_ERROR("SSL context allocation failed", QUIC_EV_CONN_TXPKT);
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005708 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005709 }
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005710
5711 ctx->wait_event.tasklet = tasklet_new();
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005712 if (!ctx->wait_event.tasklet) {
5713 TRACE_ERROR("tasklet_new() failed", QUIC_EV_CONN_TXPKT);
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005714 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005715 }
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005716
5717 ctx->wait_event.tasklet->process = quic_conn_io_cb;
5718 ctx->wait_event.tasklet->context = ctx;
5719 ctx->wait_event.events = 0;
5720 ctx->subs = NULL;
5721 ctx->xprt_ctx = NULL;
5722 ctx->qc = qc;
5723
5724 /* Set tasklet tid based on the SCID selected by us for this
5725 * connection. The upper layer will also be binded on the same thread.
5726 */
Frédéric Lécaille220894a2022-01-26 18:04:50 +01005727 qc->tid = ctx->wait_event.tasklet->tid = quic_get_cid_tid(qc->scid.data);
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005728
5729 if (qc_is_listener(qc)) {
5730 if (qc_ssl_sess_init(qc, bc->initial_ctx, &ctx->ssl,
5731 qc->enc_params, qc->enc_params_len) == -1) {
5732 goto err;
5733 }
5734
5735 /* Enabling 0-RTT */
5736 if (bc->ssl_conf.early_data)
5737 SSL_set_quic_early_data_enabled(ctx->ssl, 1);
5738
5739 SSL_set_accept_state(ctx->ssl);
5740 }
5741
5742 ctx->xprt = xprt_get(XPRT_QUIC);
5743
5744 /* Store the allocated context in <qc>. */
Frédéric Lécaillefc790062022-03-28 17:10:31 +02005745 qc->xprt_ctx = ctx;
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005746
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005747 ret = 1;
5748 leave:
5749 TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
5750 return !ret;
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005751
5752 err:
5753 if (ctx && ctx->wait_event.tasklet)
5754 tasklet_free(ctx->wait_event.tasklet);
5755 pool_free(pool_head_quic_conn_ctx, ctx);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005756 goto leave;
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01005757}
5758
Frédéric Lécaillef6954c52022-05-21 14:42:21 +02005759/* Check that all the bytes between <buf> included and <end> address
Ilya Shipitsin3b64a282022-07-29 22:26:53 +05005760 * excluded are null. This is the responsibility of the caller to
Frédéric Lécaillef6954c52022-05-21 14:42:21 +02005761 * check that there is at least one byte between <buf> end <end>.
5762 * Return 1 if this all the bytes are null, 0 if not.
5763 */
5764static inline int quic_padding_check(const unsigned char *buf,
5765 const unsigned char *end)
5766{
5767 while (buf < end && !*buf)
5768 buf++;
5769
5770 return buf == end;
5771}
5772
Frédéric Lécaille4646cf32022-04-27 15:09:53 +02005773/* Parse a QUIC packet from UDP datagram found in <buf> buffer with <end> the
5774 * end of this buffer past one byte and populate <pkt> RX packet structure
5775 * with the information collected from the packet.
5776 * This function sets ->len <pkt> field value to the end of the packet past one
5777 * byte to enable the caller to run this function again to continue to parse
Ilya Shipitsin3b64a282022-07-29 22:26:53 +05005778 * the remaining QUIC packets carried by the datagram.
Frédéric Lécaille4646cf32022-04-27 15:09:53 +02005779 * Note that this function always sets this ->len value. If a paquet could
5780 * not be correctly found, ->len value will be set to the remaining number
5781 * bytes in the datagram to entirely consume this latter.
5782 */
5783static void qc_lstnr_pkt_rcv(unsigned char *buf, const unsigned char *end,
5784 struct quic_rx_packet *pkt, int first_pkt,
Frédéric Lécaille1b0707f2022-06-30 11:28:56 +02005785 struct quic_dgram *dgram, struct list **tasklist_head)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005786{
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005787 unsigned char *beg, *payload;
Frédéric Lécaille560ddfa2022-08-24 18:59:23 +02005788 struct quic_conn *qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005789 struct listener *l;
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005790 struct proxy *prx;
5791 struct quic_counters *prx_counters;
Frédéric Lécaille1eaec332021-06-04 14:59:59 +02005792 struct ssl_sock_ctx *conn_ctx;
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005793 int drop_no_conn = 0, long_header = 0, io_cb_wakeup = 0;
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01005794 size_t b_cspace;
5795 struct quic_enc_level *qel;
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005796 uint32_t version;
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005797 const struct quic_version *qv = NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005798
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005799 TRACE_ENTER(QUIC_EV_CONN_LPKT);
5800
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005801 beg = buf;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005802 qc = NULL;
Frédéric Lécailled24c2ec2021-05-31 10:24:49 +02005803 conn_ctx = NULL;
Frédéric Lécaillec4becf52021-11-08 11:23:17 +01005804 qel = NULL;
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005805 l = dgram->owner;
5806 prx = l->bind_conf->frontend;
5807 prx_counters = EXTRA_COUNTERS_GET(prx->extra_counters_fe, &quic_stats_module);
Frédéric Lécaille8678eb02021-12-16 18:03:52 +01005808 /* This ist only to please to traces and distinguish the
5809 * packet with parsed packet number from others.
5810 */
5811 pkt->pn_node.key = (uint64_t)-1;
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005812 if (end <= buf) {
5813 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT);
5814 goto drop;
5815 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005816
5817 /* Fixed bit */
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005818 if (!(*buf & QUIC_PACKET_FIXED_BIT)) {
Frédéric Lécaillef6954c52022-05-21 14:42:21 +02005819 if (!first_pkt && quic_padding_check(buf, end)) {
5820 /* Some browsers may pad the remaining datagram space with null bytes.
5821 * That is what we called add padding out of QUIC packets. Such
5822 * datagrams must be considered as valid. But we can only consume
5823 * the remaining space.
5824 */
5825 pkt->len = end - buf;
5826 goto drop_no_conn;
5827 }
5828
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005829 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005830 goto drop;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005831 }
5832
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005833 /* Header form */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005834 if (!qc_parse_hd_form(pkt, &buf, end, &long_header, &version)) {
Frédéric Lécailleea0ec272022-06-08 13:22:17 +02005835 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT);
5836 goto drop;
5837 }
5838
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005839 if (long_header) {
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005840 uint64_t len;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005841 struct quic_cid odcid;
Frédéric Lécaille7629f5d2022-08-11 18:54:26 +02005842 const struct quic_cid *token_odcid = NULL; // ODCID received from client token
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005843
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005844 TRACE_PROTO("long header packet received", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005845 if (!quic_packet_read_long_header(&buf, end, pkt)) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005846 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005847 goto drop;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005848 }
5849
Frédéric Lécaille3e266982022-04-27 15:37:28 +02005850 if (pkt->type == QUIC_PACKET_TYPE_0RTT && !l->bind_conf->ssl_conf.early_data) {
5851 TRACE_PROTO("0-RTT packet not supported", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005852 drop_no_conn = 1;
Frédéric Lécaille3e266982022-04-27 15:37:28 +02005853 }
5854 else if (pkt->type == QUIC_PACKET_TYPE_INITIAL &&
5855 dgram->len < QUIC_INITIAL_PACKET_MINLEN) {
Frédéric Lécaille87373e72022-04-27 11:42:08 +02005856 TRACE_PROTO("Too short datagram with an Initial packet", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaille3ccea6d2022-05-23 22:54:54 +02005857 HA_ATOMIC_INC(&prx_counters->too_short_initial_dgram);
Frédéric Lécaillee7df68a2022-08-05 09:34:44 +02005858 goto drop;
Frédéric Lécaille87373e72022-04-27 11:42:08 +02005859 }
5860
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01005861 /* When multiple QUIC packets are coalesced on the same UDP datagram,
5862 * they must have the same DCID.
5863 */
5864 if (!first_pkt &&
5865 (pkt->dcid.len != dgram->dcid_len ||
5866 memcmp(dgram->dcid, pkt->dcid.data, pkt->dcid.len))) {
5867 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005868 goto drop;
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01005869 }
5870
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005871 /* Retry of Version Negotiation packets are only sent by servers */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005872 if (pkt->type == QUIC_PACKET_TYPE_RETRY || !version) {
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005873 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005874 goto drop;
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005875 }
5876
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005877 /* RFC9000 6. Version Negotiation */
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005878 qv = qc_supported_version(version);
5879 if (!qv) {
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005880 /* unsupported version, send Negotiation packet */
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01005881 if (send_version_negotiation(l->rx.fd, &dgram->saddr, pkt)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02005882 TRACE_ERROR("VN packet not sent", QUIC_EV_CONN_LPKT);
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005883 goto err;
5884 }
5885
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005886 TRACE_PROTO("VN packet sent", QUIC_EV_CONN_LPKT);
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005887 goto err;
Amaury Denoyellea22d8602021-11-10 15:17:56 +01005888 }
5889
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005890 /* For Initial packets, and for servers (QUIC clients connections),
5891 * there is no Initial connection IDs storage.
5892 */
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005893 if (pkt->type == QUIC_PACKET_TYPE_INITIAL) {
Frédéric Lécaillef3d078d2021-06-14 14:18:10 +02005894 uint64_t token_len;
Frédéric Lécaillef3d078d2021-06-14 14:18:10 +02005895
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01005896 if (!quic_dec_int(&token_len, (const unsigned char **)&buf, end) ||
5897 end - buf < token_len) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005898 TRACE_PROTO("Packet dropped",
5899 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005900 goto drop;
Frédéric Lécaillea5da31d2021-12-14 19:44:14 +01005901 }
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005902
Amaury Denoyelleb76ae692022-01-11 14:16:37 +01005903 /* TODO Retry should be automatically activated if
5904 * suspect network usage is detected.
5905 */
Frédéric Lécaillee9325e92022-08-11 17:24:38 +02005906 if (global.cluster_secret && !token_len) {
5907 if (l->bind_conf->options & BC_O_QUIC_FORCE_RETRY) {
5908 TRACE_PROTO("Initial without token, sending retry",
5909 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
5910 if (send_retry(l->rx.fd, &dgram->saddr, pkt, qv)) {
5911 TRACE_PROTO("Error during Retry generation",
5912 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005913 goto err;
5914 }
Frédéric Lécaillee9325e92022-08-11 17:24:38 +02005915
5916 HA_ATOMIC_INC(&prx_counters->retry_sent);
5917 goto err;
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005918 }
Amaury Denoyelle5ff1c972022-01-11 14:11:32 +01005919 }
Frédéric Lécaillee9325e92022-08-11 17:24:38 +02005920 else if (!global.cluster_secret && token_len) {
5921 /* Impossible case: a token was received without configured
5922 * cluster secret.
5923 */
5924 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT,
5925 NULL, NULL, NULL, qv);
5926 goto drop;
5927 }
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005928
5929 pkt->token = buf;
5930 pkt->token_len = token_len;
5931 buf += pkt->token_len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005932 }
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005933 else if (pkt->type != QUIC_PACKET_TYPE_0RTT) {
Amaury Denoyelled4962512021-12-14 17:17:28 +01005934 if (pkt->dcid.len != QUIC_HAP_CID_LEN) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005935 TRACE_PROTO("Packet dropped",
5936 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005937 goto drop;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005938 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005939 }
5940
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005941 if (!quic_dec_int(&len, (const unsigned char **)&buf, end) ||
5942 end - buf < len) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005943 TRACE_PROTO("Packet dropped",
5944 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005945 goto drop;
Frédéric Lécaillef3d078d2021-06-14 14:18:10 +02005946 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005947
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005948 payload = buf;
5949 pkt->len = len + payload - beg;
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005950 if (drop_no_conn)
5951 goto drop_no_conn;
Frédéric Lécaille2c15a662021-12-22 20:39:12 +01005952
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01005953 qc = retrieve_qc_conn_from_cid(pkt, l, &dgram->saddr);
Frédéric Lécaillee9325e92022-08-11 17:24:38 +02005954 if (global.cluster_secret && pkt->token_len) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005955 if (*pkt->token == QUIC_TOKEN_FMT_RETRY) {
5956 const struct quic_version *ver = qc ? qc->original_version : qv;
5957 if (!quic_retry_token_check(pkt->token, pkt->token_len, ver, &odcid,
5958 &pkt->scid, qc, &dgram->saddr)) {
5959 HA_ATOMIC_INC(&prx_counters->retry_error);
5960 TRACE_PROTO("Wrong retry token",
5961 QUIC_EV_CONN_LPKT, qc, NULL, NULL, qv);
5962 /* TODO: RFC 9000 8.1.2 A server SHOULD immediately close the connection
5963 * with an INVALID_TOKEN error.
5964 */
5965 goto drop;
5966 }
5967
Frédéric Lécaillee9325e92022-08-11 17:24:38 +02005968 token_odcid = &odcid;
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005969 HA_ATOMIC_INC(&prx_counters->retry_validated);
5970 }
5971 else {
5972 /* TODO: New token check */
5973 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT, qc, NULL, NULL, qv);
5974 goto drop;
5975 }
5976 }
Amaury Denoyelle8efe0322021-12-15 16:32:56 +01005977 if (!qc) {
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02005978 int ipv4;
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02005979
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005980 if (pkt->type != QUIC_PACKET_TYPE_INITIAL) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005981 TRACE_PROTO("Non Initial packet", QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02005982 goto drop;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01005983 }
5984
Willy Tarreau787e92a2022-05-20 16:06:01 +02005985 if (global.cluster_secret && !pkt->token_len && !(l->bind_conf->options & BC_O_QUIC_FORCE_RETRY) &&
Frédéric Lécailleeb791452022-05-24 16:01:39 +02005986 HA_ATOMIC_LOAD(&prx_counters->half_open_conn) >= global.tune.quic_retry_threshold) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005987 TRACE_PROTO("Initial without token, sending retry",
5988 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécaille86845c52022-06-08 19:28:36 +02005989 if (send_retry(l->rx.fd, &dgram->saddr, pkt, qv)) {
Frédéric Lécaille59507de2022-08-11 12:14:07 +02005990 TRACE_ERROR("Error during Retry generation",
Frédéric Lécaille301425b2022-06-14 17:40:39 +02005991 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécailledfd13012022-05-20 16:37:36 +02005992 goto err;
5993 }
5994
5995 HA_ATOMIC_INC(&prx_counters->retry_sent);
5996 goto err;
5997 }
5998
Frédéric Lécaille3f3ff472022-05-12 14:47:59 +02005999 /* RFC 9000 7.2. Negotiating Connection IDs:
6000 * When an Initial packet is sent by a client that has not previously
6001 * received an Initial or Retry packet from the server, the client
6002 * populates the Destination Connection ID field with an unpredictable
6003 * value. This Destination Connection ID MUST be at least 8 bytes in length.
6004 */
Frédéric Lécailledc364042022-01-27 16:51:54 +01006005 if (pkt->dcid.len < QUIC_ODCID_MINLEN) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006006 TRACE_PROTO("dropped packet",
6007 QUIC_EV_CONN_LPKT, NULL, NULL, NULL, qv);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006008 goto drop;
Frédéric Lécailledc364042022-01-27 16:51:54 +01006009 }
6010
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006011 pkt->saddr = dgram->saddr;
6012 ipv4 = dgram->saddr.ss_family == AF_INET;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006013
Frédéric Lécaillee9325e92022-08-11 17:24:38 +02006014 qc = qc_new_conn(qv, ipv4, &pkt->dcid, &pkt->scid, token_odcid,
Frédéric Lécaille748ece62022-05-21 23:58:40 +02006015 &pkt->saddr, 1, !!pkt->token_len, l);
Frédéric Lécaille6de72872021-06-11 15:44:24 +02006016 if (qc == NULL)
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006017 goto drop;
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02006018
Frédéric Lécailleeb791452022-05-24 16:01:39 +02006019 HA_ATOMIC_INC(&prx_counters->half_open_conn);
Frédéric Lécaillef3d078d2021-06-14 14:18:10 +02006020 /* Insert the DCID the QUIC client has chosen (only for listeners) */
Frédéric Lécaille560ddfa2022-08-24 18:59:23 +02006021 ebmb_insert(&quic_dghdlrs[tid].odcids, &qc->odcid_node,
6022 qc->odcid.len + qc->odcid.addrlen);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006023 }
Frédéric Lécaille560ddfa2022-08-24 18:59:23 +02006024
6025 pkt->qc = qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006026 }
6027 else {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006028 TRACE_PROTO("short header packet received", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01006029 if (end - buf < QUIC_HAP_CID_LEN) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006030 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006031 goto drop;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006032 }
6033
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01006034 memcpy(pkt->dcid.data, buf, QUIC_HAP_CID_LEN);
Amaury Denoyelleadb22762021-12-14 15:04:14 +01006035 pkt->dcid.len = QUIC_HAP_CID_LEN;
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006036
6037 /* When multiple QUIC packets are coalesced on the same UDP datagram,
6038 * they must have the same DCID.
6039 */
6040 if (!first_pkt &&
6041 (pkt->dcid.len != dgram->dcid_len ||
6042 memcmp(dgram->dcid, pkt->dcid.data, pkt->dcid.len))) {
6043 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006044 goto drop;
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006045 }
6046
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01006047 buf += QUIC_HAP_CID_LEN;
6048
6049 /* A short packet is the last one of a UDP datagram. */
6050 payload = buf;
6051 pkt->len = end - beg;
Amaury Denoyelleadb22762021-12-14 15:04:14 +01006052
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006053 qc = retrieve_qc_conn_from_cid(pkt, l, &dgram->saddr);
Frédéric Lécaille4d118d62021-12-21 14:48:58 +01006054 if (!qc) {
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01006055 size_t pktlen = end - buf;
Frédéric Lécaille4d118d62021-12-21 14:48:58 +01006056 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT, NULL, pkt, &pktlen);
Frédéric Lécailleeb791452022-05-24 16:01:39 +02006057 if (global.cluster_secret && !send_stateless_reset(l, &dgram->saddr, pkt))
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006058 TRACE_ERROR("stateless reset not sent", QUIC_EV_CONN_LPKT, qc);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006059 goto drop;
Frédéric Lécaille4d118d62021-12-21 14:48:58 +01006060 }
6061
Frédéric Lécaille8370c932021-11-08 17:01:46 +01006062 pkt->qc = qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006063 }
6064
Frédéric Lécaille59bf2552022-03-28 12:13:09 +02006065 if (qc->flags & QUIC_FL_CONN_CLOSING) {
6066 if (++qc->nb_pkt_since_cc >= qc->nb_pkt_for_cc) {
6067 qc->flags |= QUIC_FL_CONN_IMMEDIATE_CLOSE;
6068 qc->nb_pkt_for_cc++;
6069 qc->nb_pkt_since_cc = 0;
6070 }
6071 /* Skip the entire datagram */
6072 pkt->len = end - beg;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006073 TRACE_STATE("Closing state connection",
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006074 QUIC_EV_CONN_LPKT, pkt->qc, NULL, NULL, qv);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006075 goto drop;
Frédéric Lécaille59bf2552022-03-28 12:13:09 +02006076 }
Amaury Denoyelleadb22762021-12-14 15:04:14 +01006077
6078 /* When multiple QUIC packets are coalesced on the same UDP datagram,
6079 * they must have the same DCID.
6080 *
6081 * This check must be done after the final update to pkt.len to
6082 * properly drop the packet on failure.
6083 */
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006084 if (first_pkt && !quic_peer_validated_addr(qc) &&
Frédéric Lécaillefc790062022-03-28 17:10:31 +02006085 qc->flags & QUIC_FL_CONN_ANTI_AMPLIFICATION_REACHED) {
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006086 TRACE_PROTO("PTO timer must be armed after anti-amplication was reached",
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006087 QUIC_EV_CONN_LPKT, qc, NULL, NULL, qv);
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006088 /* Reset the anti-amplification bit. It will be set again
6089 * when sending the next packet if reached again.
6090 */
Frédéric Lécaillefc790062022-03-28 17:10:31 +02006091 qc->flags &= ~QUIC_FL_CONN_ANTI_AMPLIFICATION_REACHED;
6092 qc->flags |= QUIC_FL_CONN_IO_CB_WAKEUP;
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006093 io_cb_wakeup = 1;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006094 }
Amaury Denoyelleadb22762021-12-14 15:04:14 +01006095
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01006096 dgram->qc = qc;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006097
Amaury Denoyelle72d86502022-07-13 15:08:23 +02006098 if (qc->flags & QUIC_FL_CONN_IMMEDIATE_CLOSE) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006099 TRACE_PROTO("Connection error",
6100 QUIC_EV_CONN_LPKT, qc, NULL, NULL, qv);
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01006101 goto out;
6102 }
6103
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01006104 pkt->raw_len = pkt->len;
Frédéric Lécailled61bc8d2021-12-02 14:46:19 +01006105 quic_rx_pkts_del(qc);
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01006106 b_cspace = b_contig_space(&qc->rx.buf);
6107 if (b_cspace < pkt->len) {
Amaury Denoyelle80d05722022-05-16 18:13:56 +02006108 /* Do not consume buf if space not at the end. */
6109 if (b_tail(&qc->rx.buf) + b_cspace < b_wrap(&qc->rx.buf)) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006110 TRACE_PROTO("Packet dropped",
6111 QUIC_EV_CONN_LPKT, qc, NULL, NULL, qv);
Frédéric Lécaille45a16292022-06-29 12:03:34 +02006112 HA_ATOMIC_INC(&prx_counters->dropped_pkt_bufoverrun);
6113 goto drop_no_conn;
Amaury Denoyelle80d05722022-05-16 18:13:56 +02006114 }
6115
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01006116 /* Let us consume the remaining contiguous space. */
Frédéric Lécailled61bc8d2021-12-02 14:46:19 +01006117 if (b_cspace) {
6118 b_putchr(&qc->rx.buf, 0x00);
6119 b_cspace--;
6120 }
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01006121 b_add(&qc->rx.buf, b_cspace);
6122 if (b_contig_space(&qc->rx.buf) < pkt->len) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006123 TRACE_PROTO("Too big packet",
6124 QUIC_EV_CONN_LPKT, qc, pkt, &pkt->len, qv);
Frédéric Lécaille45a16292022-06-29 12:03:34 +02006125 HA_ATOMIC_INC(&prx_counters->dropped_pkt_bufoverrun);
6126 goto drop_no_conn;
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01006127 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006128 }
6129
Frédéric Lécaille99897d12022-08-08 10:28:07 +02006130 if (!qc_try_rm_hp(qc, pkt, payload, beg, &qel)) {
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006131 TRACE_PROTO("Packet dropped", QUIC_EV_CONN_LPKT, qc, NULL, NULL, qv);
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006132 goto drop;
Frédéric Lécaille1a5e88c2021-05-31 18:04:07 +02006133 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006134
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006135 TRACE_DATA("New packet", QUIC_EV_CONN_LPKT, qc, pkt, NULL, qv);
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01006136 if (pkt->aad_len)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006137 qc_pkt_insert(qc, pkt, qel);
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01006138 out:
Frédéric Lécaille01abc462021-07-21 09:34:27 +02006139 /* Wake up the connection packet handler task from here only if all
6140 * the contexts have been initialized, especially the mux context
6141 * conn_ctx->conn->ctx. Note that this is ->start xprt callback which
6142 * will start it if these contexts for the connection are not already
6143 * initialized.
6144 */
Frédéric Lécaillefc790062022-03-28 17:10:31 +02006145 conn_ctx = qc->xprt_ctx;
Amaury Denoyellecfa2d562022-01-19 16:01:05 +01006146 if (conn_ctx)
Frédéric Lécaille1b0707f2022-06-30 11:28:56 +02006147 *tasklist_head = tasklet_wakeup_after(*tasklist_head, conn_ctx->wait_event.tasklet);
Frédéric Lécailled24c2ec2021-05-31 10:24:49 +02006148
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006149 drop_no_conn:
6150 if (drop_no_conn)
6151 HA_ATOMIC_INC(&prx_counters->dropped_pkt);
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006152 TRACE_LEAVE(QUIC_EV_CONN_LPKT, qc ? qc : NULL, pkt, NULL, qv);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006153
Frédéric Lécaille4646cf32022-04-27 15:09:53 +02006154 return;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006155
Frédéric Lécaillecbd59c72022-05-20 08:11:26 +02006156 drop:
6157 HA_ATOMIC_INC(&prx_counters->dropped_pkt);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006158 err:
Frédéric Lécaille6b663152022-01-04 17:03:11 +01006159 /* Wakeup the I/O handler callback if the PTO timer must be armed.
6160 * This cannot be done by this thread.
6161 */
6162 if (io_cb_wakeup) {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02006163 conn_ctx = qc->xprt_ctx;
Frédéric Lécaille6b663152022-01-04 17:03:11 +01006164 if (conn_ctx && conn_ctx->wait_event.tasklet)
6165 tasklet_wakeup(conn_ctx->wait_event.tasklet);
6166 }
Frédéric Lécaillef7ef9762021-12-31 16:37:58 +01006167 /* If length not found, consume the entire datagram */
Frédéric Lécaille01cfec72021-12-22 10:17:01 +01006168 if (!pkt->len)
6169 pkt->len = end - beg;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006170 TRACE_LEAVE(QUIC_EV_CONN_LPKT, qc ? qc : NULL, pkt, NULL, qv);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006171}
6172
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006173/* This function builds into <buf> buffer a QUIC long packet header.
6174 * Return 1 if enough room to build this header, 0 if not.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006175 */
6176static int quic_build_packet_long_header(unsigned char **buf, const unsigned char *end,
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006177 int type, size_t pn_len,
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006178 struct quic_conn *qc, const struct quic_version *ver)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006179{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006180 int ret = 0;
6181
6182 TRACE_ENTER(QUIC_EV_CONN_LPKT, qc);
6183
6184 if (end - *buf < sizeof ver->num + qc->dcid.len + qc->scid.len + 3) {
6185 TRACE_DEVEL("not enough room", QUIC_EV_CONN_LPKT, qc);
6186 goto leave;
6187 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006188
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006189 type = quic_pkt_type(type, ver->num);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006190 /* #0 byte flags */
6191 *(*buf)++ = QUIC_PACKET_FIXED_BIT | QUIC_PACKET_LONG_HEADER_BIT |
6192 (type << QUIC_PACKET_TYPE_SHIFT) | (pn_len - 1);
6193 /* Version */
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006194 quic_write_uint32(buf, end, ver->num);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006195 *(*buf)++ = qc->dcid.len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006196 /* Destination connection ID */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006197 if (qc->dcid.len) {
6198 memcpy(*buf, qc->dcid.data, qc->dcid.len);
6199 *buf += qc->dcid.len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006200 }
6201 /* Source connection ID */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006202 *(*buf)++ = qc->scid.len;
6203 if (qc->scid.len) {
6204 memcpy(*buf, qc->scid.data, qc->scid.len);
6205 *buf += qc->scid.len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006206 }
6207
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006208 ret = 1;
6209 leave:
6210 TRACE_LEAVE(QUIC_EV_CONN_LPKT, qc);
6211 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006212}
6213
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006214/* This function builds into <buf> buffer a QUIC short packet header.
6215 * Return 1 if enough room to build this header, 0 if not.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006216 */
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006217static int quic_build_packet_short_header(unsigned char **buf, const unsigned char *end,
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006218 size_t pn_len, struct quic_conn *qc,
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006219 unsigned char tls_flags)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006220{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006221 int ret = 0;
6222
6223 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
6224
6225 if (end - *buf < 1 + qc->dcid.len) {
6226 TRACE_DEVEL("not enough room", QUIC_EV_CONN_LPKT, qc);
6227 goto leave;
6228 }
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006229
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006230 /* #0 byte flags */
Frédéric Lécaillea7d2c092021-11-30 11:18:18 +01006231 *(*buf)++ = QUIC_PACKET_FIXED_BIT |
6232 ((tls_flags & QUIC_FL_TLS_KP_BIT_SET) ? QUIC_PACKET_KEY_PHASE_BIT : 0) | (pn_len - 1);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006233 /* Destination connection ID */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006234 if (qc->dcid.len) {
6235 memcpy(*buf, qc->dcid.data, qc->dcid.len);
6236 *buf += qc->dcid.len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006237 }
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006238
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006239 ret = 1;
6240 leave:
6241 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
6242 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006243}
6244
6245/* Apply QUIC header protection to the packet with <buf> as first byte address,
6246 * <pn> as address of the Packet number field, <pnlen> being this field length
6247 * with <aead> as AEAD cipher and <key> as secret key.
6248 * Returns 1 if succeeded or 0 if failed.
6249 */
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02006250static int quic_apply_header_protection(struct quic_conn *qc, unsigned char *buf,
6251 unsigned char *pn, size_t pnlen,
6252 struct quic_tls_ctx *tls_ctx)
6253
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006254{
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02006255 int i, ret = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006256 /* We need an IV of at least 5 bytes: one byte for bytes #0
6257 * and at most 4 bytes for the packet number
6258 */
6259 unsigned char mask[5] = {0};
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02006260 EVP_CIPHER_CTX *aes_ctx = tls_ctx->tx.hp_ctx;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006261
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006262 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
6263
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02006264 if (!quic_tls_aes_encrypt(mask, pn + QUIC_PACKET_PN_MAXLEN, sizeof mask, aes_ctx)) {
6265 TRACE_ERROR("could not apply header protection", QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006266 goto out;
6267 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006268
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006269 *buf ^= mask[0] & (*buf & QUIC_PACKET_LONG_HEADER_BIT ? 0xf : 0x1f);
6270 for (i = 0; i < pnlen; i++)
6271 pn[i] ^= mask[i + 1];
6272
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006273 ret = 1;
6274 out:
6275 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006276 return ret;
6277}
6278
6279/* Reduce the encoded size of <ack_frm> ACK frame removing the last
6280 * ACK ranges if needed to a value below <limit> in bytes.
6281 * Return 1 if succeeded, 0 if not.
6282 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006283static int quic_ack_frm_reduce_sz(struct quic_conn *qc,
6284 struct quic_frame *ack_frm, size_t limit)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006285{
6286 size_t room, ack_delay_sz;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006287 int ret = 0;
6288
6289 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006290
6291 ack_delay_sz = quic_int_getsize(ack_frm->tx_ack.ack_delay);
6292 /* A frame is made of 1 byte for the frame type. */
6293 room = limit - ack_delay_sz - 1;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006294 if (!quic_rm_last_ack_ranges(qc, ack_frm->tx_ack.arngs, room))
6295 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006296
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006297 ret = 1 + ack_delay_sz + ack_frm->tx_ack.arngs->enc_sz;
6298 leave:
6299 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
6300 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006301}
6302
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006303/* Prepare into <outlist> as most as possible ack-eliciting frame from their
6304 * <inlist> prebuilt frames for <qel> encryption level to be encoded in a buffer
6305 * with <room> as available room, and <*len> the packet Length field initialized
6306 * with the number of bytes already present in this buffer which must be taken
6307 * into an account for the Length packet field value. <headlen> is the number of
6308 * bytes already present in this packet before building frames.
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006309 *
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006310 * Update consequently <*len> to reflect the size of these frames built
Frédéric Lécaillecba4cd42022-01-14 20:39:18 +01006311 * by this function. Also attach these frames to <l> frame list.
Frédéric Lécaille573b56b2022-04-25 15:42:56 +02006312 * Return 1 if at least one ack-eleciting frame could be built, 0 if not.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006313 */
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006314static inline int qc_build_frms(struct list *outlist, struct list *inlist,
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006315 size_t room, size_t *len, size_t headlen,
6316 struct quic_enc_level *qel,
Amaury Denoyelle17a74162021-12-21 14:45:39 +01006317 struct quic_conn *qc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006318{
Frédéric Lécailleea604992020-12-24 13:01:37 +01006319 int ret;
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01006320 struct quic_frame *cf, *cfbak;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006321
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006322 TRACE_ENTER(QUIC_EV_CONN_BCFRMS, qc);
6323
Frédéric Lécailleea604992020-12-24 13:01:37 +01006324 ret = 0;
Frédéric Lécaillef4e5a7c2022-01-17 17:56:20 +01006325 if (*len > room)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006326 goto leave;
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006327
Frédéric Lécailleea604992020-12-24 13:01:37 +01006328 /* If we are not probing we must take into an account the congestion
6329 * control window.
6330 */
Frédéric Lécaillef4e5a7c2022-01-17 17:56:20 +01006331 if (!qel->pktns->tx.pto_probe) {
6332 size_t remain = quic_path_prep_data(qc->path);
6333
6334 if (headlen > remain)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006335 goto leave;
Frédéric Lécaillef4e5a7c2022-01-17 17:56:20 +01006336
6337 room = QUIC_MIN(room, remain - headlen);
6338 }
6339
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006340 TRACE_PROTO("************** frames build (headlen)",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006341 QUIC_EV_CONN_BCFRMS, qc, &headlen);
Frédéric Lécaille573b56b2022-04-25 15:42:56 +02006342
6343 /* NOTE: switch/case block inside a loop, a successful status must be
6344 * returned by this function only if at least one frame could be built
6345 * in the switch/case block.
6346 */
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006347 list_for_each_entry_safe(cf, cfbak, inlist, list) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006348 /* header length, data length, frame length. */
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006349 size_t hlen, dlen, dlen_sz, avail_room, flen;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006350
Frédéric Lécailleea604992020-12-24 13:01:37 +01006351 if (!room)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006352 break;
6353
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006354 switch (cf->type) {
6355 case QUIC_FT_CRYPTO:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006356 TRACE_DEVEL(" New CRYPTO frame build (room, len)",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006357 QUIC_EV_CONN_BCFRMS, qc, &room, len);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006358 /* Compute the length of this CRYPTO frame header */
6359 hlen = 1 + quic_int_getsize(cf->crypto.offset);
6360 /* Compute the data length of this CRyPTO frame. */
6361 dlen = max_stream_data_size(room, *len + hlen, cf->crypto.len);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006362 TRACE_DEVEL(" CRYPTO data length (hlen, crypto.len, dlen)",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006363 QUIC_EV_CONN_BCFRMS, qc, &hlen, &cf->crypto.len, &dlen);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006364 if (!dlen)
Frédéric Lécaille573b56b2022-04-25 15:42:56 +02006365 continue;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006366
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006367 /* CRYPTO frame length. */
6368 flen = hlen + quic_int_getsize(dlen) + dlen;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006369 TRACE_DEVEL(" CRYPTO frame length (flen)",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006370 QUIC_EV_CONN_BCFRMS, qc, &flen);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006371 /* Add the CRYPTO data length and its encoded length to the packet
6372 * length and the length of this length.
6373 */
6374 *len += flen;
6375 room -= flen;
6376 if (dlen == cf->crypto.len) {
6377 /* <cf> CRYPTO data have been consumed. */
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01006378 LIST_DELETE(&cf->list);
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006379 LIST_APPEND(outlist, &cf->list);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006380 }
6381 else {
6382 struct quic_frame *new_cf;
6383
Frédéric Lécailleb9171912022-04-21 17:32:10 +02006384 new_cf = pool_zalloc(pool_head_quic_frame);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006385 if (!new_cf) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006386 TRACE_ERROR("No memory for new crypto frame", QUIC_EV_CONN_BCFRMS, qc);
Frédéric Lécaille573b56b2022-04-25 15:42:56 +02006387 continue;
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006388 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006389
Frédéric Lécailleb9171912022-04-21 17:32:10 +02006390 LIST_INIT(&new_cf->reflist);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006391 new_cf->type = QUIC_FT_CRYPTO;
6392 new_cf->crypto.len = dlen;
6393 new_cf->crypto.offset = cf->crypto.offset;
6394 new_cf->crypto.qel = qel;
Frédéric Lécailleb8278402022-08-19 09:32:14 +02006395 TRACE_DEVEL("splitted frame", QUIC_EV_CONN_PRSAFRM, qc, new_cf);
6396 if (cf->origin) {
6397 TRACE_DEVEL("duplicated frame", QUIC_EV_CONN_PRSAFRM, qc);
6398 /* This <cf> frame was duplicated */
6399 LIST_APPEND(&cf->origin->reflist, &new_cf->ref);
6400 new_cf->origin = cf->origin;
6401 }
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006402 LIST_APPEND(outlist, &new_cf->list);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006403 /* Consume <dlen> bytes of the current frame. */
6404 cf->crypto.len -= dlen;
6405 cf->crypto.offset += dlen;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006406 }
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006407 break;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006408
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006409 case QUIC_FT_STREAM_8 ... QUIC_FT_STREAM_F:
Frédéric Lécaille77cb38d2022-04-27 07:17:56 +02006410 if (cf->flags & QUIC_FL_TX_FRAME_LOST) {
6411 struct eb64_node *node = NULL;
6412 struct qc_stream_desc *stream_desc = NULL;
6413 struct quic_stream *strm = &cf->stream;
6414
6415 /* As this frame has been already lost, ensure the stream is always
6416 * available or the range of this frame is not consumed before
6417 * resending it.
6418 */
6419 node = eb64_lookup(&qc->streams_by_id, strm->id);
6420 if (!node) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006421 TRACE_DEVEL("released stream", QUIC_EV_CONN_PRSAFRM, qc, cf);
Frédéric Lécaille77cb38d2022-04-27 07:17:56 +02006422 LIST_DELETE(&cf->list);
6423 pool_free(pool_head_quic_frame, cf);
6424 continue;
6425 }
6426
6427 stream_desc = eb64_entry(node, struct qc_stream_desc, by_id);
6428 if (strm->offset.key + strm->len <= stream_desc->ack_offset) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006429 TRACE_DEVEL("ignored frame frame in already acked range",
Frédéric Lécaillefdc1b962022-05-31 12:04:42 +02006430 QUIC_EV_CONN_PRSAFRM, qc, cf);
Frédéric Lécaille77cb38d2022-04-27 07:17:56 +02006431 LIST_DELETE(&cf->list);
6432 pool_free(pool_head_quic_frame, cf);
6433 continue;
6434 }
6435 else if (strm->offset.key < stream_desc->ack_offset) {
6436 strm->offset.key = stream_desc->ack_offset;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006437 TRACE_DEVEL("updated partially acked frame",
Frédéric Lécaillefdc1b962022-05-31 12:04:42 +02006438 QUIC_EV_CONN_PRSAFRM, qc, cf);
Frédéric Lécaille77cb38d2022-04-27 07:17:56 +02006439 }
6440 }
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006441 /* Note that these frames are accepted in short packets only without
6442 * "Length" packet field. Here, <*len> is used only to compute the
6443 * sum of the lengths of the already built frames for this packet.
Frédéric Lécailled8b84432021-12-10 15:18:36 +01006444 *
6445 * Compute the length of this STREAM frame "header" made a all the field
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006446 * excepting the variable ones. Note that +1 is for the type of this frame.
6447 */
6448 hlen = 1 + quic_int_getsize(cf->stream.id) +
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02006449 ((cf->type & QUIC_STREAM_FRAME_TYPE_OFF_BIT) ? quic_int_getsize(cf->stream.offset.key) : 0);
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006450 /* Compute the data length of this STREAM frame. */
6451 avail_room = room - hlen - *len;
Frédéric Lécaille573b56b2022-04-25 15:42:56 +02006452 if ((ssize_t)avail_room <= 0)
6453 continue;
6454
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006455 TRACE_DEVEL(" New STREAM frame build (room, len)",
Frédéric Lécailleadc76412022-08-08 16:09:46 +02006456 QUIC_EV_CONN_BCFRMS, qc, &room, len);
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006457 if (cf->type & QUIC_STREAM_FRAME_TYPE_LEN_BIT) {
6458 dlen = max_available_room(avail_room, &dlen_sz);
6459 if (dlen > cf->stream.len) {
6460 dlen = cf->stream.len;
6461 }
6462 dlen_sz = quic_int_getsize(dlen);
6463 flen = hlen + dlen_sz + dlen;
6464 }
6465 else {
Frédéric Lécaille628e89c2022-06-24 12:13:53 +02006466 dlen = QUIC_MIN((uint64_t)avail_room, cf->stream.len);
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006467 flen = hlen + dlen;
6468 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006469 TRACE_DEVEL(" STREAM data length (hlen, stream.len, dlen)",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006470 QUIC_EV_CONN_BCFRMS, qc, &hlen, &cf->stream.len, &dlen);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006471 TRACE_DEVEL(" STREAM frame length (flen)",
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006472 QUIC_EV_CONN_BCFRMS, qc, &flen);
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006473 /* Add the STREAM data length and its encoded length to the packet
6474 * length and the length of this length.
6475 */
6476 *len += flen;
6477 room -= flen;
6478 if (dlen == cf->stream.len) {
6479 /* <cf> STREAM data have been consumed. */
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01006480 LIST_DELETE(&cf->list);
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006481 LIST_APPEND(outlist, &cf->list);
Amaury Denoyelle54445d02022-03-10 16:44:14 +01006482
Amaury Denoyelleb29a1dc2022-08-12 14:30:04 +02006483 /* Do not notify MUX on retransmission. */
Amaury Denoyelle70467562022-08-17 16:33:13 +02006484 if (qc->flags & QUIC_FL_CONN_TX_MUX_CONTEXT) {
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02006485 qcc_streams_sent_done(cf->stream.stream->ctx,
6486 cf->stream.len,
6487 cf->stream.offset.key);
6488 }
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006489 }
6490 else {
6491 struct quic_frame *new_cf;
Amaury Denoyelle642ab062022-02-23 10:54:42 +01006492 struct buffer cf_buf;
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006493
6494 new_cf = pool_zalloc(pool_head_quic_frame);
6495 if (!new_cf) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006496 TRACE_ERROR("No memory for new STREAM frame", QUIC_EV_CONN_BCFRMS, qc);
Frédéric Lécaille573b56b2022-04-25 15:42:56 +02006497 continue;
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006498 }
6499
Frédéric Lécailleb9171912022-04-21 17:32:10 +02006500 LIST_INIT(&new_cf->reflist);
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006501 new_cf->type = cf->type;
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02006502 new_cf->stream.stream = cf->stream.stream;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02006503 new_cf->stream.buf = cf->stream.buf;
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006504 new_cf->stream.id = cf->stream.id;
6505 if (cf->type & QUIC_STREAM_FRAME_TYPE_OFF_BIT)
6506 new_cf->stream.offset = cf->stream.offset;
6507 new_cf->stream.len = dlen;
6508 new_cf->type |= QUIC_STREAM_FRAME_TYPE_LEN_BIT;
6509 /* FIN bit reset */
6510 new_cf->type &= ~QUIC_STREAM_FRAME_TYPE_FIN_BIT;
6511 new_cf->stream.data = cf->stream.data;
Frédéric Lécailleb8278402022-08-19 09:32:14 +02006512 TRACE_DEVEL("splitted frame", QUIC_EV_CONN_PRSAFRM, qc, new_cf);
6513 if (cf->origin) {
6514 TRACE_DEVEL("duplicated frame", QUIC_EV_CONN_PRSAFRM, qc);
6515 /* This <cf> frame was duplicated */
6516 LIST_APPEND(&cf->origin->reflist, &new_cf->ref);
6517 new_cf->origin = cf->origin;
6518 }
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006519 LIST_APPEND(outlist, &new_cf->list);
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006520 cf->type |= QUIC_STREAM_FRAME_TYPE_OFF_BIT;
6521 /* Consume <dlen> bytes of the current frame. */
Amaury Denoyelle642ab062022-02-23 10:54:42 +01006522 cf_buf = b_make(b_orig(cf->stream.buf),
6523 b_size(cf->stream.buf),
6524 (char *)cf->stream.data - b_orig(cf->stream.buf), 0);
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006525 cf->stream.len -= dlen;
Frédéric Lécaille785d3bd2021-09-10 09:13:39 +02006526 cf->stream.offset.key += dlen;
Amaury Denoyelle642ab062022-02-23 10:54:42 +01006527 cf->stream.data = (unsigned char *)b_peek(&cf_buf, dlen);
Amaury Denoyelle54445d02022-03-10 16:44:14 +01006528
Amaury Denoyelleb29a1dc2022-08-12 14:30:04 +02006529 /* Do not notify MUX on retransmission. */
Amaury Denoyelle70467562022-08-17 16:33:13 +02006530 if (qc->flags & QUIC_FL_CONN_TX_MUX_CONTEXT) {
Amaury Denoyelle7272cd72022-03-29 15:15:54 +02006531 qcc_streams_sent_done(new_cf->stream.stream->ctx,
6532 new_cf->stream.len,
6533 new_cf->stream.offset.key);
6534 }
Frédéric Lécaillea5b1b892021-08-25 17:56:22 +02006535 }
Amaury Denoyelle54445d02022-03-10 16:44:14 +01006536
6537 /* TODO the MUX is notified about the frame sending via
6538 * previous qcc_streams_sent_done call. However, the
6539 * sending can fail later, for example if the sendto
6540 * system call returns an error. As the MUX has been
6541 * notified, the transport layer is responsible to
6542 * bufferize and resent the announced data later.
6543 */
6544
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006545 break;
6546
6547 default:
6548 flen = qc_frm_len(cf);
6549 BUG_ON(!flen);
6550 if (flen > room)
6551 continue;
6552
6553 *len += flen;
6554 room -= flen;
Frédéric Lécaille82468ea2022-01-14 20:23:22 +01006555 LIST_DELETE(&cf->list);
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006556 LIST_APPEND(outlist, &cf->list);
Frédéric Lécaille0ac38512021-08-03 16:38:49 +02006557 break;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006558 }
Frédéric Lécaille573b56b2022-04-25 15:42:56 +02006559
6560 /* Successful status as soon as a frame could be built */
Frédéric Lécailleea604992020-12-24 13:01:37 +01006561 ret = 1;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006562 }
6563
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006564 leave:
6565 TRACE_LEAVE(QUIC_EV_CONN_BCFRMS, qc);
Frédéric Lécailleea604992020-12-24 13:01:37 +01006566 return ret;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006567}
6568
Amaury Denoyelle0933c7b2022-07-18 14:11:50 +02006569/* Generate a CONNECTION_CLOSE frame for <qc> on <qel> encryption level. <out>
6570 * is used as return parameter and should be zero'ed by the caller.
6571 */
6572static void qc_build_cc_frm(struct quic_conn *qc, struct quic_enc_level *qel,
6573 struct quic_frame *out)
6574{
6575 /* TODO improve CONNECTION_CLOSE on Initial/Handshake encryption levels
6576 *
6577 * A CONNECTION_CLOSE frame should be sent in several packets with
6578 * different encryption levels depending on the client context. This is
6579 * to ensure that the client can decrypt it. See RFC 9000 10.2.3 for
6580 * more details on how to implement it.
6581 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006582 TRACE_ENTER(QUIC_EV_CONN_BFRM, qc);
6583
Amaury Denoyelle0933c7b2022-07-18 14:11:50 +02006584
6585 if (qc->err.app) {
6586 if (unlikely(qel == &qc->els[QUIC_TLS_ENC_LEVEL_INITIAL] ||
6587 qel == &qc->els[QUIC_TLS_ENC_LEVEL_HANDSHAKE])) {
6588 /* RFC 9000 10.2.3. Immediate Close during the Handshake
6589 *
6590 * Sending a CONNECTION_CLOSE of type 0x1d in an Initial or Handshake
6591 * packet could expose application state or be used to alter application
6592 * state. A CONNECTION_CLOSE of type 0x1d MUST be replaced by a
6593 * CONNECTION_CLOSE of type 0x1c when sending the frame in Initial or
6594 * Handshake packets. Otherwise, information about the application
6595 * state might be revealed. Endpoints MUST clear the value of the
6596 * Reason Phrase field and SHOULD use the APPLICATION_ERROR code when
6597 * converting to a CONNECTION_CLOSE of type 0x1c.
6598 */
6599 out->type = QUIC_FT_CONNECTION_CLOSE;
6600 out->connection_close.error_code = QC_ERR_APPLICATION_ERROR;
6601 out->connection_close.reason_phrase_len = 0;
6602 }
6603 else {
6604 out->type = QUIC_FT_CONNECTION_CLOSE_APP;
6605 out->connection_close.error_code = qc->err.code;
6606 }
6607 }
6608 else {
6609 out->type = QUIC_FT_CONNECTION_CLOSE;
6610 out->connection_close.error_code = qc->err.code;
6611 }
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006612 TRACE_LEAVE(QUIC_EV_CONN_BFRM, qc);
6613
Amaury Denoyelle0933c7b2022-07-18 14:11:50 +02006614}
6615
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006616/* This function builds a clear packet from <pkt> information (its type)
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006617 * into a buffer with <pos> as position pointer and <qel> as QUIC TLS encryption
6618 * level for <conn> QUIC connection and <qel> as QUIC TLS encryption level,
Frédéric Lécaille28c7ea32022-02-25 17:41:39 +01006619 * filling the buffer with as much frames as possible from <frms> list of
6620 * prebuilt frames.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006621 * The trailing QUIC_TLS_TAG_LEN bytes of this packet are not built. But they are
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006622 * reserved so that to ensure there is enough room to build this AEAD TAG after
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006623 * having returned from this function.
6624 * This function also updates the value of <buf_pn> pointer to point to the packet
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006625 * number field in this packet. <pn_len> will also have the packet number
6626 * length as value.
6627 *
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006628 * Return 1 if succeeded (enough room to buile this packet), O if not.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006629 */
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006630static int qc_do_build_pkt(unsigned char *pos, const unsigned char *end,
6631 size_t dglen, struct quic_tx_packet *pkt,
6632 int64_t pn, size_t *pn_len, unsigned char **buf_pn,
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02006633 int force_ack, int padding, int cc, int probe,
Frédéric Lécaille28c7ea32022-02-25 17:41:39 +01006634 struct quic_enc_level *qel, struct quic_conn *qc,
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006635 const struct quic_version *ver, struct list *frms)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006636{
Frédéric Lécailleebb10702022-08-16 12:03:00 +02006637 unsigned char *beg, *payload;
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01006638 size_t len, len_sz, len_frms, padding_len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006639 struct quic_frame frm = { .type = QUIC_FT_CRYPTO, };
6640 struct quic_frame ack_frm = { .type = QUIC_FT_ACK, };
Amaury Denoyellef9e190e2022-05-23 16:12:15 +02006641 struct quic_frame cc_frm = { };
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01006642 size_t ack_frm_len, head_len;
Frédéric Lécaille141982a2022-03-15 18:44:20 +01006643 int64_t rx_largest_acked_pn;
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006644 int add_ping_frm;
Frédéric Lécaillecba4cd42022-01-14 20:39:18 +01006645 struct list frm_list = LIST_HEAD_INIT(frm_list);
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01006646 struct quic_frame *cf;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006647 int must_ack, ret = 0;
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02006648 int nb_aepkts_since_last_ack;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006649
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006650 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc);
6651
Frédéric Lécailleea604992020-12-24 13:01:37 +01006652 /* Length field value with CRYPTO frames if present. */
6653 len_frms = 0;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006654 beg = pos;
Frédéric Lécailleb0021452022-03-29 11:42:03 +02006655 /* When not probing, and no immediate close is required, reduce the size of this
6656 * buffer to respect the congestion controller window.
6657 * This size will be limited if we have ack-eliciting frames to send from <frms>.
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006658 */
Frédéric Lécailleb0021452022-03-29 11:42:03 +02006659 if (!probe && !LIST_ISEMPTY(frms) && !cc) {
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006660 size_t path_room;
6661
Amaury Denoyelle17a74162021-12-21 14:45:39 +01006662 path_room = quic_path_prep_data(qc->path);
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006663 if (end - beg > path_room)
6664 end = beg + path_room;
6665 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006666
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006667 /* Ensure there is enough room for the TLS encryption tag and a zero token
6668 * length field if any.
6669 */
6670 if (end - pos < QUIC_TLS_TAG_LEN +
6671 (pkt->type == QUIC_PACKET_TYPE_INITIAL ? 1 : 0))
6672 goto no_room;
6673
6674 end -= QUIC_TLS_TAG_LEN;
Frédéric Lécaille205e4f32022-03-28 17:38:27 +02006675 rx_largest_acked_pn = qel->pktns->rx.largest_acked_pn;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006676 /* packet number length */
Frédéric Lécaille141982a2022-03-15 18:44:20 +01006677 *pn_len = quic_packet_number_length(pn, rx_largest_acked_pn);
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006678 /* Build the header */
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006679 if ((pkt->type == QUIC_PACKET_TYPE_SHORT &&
Amaury Denoyelle17a74162021-12-21 14:45:39 +01006680 !quic_build_packet_short_header(&pos, end, *pn_len, qc, qel->tls_ctx.flags)) ||
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006681 (pkt->type != QUIC_PACKET_TYPE_SHORT &&
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006682 !quic_build_packet_long_header(&pos, end, pkt->type, *pn_len, qc, ver)))
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006683 goto no_room;
6684
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006685 /* Encode the token length (0) for an Initial packet. */
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006686 if (pkt->type == QUIC_PACKET_TYPE_INITIAL)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006687 *pos++ = 0;
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01006688 head_len = pos - beg;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006689 /* Build an ACK frame if required. */
6690 ack_frm_len = 0;
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02006691 nb_aepkts_since_last_ack = qel->pktns->rx.nb_aepkts_since_last_ack;
6692 must_ack = !qel->pktns->tx.pto_probe &&
6693 (force_ack || ((qel->pktns->flags & QUIC_FL_PKTNS_ACK_REQUIRED) &&
6694 (LIST_ISEMPTY(frms) || nb_aepkts_since_last_ack >= QUIC_MAX_RX_AEPKTS_SINCE_LAST_ACK)));
6695 if (force_ack || must_ack) {
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02006696 struct quic_arngs *arngs = &qel->pktns->rx.arngs;
Frédéric Lécailleb0021452022-03-29 11:42:03 +02006697 BUG_ON(eb_is_empty(&qel->pktns->rx.arngs.root));
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02006698 ack_frm.tx_ack.arngs = arngs;
6699 if (qel->pktns->flags & QUIC_FL_PKTNS_NEW_LARGEST_PN) {
6700 qel->pktns->tx.ack_delay =
6701 quic_compute_ack_delay_us(qel->pktns->rx.largest_time_received, qc);
6702 qel->pktns->flags &= ~QUIC_FL_PKTNS_NEW_LARGEST_PN;
6703 }
6704 ack_frm.tx_ack.ack_delay = qel->pktns->tx.ack_delay;
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006705 /* XXX BE CAREFUL XXX : here we reserved at least one byte for the
6706 * smallest frame (PING) and <*pn_len> more for the packet number. Note
6707 * that from here, we do not know if we will have to send a PING frame.
6708 * This will be decided after having computed the ack-eliciting frames
6709 * to be added to this packet.
6710 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006711 ack_frm_len = quic_ack_frm_reduce_sz(qc, &ack_frm, end - 1 - *pn_len - pos);
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006712 if (!ack_frm_len)
6713 goto no_room;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006714 }
6715
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006716 /* Length field value without the ack-eliciting frames. */
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006717 len = ack_frm_len + *pn_len;
Frédéric Lécaille1fc5e162021-11-22 14:25:57 +01006718 len_frms = 0;
Frédéric Lécaille28c7ea32022-02-25 17:41:39 +01006719 if (!cc && !LIST_ISEMPTY(frms)) {
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006720 ssize_t room = end - pos;
Frédéric Lécailleea604992020-12-24 13:01:37 +01006721
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006722 TRACE_DEVEL("Avail. ack eliciting frames", QUIC_EV_CONN_FRMLIST, qc, frms);
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006723 /* Initialize the length of the frames built below to <len>.
6724 * If any frame could be successfully built by qc_build_frms(),
6725 * we will have len_frms > len.
6726 */
6727 len_frms = len;
Frédéric Lécailleedc81462022-02-25 17:44:29 +01006728 if (!qc_build_frms(&frm_list, frms,
6729 end - pos, &len_frms, pos - beg, qel, qc)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006730 TRACE_DEVEL("Not enough room", QUIC_EV_CONN_TXPKT,
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006731 qc, NULL, NULL, &room);
Frédéric Lécaille834399c2022-04-25 17:17:07 +02006732 if (!ack_frm_len && !qel->pktns->tx.pto_probe)
6733 goto no_room;
Amaury Denoyelle17a74162021-12-21 14:45:39 +01006734 }
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006735 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006736
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01006737 /* Length (of the remaining data). Must not fail because, the buffer size
6738 * has been checked above. Note that we have reserved QUIC_TLS_TAG_LEN bytes
6739 * for the encryption tag. It must be taken into an account for the length
6740 * of this packet.
6741 */
6742 if (len_frms)
6743 len = len_frms + QUIC_TLS_TAG_LEN;
6744 else
6745 len += QUIC_TLS_TAG_LEN;
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01006746 /* CONNECTION_CLOSE frame */
6747 if (cc) {
Amaury Denoyelle0933c7b2022-07-18 14:11:50 +02006748 qc_build_cc_frm(qc, qel, &cc_frm);
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01006749 len += qc_frm_len(&cc_frm);
6750 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006751 add_ping_frm = 0;
6752 padding_len = 0;
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01006753 len_sz = quic_int_getsize(len);
6754 /* Add this packet size to <dglen> */
6755 dglen += head_len + len_sz + len;
6756 if (padding && dglen < QUIC_INITIAL_PACKET_MINLEN) {
6757 /* This is a maximum padding size */
6758 padding_len = QUIC_INITIAL_PACKET_MINLEN - dglen;
6759 /* The length field value is of this packet is <len> + <padding_len>
6760 * the size of which may be greater than the initial computed size
Ilya Shipitsin5e87bcf2021-12-25 11:45:52 +05006761 * <len_sz>. So, let's deduce the difference between these to packet
Frédéric Lécaille28f51fa2021-11-09 14:12:12 +01006762 * sizes from <padding_len>.
6763 */
6764 padding_len -= quic_int_getsize(len + padding_len) - len_sz;
6765 len += padding_len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006766 }
Frédéric Lécaillecba4cd42022-01-14 20:39:18 +01006767 else if (LIST_ISEMPTY(&frm_list) || len_frms == len) {
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006768 if (qel->pktns->tx.pto_probe) {
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006769 /* If we cannot send a frame, we send a PING frame. */
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006770 add_ping_frm = 1;
6771 len += 1;
6772 }
6773 /* If there is no frame at all to follow, add at least a PADDING frame. */
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01006774 if (!ack_frm_len && !cc)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006775 len += padding_len = QUIC_PACKET_PN_MAXLEN - *pn_len;
6776 }
6777
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006778 if (pkt->type != QUIC_PACKET_TYPE_SHORT && !quic_enc_int(&pos, end, len))
6779 goto no_room;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006780
6781 /* Packet number field address. */
6782 *buf_pn = pos;
6783
6784 /* Packet number encoding. */
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006785 if (!quic_packet_number_encode(&pos, end, pn, *pn_len))
6786 goto no_room;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006787
Frédéric Lécailleebb10702022-08-16 12:03:00 +02006788 /* payload building (ack-eliciting or not frames) */
6789 payload = pos;
Frédéric Lécaille141982a2022-03-15 18:44:20 +01006790 if (ack_frm_len) {
6791 if (!qc_build_frm(&pos, end, &ack_frm, pkt, qc))
6792 goto no_room;
6793
6794 pkt->largest_acked_pn = quic_pktns_get_largest_acked_pn(qel->pktns);
Frédéric Lécailleb0021452022-03-29 11:42:03 +02006795 pkt->flags |= QUIC_FL_TX_PACKET_ACK;
Frédéric Lécaille141982a2022-03-15 18:44:20 +01006796 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006797
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006798 /* Ack-eliciting frames */
Frédéric Lécaillecba4cd42022-01-14 20:39:18 +01006799 if (!LIST_ISEMPTY(&frm_list)) {
Frédéric Lécaillea8a60432022-08-23 11:42:48 +02006800 struct quic_frame *tmp_cf;
6801 list_for_each_entry_safe(cf, tmp_cf, &frm_list, list) {
Frédéric Lécailleb8047de2022-08-23 17:40:09 +02006802 if (!qc_build_frm(&pos, end, cf, pkt, qc)) {
Frédéric Lécaille133e8a72020-12-18 09:33:27 +01006803 ssize_t room = end - pos;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006804 TRACE_DEVEL("Not enough room", QUIC_EV_CONN_TXPKT,
Amaury Denoyelle7aaeb5b2021-12-21 14:29:15 +01006805 qc, NULL, NULL, &room);
Frédéric Lécaille149c5312022-08-27 15:51:30 +02006806 /* Note that <cf> was added from <frms> to <frm_list> list by
Frédéric Lécailleebb10702022-08-16 12:03:00 +02006807 * qc_build_frms().
Frédéric Lécailledcc74ff2022-03-18 17:49:29 +01006808 */
6809 LIST_DELETE(&cf->list);
6810 LIST_INSERT(frms, &cf->list);
Frédéric Lécaille149c5312022-08-27 15:51:30 +02006811 continue;
Frédéric Lécaille133e8a72020-12-18 09:33:27 +01006812 }
Frédéric Lécailledcc74ff2022-03-18 17:49:29 +01006813
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01006814 quic_tx_packet_refinc(pkt);
6815 cf->pkt = pkt;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006816 }
6817 }
6818
6819 /* Build a PING frame if needed. */
6820 if (add_ping_frm) {
6821 frm.type = QUIC_FT_PING;
Amaury Denoyelle17a74162021-12-21 14:45:39 +01006822 if (!qc_build_frm(&pos, end, &frm, pkt, qc))
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006823 goto no_room;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006824 }
6825
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01006826 /* Build a CONNECTION_CLOSE frame if needed. */
Frédéric Lécaille59bf2552022-03-28 12:13:09 +02006827 if (cc) {
6828 if (!qc_build_frm(&pos, end, &cc_frm, pkt, qc))
6829 goto no_room;
6830
6831 pkt->flags |= QUIC_FL_TX_PACKET_CC;
6832 }
Frédéric Lécaille66cbb822021-11-17 11:56:21 +01006833
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006834 /* Build a PADDING frame if needed. */
6835 if (padding_len) {
6836 frm.type = QUIC_FT_PADDING;
6837 frm.padding.len = padding_len;
Amaury Denoyelle17a74162021-12-21 14:45:39 +01006838 if (!qc_build_frm(&pos, end, &frm, pkt, qc))
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006839 goto no_room;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006840 }
6841
Frédéric Lécailleebb10702022-08-16 12:03:00 +02006842 if (pos == payload) {
6843 /* No payload was built because of congestion control */
6844 TRACE_DEVEL("limited by congestion control", QUIC_EV_CONN_TXPKT, qc);
6845 goto no_room;
6846 }
6847
Frédéric Lécaille466e9da2021-12-29 12:04:13 +01006848 /* If this packet is ack-eliciting and we are probing let's
6849 * decrement the PTO probe counter.
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006850 */
Frédéric Lécaille466e9da2021-12-29 12:04:13 +01006851 if (pkt->flags & QUIC_FL_TX_PACKET_ACK_ELICITING &&
6852 qel->pktns->tx.pto_probe)
6853 qel->pktns->tx.pto_probe--;
6854
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006855 pkt->len = pos - beg;
Frédéric Lécaillecba4cd42022-01-14 20:39:18 +01006856 LIST_SPLICE(&pkt->frms, &frm_list);
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006857
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006858 ret = 1;
6859 TRACE_DEVEL("Packet ack-eliciting frames", QUIC_EV_CONN_TXPKT, qc, pkt);
6860 leave:
6861 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc);
6862 return ret;
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006863
6864 no_room:
Frédéric Lécaillecba4cd42022-01-14 20:39:18 +01006865 /* Replace the pre-built frames which could not be add to this packet */
Frédéric Lécaille28c7ea32022-02-25 17:41:39 +01006866 LIST_SPLICE(frms, &frm_list);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006867 TRACE_DEVEL("Remaining ack-eliciting frames", QUIC_EV_CONN_FRMLIST, qc, frms);
6868 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006869}
6870
Frédéric Lécaille0e50e1b2021-08-03 15:03:35 +02006871static inline void quic_tx_packet_init(struct quic_tx_packet *pkt, int type)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006872{
Frédéric Lécaille0e50e1b2021-08-03 15:03:35 +02006873 pkt->type = type;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006874 pkt->len = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006875 pkt->in_flight_len = 0;
Frédéric Lécaille0371cd52021-12-13 12:30:54 +01006876 pkt->pn_node.key = (uint64_t)-1;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006877 LIST_INIT(&pkt->frms);
Frédéric Lécaille2899fe22022-03-21 10:43:53 +01006878 pkt->time_sent = TICK_ETERNITY;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006879 pkt->next = NULL;
Frédéric Lécaille141982a2022-03-15 18:44:20 +01006880 pkt->largest_acked_pn = -1;
Frédéric Lécaille2899fe22022-03-21 10:43:53 +01006881 pkt->flags = 0;
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01006882 pkt->refcnt = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006883}
6884
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006885/* Build a packet into <buf> packet buffer with <pkt_type> as packet
Frédéric Lécaille28c7ea32022-02-25 17:41:39 +01006886 * type for <qc> QUIC connection from <qel> encryption level from <frms> list
6887 * of prebuilt frames.
6888 *
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006889 * Return -2 if the packet could not be allocated or encrypted for any reason,
6890 * -1 if there was not enough room to build a packet.
Frédéric Lécaillee9a974a2022-03-13 19:19:12 +01006891 * XXX NOTE XXX
6892 * If you provide provide qc_build_pkt() with a big enough buffer to build a packet as big as
6893 * possible (to fill an MTU), the unique reason why this function may fail is the congestion
6894 * control window limitation.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006895 */
Frédéric Lécaille9445abc2021-08-04 10:49:51 +02006896static struct quic_tx_packet *qc_build_pkt(unsigned char **pos,
6897 const unsigned char *buf_end,
Frédéric Lécaille301425b2022-06-14 17:40:39 +02006898 struct quic_enc_level *qel,
6899 struct quic_tls_ctx *tls_ctx, struct list *frms,
6900 struct quic_conn *qc, const struct quic_version *ver,
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02006901 size_t dglen, int pkt_type, int force_ack,
6902 int padding, int probe, int cc, int *err)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006903{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006904 struct quic_tx_packet *ret_pkt = NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006905 /* The pointer to the packet number field. */
6906 unsigned char *buf_pn;
6907 unsigned char *beg, *end, *payload;
6908 int64_t pn;
6909 size_t pn_len, payload_len, aad_len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006910 struct quic_tx_packet *pkt;
6911
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006912 TRACE_ENTER(QUIC_EV_CONN_TXPKT, qc, NULL, qel);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006913 *err = 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006914 pkt = pool_alloc(pool_head_quic_tx_packet);
6915 if (!pkt) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006916 TRACE_DEVEL("Not enough memory for a new packet", QUIC_EV_CONN_TXPKT, qc);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006917 *err = -2;
6918 goto err;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006919 }
6920
Frédéric Lécaille0e50e1b2021-08-03 15:03:35 +02006921 quic_tx_packet_init(pkt, pkt_type);
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006922 beg = *pos;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006923 pn_len = 0;
6924 buf_pn = NULL;
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006925
6926 pn = qel->pktns->tx.next_pn + 1;
6927 if (!qc_do_build_pkt(*pos, buf_end, dglen, pkt, pn, &pn_len, &buf_pn,
Frédéric Lécaille77ac6f52022-06-21 15:14:59 +02006928 force_ack, padding, cc, probe, qel, qc, ver, frms)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006929 // trace already emitted by function above
Frédéric Lécaille4436cb62021-08-16 12:06:46 +02006930 *err = -1;
6931 goto err;
6932 }
6933
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006934 end = beg + pkt->len;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006935 payload = buf_pn + pn_len;
6936 payload_len = end - payload;
6937 aad_len = payload - beg;
6938
Frédéric Lécaille5f7f1182022-01-10 11:00:16 +01006939 if (!quic_packet_encrypt(payload, payload_len, beg, aad_len, pn, tls_ctx, qc)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006940 // trace already emitted by function above
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006941 *err = -2;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006942 goto err;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006943 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006944
6945 end += QUIC_TLS_TAG_LEN;
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006946 pkt->len += QUIC_TLS_TAG_LEN;
Frédéric Lécaille86a53c52022-08-19 18:18:13 +02006947 if (!quic_apply_header_protection(qc, beg, buf_pn, pn_len, tls_ctx)) {
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006948 // trace already emitted by function above
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006949 *err = -2;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006950 goto err;
6951 }
6952
Frédéric Lécaille73dcc6e2021-12-07 15:27:44 +01006953 /* Consume a packet number */
6954 qel->pktns->tx.next_pn++;
Frédéric Lécailleca98a7f2021-11-10 17:30:15 +01006955 qc->tx.prep_bytes += pkt->len;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006956 if (qc->tx.prep_bytes >= 3 * qc->rx.bytes && !quic_peer_validated_addr(qc)) {
Frédéric Lécaillefc790062022-03-28 17:10:31 +02006957 qc->flags |= QUIC_FL_CONN_ANTI_AMPLIFICATION_REACHED;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006958 TRACE_PROTO("anti-amplification limit reached", QUIC_EV_CONN_TXPKT, qc);
6959 }
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006960 /* Now that a correct packet is built, let us consume <*pos> buffer. */
6961 *pos = end;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006962 /* Attach the built packet to its tree. */
Frédéric Lécaillea7348f62021-08-03 16:50:14 +02006963 pkt->pn_node.key = pn;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006964 /* Set the packet in fligth length for in flight packet only. */
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006965 if (pkt->flags & QUIC_FL_TX_PACKET_IN_FLIGHT) {
Frédéric Lécaillec5b0c932021-07-06 16:35:52 +02006966 pkt->in_flight_len = pkt->len;
6967 qc->path->prep_in_flight += pkt->len;
Frédéric Lécaille04ffb662020-12-08 15:58:39 +01006968 }
Frédéric Lécaille47756802022-03-25 09:12:16 +01006969 /* Always reset this flags */
6970 qc->flags &= ~QUIC_FL_CONN_IMMEDIATE_CLOSE;
Frédéric Lécailleb0021452022-03-29 11:42:03 +02006971 if (pkt->flags & QUIC_FL_TX_PACKET_ACK) {
6972 qel->pktns->flags &= ~QUIC_FL_PKTNS_ACK_REQUIRED;
6973 qel->pktns->rx.nb_aepkts_since_last_ack = 0;
6974 }
Frédéric Lécaille205e4f32022-03-28 17:38:27 +02006975
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006976 pkt->pktns = qel->pktns;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006977
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006978 ret_pkt = pkt;
6979 leave:
6980 TRACE_LEAVE(QUIC_EV_CONN_TXPKT, qc, ret_pkt);
6981 return ret_pkt;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006982
6983 err:
Frédéric Lécaillee2a1c1b2022-03-17 11:28:10 +01006984 /* TODO: what about the frames which have been built
6985 * for this packet.
6986 */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006987 free_quic_tx_packet(qc, pkt);
6988 goto leave;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006989}
6990
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01006991
Frédéric Lécaille422a39c2021-03-03 17:28:34 +01006992/* Called from the upper layer, to subscribe <es> to events <event_type>. The
6993 * event subscriber <es> is not allowed to change from a previous call as long
6994 * as at least one event is still subscribed. The <event_type> must only be a
6995 * combination of SUB_RETRY_RECV and SUB_RETRY_SEND. It always returns 0.
6996 */
6997static int quic_conn_subscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
6998{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02006999 struct quic_conn *qc = conn->handle.qc;
7000 struct qcc *qcc = qc->qcc;
7001
7002 TRACE_ENTER(QUIC_EV_CONN_SUB, qc);
Frédéric Lécaille513b4f22021-09-20 15:23:17 +02007003
7004 BUG_ON(event_type & ~(SUB_RETRY_SEND|SUB_RETRY_RECV));
7005 BUG_ON(qcc->subs && qcc->subs != es);
7006
7007 es->events |= event_type;
7008 qcc->subs = es;
7009
7010 if (event_type & SUB_RETRY_RECV)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007011 TRACE_DEVEL("subscribe(recv)", QUIC_EV_CONN_XPRTRECV, qc, qcc);
Frédéric Lécaille513b4f22021-09-20 15:23:17 +02007012
7013 if (event_type & SUB_RETRY_SEND)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007014 TRACE_DEVEL("subscribe(send)", QUIC_EV_CONN_XPRTSEND, qc, qcc);
7015
7016 TRACE_LEAVE(QUIC_EV_CONN_SUB, qc);
Frédéric Lécaille513b4f22021-09-20 15:23:17 +02007017
7018 return 0;
Frédéric Lécaille422a39c2021-03-03 17:28:34 +01007019}
7020
7021/* Called from the upper layer, to unsubscribe <es> from events <event_type>.
7022 * The <es> pointer is not allowed to differ from the one passed to the
7023 * subscribe() call. It always returns zero.
7024 */
7025static int quic_conn_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
7026{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007027 int ret;
7028 struct quic_conn *qc = conn->handle.qc;
7029 struct qcc *qcc = qc->qcc;
7030
7031 TRACE_ENTER(QUIC_EV_CONN_SUB, qc);
7032
7033 if (event_type & SUB_RETRY_RECV)
7034 TRACE_DEVEL("unsubscribe(recv)", QUIC_EV_CONN_XPRTRECV, qc, qcc);
7035 if (event_type & SUB_RETRY_SEND)
7036 TRACE_DEVEL("unsubscribe(send)", QUIC_EV_CONN_XPRTSEND, qc, qcc);
7037
7038 ret = conn_unsubscribe(conn, xprt_ctx, event_type, es);
7039
7040 TRACE_LEAVE(QUIC_EV_CONN_SUB, qc);
7041
7042 return ret;
Frédéric Lécaille422a39c2021-03-03 17:28:34 +01007043}
7044
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01007045/* Store in <xprt_ctx> the context attached to <conn>.
7046 * Returns always 0.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007047 */
7048static int qc_conn_init(struct connection *conn, void **xprt_ctx)
7049{
Amaury Denoyelle7ca7c842021-12-22 18:20:38 +01007050 struct quic_conn *qc = NULL;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007051
7052 TRACE_ENTER(QUIC_EV_CONN_NEW, conn);
7053
Amaury Denoyelle33ac3462022-01-18 16:44:34 +01007054 /* do not store the context if already set */
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007055 if (*xprt_ctx)
7056 goto out;
7057
Willy Tarreau784b8682022-04-11 14:18:10 +02007058 *xprt_ctx = conn->handle.qc->xprt_ctx;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007059
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007060 out:
Frédéric Lécaillefde2a982021-12-27 15:12:09 +01007061 TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007062
7063 return 0;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007064}
7065
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02007066/* Start the QUIC transport layer */
7067static int qc_xprt_start(struct connection *conn, void *ctx)
7068{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007069 int ret = 0;
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02007070 struct quic_conn *qc;
Frédéric Lécaille1eaec332021-06-04 14:59:59 +02007071 struct ssl_sock_ctx *qctx = ctx;
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02007072
Willy Tarreau784b8682022-04-11 14:18:10 +02007073 qc = conn->handle.qc;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007074 TRACE_ENTER(QUIC_EV_CONN_NEW, qc);
Amaury Denoyellecfa2d562022-01-19 16:01:05 +01007075 if (qcc_install_app_ops(qc->qcc, qc->app_ops)) {
7076 TRACE_PROTO("Cannot install app layer", QUIC_EV_CONN_LPKT, qc);
Amaury Denoyelle5d774de2022-04-14 14:59:35 +02007077 /* prepare a CONNECTION_CLOSE frame */
Amaury Denoyelle57e6db72022-07-13 15:07:56 +02007078 quic_set_connection_close(qc, quic_err_transport(QC_ERR_APPLICATION_ERROR));
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007079 goto out;
Amaury Denoyellecfa2d562022-01-19 16:01:05 +01007080 }
7081
7082 /* mux-quic can now be considered ready. */
7083 qc->mux_state = QC_MUX_READY;
7084
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02007085 tasklet_wakeup(qctx->wait_event.tasklet);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007086
7087 ret = 1;
7088 out:
7089 TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
7090 return ret;
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02007091}
7092
Willy Tarreau54a1dcb2022-04-11 11:57:35 +02007093static struct ssl_sock_ctx *qc_get_ssl_sock_ctx(struct connection *conn)
7094{
Willy Tarreau784b8682022-04-11 14:18:10 +02007095 if (!conn || conn->xprt != xprt_get(XPRT_QUIC) || !conn->handle.qc || !conn->xprt_ctx)
Willy Tarreau54a1dcb2022-04-11 11:57:35 +02007096 return NULL;
7097
Willy Tarreau784b8682022-04-11 14:18:10 +02007098 return conn->handle.qc->xprt_ctx;
Willy Tarreau54a1dcb2022-04-11 11:57:35 +02007099}
7100
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007101/* transport-layer operations for QUIC connections. */
7102static struct xprt_ops ssl_quic = {
Amaury Denoyelle414cac52021-09-22 11:14:37 +02007103 .close = quic_close,
Frédéric Lécaille422a39c2021-03-03 17:28:34 +01007104 .subscribe = quic_conn_subscribe,
7105 .unsubscribe = quic_conn_unsubscribe,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007106 .init = qc_conn_init,
Frédéric Lécaille3d77fa72021-05-31 09:30:14 +02007107 .start = qc_xprt_start,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007108 .prepare_bind_conf = ssl_sock_prepare_bind_conf,
7109 .destroy_bind_conf = ssl_sock_destroy_bind_conf,
Amaury Denoyelle71e588c2021-11-12 11:23:29 +01007110 .get_alpn = ssl_sock_get_alpn,
Willy Tarreau54a1dcb2022-04-11 11:57:35 +02007111 .get_ssl_sock_ctx = qc_get_ssl_sock_ctx,
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007112 .name = "QUIC",
7113};
7114
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007115static void __quic_conn_init(void)
7116{
7117 ha_quic_meth = BIO_meth_new(0x666, "ha QUIC methods");
7118 xprt_register(XPRT_QUIC, &ssl_quic);
7119}
Willy Tarreau79367f92022-04-25 19:18:24 +02007120INITCALL0(STG_REGISTER, __quic_conn_init);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007121
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007122static void __quic_conn_deinit(void)
7123{
7124 BIO_meth_free(ha_quic_meth);
7125}
Willy Tarreau79367f92022-04-25 19:18:24 +02007126REGISTER_POST_DEINIT(__quic_conn_deinit);
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007127
Frédéric Lécaille324ecda2021-11-02 10:14:44 +01007128/* Read all the QUIC packets found in <buf> from QUIC connection with <owner>
7129 * as owner calling <func> function.
Ilya Shipitsin1e9a6662021-01-05 22:10:46 +05007130 * Return the number of bytes read if succeeded, -1 if not.
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007131 */
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01007132struct task *quic_lstnr_dghdlr(struct task *t, void *ctx, unsigned int state)
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007133{
7134 unsigned char *pos;
7135 const unsigned char *end;
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01007136 struct quic_dghdlr *dghdlr = ctx;
7137 struct quic_dgram *dgram;
7138 int first_pkt = 1;
Frédéric Lécaille1b0707f2022-06-30 11:28:56 +02007139 struct list *tasklist_head = NULL;
Willy Tarreauf9d4a7d2022-08-05 08:45:56 +02007140 int max_dgrams = global.tune.maxpollevents;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007141
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007142 TRACE_ENTER(QUIC_EV_CONN_LPKT);
7143
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007144 while ((dgram = MT_LIST_POP(&dghdlr->dgrams, typeof(dgram), mt_list))) {
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007145 pos = dgram->buf;
7146 end = pos + dgram->len;
7147 do {
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007148 struct quic_rx_packet *pkt;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007149
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007150 pkt = pool_zalloc(pool_head_quic_rx_packet);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007151 if (!pkt) {
7152 TRACE_ERROR("RX packet allocation failed", QUIC_EV_CONN_LPKT);
7153 goto leave;
7154 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007155
Amaury Denoyelle23f908c2022-06-20 10:58:03 +02007156 LIST_INIT(&pkt->qc_rx_pkt_list);
Frédéric Lécaille7cc8b312022-05-05 12:04:28 +02007157 pkt->time_received = now_ms;
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007158 quic_rx_packet_refinc(pkt);
Frédéric Lécaille1b0707f2022-06-30 11:28:56 +02007159 qc_lstnr_pkt_rcv(pos, end, pkt, first_pkt, dgram, &tasklist_head);
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007160 first_pkt = 0;
7161 pos += pkt->len;
7162 quic_rx_packet_refdec(pkt);
Amaury Denoyelle23f908c2022-06-20 10:58:03 +02007163
7164 /* Free rejected packets */
7165 if (!pkt->refcnt) {
7166 BUG_ON(LIST_INLIST(&pkt->qc_rx_pkt_list));
7167 pool_free(pool_head_quic_rx_packet, pkt);
7168 }
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007169 } while (pos < end);
7170
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007171 /* Increasing the received bytes counter by the UDP datagram length
7172 * if this datagram could be associated to a connection.
7173 */
7174 if (dgram->qc)
7175 dgram->qc->rx.bytes += dgram->len;
Frédéric Lécaille841bf5e2022-02-02 09:41:27 +01007176
7177 /* Mark this datagram as consumed */
7178 HA_ATOMIC_STORE(&dgram->buf, NULL);
Willy Tarreauf9d4a7d2022-08-05 08:45:56 +02007179
7180 if (--max_dgrams <= 0)
7181 goto stop_here;
Frédéric Lécailledf1c7c72022-01-28 15:38:52 +01007182 }
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007183
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007184 TRACE_LEAVE(QUIC_EV_CONN_LPKT);
7185
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01007186 return t;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007187
Willy Tarreauf9d4a7d2022-08-05 08:45:56 +02007188 stop_here:
7189 /* too much work done at once, come back here later */
7190 if (!MT_LIST_ISEMPTY(&dghdlr->dgrams))
7191 tasklet_wakeup((struct tasklet *)t);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007192 leave:
7193 TRACE_LEAVE(QUIC_EV_CONN_LPKT);
Frédéric Lécaille25bc8872022-01-27 09:15:40 +01007194 return t;
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007195}
7196
Ilya Shipitsin3b64a282022-07-29 22:26:53 +05007197/* Retrieve the DCID from a QUIC datagram or packet with <buf> as first octet.
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007198 * Returns 1 if succeeded, 0 if not.
7199 */
Frédéric Lécaille6492e662022-05-17 17:23:16 +02007200int quic_get_dgram_dcid(unsigned char *buf, const unsigned char *end,
7201 unsigned char **dcid, size_t *dcid_len)
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007202{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007203 int ret = 0, long_header;
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007204 size_t minlen, skip;
7205
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007206 TRACE_ENTER(QUIC_EV_CONN_RXPKT);
7207
7208 if (!(*buf & QUIC_PACKET_FIXED_BIT)) {
7209 TRACE_PROTO("fixed bit not set", QUIC_EV_CONN_RXPKT);
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007210 goto err;
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007211 }
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007212
7213 long_header = *buf & QUIC_PACKET_LONG_HEADER_BIT;
Frédéric Lécaille36b28ed2022-05-09 18:08:13 +02007214 minlen = long_header ? QUIC_LONG_PACKET_MINLEN :
7215 QUIC_SHORT_PACKET_MINLEN + QUIC_HAP_CID_LEN + QUIC_TLS_TAG_LEN;
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007216 skip = long_header ? QUIC_LONG_PACKET_DCID_OFF : QUIC_SHORT_PACKET_DCID_OFF;
Willy Tarreauaf5138f2022-08-05 10:09:32 +02007217 if (end - buf < minlen)
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007218 goto err;
7219
7220 buf += skip;
7221 *dcid_len = long_header ? *buf++ : QUIC_HAP_CID_LEN;
7222 if (*dcid_len > QUIC_CID_MAXLEN || end - buf <= *dcid_len)
7223 goto err;
7224
7225 *dcid = buf;
7226
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007227 ret = 1;
7228 leave:
7229 TRACE_LEAVE(QUIC_EV_CONN_RXPKT);
7230 return ret;
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007231
7232 err:
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007233 TRACE_PROTO("wrong datagram", QUIC_EV_CONN_RXPKT);
7234 goto leave;
Frédéric Lécaille3d4bfe72022-01-26 16:07:16 +01007235}
7236
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02007237/* Notify the MUX layer if alive about an imminent close of <qc>. */
7238void qc_notify_close(struct quic_conn *qc)
7239{
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007240 TRACE_ENTER(QUIC_EV_CONN_CLOSE, qc);
7241
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02007242 if (qc->flags & QUIC_FL_CONN_NOTIFY_CLOSE)
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007243 goto leave;
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02007244
7245 qc->flags |= QUIC_FL_CONN_NOTIFY_CLOSE;
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02007246 /* wake up the MUX */
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007247 if (qc->mux_state == QC_MUX_READY && qc->conn->mux->wake) {
7248 TRACE_STATE("connection closure notidfied to mux",
7249 QUIC_FL_CONN_NOTIFY_CLOSE, qc);
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02007250 qc->conn->mux->wake(qc->conn);
Frédéric Lécaillea8b2f842022-08-10 17:56:45 +02007251 }
7252 else
7253 TRACE_STATE("connection closure not notidfied to mux",
7254 QUIC_FL_CONN_NOTIFY_CLOSE, qc);
7255 leave:
7256 TRACE_LEAVE(QUIC_EV_CONN_CLOSE, qc);
Amaury Denoyelleb515b0a2022-04-06 10:28:43 +02007257}
7258
Frédéric Lécaillea7e7ce92020-11-23 14:14:04 +01007259/*
7260 * Local variables:
7261 * c-indent-level: 8
7262 * c-basic-offset: 8
7263 * End:
7264 */