]> git.ipfire.org Git - thirdparty/openssl.git/blame - ssl/quic/quic_txp.c
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
QUIC ACKM: Rework probe reporting to allow use for bookkeeping
[thirdparty/openssl.git] / ssl / quic / quic_txp.c
CommitLineData
a73078b7
HL		 1/*
2 * Copyright 2022 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10#include "internal/quic_txp.h"
11#include "internal/quic_fifd.h"
12#include "internal/quic_stream_map.h"
13#include "internal/common.h"
14#include <openssl/err.h>
15
16#define MIN_CRYPTO_HDR_SIZE 3
17
18#define MIN_FRAME_SIZE_HANDSHAKE_DONE 1
19#define MIN_FRAME_SIZE_MAX_DATA 2
20#define MIN_FRAME_SIZE_ACK 5
21#define MIN_FRAME_SIZE_CRYPTO (MIN_CRYPTO_HDR_SIZE + 1)
22#define MIN_FRAME_SIZE_STREAM 3 /* minimum useful size (for non-FIN) */
23#define MIN_FRAME_SIZE_MAX_STREAMS_BIDI 2
24#define MIN_FRAME_SIZE_MAX_STREAMS_UNI 2
25
26struct ossl_quic_tx_packetiser_st {
27 OSSL_QUIC_TX_PACKETISER_ARGS args;
28
29 /*
30 * Opaque initial token blob provided by caller. TXP frees using the
31 * callback when it is no longer needed.
32 */
33 const unsigned char *initial_token;
34 size_t initial_token_len;
35 ossl_quic_initial_token_free_fn *initial_token_free_cb;
36 void *initial_token_free_cb_arg;
37
38 /* Subcomponents of the TXP that we own. */
39 QUIC_FIFD fifd; /* QUIC Frame-in-Flight Dispatcher */
40
41 /* Internal state. */
42 uint64_t next_pn[QUIC_PN_SPACE_NUM]; /* Next PN to use in given PN space. */
43 OSSL_TIME last_tx_time; /* Last time a packet was generated, or 0. */
44
45 /* Internal state - frame (re)generation flags. */
46 unsigned int want_handshake_done : 1;
47 unsigned int want_max_data : 1;
48 unsigned int want_max_streams_bidi : 1;
49 unsigned int want_max_streams_uni : 1;
50
51 /* Internal state - frame (re)generation flags - per PN space. */
52 unsigned int want_ack : QUIC_PN_SPACE_NUM;
53 unsigned int force_ack_eliciting : QUIC_PN_SPACE_NUM;
54
55 /*
56 * Internal state - connection close terminal state.
57 * Once this is set, it is not unset unlike other want_ flags - we keep
58 * sending it in every packet.
59 */
60 unsigned int want_conn_close : 1;
61
cda88baf
HL		 62 /* Has the handshake been completed? */
63 unsigned int handshake_complete : 1;
64
a73078b7
HL		 65 OSSL_QUIC_FRAME_CONN_CLOSE conn_close_frame;
66
67 /* Internal state - packet assembly. */
68 unsigned char *scratch; /* scratch buffer for packet assembly */
69 size_t scratch_len; /* number of bytes allocated for scratch */
70 OSSL_QTX_IOVEC *iovec; /* scratch iovec array for use with QTX */
71 size_t alloc_iovec; /* size of iovec array */
72};
73
74/*
75 * The TX helper records state used while generating frames into packets. It
76 * enables serialization into the packet to be done "transactionally" where
77 * serialization of a frame can be rolled back if it fails midway (e.g. if it
78 * does not fit).
79 */
80struct tx_helper {
81 OSSL_QUIC_TX_PACKETISER *txp;
82 /*
83 * The Maximum Packet Payload Length in bytes. This is the amount of
84 * space we have to generate frames into.
85 */
86 size_t max_ppl;
87 /*
88 * Number of bytes we have generated so far.
89 */
90 size_t bytes_appended;
91 /*
92 * Number of scratch bytes in txp->scratch we have used so far. Some iovecs
93 * will reference this scratch buffer. When we need to use more of it (e.g.
94 * when we need to put frame headers somewhere), we append to the scratch
95 * buffer, resizing if necessary, and increase this accordingly.
96 */
97 size_t scratch_bytes;
98 /*
99 * Bytes reserved in the MaxPPL budget. We keep this number of bytes spare
100 * until reserve_allowed is set to 1. Currently this is always at most 1, as
101 * a PING frame takes up one byte and this mechanism is only used to ensure
102 * we can encode a PING frame if we have been asked to ensure a packet is
103 * ACK-eliciting and we are unusure if we are going to add any other
104 * ACK-eliciting frames before we reach our MaxPPL budget.
105 */
106 size_t reserve;
107 /*
108 * Number of iovecs we have currently appended. This is the number of
109 * entries valid in txp->iovec.
110 */
111 size_t num_iovec;
112 /*
113 * Whether we are allowed to make use of the reserve bytes in our MaxPPL
114 * budget. This is used to ensure we have room to append a PING frame later
115 * if we need to. Once we know we will not need to append a PING frame, this
116 * is set to 1.
117 */
118 unsigned int reserve_allowed : 1;
119 /*
120 * Set to 1 if we have appended a STREAM frame with an implicit length. If
121 * this happens we should never append another frame after that frame as it
122 * cannot be validly encoded. This is just a safety check.
123 */
124 unsigned int done_implicit : 1;
125 struct {
126 /*
127 * The fields in this structure are valid if active is set, which means
128 * that a serialization transaction is currently in progress.
129 */
130 unsigned char *data;
131 WPACKET wpkt;
132 unsigned int active : 1;
133 } txn;
134};
135
136static void tx_helper_rollback(struct tx_helper *h);
137static int txp_ensure_iovec(OSSL_QUIC_TX_PACKETISER *txp, size_t num);
138
139/* Initialises the TX helper. */
140static int tx_helper_init(struct tx_helper *h, OSSL_QUIC_TX_PACKETISER *txp,
141 size_t max_ppl, size_t reserve)
142{
143 if (reserve > max_ppl)
144 return 0;
145
146 h->txp = txp;
147 h->max_ppl = max_ppl;
148 h->reserve = reserve;
149 h->num_iovec = 0;
150 h->bytes_appended = 0;
151 h->scratch_bytes = 0;
152 h->reserve_allowed = 0;
153 h->done_implicit = 0;
154 h->txn.data = NULL;
155 h->txn.active = 0;
156
157 if (max_ppl > h->txp->scratch_len) {
158 unsigned char *scratch;
159
160 scratch = OPENSSL_realloc(h->txp->scratch, max_ppl);
161 if (scratch == NULL)
162 return 0;
163
164 h->txp->scratch = scratch;
165 h->txp->scratch_len = max_ppl;
166 }
167
168 return 1;
169}
170
171static void tx_helper_cleanup(struct tx_helper *h)
172{
173 if (h->txn.active)
174 tx_helper_rollback(h);
175
176 h->txp = NULL;
177}
178
179static void tx_helper_unrestrict(struct tx_helper *h)
180{
181 h->reserve_allowed = 1;
182}
183
184/*
185 * Append an extent of memory to the iovec list. The memory must remain
186 * allocated until we finish generating the packet and call the QTX.
187 *
188 * In general, the buffers passed to this function will be from one of two
189 * ranges:
190 *
191 * - Application data contained in stream buffers managed elsewhere
192 * in the QUIC stack; or
193 *
194 * - Control frame data appended into txp->scratch using tx_helper_begin and
195 * tx_helper_commit.
196 *
197 */
198static int tx_helper_append_iovec(struct tx_helper *h,
199 const unsigned char *buf,
200 size_t buf_len)
201{
202 if (buf_len == 0)
203 return 1;
204
205 if (!ossl_assert(!h->done_implicit))
206 return 0;
207
208 if (!txp_ensure_iovec(h->txp, h->num_iovec + 1))
209 return 0;
210
211 h->txp->iovec[h->num_iovec].buf = buf;
212 h->txp->iovec[h->num_iovec].buf_len = buf_len;
213
214 ++h->num_iovec;
215 h->bytes_appended += buf_len;
216 return 1;
217}
218
219/*
220 * How many more bytes of space do we have left in our plaintext packet payload?
221 */
222static size_t tx_helper_get_space_left(struct tx_helper *h)
223{
224 return h->max_ppl
225 - (h->reserve_allowed ? 0 : h->reserve) - h->bytes_appended;
226}
227
228/*
229 * Begin a control frame serialization transaction. This allows the
230 * serialization of the control frame to be backed out if it turns out it won't
231 * fit. Write the control frame to the returned WPACKET. Ensure you always
232 * call tx_helper_rollback or tx_helper_commit (or tx_helper_cleanup). Returns
233 * NULL on failure.
234 */
235static WPACKET *tx_helper_begin(struct tx_helper *h)
236{
237 size_t space_left, len;
238 unsigned char *data;
239
240 if (!ossl_assert(!h->txn.active))
241 return NULL;
242
243 if (!ossl_assert(!h->done_implicit))
244 return NULL;
245
246 data = (unsigned char *)h->txp->scratch + h->scratch_bytes;
247 len = h->txp->scratch_len - h->scratch_bytes;
248
249 space_left = tx_helper_get_space_left(h);
250 if (!ossl_assert(space_left <= len))
251 return NULL;
252
253 if (!WPACKET_init_static_len(&h->txn.wpkt, data, len, 0))
254 return NULL;
255
256 if (!WPACKET_set_max_size(&h->txn.wpkt, space_left)) {
257 WPACKET_cleanup(&h->txn.wpkt);
258 return NULL;
259 }
260
261 h->txn.data = data;
262 h->txn.active = 1;
263 return &h->txn.wpkt;
264}
265
266static void tx_helper_end(struct tx_helper *h, int success)
267{
268 if (success)
269 WPACKET_finish(&h->txn.wpkt);
270 else
271 WPACKET_cleanup(&h->txn.wpkt);
272
273 h->txn.active = 0;
274 h->txn.data = NULL;
275}
276
277/* Abort a control frame serialization transaction. */
278static void tx_helper_rollback(struct tx_helper *h)
279{
280 if (!h->txn.active)
281 return;
282
283 tx_helper_end(h, 0);
284}
285
286/* Commit a control frame. */
287static int tx_helper_commit(struct tx_helper *h)
288{
289 size_t l = 0;
290
291 if (!h->txn.active)
292 return 0;
293
294 if (!WPACKET_get_total_written(&h->txn.wpkt, &l)) {
295 tx_helper_end(h, 0);
296 return 0;
297 }
298
299 if (!tx_helper_append_iovec(h, h->txn.data, l)) {
300 tx_helper_end(h, 0);
301 return 0;
302 }
303
304 h->scratch_bytes += l;
305 tx_helper_end(h, 1);
306 return 1;
307}
308
309static QUIC_SSTREAM *get_sstream_by_id(uint64_t stream_id, uint32_t pn_space,
310 void *arg);
311static void on_regen_notify(uint64_t frame_type, uint64_t stream_id,
312 QUIC_TXPIM_PKT *pkt, void *arg);
313static int sstream_is_pending(QUIC_SSTREAM *sstream);
314static int txp_el_pending(OSSL_QUIC_TX_PACKETISER *txp, uint32_t enc_level,
7f9d1249
HL		 315 uint32_t archetype,
316 uint32_t *conn_close_enc_level);
a73078b7
HL		 317static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp, uint32_t enc_level,
318 uint32_t archetype,
091f532e
HL		 319 int is_last_in_dgram,
320 int dgram_contains_initial,
321 int chosen_for_conn_close);
a73078b7
HL		 322static size_t txp_determine_pn_len(OSSL_QUIC_TX_PACKETISER *txp);
323static int txp_determine_ppl_from_pl(OSSL_QUIC_TX_PACKETISER *txp,
324 size_t pl,
325 uint32_t enc_level,
326 size_t hdr_len,
327 size_t *r);
328static size_t txp_get_mdpl(OSSL_QUIC_TX_PACKETISER *txp);
329static int txp_generate_for_el_actual(OSSL_QUIC_TX_PACKETISER *txp,
330 uint32_t enc_level,
331 uint32_t archetype,
332 size_t min_ppl,
333 size_t max_ppl,
334 size_t pkt_overhead,
7f9d1249 335 QUIC_PKT_HDR *phdr,
091f532e 336 int chosen_for_conn_close);
a73078b7
HL		 337
338OSSL_QUIC_TX_PACKETISER *ossl_quic_tx_packetiser_new(const OSSL_QUIC_TX_PACKETISER_ARGS *args)
339{
340 OSSL_QUIC_TX_PACKETISER *txp;
341
342 if (args == NULL
343 || args->qtx == NULL
344 || args->txpim == NULL
345 || args->cfq == NULL
346 || args->ackm == NULL
347 || args->qsm == NULL
348 || args->conn_txfc == NULL
349 || args->conn_rxfc == NULL) {
350 ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
351 return NULL;
352 }
353
354 txp = OPENSSL_zalloc(sizeof(*txp));
355 if (txp == NULL)
356 return NULL;
357
358 txp->args = *args;
359 txp->last_tx_time = ossl_time_zero();
360
361 if (!ossl_quic_fifd_init(&txp->fifd,
362 txp->args.cfq, txp->args.ackm, txp->args.txpim,
363 get_sstream_by_id, txp,
364 on_regen_notify, txp)) {
365 OPENSSL_free(txp);
366 return NULL;
367 }
368
369 return txp;
370}
371
372void ossl_quic_tx_packetiser_free(OSSL_QUIC_TX_PACKETISER *txp)
373{
374 if (txp == NULL)
375 return;
376
377 ossl_quic_tx_packetiser_set_initial_token(txp, NULL, 0, NULL, NULL);
378 ossl_quic_fifd_cleanup(&txp->fifd);
379 OPENSSL_free(txp->iovec);
380 OPENSSL_free(txp->conn_close_frame.reason);
381 OPENSSL_free(txp->scratch);
382 OPENSSL_free(txp);
383}
384
385void ossl_quic_tx_packetiser_set_initial_token(OSSL_QUIC_TX_PACKETISER *txp,
386 const unsigned char *token,
387 size_t token_len,
388 ossl_quic_initial_token_free_fn *free_cb,
389 void *free_cb_arg)
390{
391 if (txp->initial_token != NULL && txp->initial_token_free_cb != NULL)
392 txp->initial_token_free_cb(txp->initial_token, txp->initial_token_len,
393 txp->initial_token_free_cb_arg);
394
395 txp->initial_token = token;
396 txp->initial_token_len = token_len;
397 txp->initial_token_free_cb = free_cb;
398 txp->initial_token_free_cb_arg = free_cb_arg;
399}
400
401int ossl_quic_tx_packetiser_set_cur_dcid(OSSL_QUIC_TX_PACKETISER *txp,
402 const QUIC_CONN_ID *dcid)
403{
404 if (dcid == NULL) {
405 ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
406 return 0;
407 }
408
409 txp->args.cur_dcid = *dcid;
410 return 1;
411}
412
413int ossl_quic_tx_packetiser_set_cur_scid(OSSL_QUIC_TX_PACKETISER *txp,
414 const QUIC_CONN_ID *scid)
415{
416 if (scid == NULL) {
417 ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
418 return 0;
419 }
420
421 txp->args.cur_scid = *scid;
422 return 1;
423}
424
425/* Change the destination L4 address the TXP uses to send datagrams. */
426int ossl_quic_tx_packetiser_set_peer(OSSL_QUIC_TX_PACKETISER *txp,
427 const BIO_ADDR *peer)
428{
429 if (peer == NULL) {
430 ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
431 return 0;
432 }
433
434 txp->args.peer = *peer;
435 return 1;
436}
437
438int ossl_quic_tx_packetiser_discard_enc_level(OSSL_QUIC_TX_PACKETISER *txp,
439 uint32_t enc_level)
440{
441 if (enc_level >= QUIC_ENC_LEVEL_NUM) {
442 ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
443 return 0;
444 }
445
446 if (enc_level != QUIC_ENC_LEVEL_0RTT)
447 txp->args.crypto[ossl_quic_enc_level_to_pn_space(enc_level)] = NULL;
448
a73078b7
HL		 449 return 1;
450}
451
cda88baf
HL		 452void ossl_quic_tx_packetiser_notify_handshake_complete(OSSL_QUIC_TX_PACKETISER *txp)
453{
454 txp->handshake_complete = 1;
455}
456
a73078b7
HL		 457void ossl_quic_tx_packetiser_schedule_handshake_done(OSSL_QUIC_TX_PACKETISER *txp)
458{
459 txp->want_handshake_done = 1;
460}
461
462void ossl_quic_tx_packetiser_schedule_ack_eliciting(OSSL_QUIC_TX_PACKETISER *txp,
463 uint32_t pn_space)
464{
465 txp->force_ack_eliciting |= (1UL << pn_space);
466}
467
468#define TXP_ERR_INTERNAL 0 /* Internal (e.g. alloc) error */
469#define TXP_ERR_SUCCESS 1 /* Success */
470#define TXP_ERR_SPACE 2 /* Not enough room for another packet */
471#define TXP_ERR_INPUT 3 /* Invalid/malformed input */
472
04e5226f
HL		 473int ossl_quic_tx_packetiser_has_pending(OSSL_QUIC_TX_PACKETISER *txp,
474 uint32_t archetype,
475 uint32_t flags)
476{
7f9d1249 477 uint32_t enc_level, conn_close_enc_level = QUIC_ENC_LEVEL_NUM;
04e5226f
HL		 478 int bypass_cc = ((flags & TX_PACKETISER_BYPASS_CC) != 0);
479
480 if (!bypass_cc && !txp->args.cc_method->can_send(txp->args.cc_data))
481 return 0;
482
483 for (enc_level = QUIC_ENC_LEVEL_INITIAL;
484 enc_level < QUIC_ENC_LEVEL_NUM;
485 ++enc_level)
7f9d1249 486 if (txp_el_pending(txp, enc_level, archetype, &conn_close_enc_level))
04e5226f
HL		 487 return 1;
488
489 return 0;
490}
491
a73078b7
HL		 492/*
493 * Generates a datagram by polling the various ELs to determine if they want to
494 * generate any frames, and generating a datagram which coalesces packets for
495 * any ELs which do.
496 */
497int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
498 uint32_t archetype)
499{
7f9d1249 500 uint32_t enc_level, conn_close_enc_level = QUIC_ENC_LEVEL_NUM;
091f532e 501 int have_pkt_for_el[QUIC_ENC_LEVEL_NUM], is_last_in_dgram;
a73078b7
HL		 502 size_t num_el_in_dgram = 0, pkts_done = 0;
503 int rc;
504
505 if (!txp->args.cc_method->can_send(txp->args.cc_data))
506 return TX_PACKETISER_RES_NO_PKT;
507
508 for (enc_level = QUIC_ENC_LEVEL_INITIAL;
509 enc_level < QUIC_ENC_LEVEL_NUM;
510 ++enc_level) {
7f9d1249
HL		 511 have_pkt_for_el[enc_level] = txp_el_pending(txp, enc_level, archetype,
512 &conn_close_enc_level);
a73078b7
HL		 513 if (have_pkt_for_el[enc_level])
514 ++num_el_in_dgram;
515 }
516
517 if (num_el_in_dgram == 0)
518 return TX_PACKETISER_RES_NO_PKT;
519
520 /*
521 * Should not be needed, but a sanity check in case anyone else has been
522 * using the QTX.
523 */
524 ossl_qtx_finish_dgram(txp->args.qtx);
525
526 for (enc_level = QUIC_ENC_LEVEL_INITIAL;
527 enc_level < QUIC_ENC_LEVEL_NUM;
528 ++enc_level) {
529 if (!have_pkt_for_el[enc_level])
530 continue;
531
532 is_last_in_dgram = (pkts_done + 1 == num_el_in_dgram);
533 rc = txp_generate_for_el(txp, enc_level, archetype, is_last_in_dgram,
7f9d1249
HL		 534 have_pkt_for_el[QUIC_ENC_LEVEL_INITIAL],
535 enc_level == conn_close_enc_level);
a73078b7
HL		 536
537 if (rc != TXP_ERR_SUCCESS) {
538 /*
539 * If we already successfully did at least one, make sure we report
540 * this via the return code.
541 */
542 if (pkts_done > 0)
543 break;
544 else
545 return TX_PACKETISER_RES_FAILURE;
546 }
547
548 ++pkts_done;
549 }
550
551 ossl_qtx_finish_dgram(txp->args.qtx);
552 return TX_PACKETISER_RES_SENT_PKT;
553}
554
555struct archetype_data {
556 unsigned int allow_ack : 1;
557 unsigned int allow_ping : 1;
558 unsigned int allow_crypto : 1;
559 unsigned int allow_handshake_done : 1;
560 unsigned int allow_path_challenge : 1;
561 unsigned int allow_path_response : 1;
562 unsigned int allow_new_conn_id : 1;
563 unsigned int allow_retire_conn_id : 1;
564 unsigned int allow_stream_rel : 1;
565 unsigned int allow_conn_fc : 1;
566 unsigned int allow_conn_close : 1;
567 unsigned int allow_cfq_other : 1;
568 unsigned int allow_new_token : 1;
569 unsigned int allow_force_ack_eliciting : 1;
570};
571
572static const struct archetype_data archetypes[QUIC_ENC_LEVEL_NUM][TX_PACKETISER_ARCHETYPE_NUM] = {
573 /* EL 0(INITIAL) */
574 {
575 /* EL 0(INITIAL) - Archetype 0(NORMAL) */
576 {
577 /*allow_ack =*/ 1,
578 /*allow_ping =*/ 1,
579 /*allow_crypto =*/ 1,
580 /*allow_handshake_done =*/ 0,
581 /*allow_path_challenge =*/ 0,
582 /*allow_path_response =*/ 0,
583 /*allow_new_conn_id =*/ 0,
584 /*allow_retire_conn_id =*/ 0,
585 /*allow_stream_rel =*/ 0,
586 /*allow_conn_fc =*/ 0,
587 /*allow_conn_close =*/ 1,
588 /*allow_cfq_other =*/ 1,
589 /*allow_new_token =*/ 0,
590 /*allow_force_ack_eliciting =*/ 1,
591 },
592 /* EL 0(INITIAL) - Archetype 1(ACK_ONLY) */
593 {
594 /*allow_ack =*/ 1,
595 /*allow_ping =*/ 0,
596 /*allow_crypto =*/ 0,
597 /*allow_handshake_done =*/ 0,
598 /*allow_path_challenge =*/ 0,
599 /*allow_path_response =*/ 0,
600 /*allow_new_conn_id =*/ 0,
601 /*allow_retire_conn_id =*/ 0,
602 /*allow_stream_rel =*/ 0,
603 /*allow_conn_fc =*/ 0,
604 /*allow_conn_close =*/ 0,
605 /*allow_cfq_other =*/ 0,
606 /*allow_new_token =*/ 0,
607 /*allow_force_ack_eliciting =*/ 1,
608 },
609 },
610 /* EL 1(HANDSHAKE) */
611 {
612 /* EL 1(HANDSHAKE) - Archetype 0(NORMAL) */
613 {
614 /*allow_ack =*/ 1,
615 /*allow_ping =*/ 1,
616 /*allow_crypto =*/ 1,
617 /*allow_handshake_done =*/ 0,
618 /*allow_path_challenge =*/ 0,
619 /*allow_path_response =*/ 0,
620 /*allow_new_conn_id =*/ 0,
621 /*allow_retire_conn_id =*/ 0,
622 /*allow_stream_rel =*/ 0,
623 /*allow_conn_fc =*/ 0,
624 /*allow_conn_close =*/ 1,
625 /*allow_cfq_other =*/ 1,
626 /*allow_new_token =*/ 0,
627 /*allow_force_ack_eliciting =*/ 1,
628 },
629 /* EL 1(HANDSHAKE) - Archetype 1(ACK_ONLY) */
630 {
631 /*allow_ack =*/ 1,
632 /*allow_ping =*/ 0,
633 /*allow_crypto =*/ 0,
634 /*allow_handshake_done =*/ 0,
635 /*allow_path_challenge =*/ 0,
636 /*allow_path_response =*/ 0,
637 /*allow_new_conn_id =*/ 0,
638 /*allow_retire_conn_id =*/ 0,
639 /*allow_stream_rel =*/ 0,
640 /*allow_conn_fc =*/ 0,
641 /*allow_conn_close =*/ 0,
642 /*allow_cfq_other =*/ 0,
643 /*allow_new_token =*/ 0,
644 /*allow_force_ack_eliciting =*/ 1,
645 },
646 },
647 /* EL 2(0RTT) */
648 {
649 /* EL 2(0RTT) - Archetype 0(NORMAL) */
650 {
651 /*allow_ack =*/ 0,
652 /*allow_ping =*/ 1,
653 /*allow_crypto =*/ 0,
654 /*allow_handshake_done =*/ 0,
655 /*allow_path_challenge =*/ 0,
656 /*allow_path_response =*/ 0,
657 /*allow_new_conn_id =*/ 1,
658 /*allow_retire_conn_id =*/ 1,
659 /*allow_stream_rel =*/ 1,
660 /*allow_conn_fc =*/ 1,
661 /*allow_conn_close =*/ 1,
662 /*allow_cfq_other =*/ 0,
663 /*allow_new_token =*/ 0,
664 /*allow_force_ack_eliciting =*/ 0,
665 },
666 /* EL 2(0RTT) - Archetype 1(ACK_ONLY) */
667 {
668 /*allow_ack =*/ 0,
669 /*allow_ping =*/ 0,
670 /*allow_crypto =*/ 0,
671 /*allow_handshake_done =*/ 0,
672 /*allow_path_challenge =*/ 0,
673 /*allow_path_response =*/ 0,
674 /*allow_new_conn_id =*/ 0,
675 /*allow_retire_conn_id =*/ 0,
676 /*allow_stream_rel =*/ 0,
677 /*allow_conn_fc =*/ 0,
678 /*allow_conn_close =*/ 0,
679 /*allow_cfq_other =*/ 0,
680 /*allow_new_token =*/ 0,
681 /*allow_force_ack_eliciting =*/ 0,
682 },
683 },
684 /* EL 3(1RTT) */
685 {
686 /* EL 3(1RTT) - Archetype 0(NORMAL) */
687 {
688 /*allow_ack =*/ 1,
689 /*allow_ping =*/ 1,
690 /*allow_crypto =*/ 1,
691 /*allow_handshake_done =*/ 1,
692 /*allow_path_challenge =*/ 0,
693 /*allow_path_response =*/ 0,
694 /*allow_new_conn_id =*/ 1,
695 /*allow_retire_conn_id =*/ 1,
696 /*allow_stream_rel =*/ 1,
697 /*allow_conn_fc =*/ 1,
698 /*allow_conn_close =*/ 1,
699 /*allow_cfq_other =*/ 1,
700 /*allow_new_token =*/ 1,
701 /*allow_force_ack_eliciting =*/ 1,
702 },
703 /* EL 3(1RTT) - Archetype 1(ACK_ONLY) */
704 {
705 /*allow_ack =*/ 1,
706 /*allow_ping =*/ 0,
707 /*allow_crypto =*/ 0,
708 /*allow_handshake_done =*/ 0,
709 /*allow_path_challenge =*/ 0,
710 /*allow_path_response =*/ 0,
711 /*allow_new_conn_id =*/ 0,
712 /*allow_retire_conn_id =*/ 0,
713 /*allow_stream_rel =*/ 0,
714 /*allow_conn_fc =*/ 0,
715 /*allow_conn_close =*/ 0,
716 /*allow_cfq_other =*/ 0,
717 /*allow_new_token =*/ 0,
718 /*allow_force_ack_eliciting =*/ 1,
719 }
720 }
721};
722
723static int txp_get_archetype_data(uint32_t enc_level,
724 uint32_t archetype,
725 struct archetype_data *a)
726{
727 if (enc_level >= QUIC_ENC_LEVEL_NUM
728 || archetype >= TX_PACKETISER_ARCHETYPE_NUM)
729 return 0;
730
731 /* No need to avoid copying this as it should not exceed one int in size. */
732 *a = archetypes[enc_level][archetype];
733 return 1;
734}
735
736/*
737 * Returns 1 if the given EL wants to produce one or more frames.
738 * Always returns 0 if the given EL is discarded.
739 */
740static int txp_el_pending(OSSL_QUIC_TX_PACKETISER *txp, uint32_t enc_level,
7f9d1249
HL		 741 uint32_t archetype,
742 uint32_t *conn_close_enc_level)
a73078b7
HL		 743{
744 struct archetype_data a;
745 uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level);
746 QUIC_CFQ_ITEM *cfq_item;
747
748 if (!ossl_qtx_is_enc_level_provisioned(txp->args.qtx, enc_level))
749 return 0;
750
7f9d1249
HL		 751 if (*conn_close_enc_level > enc_level)
752 *conn_close_enc_level = enc_level;
753
a73078b7
HL		 754 if (!txp_get_archetype_data(enc_level, archetype, &a))
755 return 0;
756
757 /* Does the crypto stream for this EL want to produce anything? */
758 if (a.allow_crypto && sstream_is_pending(txp->args.crypto[pn_space]))
759 return 1;
760
761 /* Does the ACKM for this PN space want to produce anything? */
762 if (a.allow_ack && (ossl_ackm_is_ack_desired(txp->args.ackm, pn_space)
763 || (txp->want_ack & (1UL << pn_space)) != 0))
764 return 1;
765
766 /* Do we need to force emission of an ACK-eliciting packet? */
767 if (a.allow_force_ack_eliciting
768 && (txp->force_ack_eliciting & (1UL << pn_space)) != 0)
769 return 1;
770
771 /* Does the connection-level RXFC want to produce a frame? */
772 if (a.allow_conn_fc && (txp->want_max_data
773 || ossl_quic_rxfc_has_cwm_changed(txp->args.conn_rxfc, 0)))
774 return 1;
775
776 /* Do we want to produce a MAX_STREAMS frame? */
777 if (a.allow_conn_fc && (txp->want_max_streams_bidi
778 || txp->want_max_streams_uni))
779 return 1;
780
781 /* Do we want to produce a HANDSHAKE_DONE frame? */
782 if (a.allow_handshake_done && txp->want_handshake_done)
783 return 1;
784
785 /* Do we want to produce a CONNECTION_CLOSE frame? */
7f9d1249
HL		 786 if (a.allow_conn_close && txp->want_conn_close &&
787 *conn_close_enc_level == enc_level)
788 /*
789 * This is a bit of a special case since CONNECTION_CLOSE can appear in
790 * most packet types, and when we decide we want to send it this status
791 * isn't tied to a specific EL. So if we want to send it, we send it
792 * only on the lowest non-dropped EL.
793 */
a73078b7
HL		 794 return 1;
795
796 /* Does the CFQ have any frames queued for this PN space? */
797 if (enc_level != QUIC_ENC_LEVEL_0RTT)
798 for (cfq_item = ossl_quic_cfq_get_priority_head(txp->args.cfq, pn_space);
799 cfq_item != NULL;
800 cfq_item = ossl_quic_cfq_item_get_priority_next(cfq_item, pn_space)) {
801 uint64_t frame_type = ossl_quic_cfq_item_get_frame_type(cfq_item);
802
803 switch (frame_type) {
804 case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
805 if (a.allow_new_conn_id)
806 return 1;
807 break;
808 case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID:
809 if (a.allow_retire_conn_id)
810 return 1;
811 break;
812 case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
813 if (a.allow_new_token)
814 return 1;
815 break;
816 default:
817 if (a.allow_cfq_other)
818 return 1;
819 break;
820 }
821 }
822
cda88baf 823 if (a.allow_stream_rel && txp->handshake_complete) {
a73078b7
HL		 824 QUIC_STREAM_ITER it;
825
826 /* If there are any active streams, 0/1-RTT wants to produce a packet.
827 * Whether a stream is on the active list is required to be precise
828 * (i.e., a stream is never on the active list if we cannot produce a
829 * frame for it), and all stream-related frames are governed by
830 * a.allow_stream_rel (i.e., if we can send one type of stream-related
831 * frame, we can send any of them), so we don't need to inspect
832 * individual streams on the active list, just confirm that the active
833 * list is non-empty.
834 */
835 ossl_quic_stream_iter_init(&it, txp->args.qsm, 0);
836 if (it.stream != NULL)
837 return 1;
838 }
839
840 return 0;
841}
842
843static int sstream_is_pending(QUIC_SSTREAM *sstream)
844{
845 OSSL_QUIC_FRAME_STREAM hdr;
846 OSSL_QTX_IOVEC iov[2];
847 size_t num_iov = OSSL_NELEM(iov);
848
849 return ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov, &num_iov);
850}
851
852/*
853 * Generates a packet for a given EL, coalescing it into the current datagram.
854 *
855 * is_last_in_dgram and dgram_contains_initial are used to determine padding
856 * requirements.
857 *
858 * Returns TXP_ERR_* value.
859 */
860static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp, uint32_t enc_level,
861 uint32_t archetype,
091f532e
HL		 862 int is_last_in_dgram,
863 int dgram_contains_initial,
864 int chosen_for_conn_close)
a73078b7 865{
091f532e 866 int must_pad = dgram_contains_initial && is_last_in_dgram;
a73078b7
HL		 867 size_t min_dpl, min_pl, min_ppl, cmpl, cmppl, running_total;
868 size_t mdpl, hdr_len, pkt_overhead, cc_limit;
869 uint64_t cc_limit_;
870 QUIC_PKT_HDR phdr;
871 OSSL_TIME time_since_last;
872
873 /* Determine the limit CC imposes on what we can send. */
874 if (ossl_time_is_zero(txp->last_tx_time))
875 time_since_last = ossl_time_zero();
876 else
877 time_since_last = ossl_time_subtract(txp->args.now(txp->args.now_arg),
878 txp->last_tx_time);
879
880 cc_limit_ = txp->args.cc_method->get_send_allowance(txp->args.cc_data,
881 time_since_last,
882 ossl_time_is_zero(time_since_last));
883
884 cc_limit = (cc_limit_ > SIZE_MAX ? SIZE_MAX : (size_t)cc_limit_);
885
886 /* Assemble packet header. */
887 phdr.type = ossl_quic_enc_level_to_pkt_type(enc_level);
888 phdr.spin_bit = 0;
889 phdr.pn_len = txp_determine_pn_len(txp);
890 phdr.partial = 0;
891 phdr.fixed = 1;
892 phdr.version = QUIC_VERSION_1;
893 phdr.dst_conn_id = txp->args.cur_dcid;
894 phdr.src_conn_id = txp->args.cur_scid;
895
896 /*
897 * We need to know the length of the payload to get an accurate header
898 * length for non-1RTT packets, because the Length field found in
899 * Initial/Handshake/0-RTT packets uses a variable-length encoding. However,
900 * we don't have a good idea of the length of our payload, because the
901 * length of the payload depends on the room in the datagram after fitting
902 * the header, which depends on the size of the header.
903 *
904 * In general, it does not matter if a packet is slightly shorter (because
905 * e.g. we predicted use of a 2-byte length field, but ended up only needing
906 * a 1-byte length field). However this does matter for Initial packets
907 * which must be at least 1200 bytes, which is also the assumed default MTU;
908 * therefore in many cases Initial packets will be padded to 1200 bytes,
909 * which means if we overestimated the header size, we will be short by a
910 * few bytes and the server will ignore the packet for being too short. In
911 * this case, however, such packets always *will* be padded to meet 1200
912 * bytes, which requires a 2-byte length field, so we don't actually need to
913 * worry about this. Thus we estimate the header length assuming a 2-byte
914 * length field here, which should in practice work well in all cases.
915 */
916 phdr.len = OSSL_QUIC_VLINT_2B_MAX - phdr.pn_len;
917
918 if (enc_level == QUIC_ENC_LEVEL_INITIAL) {
919 phdr.token = txp->initial_token;
920 phdr.token_len = txp->initial_token_len;
921 } else {
922 phdr.token = NULL;
923 phdr.token_len = 0;
924 }
925
926 hdr_len = ossl_quic_wire_get_encoded_pkt_hdr_len(phdr.dst_conn_id.id_len,
927 &phdr);
928 if (hdr_len == 0)
929 return TXP_ERR_INPUT;
930
931 /* MinDPL: Minimum total datagram payload length. */
932 min_dpl = must_pad ? QUIC_MIN_INITIAL_DGRAM_LEN : 0;
933
934 /* How much data is already in the current datagram? */
935 running_total = ossl_qtx_get_cur_dgram_len_bytes(txp->args.qtx);
936
937 /* MinPL: Minimum length of the fully encoded packet. */
938 min_pl = running_total < min_dpl ? min_dpl - running_total : 0;
939 if ((uint64_t)min_pl > cc_limit)
940 /*
941 * Congestion control does not allow us to send a packet of adequate
942 * size.
943 */
944 return TXP_ERR_SPACE;
945
946 /* MinPPL: Minimum plaintext payload length needed to meet MinPL. */
947 if (!txp_determine_ppl_from_pl(txp, min_pl, enc_level, hdr_len, &min_ppl))
948 /* MinPL is less than a valid packet size, so just use a MinPPL of 0. */
949 min_ppl = 0;
950
951 /* MDPL: Maximum datagram payload length. */
952 mdpl = txp_get_mdpl(txp);
953
954 /*
955 * CMPL: Maximum encoded packet size we can put into this datagram given any
956 * previous packets coalesced into it.
957 */
958 if (running_total > mdpl)
959 /* Should not be possible, but if it happens: */
960 cmpl = 0;
961 else
962 cmpl = mdpl - running_total;
963
964 /* Clamp CMPL based on congestion control limit. */
965 if (cmpl > cc_limit)
966 cmpl = cc_limit;
967
968 /* CMPPL: Maximum amount we can put into the current datagram payload. */
969 if (!txp_determine_ppl_from_pl(txp, cmpl, enc_level, hdr_len, &cmppl))
970 return TXP_ERR_SPACE;
971
972 /* Packet overhead (size of headers, AEAD tag, etc.) */
973 pkt_overhead = cmpl - cmppl;
974
975 return txp_generate_for_el_actual(txp, enc_level, archetype, min_ppl, cmppl,
7f9d1249
HL		 976 pkt_overhead, &phdr,
977 chosen_for_conn_close);
a73078b7
HL		 978}
979
980/* Determine how many bytes we should use for the encoded PN. */
981static size_t txp_determine_pn_len(OSSL_QUIC_TX_PACKETISER *txp)
982{
983 return 4; /* TODO(QUIC) */
984}
985
986/* Determine plaintext packet payload length from payload length. */
987static int txp_determine_ppl_from_pl(OSSL_QUIC_TX_PACKETISER *txp,
988 size_t pl,
989 uint32_t enc_level,
990 size_t hdr_len,
991 size_t *r)
992{
993 if (pl < hdr_len)
994 return 0;
995
996 pl -= hdr_len;
997
998 if (!ossl_qtx_calculate_plaintext_payload_len(txp->args.qtx, enc_level,
999 pl, &pl))
1000 return 0;
1001
1002 *r = pl;
1003 return 1;
1004}
1005
1006static size_t txp_get_mdpl(OSSL_QUIC_TX_PACKETISER *txp)
1007{
1008 return ossl_qtx_get_mdpl(txp->args.qtx);
1009}
1010
1011static QUIC_SSTREAM *get_sstream_by_id(uint64_t stream_id, uint32_t pn_space,
1012 void *arg)
1013{
1014 OSSL_QUIC_TX_PACKETISER *txp = arg;
1015 QUIC_STREAM *s;
1016
1017 if (stream_id == UINT64_MAX)
1018 return txp->args.crypto[pn_space];
1019
1020 s = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
1021 if (s == NULL)
1022 return NULL;
1023
1024 return s->sstream;
1025}
1026
1027static void on_regen_notify(uint64_t frame_type, uint64_t stream_id,
1028 QUIC_TXPIM_PKT *pkt, void *arg)
1029{
1030 OSSL_QUIC_TX_PACKETISER *txp = arg;
1031
1032 switch (frame_type) {
1033 case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
1034 txp->want_handshake_done = 1;
1035 break;
1036 case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
1037 txp->want_max_data = 1;
1038 break;
1039 case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI:
1040 txp->want_max_streams_bidi = 1;
1041 break;
1042 case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI:
1043 txp->want_max_streams_uni = 1;
1044 break;
1045 case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN:
1046 txp->want_ack |= (1UL << pkt->ackm_pkt.pkt_space);
1047 break;
1048 case OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA:
1049 {
1050 QUIC_STREAM *s
1051 = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
1052
1053 if (s == NULL)
1054 return;
1055
1056 s->want_max_stream_data = 1;
1057 ossl_quic_stream_map_update_state(txp->args.qsm, s);
1058 }
1059 break;
1060 case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
1061 {
1062 QUIC_STREAM *s
1063 = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
1064
1065 if (s == NULL)
1066 return;
1067
1068 s->want_stop_sending = 1;
1069 ossl_quic_stream_map_update_state(txp->args.qsm, s);
1070 }
1071 break;
1072 case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
1073 {
1074 QUIC_STREAM *s
1075 = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
1076
1077 if (s == NULL)
1078 return;
1079
1080 s->want_reset_stream = 1;
1081 ossl_quic_stream_map_update_state(txp->args.qsm, s);
1082 }
1083 break;
1084 default:
1085 assert(0);
1086 break;
1087 }
1088}
1089
1090static int txp_generate_pre_token(OSSL_QUIC_TX_PACKETISER *txp,
1091 struct tx_helper *h,
1092 QUIC_TXPIM_PKT *tpkt,
1093 uint32_t pn_space,
7f9d1249 1094 struct archetype_data *a,
091f532e 1095 int chosen_for_conn_close)
a73078b7
HL		 1096{
1097 const OSSL_QUIC_FRAME_ACK *ack;
1098 OSSL_QUIC_FRAME_ACK ack2;
1099
1100 tpkt->ackm_pkt.largest_acked = QUIC_PN_INVALID;
1101
1102 /* ACK Frames (Regenerate) */
1103 if (a->allow_ack
1104 && tx_helper_get_space_left(h) >= MIN_FRAME_SIZE_ACK
1105 && (txp->want_ack
1106 || ossl_ackm_is_ack_desired(txp->args.ackm, pn_space))
1107 && (ack = ossl_ackm_get_ack_frame(txp->args.ackm, pn_space)) != NULL) {
1108 WPACKET *wpkt = tx_helper_begin(h);
1109
1110 if (wpkt == NULL)
1111 return 0;
1112
1113 /* We do not currently support ECN */
1114 ack2 = *ack;
1115 ack2.ecn_present = 0;
1116
1117 if (ossl_quic_wire_encode_frame_ack(wpkt,
1118 txp->args.ack_delay_exponent,
1119 &ack2)) {
1120 if (!tx_helper_commit(h))
1121 return 0;
1122
1123 tpkt->had_ack_frame = 1;
1124
1125 if (ack->num_ack_ranges > 0)
1126 tpkt->ackm_pkt.largest_acked = ack->ack_ranges[0].end;
1127 } else {
1128 tx_helper_rollback(h);
1129 }
1130 }
1131
1132 /* CONNECTION_CLOSE Frames (Regenerate) */
7f9d1249 1133 if (a->allow_conn_close && txp->want_conn_close && chosen_for_conn_close) {
a73078b7
HL		 1134 WPACKET *wpkt = tx_helper_begin(h);
1135
1136 if (wpkt == NULL)
1137 return 0;
1138
1139 if (ossl_quic_wire_encode_frame_conn_close(wpkt,
1140 &txp->conn_close_frame)) {
1141 if (!tx_helper_commit(h))
1142 return 0;
1143 } else {
1144 tx_helper_rollback(h);
1145 }
1146 }
1147
1148 return 1;
1149}
1150
1151static int try_len(size_t space_left, size_t orig_len,
1152 size_t base_hdr_len, size_t lenbytes,
1153 uint64_t maxn, size_t *hdr_len, size_t *payload_len)
1154{
1155 size_t n;
1156 size_t maxn_ = maxn > SIZE_MAX ? SIZE_MAX : (size_t)maxn;
1157
1158 *hdr_len = base_hdr_len + lenbytes;
1159
cf06f347
HL		 1160 if (orig_len == 0 && space_left >= *hdr_len) {
1161 *payload_len = 0;
1162 return 1;
1163 }
1164
a73078b7
HL		 1165 n = orig_len;
1166 if (n > maxn_)
1167 n = maxn_;
1168 if (n + *hdr_len > space_left)
1169 n = (space_left >= *hdr_len) ? space_left - *hdr_len : 0;
1170
1171 *payload_len = n;
1172 return n > 0;
1173}
1174
cf06f347
HL		 1175static int determine_len(size_t space_left, size_t orig_len,
1176 size_t base_hdr_len,
1177 uint64_t *hlen, uint64_t *len)
a73078b7 1178{
cf06f347 1179 int ok = 0;
a73078b7
HL		 1180 size_t chosen_payload_len = 0;
1181 size_t chosen_hdr_len = 0;
1182 size_t payload_len[4], hdr_len[4];
1183 int i, valid[4] = {0};
1184
1185 valid[0] = try_len(space_left, orig_len, base_hdr_len,
1186 1, OSSL_QUIC_VLINT_1B_MAX,
1187 &hdr_len[0], &payload_len[0]);
1188 valid[1] = try_len(space_left, orig_len, base_hdr_len,
1189 2, OSSL_QUIC_VLINT_2B_MAX,
1190 &hdr_len[1], &payload_len[1]);
1191 valid[2] = try_len(space_left, orig_len, base_hdr_len,
1192 4, OSSL_QUIC_VLINT_4B_MAX,
1193 &hdr_len[2], &payload_len[2]);
1194 valid[3] = try_len(space_left, orig_len, base_hdr_len,
1195 8, OSSL_QUIC_VLINT_8B_MAX,
1196 &hdr_len[3], &payload_len[3]);
1197
1198 for (i = OSSL_NELEM(valid) - 1; i >= 0; --i)
1199 if (valid[i] && payload_len[i] >= chosen_payload_len) {
1200 chosen_payload_len = payload_len[i];
1201 chosen_hdr_len = hdr_len[i];
cf06f347 1202 ok = 1;
a73078b7
HL		 1203 }
1204
1205 *hlen = chosen_hdr_len;
1206 *len = chosen_payload_len;
cf06f347 1207 return ok;
a73078b7
HL		 1208}
1209
1210/*
1211 * Given a CRYPTO frame header with accurate chdr->len and a budget
1212 * (space_left), try to find the optimal value of chdr->len to fill as much of
1213 * the budget as possible. This is slightly hairy because larger values of
1214 * chdr->len cause larger encoded sizes of the length field of the frame, which
1215 * in turn mean less space available for payload data. We check all possible
1216 * encodings and choose the optimal encoding.
1217 */
1218static int determine_crypto_len(struct tx_helper *h,
1219 OSSL_QUIC_FRAME_CRYPTO *chdr,
1220 size_t space_left,
1221 uint64_t *hlen,
1222 uint64_t *len)
1223{
1224 size_t orig_len;
1225 size_t base_hdr_len; /* CRYPTO header length without length field */
1226
1227 if (chdr->len > SIZE_MAX)
1228 return 0;
1229
1230 orig_len = (size_t)chdr->len;
1231
1232 chdr->len = 0;
1233 base_hdr_len = ossl_quic_wire_get_encoded_frame_len_crypto_hdr(chdr);
1234 chdr->len = orig_len;
1235 if (base_hdr_len == 0)
1236 return 0;
1237
1238 --base_hdr_len;
1239
cf06f347 1240 return determine_len(space_left, orig_len, base_hdr_len, hlen, len);
a73078b7
HL		 1241}
1242
1243static int determine_stream_len(struct tx_helper *h,
1244 OSSL_QUIC_FRAME_STREAM *shdr,
1245 size_t space_left,
1246 uint64_t *hlen,
1247 uint64_t *len)
1248{
1249 size_t orig_len;
1250 size_t base_hdr_len; /* STREAM header length without length field */
1251
1252 if (shdr->len > SIZE_MAX)
1253 return 0;
1254
1255 orig_len = (size_t)shdr->len;
1256
1257 shdr->len = 0;
1258 base_hdr_len = ossl_quic_wire_get_encoded_frame_len_stream_hdr(shdr);
1259 shdr->len = orig_len;
1260 if (base_hdr_len == 0)
1261 return 0;
1262
1263 if (shdr->has_explicit_len)
1264 --base_hdr_len;
1265
cf06f347 1266 return determine_len(space_left, orig_len, base_hdr_len, hlen, len);
a73078b7
HL		 1267}
1268
1269static int txp_generate_crypto_frames(OSSL_QUIC_TX_PACKETISER *txp,
1270 struct tx_helper *h,
1271 uint32_t pn_space,
1272 QUIC_TXPIM_PKT *tpkt,
091f532e 1273 int *have_ack_eliciting)
a73078b7
HL		 1274{
1275 size_t num_stream_iovec;
1276 OSSL_QUIC_FRAME_STREAM shdr = {0};
1277 OSSL_QUIC_FRAME_CRYPTO chdr = {0};
1278 OSSL_QTX_IOVEC iov[2];
1279 uint64_t hdr_bytes;
1280 WPACKET *wpkt;
24c1be5c 1281 QUIC_TXPIM_CHUNK chunk = {0};
a73078b7
HL		 1282 size_t i, space_left;
1283
1284 for (i = 0;; ++i) {
1285 space_left = tx_helper_get_space_left(h);
1286
1287 if (space_left < MIN_FRAME_SIZE_CRYPTO)
1288 return 1; /* no point trying */
1289
1290 /* Do we have any CRYPTO data waiting? */
1291 num_stream_iovec = OSSL_NELEM(iov);
1292 if (!ossl_quic_sstream_get_stream_frame(txp->args.crypto[pn_space],
1293 i, &shdr, iov,
1294 &num_stream_iovec))
1295 return 1; /* nothing to do */
1296
1297 /* Convert STREAM frame header to CRYPTO frame header */
1298 chdr.offset = shdr.offset;
1299 chdr.len = shdr.len;
1300
1301 if (chdr.len == 0)
1302 return 1; /* nothing to do */
1303
1304 /* Find best fit (header length, payload length) combination. */
1305 if (!determine_crypto_len(h, &chdr, space_left, &hdr_bytes,
cf06f347 1306 &chdr.len))
a73078b7 1307 return 1; /* can't fit anything */
a73078b7
HL		 1308
1309 /*
1310 * Truncate IOVs to match our chosen length.
1311 *
1312 * The length cannot be more than SIZE_MAX because this length comes
1313 * from our send stream buffer.
1314 */
1315 ossl_quic_sstream_adjust_iov((size_t)chdr.len, iov, num_stream_iovec);
1316
1317 /*
1318 * Ensure we have enough iovecs allocated (1 for the header, up to 2 for
1319 * the the stream data.)
1320 */
1321 if (!txp_ensure_iovec(txp, h->num_iovec + 3))
1322 return 0; /* alloc error */
1323
1324 /* Encode the header. */
1325 wpkt = tx_helper_begin(h);
1326 if (wpkt == NULL)
1327 return 0; /* alloc error */
1328
1329 if (!ossl_quic_wire_encode_frame_crypto_hdr(wpkt, &chdr)) {
1330 tx_helper_rollback(h);
1331 return 1; /* can't fit */
1332 }
1333
1334 if (!tx_helper_commit(h))
1335 return 0; /* alloc error */
1336
1337 /* Add payload iovecs to the helper (infallible). */
1338 for (i = 0; i < num_stream_iovec; ++i)
1339 tx_helper_append_iovec(h, iov[i].buf, iov[i].buf_len);
1340
1341 *have_ack_eliciting = 1;
1342 tx_helper_unrestrict(h); /* no longer need PING */
1343
1344 /* Log chunk to TXPIM. */
1345 chunk.stream_id = UINT64_MAX; /* crypto stream */
1346 chunk.start = chdr.offset;
1347 chunk.end = chdr.offset + chdr.len - 1;
1348 chunk.has_fin = 0; /* Crypto stream never ends */
1349 if (!ossl_quic_txpim_pkt_append_chunk(tpkt, &chunk))
1350 return 0; /* alloc error */
1351 }
1352}
1353
1354struct chunk_info {
1355 OSSL_QUIC_FRAME_STREAM shdr;
1356 OSSL_QTX_IOVEC iov[2];
1357 size_t num_stream_iovec;
091f532e 1358 int valid;
a73078b7
HL		 1359};
1360
1361static int txp_plan_stream_chunk(OSSL_QUIC_TX_PACKETISER *txp,
1362 struct tx_helper *h,
1363 QUIC_SSTREAM *sstream,
1364 QUIC_TXFC *stream_txfc,
1365 size_t skip,
1366 struct chunk_info *chunk)
1367{
1368 uint64_t fc_credit, fc_swm, fc_limit;
1369
1370 chunk->num_stream_iovec = OSSL_NELEM(chunk->iov);
1371 chunk->valid = ossl_quic_sstream_get_stream_frame(sstream, skip,
1372 &chunk->shdr,
1373 chunk->iov,
1374 &chunk->num_stream_iovec);
1375 if (!chunk->valid)
1376 return 1;
1377
1378 if (!ossl_assert(chunk->shdr.len > 0 || chunk->shdr.is_fin))
1379 /* Should only have 0-length chunk if FIN */
1380 return 0;
1381
1382 /* Clamp according to connection and stream-level TXFC. */
1383 fc_credit = ossl_quic_txfc_get_credit(stream_txfc);
1384 fc_swm = ossl_quic_txfc_get_swm(stream_txfc);
1385 fc_limit = fc_swm + fc_credit;
1386
1387 if (chunk->shdr.len > 0 && chunk->shdr.offset + chunk->shdr.len > fc_limit) {
1388 chunk->shdr.len = (fc_limit <= chunk->shdr.offset)
1389 ? 0 : fc_limit - chunk->shdr.offset;
1390 chunk->shdr.is_fin = 0;
1391 }
1392
1393 if (chunk->shdr.len == 0 && !chunk->shdr.is_fin) {
1394 /*
1395 * Nothing to do due to TXFC. Since SSTREAM returns chunks in ascending
1396 * order of offset we don't need to check any later chunks, so stop
1397 * iterating here.
1398 */
1399 chunk->valid = 0;
1400 return 1;
1401 }
1402
1403 return 1;
1404}
1405
1406/*
1407 * Returns 0 on fatal error (e.g. allocation failure), 1 on success.
1408 * *packet_full is set to 1 if there is no longer enough room for another STREAM
1409 * frame, and *stream_drained is set to 1 if all stream buffers have now been
1410 * sent.
1411 */
1412static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
1413 struct tx_helper *h,
1414 uint32_t pn_space,
1415 QUIC_TXPIM_PKT *tpkt,
1416 uint64_t id,
1417 QUIC_SSTREAM *sstream,
1418 QUIC_TXFC *stream_txfc,
1419 QUIC_STREAM *next_stream,
1420 size_t min_ppl,
091f532e
HL		 1421 int *have_ack_eliciting,
1422 int *packet_full,
1423 int *stream_drained,
a73078b7
HL		 1424 uint64_t *new_credit_consumed)
1425{
1426 int rc = 0;
1427 struct chunk_info chunks[2] = {0};
1428
1429 OSSL_QUIC_FRAME_STREAM *shdr;
1430 WPACKET *wpkt;
1431 QUIC_TXPIM_CHUNK chunk;
1432 size_t i, j, space_left;
1433 int needs_padding_if_implicit, can_fill_payload, use_explicit_len;
1434 int could_have_following_chunk;
05f97354 1435 uint64_t orig_len;
a73078b7
HL		 1436 uint64_t hdr_len_implicit, payload_len_implicit;
1437 uint64_t hdr_len_explicit, payload_len_explicit;
1438 uint64_t fc_swm, fc_new_hwm;
1439
1440 fc_swm = ossl_quic_txfc_get_swm(stream_txfc);
1441 fc_new_hwm = fc_swm;
1442
1443 /*
1444 * Load the first two chunks if any offered by the send stream. We retrieve
1445 * the next chunk in advance so we can determine if we need to send any more
1446 * chunks from the same stream after this one, which is needed when
1447 * determining when we can use an implicit length in a STREAM frame.
1448 */
1449 for (i = 0; i < 2; ++i) {
1450 if (!txp_plan_stream_chunk(txp, h, sstream, stream_txfc, i, &chunks[i]))
1451 goto err;
1452
1453 if (i == 0 && !chunks[i].valid) {
1454 /* No chunks, nothing to do. */
1455 *stream_drained = 1;
1456 rc = 1;
1457 goto err;
1458 }
1459 }
1460
1461 for (i = 0;; ++i) {
1462 space_left = tx_helper_get_space_left(h);
1463
cf06f347
HL		 1464 if (!chunks[i % 2].valid) {
1465 /* Out of chunks; we're done. */
1466 *stream_drained = 1;
a73078b7
HL		 1467 rc = 1;
1468 goto err;
1469 }
1470
cf06f347
HL		 1471 if (space_left < MIN_FRAME_SIZE_STREAM) {
1472 *packet_full = 1;
a73078b7
HL		 1473 rc = 1;
1474 goto err;
1475 }
1476
1477 if (!ossl_assert(!h->done_implicit))
1478 /*
1479 * Logic below should have ensured we didn't append an
1480 * implicit-length unless we filled the packet or didn't have
1481 * another stream to handle, so this should not be possible.
1482 */
1483 goto err;
1484
1485 shdr = &chunks[i % 2].shdr;
05f97354 1486 orig_len = shdr->len;
a73078b7
HL		 1487 if (i > 0)
1488 /* Load next chunk for lookahead. */
1489 if (!txp_plan_stream_chunk(txp, h, sstream, stream_txfc, i + 1,
1490 &chunks[(i + 1) % 2]))
1491 goto err;
1492
1493 /*
1494 * Find best fit (header length, payload length) combination for if we
1495 * use an implicit length.
1496 */
1497 shdr->has_explicit_len = 0;
1498 hdr_len_implicit = payload_len_implicit = 0;
1499 if (!determine_stream_len(h, shdr, space_left,
cf06f347 1500 &hdr_len_implicit, &payload_len_implicit)) {
a73078b7
HL		 1501 *packet_full = 1;
1502 rc = 1;
1503 goto err; /* can't fit anything */
1504 }
1505
1506 /*
1507 * If using the implicit-length representation would need padding, we
1508 * can't use it.
1509 */
1510 needs_padding_if_implicit = (h->bytes_appended + hdr_len_implicit
1511 + payload_len_implicit < min_ppl);
1512
1513 /*
1514 * If there is a next stream, we don't use the implicit length so we can
1515 * add more STREAM frames after this one, unless there is enough data
1516 * for this STREAM frame to fill the packet.
1517 */
1518 can_fill_payload = (hdr_len_implicit + payload_len_implicit
1519 >= space_left);
1520
1521 /*
1522 * Is there is a stream after this one, or another chunk pending
1523 * transmission in this stream?
1524 */
1525 could_have_following_chunk
1526 = (next_stream != NULL || chunks[(i + 1) % 2].valid);
1527
1528 /* Choose between explicit or implicit length representations. */
1529 use_explicit_len = !((can_fill_payload || !could_have_following_chunk)
1530 && !needs_padding_if_implicit);
1531
1532 if (use_explicit_len) {
1533 /*
1534 * Find best fit (header length, payload length) combination for if
1535 * we use an explicit length.
1536 */
1537 shdr->has_explicit_len = 1;
1538 hdr_len_explicit = payload_len_explicit = 0;
1539 if (!determine_stream_len(h, shdr, space_left,
cf06f347 1540 &hdr_len_explicit, &payload_len_explicit)) {
a73078b7
HL		 1541 *packet_full = 1;
1542 rc = 1;
1543 goto err; /* can't fit anything */
1544 }
1545
1546 shdr->len = payload_len_explicit;
1547 } else {
1548 shdr->has_explicit_len = 0;
1549 shdr->len = payload_len_implicit;
1550 }
1551
cf06f347
HL		 1552 /* If this is a FIN, don't keep filling the packet with more FINs. */
1553 if (shdr->is_fin)
1554 chunks[(i + 1) % 2].valid = 0;
1555
a73078b7
HL		 1556 /* Truncate IOVs to match our chosen length. */
1557 ossl_quic_sstream_adjust_iov((size_t)shdr->len, chunks[i % 2].iov,
1558 chunks[i % 2].num_stream_iovec);
1559
1560 /*
1561 * Ensure we have enough iovecs allocated (1 for the header, up to 2 for
1562 * the the stream data.)
1563 */
1564 if (!txp_ensure_iovec(txp, h->num_iovec + 3))
1565 goto err; /* alloc error */
1566
1567 /* Encode the header. */
1568 wpkt = tx_helper_begin(h);
1569 if (wpkt == NULL)
1570 goto err; /* alloc error */
1571
1572 shdr->stream_id = id;
1573 if (!ossl_assert(ossl_quic_wire_encode_frame_stream_hdr(wpkt, shdr))) {
1574 /* (Should not be possible.) */
1575 tx_helper_rollback(h);
1576 *packet_full = 1;
1577 rc = 1;
1578 goto err; /* can't fit */
1579 }
1580
1581 if (!tx_helper_commit(h))
1582 goto err; /* alloc error */
1583
1584 /* Add payload iovecs to the helper (infallible). */
1585 for (j = 0; j < chunks[i % 2].num_stream_iovec; ++j)
1586 tx_helper_append_iovec(h, chunks[i % 2].iov[j].buf,
1587 chunks[i % 2].iov[j].buf_len);
1588
1589 *have_ack_eliciting = 1;
1590 tx_helper_unrestrict(h); /* no longer need PING */
1591 if (!shdr->has_explicit_len)
1592 h->done_implicit = 1;
1593
1594 /* Log new TXFC credit which was consumed. */
1595 if (shdr->len > 0 && shdr->offset + shdr->len > fc_new_hwm)
1596 fc_new_hwm = shdr->offset + shdr->len;
1597
1598 /* Log chunk to TXPIM. */
1599 chunk.stream_id = shdr->stream_id;
1600 chunk.start = shdr->offset;
1601 chunk.end = shdr->offset + shdr->len - 1;
1602 chunk.has_fin = shdr->is_fin;
1603 chunk.has_stop_sending = 0;
1604 chunk.has_reset_stream = 0;
1605 if (!ossl_quic_txpim_pkt_append_chunk(tpkt, &chunk))
1606 goto err; /* alloc error */
05f97354
HL		 1607
1608 if (shdr->len < orig_len) {
1609 /*
1610 * If we did not serialize all of this chunk we definitely do not
1611 * want to try the next chunk (and we must not mark the stream
1612 * as drained).
1613 */
1614 rc = 1;
1615 goto err;
1616 }
a73078b7
HL		 1617 }
1618
1619err:
1620 *new_credit_consumed = fc_new_hwm - fc_swm;
1621 return rc;
1622}
1623
1624static void txp_enlink_tmp(QUIC_STREAM **tmp_head, QUIC_STREAM *stream)
1625{
1626 stream->txp_next = *tmp_head;
1627 *tmp_head = stream;
1628}
1629
1630static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
1631 struct tx_helper *h,
1632 uint32_t pn_space,
1633 QUIC_TXPIM_PKT *tpkt,
1634 size_t min_ppl,
091f532e 1635 int *have_ack_eliciting,
a73078b7
HL		 1636 QUIC_STREAM **tmp_head)
1637{
1638 QUIC_STREAM_ITER it;
1639 void *rstream;
1640 WPACKET *wpkt;
1641 uint64_t cwm;
1642 QUIC_STREAM *stream, *snext;
1643
1644 for (ossl_quic_stream_iter_init(&it, txp->args.qsm, 1);
1645 it.stream != NULL;) {
1646
1647 stream = it.stream;
1648 ossl_quic_stream_iter_next(&it);
1649 snext = it.stream;
1650
1651 stream->txp_sent_fc = 0;
1652 stream->txp_sent_stop_sending = 0;
1653 stream->txp_sent_reset_stream = 0;
1654 stream->txp_drained = 0;
1655 stream->txp_blocked = 0;
1656 stream->txp_txfc_new_credit_consumed = 0;
1657
1658 rstream = stream->rstream;
1659
1660 /* Stream Abort Frames (STOP_SENDING, RESET_STREAM) */
1661 if (stream->want_stop_sending) {
1662 OSSL_QUIC_FRAME_STOP_SENDING f;
1663
1664 wpkt = tx_helper_begin(h);
1665 if (wpkt == NULL)
1666 return 0; /* alloc error */
1667
1668 f.stream_id = stream->id;
1669 f.app_error_code = stream->stop_sending_aec;
1670 if (!ossl_quic_wire_encode_frame_stop_sending(wpkt, &f)) {
1671 tx_helper_rollback(h); /* can't fit */
1672 txp_enlink_tmp(tmp_head, stream);
1673 break;
1674 }
1675
1676 if (!tx_helper_commit(h))
1677 return 0; /* alloc error */
1678
1679 *have_ack_eliciting = 1;
1680 tx_helper_unrestrict(h); /* no longer need PING */
1681 stream->txp_sent_stop_sending = 1;
1682 }
1683
1684 if (stream->want_reset_stream) {
1685 OSSL_QUIC_FRAME_RESET_STREAM f;
1686
1687 wpkt = tx_helper_begin(h);
1688 if (wpkt == NULL)
1689 return 0; /* alloc error */
1690
1691 f.stream_id = stream->id;
1692 f.app_error_code = stream->reset_stream_aec;
1693 f.final_size = ossl_quic_sstream_get_cur_size(stream->sstream);
1694 if (!ossl_quic_wire_encode_frame_reset_stream(wpkt, &f)) {
1695 tx_helper_rollback(h); /* can't fit */
1696 txp_enlink_tmp(tmp_head, stream);
1697 break;
1698 }
1699
1700 if (!tx_helper_commit(h))
1701 return 0; /* alloc error */
1702
1703 *have_ack_eliciting = 1;
1704 tx_helper_unrestrict(h); /* no longer need PING */
1705 stream->txp_sent_reset_stream = 1;
1706 }
1707
1708 /* Stream Flow Control Frames (MAX_STREAM_DATA) */
1709 if (rstream != NULL
1710 && (stream->want_max_stream_data
1711 || ossl_quic_rxfc_has_cwm_changed(&stream->rxfc, 0))) {
1712
1713 wpkt = tx_helper_begin(h);
1714 if (wpkt == NULL)
1715 return 0; /* alloc error */
1716
1717 cwm = ossl_quic_rxfc_get_cwm(&stream->rxfc);
1718
1719 if (!ossl_quic_wire_encode_frame_max_stream_data(wpkt, stream->id,
1720 cwm)) {
1721 tx_helper_rollback(h); /* can't fit */
1722 txp_enlink_tmp(tmp_head, stream);
1723 break;
1724 }
1725
1726 if (!tx_helper_commit(h))
1727 return 0; /* alloc error */
1728
1729 *have_ack_eliciting = 1;
1730 tx_helper_unrestrict(h); /* no longer need PING */
1731 stream->txp_sent_fc = 1;
1732 }
1733
1734 /* Stream Data Frames (STREAM) */
1735 if (stream->sstream != NULL) {
091f532e 1736 int packet_full = 0, stream_drained = 0;
a73078b7
HL		 1737
1738 if (!txp_generate_stream_frames(txp, h, pn_space, tpkt,
1739 stream->id, stream->sstream,
1740 &stream->txfc,
1741 snext, min_ppl,
1742 have_ack_eliciting,
1743 &packet_full,
1744 &stream_drained,
1745 &stream->txp_txfc_new_credit_consumed)) {
1746 /* Fatal error (allocation, etc.) */
1747 txp_enlink_tmp(tmp_head, stream);
1748 return 0;
1749 }
1750
1751 if (stream_drained)
1752 stream->txp_drained = 1;
1753
1754 if (packet_full) {
1755 txp_enlink_tmp(tmp_head, stream);
1756 break;
1757 }
1758 }
1759
1760 txp_enlink_tmp(tmp_head, stream);
1761 }
1762
1763 return 1;
1764}
1765
1766/*
1767 * Generates a packet for a given EL with the given minimum and maximum
1768 * plaintext packet payload lengths. Returns TXP_ERR_* value.
1769 */
1770static int txp_generate_for_el_actual(OSSL_QUIC_TX_PACKETISER *txp,
1771 uint32_t enc_level,
1772 uint32_t archetype,
1773 size_t min_ppl,
1774 size_t max_ppl,
1775 size_t pkt_overhead,
7f9d1249 1776 QUIC_PKT_HDR *phdr,
091f532e 1777 int chosen_for_conn_close)
a73078b7
HL		 1778{
1779 int rc = TXP_ERR_SUCCESS;
1780 struct archetype_data a;
1781 uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level);
1782 struct tx_helper h;
091f532e
HL		 1783 int have_helper = 0, have_ack_eliciting = 0, done_pre_token = 0;
1784 int require_ack_eliciting;
a73078b7
HL		 1785 QUIC_CFQ_ITEM *cfq_item;
1786 QUIC_TXPIM_PKT *tpkt = NULL;
1787 OSSL_QTX_PKT pkt;
1788 QUIC_STREAM *tmp_head = NULL, *stream;
1789
1790 if (!txp_get_archetype_data(enc_level, archetype, &a))
1791 goto fatal_err;
1792
1793 require_ack_eliciting
1794 = (a.allow_force_ack_eliciting
1795 && (txp->force_ack_eliciting & (1UL << pn_space)));
1796
1797 /* Minimum cannot be bigger than maximum. */
1798 if (min_ppl > max_ppl)
1799 goto fatal_err;
1800
1801 /* Maximum PN reached? */
1802 if (txp->next_pn[pn_space] >= (((QUIC_PN)1) << 62))
1803 goto fatal_err;
1804
1805 if ((tpkt = ossl_quic_txpim_pkt_alloc(txp->args.txpim)) == NULL)
1806 goto fatal_err;
1807
1808 /*
1809 * Initialise TX helper. If we must be ACK eliciting, reserve 1 byte for
1810 * PING.
1811 */
1812 if (!tx_helper_init(&h, txp, max_ppl, require_ack_eliciting ? 1 : 0))
1813 goto fatal_err;
1814
1815 have_helper = 1;
1816
1817 /*
1818 * Frame Serialization
1819 * ===================
1820 *
1821 * We now serialize frames into the packet in descending order of priority.
1822 */
1823
1824 /* HANDSHAKE_DONE (Regenerate) */
1825 if (a.allow_handshake_done && txp->want_handshake_done
1826 && tx_helper_get_space_left(&h) >= MIN_FRAME_SIZE_HANDSHAKE_DONE) {
1827 WPACKET *wpkt = tx_helper_begin(&h);
1828
1829 if (wpkt == NULL)
1830 goto fatal_err;
1831
1832 if (ossl_quic_wire_encode_frame_handshake_done(wpkt)) {
1833 tpkt->had_handshake_done_frame = 1;
1834 have_ack_eliciting = 1;
1835
1836 if (!tx_helper_commit(&h))
1837 goto fatal_err;
1838
1839 tx_helper_unrestrict(&h); /* no longer need PING */
1840 } else {
1841 tx_helper_rollback(&h);
1842 }
1843 }
1844
1845 /* MAX_DATA (Regenerate) */
1846 if (a.allow_conn_fc
1847 && (txp->want_max_data
1848 || ossl_quic_rxfc_has_cwm_changed(txp->args.conn_rxfc, 0))
1849 && tx_helper_get_space_left(&h) >= MIN_FRAME_SIZE_MAX_DATA) {
1850 WPACKET *wpkt = tx_helper_begin(&h);
1851 uint64_t cwm = ossl_quic_rxfc_get_cwm(txp->args.conn_rxfc);
1852
1853 if (wpkt == NULL)
1854 goto fatal_err;
1855
1856 if (ossl_quic_wire_encode_frame_max_data(wpkt, cwm)) {
1857 tpkt->had_max_data_frame = 1;
1858 have_ack_eliciting = 1;
1859
1860 if (!tx_helper_commit(&h))
1861 goto fatal_err;
1862
1863 tx_helper_unrestrict(&h); /* no longer need PING */
1864 } else {
1865 tx_helper_rollback(&h);
1866 }
1867 }
1868
1869 /* MAX_STREAMS_BIDI (Regenerate) */
1870 /*
1871 * TODO(STREAMS): Once we support multiple streams, add stream count FC
1872 * and plug this in.
1873 */
1874 if (a.allow_conn_fc
1875 && txp->want_max_streams_bidi
1876 && tx_helper_get_space_left(&h) >= MIN_FRAME_SIZE_MAX_STREAMS_BIDI) {
1877 WPACKET *wpkt = tx_helper_begin(&h);
1878 uint64_t max_streams = 1; /* TODO */
1879
1880 if (wpkt == NULL)
1881 goto fatal_err;
1882
1883 if (ossl_quic_wire_encode_frame_max_streams(wpkt, /*is_uni=*/0,
1884 max_streams)) {
1885 tpkt->had_max_streams_bidi_frame = 1;
1886 have_ack_eliciting = 1;
1887
1888 if (!tx_helper_commit(&h))
1889 goto fatal_err;
1890
1891 tx_helper_unrestrict(&h); /* no longer need PING */
1892 } else {
1893 tx_helper_rollback(&h);
1894 }
1895 }
1896
1897 /* MAX_STREAMS_UNI (Regenerate) */
1898 if (a.allow_conn_fc
1899 && txp->want_max_streams_uni
1900 && tx_helper_get_space_left(&h) >= MIN_FRAME_SIZE_MAX_STREAMS_UNI) {
1901 WPACKET *wpkt = tx_helper_begin(&h);
1902 uint64_t max_streams = 0; /* TODO */
1903
1904 if (wpkt == NULL)
1905 goto fatal_err;
1906
1907 if (ossl_quic_wire_encode_frame_max_streams(wpkt, /*is_uni=*/1,
1908 max_streams)) {
1909 tpkt->had_max_streams_uni_frame = 1;
1910 have_ack_eliciting = 1;
1911
1912 if (!tx_helper_commit(&h))
1913 goto fatal_err;
1914
1915 tx_helper_unrestrict(&h); /* no longer need PING */
1916 } else {
1917 tx_helper_rollback(&h);
1918 }
1919 }
1920
1921 /* GCR Frames */
1922 for (cfq_item = ossl_quic_cfq_get_priority_head(txp->args.cfq, pn_space);
1923 cfq_item != NULL;
1924 cfq_item = ossl_quic_cfq_item_get_priority_next(cfq_item, pn_space)) {
1925 uint64_t frame_type = ossl_quic_cfq_item_get_frame_type(cfq_item);
1926 const unsigned char *encoded = ossl_quic_cfq_item_get_encoded(cfq_item);
1927 size_t encoded_len = ossl_quic_cfq_item_get_encoded_len(cfq_item);
1928
1929 switch (frame_type) {
1930 case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
1931 if (!a.allow_new_conn_id)
1932 continue;
1933 break;
1934 case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID:
1935 if (!a.allow_retire_conn_id)
1936 continue;
1937 break;
1938 case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
1939 if (!a.allow_new_token)
1940 continue;
1941
1942 /*
1943 * NEW_TOKEN frames are handled via GCR, but some
1944 * Regenerate-strategy frames should come before them (namely
1945 * ACK, CONNECTION_CLOSE, PATH_CHALLENGE and PATH_RESPONSE). If
1946 * we find a NEW_TOKEN frame, do these now. If there are no
1947 * NEW_TOKEN frames in the GCR queue we will handle these below.
1948 */
1949 if (!done_pre_token)
7f9d1249
HL		 1950 if (txp_generate_pre_token(txp, &h, tpkt, pn_space, &a,
1951 chosen_for_conn_close))
a73078b7
HL		 1952 done_pre_token = 1;
1953
1954 break;
1955 default:
1956 if (!a.allow_cfq_other)
1957 continue;
1958 break;
1959 }
1960
1961 /*
1962 * If the frame is too big, don't try to schedule any more GCR frames in
1963 * this packet rather than sending subsequent ones out of order.
1964 */
1965 if (encoded_len > tx_helper_get_space_left(&h))
1966 break;
1967
1968 if (!tx_helper_append_iovec(&h, encoded, encoded_len))
1969 goto fatal_err;
1970
1971 ossl_quic_txpim_pkt_add_cfq_item(tpkt, cfq_item);
1972
1973 if (ossl_quic_frame_type_is_ack_eliciting(frame_type)) {
1974 have_ack_eliciting = 1;
1975 tx_helper_unrestrict(&h); /* no longer need PING */
1976 }
1977 }
1978
1979 /*
1980 * If we didn't generate ACK, CONNECTION_CLOSE, PATH_CHALLENGE or
1981 * PATH_RESPONSE (as desired) before, do so now.
1982 */
1983 if (!done_pre_token)
7f9d1249
HL		 1984 if (txp_generate_pre_token(txp, &h, tpkt, pn_space, &a,
1985 chosen_for_conn_close))
a73078b7
HL		 1986 done_pre_token = 1;
1987
1988 /* CRYPTO Frames */
1989 if (a.allow_crypto)
1990 if (!txp_generate_crypto_frames(txp, &h, pn_space, tpkt,
1991 &have_ack_eliciting))
1992 goto fatal_err;
1993
1994 /* Stream-specific frames */
cda88baf 1995 if (a.allow_stream_rel && txp->handshake_complete)
a73078b7
HL		 1996 if (!txp_generate_stream_related(txp, &h, pn_space, tpkt, min_ppl,
1997 &have_ack_eliciting,
1998 &tmp_head))
1999 goto fatal_err;
2000
2001 /* PING */
2002 tx_helper_unrestrict(&h);
2003
2004 if (require_ack_eliciting && !have_ack_eliciting && a.allow_ping) {
2005 WPACKET *wpkt;
2006
2007 wpkt = tx_helper_begin(&h);
2008 if (wpkt == NULL)
2009 goto fatal_err;
2010
2011 if (!ossl_quic_wire_encode_frame_ping(wpkt)
2012 || !tx_helper_commit(&h))
2013 /*
2014 * We treat a request to be ACK-eliciting as a requirement, so this
2015 * is an error.
2016 */
2017 goto fatal_err;
2018
2019 have_ack_eliciting = 1;
2020 }
2021
2022 /* PADDING */
2023 if (h.bytes_appended < min_ppl) {
2024 WPACKET *wpkt = tx_helper_begin(&h);
2025 if (wpkt == NULL)
2026 goto fatal_err;
2027
2028 if (!ossl_quic_wire_encode_padding(wpkt, min_ppl - h.bytes_appended)
2029 || !tx_helper_commit(&h))
2030 goto fatal_err;
2031 }
2032
2033 /*
2034 * Dispatch
2035 * ========
2036 */
2037 /* ACKM Data */
2038 tpkt->ackm_pkt.num_bytes = h.bytes_appended + pkt_overhead;
2039 tpkt->ackm_pkt.pkt_num = txp->next_pn[pn_space];
2040 /* largest_acked is set in txp_generate_pre_token */
2041 tpkt->ackm_pkt.pkt_space = pn_space;
2042 tpkt->ackm_pkt.is_inflight = 1;
2043 tpkt->ackm_pkt.is_ack_eliciting = have_ack_eliciting;
2044 tpkt->ackm_pkt.is_pto_probe = 0;
2045 tpkt->ackm_pkt.is_mtu_probe = 0;
2046 tpkt->ackm_pkt.time = ossl_time_now();
2047
2048 /* Packet Information for QTX */
2049 pkt.hdr = phdr;
2050 pkt.iovec = txp->iovec;
2051 pkt.num_iovec = h.num_iovec;
2052 pkt.local = NULL;
2053 pkt.peer = BIO_ADDR_family(&txp->args.peer) == AF_UNSPEC
2054 ? NULL : &txp->args.peer;
2055 pkt.pn = txp->next_pn[pn_space];
2056 pkt.flags = OSSL_QTX_PKT_FLAG_COALESCE; /* always try to coalesce */
2057
2058 /* Do TX key update if needed. */
2059 if (enc_level == QUIC_ENC_LEVEL_1RTT) {
2060 uint64_t cur_pkt_count, max_pkt_count;
2061
2062 cur_pkt_count = ossl_qtx_get_cur_epoch_pkt_count(txp->args.qtx, enc_level);
2063 max_pkt_count = ossl_qtx_get_max_epoch_pkt_count(txp->args.qtx, enc_level);
2064
2065 if (cur_pkt_count >= max_pkt_count / 2)
2066 if (!ossl_qtx_trigger_key_update(txp->args.qtx))
2067 goto fatal_err;
2068 }
2069
2070 if (!ossl_assert(h.bytes_appended > 0))
2071 goto fatal_err;
2072
2073 /* Generate TXPIM chunks representing STOP_SENDING and RESET_STREAM frames. */
2074 for (stream = tmp_head; stream != NULL; stream = stream->txp_next)
2075 if (stream->txp_sent_stop_sending || stream->txp_sent_reset_stream) {
2076 /* Log STOP_SENDING chunk to TXPIM. */
2077 QUIC_TXPIM_CHUNK chunk;
2078
2079 chunk.stream_id = stream->id;
2080 chunk.start = UINT64_MAX;
2081 chunk.end = 0;
2082 chunk.has_fin = 0;
2083 chunk.has_stop_sending = stream->txp_sent_stop_sending;
2084 chunk.has_reset_stream = stream->txp_sent_reset_stream;
2085 if (!ossl_quic_txpim_pkt_append_chunk(tpkt, &chunk))
2086 return 0; /* alloc error */
2087 }
2088
2089 /* Dispatch to FIFD. */
2090 if (!ossl_quic_fifd_pkt_commit(&txp->fifd, tpkt))
2091 goto fatal_err;
2092
2093 /* Send the packet. */
2094 if (!ossl_qtx_write_pkt(txp->args.qtx, &pkt))
2095 goto fatal_err;
2096
2097 ++txp->next_pn[pn_space];
2098
2099 /*
2100 * Record FC and stream abort frames as sent; deactivate streams which no
2101 * longer have anything to do.
2102 */
2103 for (stream = tmp_head; stream != NULL; stream = stream->txp_next) {
2104 if (stream->txp_sent_fc) {
2105 stream->want_max_stream_data = 0;
2106 ossl_quic_rxfc_has_cwm_changed(&stream->rxfc, 1);
2107 }
2108
2109 if (stream->txp_sent_stop_sending)
2110 stream->want_stop_sending = 0;
2111
2112 if (stream->txp_sent_reset_stream)
2113 stream->want_reset_stream = 0;
2114
2115 if (stream->txp_txfc_new_credit_consumed > 0) {
2116 if (!ossl_assert(ossl_quic_txfc_consume_credit(&stream->txfc,
2117 stream->txp_txfc_new_credit_consumed)))
2118 /*
2119 * Should not be possible, but we should continue with our
2120 * bookkeeping as we have already committed the packet to the
2121 * FIFD. Just change the value we return.
2122 */
2123 rc = TXP_ERR_INTERNAL;
2124
2125 stream->txp_txfc_new_credit_consumed = 0;
2126 }
2127
2128 /*
2129 * If we no longer need to generate any flow control (MAX_STREAM_DATA),
2130 * STOP_SENDING or RESET_STREAM frames, nor any STREAM frames (because
2131 * the stream is drained of data or TXFC-blocked), we can mark the
2132 * stream as inactive.
2133 */
2134 ossl_quic_stream_map_update_state(txp->args.qsm, stream);
2135
05f97354
HL		 2136 if (stream->txp_drained)
2137 assert(!ossl_quic_sstream_has_pending(stream->sstream));
a73078b7
HL		 2138 }
2139
2140 /* We have now sent the packet, so update state accordingly. */
2141 if (have_ack_eliciting)
2142 txp->force_ack_eliciting &= ~(1UL << pn_space);
2143
2144 if (tpkt->had_handshake_done_frame)
2145 txp->want_handshake_done = 0;
2146
2147 if (tpkt->had_max_data_frame) {
2148 txp->want_max_data = 0;
2149 ossl_quic_rxfc_has_cwm_changed(txp->args.conn_rxfc, 1);
2150 }
2151
2152 if (tpkt->had_max_streams_bidi_frame)
2153 txp->want_max_streams_bidi = 0;
2154
2155 if (tpkt->had_max_streams_uni_frame)
2156 txp->want_max_streams_uni = 0;
2157
2158 if (tpkt->had_ack_frame)
2159 txp->want_ack &= ~(1UL << pn_space);
2160
2161 /* Done. */
2162 tx_helper_cleanup(&h);
2163 return rc;
2164
2165fatal_err:
2166 /*
2167 * Handler for fatal errors, i.e. errors causing us to abort the entire
2168 * packet rather than just one frame. Examples of such errors include
2169 * allocation errors.
2170 */
2171 if (have_helper)
2172 tx_helper_cleanup(&h);
2173 if (tpkt != NULL)
2174 ossl_quic_txpim_pkt_release(txp->args.txpim, tpkt);
2175 return TXP_ERR_INTERNAL;
2176}
2177
2178/* Ensure the iovec array is at least num elements long. */
2179static int txp_ensure_iovec(OSSL_QUIC_TX_PACKETISER *txp, size_t num)
2180{
2181 OSSL_QTX_IOVEC *iovec;
2182
2183 if (txp->alloc_iovec >= num)
2184 return 1;
2185
2186 num = txp->alloc_iovec != 0 ? txp->alloc_iovec * 2 : 8;
2187
2188 iovec = OPENSSL_realloc(txp->iovec, sizeof(OSSL_QTX_IOVEC) * num);
2189 if (iovec == NULL)
2190 return 0;
2191
2192 txp->iovec = iovec;
2193 txp->alloc_iovec = num;
2194 return 1;
2195}
2196
2197int ossl_quic_tx_packetiser_schedule_conn_close(OSSL_QUIC_TX_PACKETISER *txp,
2198 const OSSL_QUIC_FRAME_CONN_CLOSE *f)
2199{
2200 char *reason = NULL;
2201 size_t reason_len = f->reason_len;
2202 size_t max_reason_len = txp_get_mdpl(txp) / 2;
2203
2204 if (txp->want_conn_close)
2205 return 0;
2206
2207 /*
2208 * Arbitrarily limit the length of the reason length string to half of the
2209 * MDPL.
2210 */
2211 if (reason_len > max_reason_len)
2212 reason_len = max_reason_len;
2213
2214 if (reason_len > 0) {
2215 reason = OPENSSL_memdup(f->reason, reason_len);
2216 if (reason == NULL)
2217 return 0;
2218 }
2219
2220 txp->conn_close_frame = *f;
2221 txp->conn_close_frame.reason = reason;
2222 txp->conn_close_frame.reason_len = reason_len;
2223 txp->want_conn_close = 1;
2224 return 1;
2225}
A mirror of the official openssl repository