blob: 96c1b0e2d7b01b33061b8db0441edf8333704ccd [file] [log] [blame]
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001/*
2 * HTTP/3 protocol processing
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation, version 2.1
7 * exclusively.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19#include <haproxy/buf.h>
Amaury Denoyelle99043552021-08-24 15:36:02 +020020#include <haproxy/connection.h>
Frédéric Lécailleccac11f2021-03-03 16:09:02 +010021#include <haproxy/dynbuf.h>
22#include <haproxy/h3.h>
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +020023#include <haproxy/h3_stats.h>
Amaury Denoyelleb49fa1a2021-08-24 15:30:12 +020024#include <haproxy/http.h>
25#include <haproxy/htx.h>
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +020026#include <haproxy/intops.h>
Frédéric Lécailleccac11f2021-03-03 16:09:02 +010027#include <haproxy/istbuf.h>
Amaury Denoyelle846cc042022-04-04 16:13:44 +020028#include <haproxy/mux_quic.h>
Frédéric Lécailleccac11f2021-03-03 16:09:02 +010029#include <haproxy/pool.h>
30#include <haproxy/qpack-dec.h>
Amaury Denoyelle15b09612021-08-24 16:20:27 +020031#include <haproxy/qpack-enc.h>
32#include <haproxy/quic_enc.h>
Willy Tarreaucb086c62022-05-27 09:47:12 +020033#include <haproxy/stconn.h>
Frédéric Lécailleccac11f2021-03-03 16:09:02 +010034#include <haproxy/tools.h>
Amaury Denoyelle016aa932022-05-30 15:49:36 +020035#include <haproxy/trace.h>
Frédéric Lécailleccac11f2021-03-03 16:09:02 +010036#include <haproxy/xprt_quic.h>
37
Amaury Denoyelle016aa932022-05-30 15:49:36 +020038/* trace source and events */
39static void h3_trace(enum trace_level level, uint64_t mask,
40 const struct trace_source *src,
41 const struct ist where, const struct ist func,
42 const void *a1, const void *a2, const void *a3, const void *a4);
43
44static const struct trace_event h3_trace_events[] = {
Amaury Denoyelle494512d2022-05-30 15:50:34 +020045#define H3_EV_RX_FRAME (1ULL << 0)
46 { .mask = H3_EV_RX_FRAME, .name = "rx_frame", .desc = "receipt of any H3 frame" },
47#define H3_EV_RX_DATA (1ULL << 1)
48 { .mask = H3_EV_RX_DATA, .name = "rx_data", .desc = "receipt of H3 DATA frame" },
49#define H3_EV_RX_HDR (1ULL << 2)
50 { .mask = H3_EV_RX_HDR, .name = "rx_hdr", .desc = "receipt of H3 HEADERS frame" },
51#define H3_EV_RX_SETTINGS (1ULL << 3)
52 { .mask = H3_EV_RX_SETTINGS, .name = "rx_settings", .desc = "receipt of H3 SETTINGS frame" },
Amaury Denoyellea717eb72022-05-30 15:51:01 +020053#define H3_EV_TX_DATA (1ULL << 4)
54 { .mask = H3_EV_TX_DATA, .name = "tx_data", .desc = "transmission of H3 DATA frame" },
55#define H3_EV_TX_HDR (1ULL << 5)
56 { .mask = H3_EV_TX_HDR, .name = "tx_hdr", .desc = "transmission of H3 HEADERS frame" },
57#define H3_EV_TX_SETTINGS (1ULL << 6)
58 { .mask = H3_EV_TX_SETTINGS, .name = "tx_settings", .desc = "transmission of H3 SETTINGS frame" },
Amaury Denoyelled5581d52022-05-30 15:51:31 +020059#define H3_EV_H3S_NEW (1ULL << 7)
60 { .mask = H3_EV_H3S_NEW, .name = "h3s_new", .desc = "new H3 stream" },
61#define H3_EV_H3S_END (1ULL << 8)
62 { .mask = H3_EV_H3S_END, .name = "h3s_end", .desc = "H3 stream terminated" },
Amaury Denoyelle016aa932022-05-30 15:49:36 +020063 { }
64};
65
66static const struct name_desc h3_trace_lockon_args[4] = {
67 /* arg1 */ { /* already used by the connection */ },
68 /* arg2 */ { .name="qcs", .desc="QUIC stream" },
69 /* arg3 */ { },
70 /* arg4 */ { }
71};
72
73static const struct name_desc h3_trace_decoding[] = {
74#define H3_VERB_CLEAN 1
75 { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" },
76#define H3_VERB_MINIMAL 2
77 { .name="minimal", .desc="report only qcc/qcs state and flags, no real decoding" },
78 { /* end */ }
79};
80
81struct trace_source trace_h3 = {
82 .name = IST("h3"),
83 .desc = "HTTP/3 transcoder",
84 .arg_def = TRC_ARG1_CONN, /* TRACE()'s first argument is always a connection */
85 .default_cb = h3_trace,
86 .known_events = h3_trace_events,
87 .lockon_args = h3_trace_lockon_args,
88 .decoding = h3_trace_decoding,
89 .report_events = ~0, /* report everything by default */
90};
91
92#define TRACE_SOURCE &trace_h3
93INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE);
94
Frédéric Lécailleccac11f2021-03-03 16:09:02 +010095#if defined(DEBUG_H3)
96#define h3_debug_printf fprintf
97#define h3_debug_hexdump debug_hexdump
98#else
99#define h3_debug_printf(...) do { } while (0)
100#define h3_debug_hexdump(...) do { } while (0)
101#endif
102
Amaury Denoyelle302ecd42022-05-24 15:24:32 +0200103#define H3_CF_SETTINGS_SENT 0x00000001 /* SETTINGS frame already sent on local control stream */
104#define H3_CF_SETTINGS_RECV 0x00000002 /* SETTINGS frame already received on remote control stream */
105#define H3_CF_UNI_CTRL_SET 0x00000004 /* Remote H3 Control stream opened */
106#define H3_CF_UNI_QPACK_DEC_SET 0x00000008 /* Remote QPACK decoder stream opened */
107#define H3_CF_UNI_QPACK_ENC_SET 0x00000010 /* Remote QPACK encoder stream opened */
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100108
109/* Default settings */
Amaury Denoyelle33949392021-08-24 15:16:58 +0200110static uint64_t h3_settings_qpack_max_table_capacity = 0;
111static uint64_t h3_settings_qpack_blocked_streams = 4096;
112static uint64_t h3_settings_max_field_section_size = QUIC_VARINT_8_BYTE_MAX; /* Unlimited */
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100113
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +0200114struct h3c {
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100115 struct qcc *qcc;
116 enum h3_err err;
117 uint32_t flags;
Amaury Denoyelle9cc47512022-05-24 16:27:41 +0200118
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100119 /* Settings */
120 uint64_t qpack_max_table_capacity;
121 uint64_t qpack_blocked_streams;
122 uint64_t max_field_section_size;
Amaury Denoyelle9cc47512022-05-24 16:27:41 +0200123
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100124 struct buffer_wait buf_wait; /* wait list for buffer allocations */
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +0200125 /* Stats counters */
126 struct h3_counters *prx_counters;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100127};
128
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +0200129DECLARE_STATIC_POOL(pool_head_h3c, "h3c", sizeof(struct h3c));
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100130
Amaury Denoyelle35550642022-05-24 15:14:53 +0200131#define H3_SF_UNI_INIT 0x00000001 /* stream type not parsed for unidirectional stream */
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200132#define H3_SF_UNI_NO_H3 0x00000002 /* unidirectional stream does not carry H3 frames */
Amaury Denoyelle35550642022-05-24 15:14:53 +0200133
Amaury Denoyelle67e92d32022-04-27 18:04:01 +0200134struct h3s {
Amaury Denoyellec0156792022-06-03 15:29:07 +0200135 struct h3c *h3c;
136
Amaury Denoyelle3236a8e2022-05-24 15:24:03 +0200137 enum h3s_t type;
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200138 int demux_frame_len;
139 int demux_frame_type;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200140
141 int flags;
Amaury Denoyelle67e92d32022-04-27 18:04:01 +0200142};
143
144DECLARE_STATIC_POOL(pool_head_h3s, "h3s", sizeof(struct h3s));
145
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200146/* Initialize an uni-stream <qcs> by reading its type from <b>.
Amaury Denoyelle35550642022-05-24 15:14:53 +0200147 *
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200148 * Returns the count of consumed bytes or a negative error code.
Amaury Denoyelle35550642022-05-24 15:14:53 +0200149 */
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200150static ssize_t h3_init_uni_stream(struct h3c *h3c, struct qcs *qcs,
151 struct buffer *b)
Amaury Denoyelle35550642022-05-24 15:14:53 +0200152{
153 /* decode unidirectional stream type */
154 struct h3s *h3s = qcs->ctx;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200155 uint64_t type;
156 size_t len = 0, ret;
157
Amaury Denoyelled5581d52022-05-30 15:51:31 +0200158 TRACE_ENTER(H3_EV_H3S_NEW, qcs->qcc->conn, qcs);
159
Amaury Denoyelle35550642022-05-24 15:14:53 +0200160 BUG_ON_HOT(!quic_stream_is_uni(qcs->id) ||
161 h3s->flags & H3_SF_UNI_INIT);
162
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200163 ret = b_quic_dec_int(&type, b, &len);
Amaury Denoyelle35550642022-05-24 15:14:53 +0200164 if (!ret) {
165 ABORT_NOW();
166 }
167
168 switch (type) {
169 case H3_UNI_S_T_CTRL:
170 if (h3c->flags & H3_CF_UNI_CTRL_SET) {
171 qcc_emit_cc_app(qcs->qcc, H3_STREAM_CREATION_ERROR);
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200172 return -1;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200173 }
174 h3c->flags |= H3_CF_UNI_CTRL_SET;
175 h3s->type = H3S_T_CTRL;
176 break;
177
178 case H3_UNI_S_T_PUSH:
179 /* TODO not supported for the moment */
180 h3s->type = H3S_T_PUSH;
181 break;
182
183 case H3_UNI_S_T_QPACK_DEC:
184 if (h3c->flags & H3_CF_UNI_QPACK_DEC_SET) {
185 qcc_emit_cc_app(qcs->qcc, H3_STREAM_CREATION_ERROR);
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200186 return -1;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200187 }
188 h3c->flags |= H3_CF_UNI_QPACK_DEC_SET;
189 h3s->type = H3S_T_QPACK_DEC;
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200190 h3s->flags |= H3_SF_UNI_NO_H3;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200191 break;
192
193 case H3_UNI_S_T_QPACK_ENC:
194 if (h3c->flags & H3_CF_UNI_QPACK_ENC_SET) {
195 qcc_emit_cc_app(qcs->qcc, H3_STREAM_CREATION_ERROR);
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200196 return -1;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200197 }
198 h3c->flags |= H3_CF_UNI_QPACK_ENC_SET;
199 h3s->type = H3S_T_QPACK_ENC;
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200200 h3s->flags |= H3_SF_UNI_NO_H3;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200201 break;
202
203 default:
Amaury Denoyelle849b24f2022-05-24 17:22:07 +0200204 /* draft-ietf-quic-http34 9. Extensions to HTTP/3
205 *
206 * Implementations MUST [...] abort reading on unidirectional
207 * streams that have unknown or unsupported types.
208 */
209 qcs->flags |= QC_SF_READ_ABORTED;
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200210 return -1;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200211 };
212
213 h3s->flags |= H3_SF_UNI_INIT;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200214
Amaury Denoyelled5581d52022-05-30 15:51:31 +0200215 TRACE_LEAVE(H3_EV_H3S_NEW, qcs->qcc->conn, qcs);
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200216 return len;
Amaury Denoyelle35550642022-05-24 15:14:53 +0200217}
218
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200219/* Parse an uni-stream <qcs> from <rxbuf> which does not contains H3 frames.
220 * This may be used for QPACK encoder/decoder streams for example.
221 *
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200222 * Returns the number of consumed bytes or a negative error code.
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200223 */
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200224static ssize_t h3_parse_uni_stream_no_h3(struct qcs *qcs, struct buffer *b)
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200225{
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200226 struct h3s *h3s = qcs->ctx;
227
228 BUG_ON_HOT(!quic_stream_is_uni(qcs->id) ||
229 !(h3s->flags & H3_SF_UNI_NO_H3));
230
231 switch (h3s->type) {
232 case H3S_T_QPACK_DEC:
Amaury Denoyelle5869cb62022-05-31 15:21:27 +0200233 if (qpack_decode_dec(qcs, NULL))
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200234 return -1;
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200235 break;
236 case H3S_T_QPACK_ENC:
Amaury Denoyelle5869cb62022-05-31 15:21:27 +0200237 if (qpack_decode_enc(qcs, NULL))
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200238 return -1;
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200239 break;
Amaury Denoyelle849b24f2022-05-24 17:22:07 +0200240 case H3S_T_UNKNOWN:
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200241 default:
Amaury Denoyelle849b24f2022-05-24 17:22:07 +0200242 /* Unknown stream should be flagged with QC_SF_READ_ABORTED. */
243 ABORT_NOW();
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200244 }
245
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200246 /* TODO adjust return code */
Amaury Denoyellefc99a692022-05-24 15:25:19 +0200247 return 0;
248}
249
Amaury Denoyelle88d5dd12022-05-31 11:44:52 +0200250/* Decode a H3 frame header from <rxbuf> buffer. The frame type is stored in
251 * <ftype> and length in <flen>.
252 *
253 * Returns the size of the H3 frame header. Note that the input buffer is not
254 * consumed.
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100255 */
256static inline size_t h3_decode_frm_header(uint64_t *ftype, uint64_t *flen,
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200257 struct buffer *b)
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100258{
259 size_t hlen;
260
261 hlen = 0;
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200262 if (!b_quic_dec_int(ftype, b, &hlen) ||
263 !b_quic_dec_int(flen, b, &hlen)) {
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100264 return 0;
Amaury Denoyelle88d5dd12022-05-31 11:44:52 +0200265 }
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100266
267 return hlen;
268}
269
Amaury Denoyelle302ecd42022-05-24 15:24:32 +0200270/* Check if H3 frame of type <ftype> is valid when received on stream <qcs>.
271 *
272 * Returns a boolean. If false, a connection error H3_FRAME_UNEXPECTED should
273 * be reported.
274 */
275static int h3_is_frame_valid(struct h3c *h3c, struct qcs *qcs, uint64_t ftype)
276{
277 struct h3s *h3s = qcs->ctx;
278 const uint64_t id = qcs->id;
279
280 BUG_ON_HOT(h3s->type == H3S_T_UNKNOWN);
281
282 switch (ftype) {
283 case H3_FT_DATA:
284 case H3_FT_HEADERS:
285 return h3s->type != H3S_T_CTRL;
286
287 case H3_FT_CANCEL_PUSH:
288 case H3_FT_GOAWAY:
289 case H3_FT_MAX_PUSH_ID:
290 /* Only allowed for control stream. First frame of control
291 * stream MUST be SETTINGS.
292 */
293 return h3s->type == H3S_T_CTRL &&
294 (h3c->flags & H3_CF_SETTINGS_RECV);
295
296 case H3_FT_SETTINGS:
297 /* draft-ietf-quic-http34 7.2.4. SETTINGS
298 *
299 * If an endpoint receives a second SETTINGS frame on the control
300 * stream, the endpoint MUST respond with a connection error of type
301 * H3_FRAME_UNEXPECTED.
302 */
303 return h3s->type == H3S_T_CTRL &&
304 !(h3c->flags & H3_CF_SETTINGS_RECV);
305
306 case H3_FT_PUSH_PROMISE:
307 return h3s->type != H3S_T_CTRL &&
308 (id & QCS_ID_SRV_INTIATOR_BIT);
309
310 default:
311 /* draft-ietf-quic-http34 9. Extensions to HTTP/3
312 *
313 * Implementations MUST discard frames [...] that have unknown
314 * or unsupported types.
315 */
316 return h3s->type != H3S_T_CTRL || (h3c->flags & H3_CF_SETTINGS_RECV);
317 }
318}
319
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100320/* Parse from buffer <buf> a H3 HEADERS frame of length <len>. Data are copied
Willy Tarreau4596fe22022-05-17 19:07:51 +0200321 * in a local HTX buffer and transfer to the stream connector layer. <fin> must be
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100322 * set if this is the last data to transfer from this stream.
323 *
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200324 * Returns the number of consumed bytes or a negative error code.
Amaury Denoyelleb9ce14e2021-11-08 09:13:42 +0100325 */
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200326static ssize_t h3_headers_to_htx(struct qcs *qcs, const struct buffer *buf,
327 uint64_t len, char fin)
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100328{
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100329 struct buffer htx_buf = BUF_NULL;
330 struct buffer *tmp = get_trash_chunk();
Amaury Denoyelle7059ebc2021-12-08 15:51:04 +0100331 struct htx *htx = NULL;
Amaury Denoyelleb49fa1a2021-08-24 15:30:12 +0200332 struct htx_sl *sl;
Amaury Denoyellefd7cdc32021-08-24 15:13:20 +0200333 struct http_hdr list[global.tune.max_http_hdr];
Amaury Denoyelleb49fa1a2021-08-24 15:30:12 +0200334 unsigned int flags = HTX_SL_F_NONE;
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100335 struct ist meth = IST_NULL, path = IST_NULL;
336 //struct ist scheme = IST_NULL, authority = IST_NULL;
337 struct ist authority = IST_NULL;
Amaury Denoyellefd7cdc32021-08-24 15:13:20 +0200338 int hdr_idx;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100339
Amaury Denoyelle494512d2022-05-30 15:50:34 +0200340 TRACE_ENTER(H3_EV_RX_FRAME|H3_EV_RX_HDR, qcs->qcc->conn, qcs);
341
Amaury Denoyelle30f23f52022-04-27 14:41:53 +0200342 /* TODO support buffer wrapping */
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200343 BUG_ON(b_head(buf) + len >= b_wrap(buf));
344 if (qpack_decode_fs((const unsigned char *)b_head(buf), len, tmp, list) < 0)
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200345 return -1;
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100346
347 qc_get_buf(qcs, &htx_buf);
348 BUG_ON(!b_size(&htx_buf));
349 htx = htx_from_buf(&htx_buf);
350
351 /* first treat pseudo-header to build the start line */
352 hdr_idx = 0;
353 while (1) {
354 if (isteq(list[hdr_idx].n, ist("")))
355 break;
356
357 if (istmatch(list[hdr_idx].n, ist(":"))) {
358 /* pseudo-header */
359 if (isteq(list[hdr_idx].n, ist(":method")))
360 meth = list[hdr_idx].v;
361 else if (isteq(list[hdr_idx].n, ist(":path")))
362 path = list[hdr_idx].v;
363 //else if (isteq(list[hdr_idx].n, ist(":scheme")))
364 // scheme = list[hdr_idx].v;
365 else if (isteq(list[hdr_idx].n, ist(":authority")))
366 authority = list[hdr_idx].v;
367 }
368
369 ++hdr_idx;
370 }
371
372 flags |= HTX_SL_F_VER_11;
Amaury Denoyelle0fa14a62022-04-26 16:24:39 +0200373 flags |= HTX_SL_F_XFER_LEN;
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100374
375 sl = htx_add_stline(htx, HTX_BLK_REQ_SL, flags, meth, path, ist("HTTP/3.0"));
376 if (!sl)
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200377 return -1;
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100378
379 if (fin)
380 sl->flags |= HTX_SL_F_BODYLESS;
381
382 sl->info.req.meth = find_http_meth(meth.ptr, meth.len);
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100383
384 if (isttest(authority))
385 htx_add_header(htx, ist("host"), authority);
386
387 /* now treat standard headers */
388 hdr_idx = 0;
389 while (1) {
390 if (isteq(list[hdr_idx].n, ist("")))
391 break;
392
393 if (!istmatch(list[hdr_idx].n, ist(":")))
394 htx_add_header(htx, list[hdr_idx].n, list[hdr_idx].v);
395
396 ++hdr_idx;
397 }
398
399 htx_add_endof(htx, HTX_BLK_EOH);
400 htx_to_buf(htx, &htx_buf);
401
402 if (fin)
403 htx->flags |= HTX_FL_EOM;
404
Willy Tarreau3215e732022-05-27 10:09:11 +0200405 if (!qc_attach_sc(qcs, &htx_buf))
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200406 return -1;
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100407
Willy Tarreau4596fe22022-05-17 19:07:51 +0200408 /* buffer is transferred to the stream connector and set to NULL
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100409 * except on stream creation error.
410 */
411 b_free(&htx_buf);
412 offer_buffers(NULL, 1);
413
Amaury Denoyelle494512d2022-05-30 15:50:34 +0200414 TRACE_LEAVE(H3_EV_RX_FRAME|H3_EV_RX_HDR, qcs->qcc->conn, qcs);
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200415 return len;
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100416}
417
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100418/* Copy from buffer <buf> a H3 DATA frame of length <len> in QUIC stream <qcs>
419 * HTX buffer. <fin> must be set if this is the last data to transfer from this
420 * stream.
421 *
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200422 * Returns the number of consumed bytes or a negative error code.
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100423 */
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200424static ssize_t h3_data_to_htx(struct qcs *qcs, const struct buffer *buf,
425 uint64_t len, char fin)
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100426{
427 struct buffer *appbuf;
428 struct htx *htx = NULL;
Amaury Denoyelle1290f1e2022-05-13 14:49:05 +0200429 size_t htx_sent = 0;
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100430 int htx_space;
Amaury Denoyelle30f23f52022-04-27 14:41:53 +0200431 char *head;
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100432
Amaury Denoyelle494512d2022-05-30 15:50:34 +0200433 TRACE_ENTER(H3_EV_RX_FRAME|H3_EV_RX_DATA, qcs->qcc->conn, qcs);
434
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100435 appbuf = qc_get_buf(qcs, &qcs->rx.app_buf);
436 BUG_ON(!appbuf);
437 htx = htx_from_buf(appbuf);
438
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200439 if (len > b_data(buf)) {
440 len = b_data(buf);
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200441 fin = 0;
442 }
443
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200444 head = b_head(buf);
Amaury Denoyelle30f23f52022-04-27 14:41:53 +0200445 retry:
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100446 htx_space = htx_free_data_space(htx);
Amaury Denoyellef1fc0b32022-05-02 11:07:06 +0200447 if (!htx_space) {
448 qcs->flags |= QC_SF_DEM_FULL;
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200449 goto out;
Amaury Denoyellef1fc0b32022-05-02 11:07:06 +0200450 }
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200451
452 if (len > htx_space) {
453 len = htx_space;
454 fin = 0;
Amaury Denoyelleff191de2022-02-21 18:38:29 +0100455 }
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100456
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200457 if (head + len > b_wrap(buf)) {
458 size_t contig = b_wrap(buf) - head;
459 htx_sent = htx_add_data(htx, ist2(b_head(buf), contig));
Amaury Denoyelle73d6ffe2022-05-16 13:54:31 +0200460 if (htx_sent < contig) {
461 qcs->flags |= QC_SF_DEM_FULL;
462 goto out;
463 }
464
Amaury Denoyelle30f23f52022-04-27 14:41:53 +0200465 len -= contig;
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200466 head = b_orig(buf);
Amaury Denoyelle30f23f52022-04-27 14:41:53 +0200467 goto retry;
Amaury Denoyelleff191de2022-02-21 18:38:29 +0100468 }
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100469
Amaury Denoyelle30f23f52022-04-27 14:41:53 +0200470 htx_sent += htx_add_data(htx, ist2(head, len));
Amaury Denoyelle73d6ffe2022-05-16 13:54:31 +0200471 if (htx_sent < len) {
472 qcs->flags |= QC_SF_DEM_FULL;
473 goto out;
474 }
Amaury Denoyelle30f23f52022-04-27 14:41:53 +0200475
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200476 if (fin && len == htx_sent)
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100477 htx->flags |= HTX_FL_EOM;
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100478
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200479 out:
480 htx_to_buf(htx, appbuf);
Amaury Denoyelle494512d2022-05-30 15:50:34 +0200481
482 TRACE_LEAVE(H3_EV_RX_FRAME|H3_EV_RX_DATA, qcs->qcc->conn, qcs);
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200483 return htx_sent;
Amaury Denoyelle91379f72022-02-14 17:14:59 +0100484}
485
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200486/* Parse a SETTINGS frame of length <len> of payload <buf>.
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200487 *
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200488 * Returns the number of consumed bytes or a negative error code.
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200489 */
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200490static ssize_t h3_parse_settings_frm(struct h3c *h3c, const struct buffer *buf,
491 size_t len)
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200492{
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200493 struct buffer b;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200494 uint64_t id, value;
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200495 size_t ret = 0;
496 long mask = 0; /* used to detect duplicated settings identifier */
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200497
Amaury Denoyelle494512d2022-05-30 15:50:34 +0200498 TRACE_ENTER(H3_EV_RX_FRAME|H3_EV_RX_SETTINGS, h3c->qcc->conn);
499
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200500 /* Work on a copy of <buf>. */
501 b = b_make(b_orig(buf), b_size(buf), b_head_ofs(buf), b_data(buf));
502
503 /* TODO handle incomplete SETTINGS frame */
504 BUG_ON(len < b_data(&b));
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200505
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200506 while (b_data(&b)) {
507 if (!b_quic_dec_int(&id, &b, &ret) || !b_quic_dec_int(&value, &b, &ret)) {
508 h3c->err = H3_FRAME_ERROR;
509 return -1;
510 }
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200511
512 h3_debug_printf(stderr, "%s id: %llu value: %llu\n",
513 __func__, (unsigned long long)id, (unsigned long long)value);
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200514
515 /* draft-ietf-quic-http34 7.2.4. SETTINGS
516 *
517 * The same setting identifier MUST NOT occur more than once in the
518 * SETTINGS frame. A receiver MAY treat the presence of duplicate
519 * setting identifiers as a connection error of type H3_SETTINGS_ERROR.
520 */
521
522 /* Ignore duplicate check for ID too big used for GREASE. */
523 if (id < sizeof(mask)) {
524 if (ha_bit_test(id, &mask)) {
525 h3c->err = H3_SETTINGS_ERROR;
526 return -1;
527 }
528 ha_bit_set(id, &mask);
529 }
530
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200531 switch (id) {
532 case H3_SETTINGS_QPACK_MAX_TABLE_CAPACITY:
533 h3c->qpack_max_table_capacity = value;
534 break;
535 case H3_SETTINGS_MAX_FIELD_SECTION_SIZE:
536 h3c->max_field_section_size = value;
537 break;
538 case H3_SETTINGS_QPACK_BLOCKED_STREAMS:
539 h3c->qpack_blocked_streams = value;
540 break;
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200541
542 case H3_SETTINGS_RESERVED_0:
543 case H3_SETTINGS_RESERVED_2:
544 case H3_SETTINGS_RESERVED_3:
545 case H3_SETTINGS_RESERVED_4:
546 case H3_SETTINGS_RESERVED_5:
547 /* draft-ietf-quic-http34 7.2.4.1. Defined SETTINGS Parameters
548 *
549 * Setting identifiers which were defined in [HTTP2] where there is no
550 * corresponding HTTP/3 setting have also been reserved
551 * (Section 11.2.2). These reserved settings MUST NOT be sent, and
552 * their receipt MUST be treated as a connection error of type
553 * H3_SETTINGS_ERROR.
554 */
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200555 h3c->err = H3_SETTINGS_ERROR;
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200556 return -1;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200557 default:
558 /* MUST be ignored */
559 break;
560 }
561 }
562
Amaury Denoyelle494512d2022-05-30 15:50:34 +0200563 TRACE_LEAVE(H3_EV_RX_FRAME|H3_EV_RX_SETTINGS);
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200564 return ret;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200565}
566
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100567/* Decode <qcs> remotely initiated bidi-stream. <fin> must be set to indicate
568 * that we received the last data of the stream.
Amaury Denoyelle0ffd6e72022-05-24 11:07:28 +0200569 *
570 * Returns 0 on success else non-zero.
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100571 */
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200572static ssize_t h3_decode_qcs(struct qcs *qcs, struct buffer *b, int fin)
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100573{
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200574 struct h3s *h3s = qcs->ctx;
Amaury Denoyellec0156792022-06-03 15:29:07 +0200575 struct h3c *h3c = h3s->h3c;
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200576 ssize_t total = 0, ret;
Amaury Denoyelle7b0f1222022-02-14 17:13:55 +0100577
Amaury Denoyellebb970422022-04-12 16:40:52 +0200578 h3_debug_printf(stderr, "%s: STREAM ID: %lu\n", __func__, qcs->id);
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200579 if (!b_data(b))
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100580 return 0;
581
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200582 if (quic_stream_is_uni(qcs->id) && !(h3s->flags & H3_SF_UNI_INIT)) {
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200583 if ((ret = h3_init_uni_stream(h3c, qcs, b)) < 0)
584 return -1;
585
586 total += ret;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200587 }
588
589 if (quic_stream_is_uni(qcs->id) && (h3s->flags & H3_SF_UNI_NO_H3)) {
590 /* For non-h3 STREAM, parse it and return immediately. */
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200591 if ((ret = h3_parse_uni_stream_no_h3(qcs, b)) < 0)
592 return -1;
593
594 total += ret;
595 return total;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200596 }
597
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200598 while (b_data(b) && !(qcs->flags & QC_SF_DEM_FULL)) {
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100599 uint64_t ftype, flen;
Amaury Denoyelle95b93a32022-02-14 15:49:53 +0100600 char last_stream_frame = 0;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100601
602 /* Work on a copy of <rxbuf> */
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200603 if (!h3s->demux_frame_len) {
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200604 size_t hlen = h3_decode_frm_header(&ftype, &flen, b);
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200605 if (!hlen)
606 break;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100607
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200608 h3_debug_printf(stderr, "%s: ftype: %lu, flen: %lu\n",
609 __func__, ftype, flen);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100610
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200611 h3s->demux_frame_type = ftype;
612 h3s->demux_frame_len = flen;
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200613 total += hlen;
Amaury Denoyelle417c7c02022-05-31 14:18:33 +0200614
615 if (!h3_is_frame_valid(h3c, qcs, ftype)) {
616 qcc_emit_cc_app(qcs->qcc, H3_FRAME_UNEXPECTED);
Amaury Denoyelledca4c532022-06-07 18:24:34 +0200617 return -1;
Amaury Denoyelle417c7c02022-05-31 14:18:33 +0200618 }
619
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200620 if (!b_data(b))
Amaury Denoyelle417c7c02022-05-31 14:18:33 +0200621 break;
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200622 }
Amaury Denoyelle0484f922022-02-15 16:59:39 +0100623
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200624 flen = h3s->demux_frame_len;
625 ftype = h3s->demux_frame_type;
Amaury Denoyelle80097cc2022-05-24 11:13:46 +0200626
627 /* Do not demux incomplete frames except H3 DATA which can be
628 * fragmented in multiple HTX blocks.
629 */
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200630 if (flen > b_data(b) && ftype != H3_FT_DATA) {
Amaury Denoyelle80097cc2022-05-24 11:13:46 +0200631 /* Reject frames bigger than bufsize.
632 *
633 * TODO HEADERS should in complement be limited with H3
634 * SETTINGS_MAX_FIELD_SECTION_SIZE parameter to prevent
635 * excessive decompressed size.
636 */
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200637 if (flen > QC_S_RX_BUF_SZ) {
Amaury Denoyelle80097cc2022-05-24 11:13:46 +0200638 qcc_emit_cc_app(qcs->qcc, H3_EXCESSIVE_LOAD);
Amaury Denoyelledca4c532022-06-07 18:24:34 +0200639 return -1;
Amaury Denoyelle80097cc2022-05-24 11:13:46 +0200640 }
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +0200641 break;
Amaury Denoyelleb5454d42022-05-12 16:56:16 +0200642 }
Amaury Denoyelle80097cc2022-05-24 11:13:46 +0200643
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200644 last_stream_frame = (fin && flen == b_data(b));
Amaury Denoyelle95b93a32022-02-14 15:49:53 +0100645
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +0200646 h3_inc_frame_type_cnt(h3c->prx_counters, ftype);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100647 switch (ftype) {
648 case H3_FT_DATA:
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200649 ret = h3_data_to_htx(qcs, b, flen, last_stream_frame);
Amaury Denoyelle31e4f6e2022-02-15 17:30:27 +0100650 /* TODO handle error reporting. Stream closure required. */
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200651 if (ret < 0) { ABORT_NOW(); }
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100652 break;
653 case H3_FT_HEADERS:
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200654 ret = h3_headers_to_htx(qcs, b, flen, last_stream_frame);
Amaury Denoyelle31e4f6e2022-02-15 17:30:27 +0100655 /* TODO handle error reporting. Stream closure required. */
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200656 if (ret < 0) { ABORT_NOW(); }
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100657 break;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200658 case H3_FT_CANCEL_PUSH:
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100659 case H3_FT_PUSH_PROMISE:
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200660 case H3_FT_MAX_PUSH_ID:
661 case H3_FT_GOAWAY:
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100662 /* Not supported */
Amaury Denoyelle80097cc2022-05-24 11:13:46 +0200663 ret = flen;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100664 break;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200665 case H3_FT_SETTINGS:
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200666 ret = h3_parse_settings_frm(qcs->qcc->ctx, b, flen);
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200667 if (ret < 0) {
668 qcc_emit_cc_app(qcs->qcc, h3c->err);
Amaury Denoyelledca4c532022-06-07 18:24:34 +0200669 return -1;
Amaury Denoyelle8c6176b2022-05-24 18:16:49 +0200670 }
671 h3c->flags |= H3_CF_SETTINGS_RECV;
Amaury Denoyellef8db5aa2022-05-24 15:26:07 +0200672 break;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100673 default:
Amaury Denoyelled1acaf92021-11-15 15:52:55 +0100674 /* draft-ietf-quic-http34 9. Extensions to HTTP/3
Amaury Denoyelle302ecd42022-05-24 15:24:32 +0200675 *
676 * Implementations MUST discard frames [...] that have unknown
677 * or unsupported types.
Amaury Denoyelled1acaf92021-11-15 15:52:55 +0100678 */
679 h3_debug_printf(stderr, "ignore unknown frame type 0x%lx\n", ftype);
Amaury Denoyelle80097cc2022-05-24 11:13:46 +0200680 ret = flen;
681 break;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100682 }
Amaury Denoyelle314578a2022-04-27 14:52:52 +0200683
Amaury Denoyelle291ee252022-05-02 10:35:39 +0200684 if (ret) {
Amaury Denoyelle291ee252022-05-02 10:35:39 +0200685 BUG_ON(h3s->demux_frame_len < ret);
686 h3s->demux_frame_len -= ret;
Amaury Denoyelle62eef852022-06-03 16:40:34 +0200687 b_del(b, ret);
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200688 total += ret;
Amaury Denoyelle291ee252022-05-02 10:35:39 +0200689 }
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100690 }
691
Amaury Denoyelle03cc62c2022-04-27 16:53:16 +0200692 /* TODO may be useful to wakeup the MUX if blocked due to full buffer.
693 * However, currently, io-cb of MUX does not handle Rx.
694 */
695
Amaury Denoyelle1f21ebd2022-06-07 17:30:55 +0200696 return total;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100697}
698
Amaury Denoyellea5871362021-10-07 16:26:12 +0200699/* Returns buffer for data sending.
700 * May be NULL if the allocation failed.
701 */
702static struct buffer *mux_get_buf(struct qcs *qcs)
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100703{
Amaury Denoyellea5871362021-10-07 16:26:12 +0200704 if (!b_size(&qcs->tx.buf))
705 b_alloc(&qcs->tx.buf);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100706
Amaury Denoyellea5871362021-10-07 16:26:12 +0200707 return &qcs->tx.buf;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100708}
709
Amaury Denoyelle6b923942022-05-23 14:25:53 +0200710/* Function used to emit stream data from <qcs> control uni-stream */
711static int h3_control_send(struct qcs *qcs, void *ctx)
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100712{
713 int ret;
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +0200714 struct h3c *h3c = ctx;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100715 unsigned char data[(2 + 3) * 2 * QUIC_VARINT_MAX_SIZE]; /* enough for 3 settings */
Amaury Denoyellea5871362021-10-07 16:26:12 +0200716 struct buffer pos, *res;
Amaury Denoyelle65df3ad2022-05-24 15:06:10 +0200717 size_t frm_len;
Amaury Denoyelle65df3ad2022-05-24 15:06:10 +0200718
Amaury Denoyellea717eb72022-05-30 15:51:01 +0200719 TRACE_ENTER(H3_EV_TX_SETTINGS, qcs->qcc->conn, qcs);
720
Amaury Denoyelle65df3ad2022-05-24 15:06:10 +0200721 BUG_ON_HOT(h3c->flags & H3_CF_SETTINGS_SENT);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100722
723 ret = 0;
Amaury Denoyellea5871362021-10-07 16:26:12 +0200724 pos = b_make((char *)data, sizeof(data), 0, 0);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100725
Amaury Denoyelle65df3ad2022-05-24 15:06:10 +0200726 frm_len = quic_int_getsize(H3_SETTINGS_QPACK_MAX_TABLE_CAPACITY) +
727 quic_int_getsize(h3_settings_qpack_max_table_capacity) +
728 quic_int_getsize(H3_SETTINGS_QPACK_BLOCKED_STREAMS) +
729 quic_int_getsize(h3_settings_qpack_blocked_streams);
730 if (h3_settings_max_field_section_size) {
731 frm_len += quic_int_getsize(H3_SETTINGS_MAX_FIELD_SECTION_SIZE) +
732 quic_int_getsize(h3_settings_max_field_section_size);
733 }
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100734
Amaury Denoyelle65df3ad2022-05-24 15:06:10 +0200735 b_quic_enc_int(&pos, H3_UNI_S_T_CTRL);
736 /* Build a SETTINGS frame */
737 b_quic_enc_int(&pos, H3_FT_SETTINGS);
738 b_quic_enc_int(&pos, frm_len);
739 b_quic_enc_int(&pos, H3_SETTINGS_QPACK_MAX_TABLE_CAPACITY);
740 b_quic_enc_int(&pos, h3_settings_qpack_max_table_capacity);
741 b_quic_enc_int(&pos, H3_SETTINGS_QPACK_BLOCKED_STREAMS);
742 b_quic_enc_int(&pos, h3_settings_qpack_blocked_streams);
743 if (h3_settings_max_field_section_size) {
744 b_quic_enc_int(&pos, H3_SETTINGS_MAX_FIELD_SECTION_SIZE);
745 b_quic_enc_int(&pos, h3_settings_max_field_section_size);
746 }
Amaury Denoyellea5871362021-10-07 16:26:12 +0200747
Amaury Denoyelle65df3ad2022-05-24 15:06:10 +0200748 res = mux_get_buf(qcs);
749 if (b_room(res) < b_data(&pos)) {
750 // TODO the mux should be put in blocked state, with
751 // the stream in state waiting for settings to be sent
752 ABORT_NOW();
753 }
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100754
Amaury Denoyelle65df3ad2022-05-24 15:06:10 +0200755 ret = b_force_xfer(res, &pos, b_data(&pos));
756 if (ret > 0) {
757 h3c->flags |= H3_CF_SETTINGS_SENT;
758 if (!(qcs->qcc->wait_event.events & SUB_RETRY_SEND))
759 tasklet_wakeup(qcs->qcc->wait_event.tasklet);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100760 }
761
Amaury Denoyellea717eb72022-05-30 15:51:01 +0200762 TRACE_LEAVE(H3_EV_TX_SETTINGS, qcs->qcc->conn, qcs);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +0100763 return ret;
764}
765
Amaury Denoyelle15b09612021-08-24 16:20:27 +0200766static int h3_resp_headers_send(struct qcs *qcs, struct htx *htx)
767{
768 struct buffer outbuf;
769 struct buffer headers_buf = BUF_NULL;
770 struct buffer *res;
771 struct http_hdr list[global.tune.max_http_hdr];
772 struct htx_sl *sl;
773 struct htx_blk *blk;
774 enum htx_blk_type type;
775 int frame_length_size; /* size in bytes of frame length varint field */
776 int ret = 0;
777 int hdr;
778 int status = 0;
779
Amaury Denoyellea717eb72022-05-30 15:51:01 +0200780 TRACE_ENTER(H3_EV_TX_HDR, qcs->qcc->conn, qcs);
781
Amaury Denoyelle15b09612021-08-24 16:20:27 +0200782 sl = NULL;
783 hdr = 0;
784 for (blk = htx_get_head_blk(htx); blk; blk = htx_get_next_blk(htx, blk)) {
785 type = htx_get_blk_type(blk);
786
787 if (type == HTX_BLK_UNUSED)
788 continue;
789
790 if (type == HTX_BLK_EOH)
791 break;
792
793 if (type == HTX_BLK_RES_SL) {
794 /* start-line -> HEADERS h3 frame */
795 BUG_ON(sl);
796 sl = htx_get_blk_ptr(htx, blk);
797 /* TODO should be on h3 layer */
798 status = sl->info.res.status;
799 }
800 else if (type == HTX_BLK_HDR) {
801 list[hdr].n = htx_get_blk_name(htx, blk);
802 list[hdr].v = htx_get_blk_value(htx, blk);
803 hdr++;
804 }
805 else {
806 ABORT_NOW();
807 goto err;
808 }
809 }
810
811 BUG_ON(!sl);
812
813 list[hdr].n = ist("");
814
Amaury Denoyelled3d97c62021-10-05 11:45:58 +0200815 res = mux_get_buf(qcs);
Amaury Denoyelle15b09612021-08-24 16:20:27 +0200816
817 /* At least 5 bytes to store frame type + length as a varint max size */
818 if (b_room(res) < 5)
819 ABORT_NOW();
820
821 b_reset(&outbuf);
822 outbuf = b_make(b_tail(res), b_contig_space(res), 0, 0);
823 /* Start the headers after frame type + length */
824 headers_buf = b_make(b_head(res) + 5, b_size(res) - 5, 0, 0);
825
826 if (qpack_encode_field_section_line(&headers_buf))
827 ABORT_NOW();
828 if (qpack_encode_int_status(&headers_buf, status))
829 ABORT_NOW();
830
831 for (hdr = 0; hdr < sizeof(list) / sizeof(list[0]); ++hdr) {
832 if (isteq(list[hdr].n, ist("")))
833 break;
834
Amaury Denoyelleffafb3d2022-02-15 16:10:42 +0100835 /* draft-ietf-quic-http34 4.1. HTTP Message Exchanges
836 * Transfer codings (see Section 6.1 of [HTTP11]) are not
837 * defined for HTTP/3; the Transfer-Encoding header field MUST
838 * NOT be used.
839 */
840 if (isteq(list[hdr].n, ist("transfer-encoding")))
841 continue;
842
Amaury Denoyelle15b09612021-08-24 16:20:27 +0200843 if (qpack_encode_header(&headers_buf, list[hdr].n, list[hdr].v))
844 ABORT_NOW();
845 }
846
847 /* Now that all headers are encoded, we are certain that res buffer is
848 * big enough
849 */
850 frame_length_size = quic_int_getsize(b_data(&headers_buf));
851 res->head += 4 - frame_length_size;
852 b_putchr(res, 0x01); /* h3 HEADERS frame type */
853 if (!b_quic_enc_int(res, b_data(&headers_buf)))
854 ABORT_NOW();
855 b_add(res, b_data(&headers_buf));
856
857 ret = 0;
858 blk = htx_get_head_blk(htx);
859 while (blk) {
860 type = htx_get_blk_type(blk);
861 ret += htx_get_blksz(blk);
862 blk = htx_remove_blk(htx, blk);
863 if (type == HTX_BLK_EOH)
864 break;
865 }
866
Amaury Denoyellea717eb72022-05-30 15:51:01 +0200867 TRACE_LEAVE(H3_EV_TX_HDR, qcs->qcc->conn, qcs);
Amaury Denoyelle15b09612021-08-24 16:20:27 +0200868 return ret;
869
870 err:
Amaury Denoyellea717eb72022-05-30 15:51:01 +0200871 TRACE_DEVEL("leaving on error", H3_EV_TX_HDR, qcs->qcc->conn, qcs);
Amaury Denoyelle15b09612021-08-24 16:20:27 +0200872 return 0;
873}
874
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200875/* Returns the total of bytes sent. */
876static int h3_resp_data_send(struct qcs *qcs, struct buffer *buf, size_t count)
877{
878 struct buffer outbuf;
879 struct buffer *res;
880 size_t total = 0;
881 struct htx *htx;
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200882 int bsize, fsize, hsize;
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200883 struct htx_blk *blk;
884 enum htx_blk_type type;
885
Amaury Denoyellea717eb72022-05-30 15:51:01 +0200886 TRACE_ENTER(H3_EV_TX_DATA, qcs->qcc->conn, qcs);
887
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200888 htx = htx_from_buf(buf);
889
890 new_frame:
891 if (!count || htx_is_empty(htx))
892 goto end;
893
894 blk = htx_get_head_blk(htx);
895 type = htx_get_blk_type(blk);
896 fsize = bsize = htx_get_blksz(blk);
897
898 if (type != HTX_BLK_DATA)
899 goto end;
900
Amaury Denoyelled3d97c62021-10-05 11:45:58 +0200901 res = mux_get_buf(qcs);
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200902
903 if (fsize > count)
904 fsize = count;
905
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200906 /* h3 DATA headers : 1-byte frame type + varint frame length */
907 hsize = 1 + QUIC_VARINT_MAX_SIZE;
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200908
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200909 while (1) {
910 b_reset(&outbuf);
911 outbuf = b_make(b_tail(res), b_contig_space(res), 0, 0);
912 if (b_size(&outbuf) > hsize || !b_space_wraps(res))
913 break;
914 b_slow_realign(res, trash.area, b_data(res));
915 }
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200916
Amaury Denoyelle84ea8dc2021-12-03 14:40:01 +0100917 /* Not enough room for headers and at least one data byte, block the
Willy Tarreau4596fe22022-05-17 19:07:51 +0200918 * stream. It is expected that the stream connector layer will subscribe
919 * on SEND.
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200920 */
Amaury Denoyelle84ea8dc2021-12-03 14:40:01 +0100921 if (b_size(&outbuf) <= hsize) {
922 qcs->flags |= QC_SF_BLK_MROOM;
923 goto end;
924 }
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200925
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200926 if (b_size(&outbuf) < hsize + fsize)
927 fsize = b_size(&outbuf) - hsize;
928 BUG_ON(fsize <= 0);
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200929
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200930 b_putchr(&outbuf, 0x00); /* h3 frame type = DATA */
931 b_quic_enc_int(&outbuf, fsize); /* h3 frame length */
932
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200933 b_putblk(&outbuf, htx_get_blk_ptr(htx, blk), fsize);
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200934 total += fsize;
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200935 count -= fsize;
936
937 if (fsize == bsize)
938 htx_remove_blk(htx, blk);
939 else
940 htx_cut_data_blk(htx, blk, fsize);
941
Amaury Denoyellea543eb12021-10-06 14:53:13 +0200942 /* commit the buffer */
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200943 b_add(res, b_data(&outbuf));
944 goto new_frame;
945
946 end:
Amaury Denoyellea717eb72022-05-30 15:51:01 +0200947 TRACE_LEAVE(H3_EV_TX_DATA, qcs->qcc->conn, qcs);
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200948 return total;
949}
950
Willy Tarreau3215e732022-05-27 10:09:11 +0200951size_t h3_snd_buf(struct stconn *sc, struct buffer *buf, size_t count, int flags)
Amaury Denoyelle26dfd902021-08-24 16:33:53 +0200952{
953 size_t total = 0;
Willy Tarreau3215e732022-05-27 10:09:11 +0200954 struct qcs *qcs = __sc_mux_strm(sc);
Amaury Denoyelle26dfd902021-08-24 16:33:53 +0200955 struct htx *htx;
956 enum htx_blk_type btype;
957 struct htx_blk *blk;
958 uint32_t bsize;
959 int32_t idx;
960 int ret;
961
Amaury Denoyelled8769d12022-03-25 15:28:33 +0100962 h3_debug_printf(stderr, "%s\n", __func__);
Amaury Denoyelledeed7772021-12-03 11:36:46 +0100963
Amaury Denoyelle26dfd902021-08-24 16:33:53 +0200964 htx = htx_from_buf(buf);
965
Amaury Denoyelle84ea8dc2021-12-03 14:40:01 +0100966 while (count && !htx_is_empty(htx) && !(qcs->flags & QC_SF_BLK_MROOM)) {
Amaury Denoyelle26dfd902021-08-24 16:33:53 +0200967 idx = htx_get_head(htx);
968 blk = htx_get_blk(htx, idx);
969 btype = htx_get_blk_type(blk);
970 bsize = htx_get_blksz(blk);
971
972 /* Not implemented : QUIC on backend side */
973 BUG_ON(btype == HTX_BLK_REQ_SL);
974
975 switch (btype) {
976 case HTX_BLK_RES_SL:
Amaury Denoyelle15b09612021-08-24 16:20:27 +0200977 /* start-line -> HEADERS h3 frame */
978 ret = h3_resp_headers_send(qcs, htx);
979 if (ret > 0) {
980 total += ret;
981 count -= ret;
982 if (ret < bsize)
983 goto out;
984 }
985 break;
Amaury Denoyelle26dfd902021-08-24 16:33:53 +0200986
987 case HTX_BLK_DATA:
Amaury Denoyelle8e2a9982021-08-24 16:24:37 +0200988 ret = h3_resp_data_send(qcs, buf, count);
989 if (ret > 0) {
990 htx = htx_from_buf(buf);
991 total += ret;
992 count -= ret;
993 if (ret < bsize)
994 goto out;
995 }
996 break;
Amaury Denoyelle26dfd902021-08-24 16:33:53 +0200997
998 case HTX_BLK_TLR:
999 case HTX_BLK_EOT:
1000 /* TODO trailers */
1001
1002 default:
1003 htx_remove_blk(htx, blk);
1004 total += bsize;
1005 count -= bsize;
1006 break;
1007 }
1008 }
1009
Amaury Denoyellec2025c12021-12-03 15:03:36 +01001010 if ((htx->flags & HTX_FL_EOM) && htx_is_empty(htx))
1011 qcs->flags |= QC_SF_FIN_STREAM;
1012
Amaury Denoyelle26dfd902021-08-24 16:33:53 +02001013 out:
Amaury Denoyellea543eb12021-10-06 14:53:13 +02001014 if (total) {
1015 if (!(qcs->qcc->wait_event.events & SUB_RETRY_SEND))
1016 tasklet_wakeup(qcs->qcc->wait_event.tasklet);
1017 }
1018
Amaury Denoyelle26dfd902021-08-24 16:33:53 +02001019 return total;
Amaury Denoyellef52151d2021-08-24 16:11:18 +02001020}
1021
Amaury Denoyellec0156792022-06-03 15:29:07 +02001022static int h3_attach(struct qcs *qcs, void *conn_ctx)
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001023{
1024 struct h3s *h3s;
1025
Amaury Denoyelled5581d52022-05-30 15:51:31 +02001026 TRACE_ENTER(H3_EV_H3S_NEW, qcs->qcc->conn, qcs);
1027
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001028 h3s = pool_alloc(pool_head_h3s);
1029 if (!h3s)
1030 return 1;
1031
1032 qcs->ctx = h3s;
Amaury Denoyellec0156792022-06-03 15:29:07 +02001033 h3s->h3c = conn_ctx;
1034
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +02001035 h3s->demux_frame_len = 0;
1036 h3s->demux_frame_type = 0;
Amaury Denoyelle35550642022-05-24 15:14:53 +02001037 h3s->flags = 0;
Amaury Denoyelle48f01bd2022-04-27 15:37:20 +02001038
Amaury Denoyelle3236a8e2022-05-24 15:24:03 +02001039 if (quic_stream_is_bidi(qcs->id)) {
1040 h3s->type = H3S_T_REQ;
1041 }
1042 else {
1043 /* stream type must be decoded for unidirectional streams */
1044 h3s->type = H3S_T_UNKNOWN;
1045 }
1046
Amaury Denoyelled5581d52022-05-30 15:51:31 +02001047 TRACE_LEAVE(H3_EV_H3S_NEW, qcs->qcc->conn, qcs);
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001048 return 0;
1049}
1050
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001051static void h3_detach(struct qcs *qcs)
1052{
1053 struct h3s *h3s = qcs->ctx;
Amaury Denoyelled5581d52022-05-30 15:51:31 +02001054
1055 TRACE_ENTER(H3_EV_H3S_END, qcs->qcc->conn, qcs);
1056
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001057 pool_free(pool_head_h3s, h3s);
1058 qcs->ctx = NULL;
Amaury Denoyelled5581d52022-05-30 15:51:31 +02001059
1060 TRACE_LEAVE(H3_EV_H3S_END, qcs->qcc->conn, qcs);
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001061}
1062
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001063static int h3_finalize(void *ctx)
1064{
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001065 struct h3c *h3c = ctx;
Amaury Denoyelle9cc47512022-05-24 16:27:41 +02001066 struct qcs *qcs;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001067
Amaury Denoyelle9cc47512022-05-24 16:27:41 +02001068 qcs = qcs_new(h3c->qcc, 0x3, QCS_SRV_UNI);
1069 if (!qcs)
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001070 return 0;
1071
Amaury Denoyelle9cc47512022-05-24 16:27:41 +02001072 h3_control_send(qcs, h3c);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001073
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001074 return 1;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001075}
1076
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001077/* Initialize the HTTP/3 context for <qcc> mux.
1078 * Return 1 if succeeded, 0 if not.
1079 */
1080static int h3_init(struct qcc *qcc)
1081{
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001082 struct h3c *h3c;
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02001083 struct quic_conn *qc = qcc->conn->handle.qc;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001084
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001085 h3c = pool_alloc(pool_head_h3c);
1086 if (!h3c)
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001087 goto fail_no_h3;
1088
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001089 h3c->qcc = qcc;
1090 h3c->err = H3_NO_ERROR;
1091 h3c->flags = 0;
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001092
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001093 qcc->ctx = h3c;
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02001094 h3c->prx_counters =
1095 EXTRA_COUNTERS_GET(qc->li->bind_conf->frontend->extra_counters_fe,
1096 &h3_stats_module);
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001097 LIST_INIT(&h3c->buf_wait.list);
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001098
1099 return 1;
1100
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001101 fail_no_h3:
1102 return 0;
1103}
1104
Amaury Denoyelle8347f272022-03-29 14:46:55 +02001105static void h3_release(void *ctx)
1106{
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001107 struct h3c *h3c = ctx;
Amaury Denoyelle8d1ecac2022-05-24 14:55:43 +02001108 pool_free(pool_head_h3c, h3c);
Amaury Denoyelle8347f272022-03-29 14:46:55 +02001109}
1110
Amaury Denoyelle198d35f2022-04-01 17:56:58 +02001111/* Check if the H3 connection can still be considered as active.
1112 *
1113 * Return true if active else false.
1114 */
1115static int h3_is_active(const struct qcc *qcc, void *ctx)
1116{
1117 if (qcc->strms[QCS_CLT_BIDI].nb_streams)
1118 return 1;
1119
1120 return 0;
1121}
1122
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02001123/* Increment the h3 error code counters for <error_code> value */
1124static void h3_stats_inc_err_cnt(void *ctx, int err_code)
1125{
1126 struct h3c *h3c = ctx;
1127
1128 h3_inc_err_cnt(h3c->prx_counters, err_code);
1129}
1130
Amaury Denoyelle016aa932022-05-30 15:49:36 +02001131/* h3 trace handler */
1132static void h3_trace(enum trace_level level, uint64_t mask,
1133 const struct trace_source *src,
1134 const struct ist where, const struct ist func,
1135 const void *a1, const void *a2, const void *a3, const void *a4)
1136{
1137 const struct connection *conn = a1;
1138 const struct qcc *qcc = conn ? conn->ctx : NULL;
1139 const struct qcs *qcs = a2;
1140
1141 if (src->verbosity > H3_VERB_CLEAN) {
1142 chunk_appendf(&trace_buf, " : qcc=%p(F)", qcc);
1143
1144 if (qcs)
1145 chunk_appendf(&trace_buf, " qcs=%p(%lu)", qcs, qcs->id);
1146 }
1147}
1148
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001149/* HTTP/3 application layer operations */
1150const struct qcc_app_ops h3_ops = {
1151 .init = h3_init,
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001152 .attach = h3_attach,
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001153 .decode_qcs = h3_decode_qcs,
Amaury Denoyelleabbe91e2021-11-12 16:09:29 +01001154 .snd_buf = h3_snd_buf,
Amaury Denoyelle67e92d32022-04-27 18:04:01 +02001155 .detach = h3_detach,
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001156 .finalize = h3_finalize,
Amaury Denoyelle198d35f2022-04-01 17:56:58 +02001157 .is_active = h3_is_active,
Amaury Denoyelle8347f272022-03-29 14:46:55 +02001158 .release = h3_release,
Frédéric Lécaille6f7607e2022-05-25 22:25:37 +02001159 .inc_err_cnt = h3_stats_inc_err_cnt,
Frédéric Lécailleccac11f2021-03-03 16:09:02 +01001160};