/src/openssl/ssl/quic/quic_stream_map.c
Line | Count | Source |
1 | | /* |
2 | | * Copyright 2022-2026 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_stream_map.h" |
11 | | #include "internal/nelem.h" |
12 | | #include "internal/quic_channel.h" |
13 | | |
14 | | /* |
15 | | * QUIC Stream Map |
16 | | * =============== |
17 | | */ |
18 | | DEFINE_LHASH_OF_EX(QUIC_STREAM); |
19 | | |
20 | | static void shutdown_flush_done(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); |
21 | | |
22 | | /* Circular list management. */ |
23 | | static void list_insert_tail(QUIC_STREAM_LIST_NODE *l, |
24 | | QUIC_STREAM_LIST_NODE *n) |
25 | 0 | { |
26 | | /* Must not be in list. */ |
27 | 0 | assert(n->prev == NULL && n->next == NULL |
28 | 0 | && l->prev != NULL && l->next != NULL); |
29 | |
|
30 | 0 | n->prev = l->prev; |
31 | 0 | n->prev->next = n; |
32 | 0 | l->prev = n; |
33 | 0 | n->next = l; |
34 | 0 | } |
35 | | |
36 | | static void list_remove(QUIC_STREAM_LIST_NODE *l, |
37 | | QUIC_STREAM_LIST_NODE *n) |
38 | 0 | { |
39 | 0 | assert(n->prev != NULL && n->next != NULL |
40 | 0 | && n->prev != n && n->next != n); |
41 | |
|
42 | 0 | n->prev->next = n->next; |
43 | 0 | n->next->prev = n->prev; |
44 | 0 | n->next = n->prev = NULL; |
45 | 0 | } |
46 | | |
47 | | static QUIC_STREAM *list_next(QUIC_STREAM_LIST_NODE *l, QUIC_STREAM_LIST_NODE *n, |
48 | | size_t off) |
49 | 0 | { |
50 | 0 | assert(n->prev != NULL && n->next != NULL |
51 | 0 | && (n == l || (n->prev != n && n->next != n)) |
52 | 0 | && l->prev != NULL && l->next != NULL); |
53 | |
|
54 | 0 | n = n->next; |
55 | |
|
56 | 0 | if (n == l) |
57 | 0 | n = n->next; |
58 | 0 | if (n == l) |
59 | 0 | return NULL; |
60 | | |
61 | 0 | assert(n != NULL); |
62 | |
|
63 | 0 | return (QUIC_STREAM *)(((char *)n) - off); |
64 | 0 | } |
65 | | |
66 | 0 | #define active_next(l, s) list_next((l), &(s)->active_node, \ |
67 | 0 | offsetof(QUIC_STREAM, active_node)) |
68 | 0 | #define accept_next(l, s) list_next((l), &(s)->accept_node, \ |
69 | 0 | offsetof(QUIC_STREAM, accept_node)) |
70 | 0 | #define accept_head(l) list_next((l), (l), \ |
71 | 0 | offsetof(QUIC_STREAM, accept_node)) |
72 | 0 | #define ready_for_gc_head(l) list_next((l), (l), \ |
73 | 0 | offsetof(QUIC_STREAM, ready_for_gc_node)) |
74 | | |
75 | | static unsigned long hash_stream(const QUIC_STREAM *s) |
76 | 0 | { |
77 | | /* |
78 | | * The low two bits of a stream ID identify its initiator and direction. |
79 | | * Folding in bits from the stream ordinal improves bucket use for |
80 | | * consecutive IDs of one type. With mixed stream types, this can produce |
81 | | * longer chains than the original hash at some intermediate table sizes |
82 | | * while LHASH expands. |
83 | | */ |
84 | 0 | return (unsigned long)(s->id ^ (s->id >> 2)); |
85 | 0 | } |
86 | | |
87 | | static int cmp_stream(const QUIC_STREAM *a, const QUIC_STREAM *b) |
88 | 0 | { |
89 | 0 | if (a->id < b->id) |
90 | 0 | return -1; |
91 | 0 | if (a->id > b->id) |
92 | 0 | return 1; |
93 | 0 | return 0; |
94 | 0 | } |
95 | | |
96 | | int ossl_quic_stream_map_init(QUIC_STREAM_MAP *qsm, |
97 | | uint64_t (*get_stream_limit_cb)(int uni, void *arg), |
98 | | void *get_stream_limit_cb_arg, |
99 | | QUIC_RXFC *max_streams_bidi_rxfc, |
100 | | QUIC_RXFC *max_streams_uni_rxfc, |
101 | | QUIC_CHANNEL *ch) |
102 | 0 | { |
103 | 0 | qsm->map = lh_QUIC_STREAM_new(hash_stream, cmp_stream); |
104 | 0 | if (qsm->map == NULL) |
105 | 0 | return 0; |
106 | 0 | qsm->active_list.prev = qsm->active_list.next = &qsm->active_list; |
107 | 0 | qsm->accept_list.prev = qsm->accept_list.next = &qsm->accept_list; |
108 | 0 | qsm->ready_for_gc_list.prev = qsm->ready_for_gc_list.next |
109 | 0 | = &qsm->ready_for_gc_list; |
110 | 0 | qsm->rr_stepping = 1; |
111 | 0 | qsm->rr_counter = 0; |
112 | 0 | qsm->rr_cur = NULL; |
113 | |
|
114 | 0 | qsm->num_accept_bidi = 0; |
115 | 0 | qsm->num_accept_uni = 0; |
116 | 0 | qsm->num_shutdown_flush = 0; |
117 | |
|
118 | 0 | qsm->get_stream_limit_cb = get_stream_limit_cb; |
119 | 0 | qsm->get_stream_limit_cb_arg = get_stream_limit_cb_arg; |
120 | 0 | qsm->max_streams_bidi_rxfc = max_streams_bidi_rxfc; |
121 | 0 | qsm->max_streams_uni_rxfc = max_streams_uni_rxfc; |
122 | 0 | qsm->ch = ch; |
123 | 0 | return 1; |
124 | 0 | } |
125 | | |
126 | | static void release_each(QUIC_STREAM *stream, void *arg) |
127 | 0 | { |
128 | 0 | QUIC_STREAM_MAP *qsm = arg; |
129 | |
|
130 | 0 | ossl_quic_stream_map_release(qsm, stream); |
131 | 0 | } |
132 | | |
133 | | void ossl_quic_stream_map_cleanup(QUIC_STREAM_MAP *qsm) |
134 | 0 | { |
135 | 0 | if (qsm->map == NULL) |
136 | 0 | return; |
137 | 0 | lh_QUIC_STREAM_set_down_load(qsm->map, 0); |
138 | 0 | ossl_quic_stream_map_visit(qsm, release_each, qsm); |
139 | |
|
140 | 0 | lh_QUIC_STREAM_free(qsm->map); |
141 | 0 | qsm->map = NULL; |
142 | 0 | } |
143 | | |
144 | | void ossl_quic_stream_map_visit(QUIC_STREAM_MAP *qsm, |
145 | | void (*visit_cb)(QUIC_STREAM *stream, void *arg), |
146 | | void *visit_cb_arg) |
147 | 0 | { |
148 | 0 | lh_QUIC_STREAM_doall_arg(qsm->map, visit_cb, visit_cb_arg); |
149 | 0 | } |
150 | | |
151 | | QUIC_STREAM *ossl_quic_stream_map_alloc(QUIC_STREAM_MAP *qsm, |
152 | | uint64_t stream_id, |
153 | | int type) |
154 | 0 | { |
155 | 0 | QUIC_STREAM *s; |
156 | 0 | QUIC_STREAM key; |
157 | |
|
158 | 0 | key.id = stream_id; |
159 | |
|
160 | 0 | s = lh_QUIC_STREAM_retrieve(qsm->map, &key); |
161 | 0 | if (s != NULL) |
162 | 0 | return NULL; |
163 | | |
164 | 0 | s = OPENSSL_zalloc(sizeof(*s)); |
165 | 0 | if (s == NULL) |
166 | 0 | return NULL; |
167 | | |
168 | 0 | s->id = stream_id; |
169 | 0 | s->type = type; |
170 | 0 | s->as_server = ossl_quic_channel_is_server(qsm->ch); |
171 | 0 | s->send_state = (ossl_quic_stream_is_local_init(s) |
172 | 0 | || ossl_quic_stream_is_bidi(s)) |
173 | 0 | ? QUIC_SSTREAM_STATE_READY |
174 | 0 | : QUIC_SSTREAM_STATE_NONE; |
175 | 0 | s->recv_state = (!ossl_quic_stream_is_local_init(s) |
176 | 0 | || ossl_quic_stream_is_bidi(s)) |
177 | 0 | ? QUIC_RSTREAM_STATE_RECV |
178 | 0 | : QUIC_RSTREAM_STATE_NONE; |
179 | |
|
180 | 0 | s->send_final_size = UINT64_MAX; |
181 | |
|
182 | 0 | lh_QUIC_STREAM_insert(qsm->map, s); |
183 | 0 | if (lh_QUIC_STREAM_error(qsm->map)) { |
184 | 0 | OPENSSL_free(s); |
185 | 0 | return NULL; |
186 | 0 | } |
187 | 0 | return s; |
188 | 0 | } |
189 | | |
190 | | void ossl_quic_stream_map_release(QUIC_STREAM_MAP *qsm, QUIC_STREAM *stream) |
191 | 0 | { |
192 | 0 | if (stream == NULL) |
193 | 0 | return; |
194 | | |
195 | 0 | if (stream->active_node.next != NULL) |
196 | 0 | list_remove(&qsm->active_list, &stream->active_node); |
197 | 0 | if (stream->accept_node.next != NULL) |
198 | 0 | list_remove(&qsm->accept_list, &stream->accept_node); |
199 | 0 | if (stream->ready_for_gc_node.next != NULL) |
200 | 0 | list_remove(&qsm->ready_for_gc_list, &stream->ready_for_gc_node); |
201 | |
|
202 | 0 | ossl_quic_sstream_free(stream->sstream); |
203 | 0 | stream->sstream = NULL; |
204 | |
|
205 | 0 | ossl_quic_rstream_free(stream->rstream); |
206 | 0 | stream->rstream = NULL; |
207 | |
|
208 | 0 | lh_QUIC_STREAM_delete(qsm->map, stream); |
209 | 0 | OPENSSL_free(stream); |
210 | 0 | } |
211 | | |
212 | | QUIC_STREAM *ossl_quic_stream_map_get_by_id(QUIC_STREAM_MAP *qsm, |
213 | | uint64_t stream_id) |
214 | 0 | { |
215 | 0 | QUIC_STREAM key; |
216 | |
|
217 | 0 | key.id = stream_id; |
218 | |
|
219 | 0 | return lh_QUIC_STREAM_retrieve(qsm->map, &key); |
220 | 0 | } |
221 | | |
222 | | static void stream_map_mark_active(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s) |
223 | 0 | { |
224 | 0 | if (s->active) |
225 | 0 | return; |
226 | | |
227 | 0 | list_insert_tail(&qsm->active_list, &s->active_node); |
228 | |
|
229 | 0 | if (qsm->rr_cur == NULL) |
230 | 0 | qsm->rr_cur = s; |
231 | |
|
232 | 0 | s->active = 1; |
233 | 0 | } |
234 | | |
235 | | static void stream_map_mark_inactive(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s) |
236 | 0 | { |
237 | 0 | if (!s->active) |
238 | 0 | return; |
239 | | |
240 | 0 | if (qsm->rr_cur == s) |
241 | 0 | qsm->rr_cur = active_next(&qsm->active_list, s); |
242 | 0 | if (qsm->rr_cur == s) |
243 | 0 | qsm->rr_cur = NULL; |
244 | |
|
245 | 0 | list_remove(&qsm->active_list, &s->active_node); |
246 | |
|
247 | 0 | s->active = 0; |
248 | 0 | } |
249 | | |
250 | | void ossl_quic_stream_map_set_rr_stepping(QUIC_STREAM_MAP *qsm, size_t stepping) |
251 | 0 | { |
252 | 0 | qsm->rr_stepping = stepping; |
253 | 0 | qsm->rr_counter = 0; |
254 | 0 | } |
255 | | |
256 | | static int stream_has_data_to_send(QUIC_STREAM *s) |
257 | 0 | { |
258 | 0 | OSSL_QUIC_FRAME_STREAM shdr; |
259 | 0 | OSSL_QTX_IOVEC iov[2]; |
260 | 0 | size_t num_iov; |
261 | 0 | uint64_t fc_credit, fc_swm, fc_limit; |
262 | |
|
263 | 0 | switch (s->send_state) { |
264 | 0 | case QUIC_SSTREAM_STATE_READY: |
265 | 0 | case QUIC_SSTREAM_STATE_SEND: |
266 | 0 | case QUIC_SSTREAM_STATE_DATA_SENT: |
267 | | /* |
268 | | * We can still have data to send in DATA_SENT due to retransmissions, |
269 | | * etc. |
270 | | */ |
271 | 0 | break; |
272 | 0 | default: |
273 | 0 | return 0; /* Nothing to send. */ |
274 | 0 | } |
275 | | |
276 | | /* |
277 | | * We cannot determine if we have data to send simply by checking if |
278 | | * ossl_quic_txfc_get_credit() is zero, because we may also have older |
279 | | * stream data we need to retransmit. The SSTREAM returns older data first, |
280 | | * so we do a simple comparison of the next chunk the SSTREAM wants to send |
281 | | * against the TXFC CWM. |
282 | | */ |
283 | 0 | num_iov = OSSL_NELEM(iov); |
284 | 0 | if (!ossl_quic_sstream_get_stream_frame(s->sstream, 0, &shdr, iov, |
285 | 0 | &num_iov)) |
286 | 0 | return 0; |
287 | | |
288 | 0 | fc_credit = ossl_quic_txfc_get_credit(&s->txfc, 0); |
289 | 0 | fc_swm = ossl_quic_txfc_get_swm(&s->txfc); |
290 | 0 | fc_limit = fc_swm + fc_credit; |
291 | |
|
292 | 0 | return (shdr.is_fin && shdr.len == 0) || shdr.offset < fc_limit; |
293 | 0 | } |
294 | | |
295 | | static ossl_unused int qsm_send_part_permits_gc(const QUIC_STREAM *qs) |
296 | 0 | { |
297 | 0 | switch (qs->send_state) { |
298 | 0 | case QUIC_SSTREAM_STATE_NONE: |
299 | 0 | case QUIC_SSTREAM_STATE_DATA_RECVD: |
300 | 0 | case QUIC_SSTREAM_STATE_RESET_RECVD: |
301 | 0 | return 1; |
302 | 0 | default: |
303 | 0 | return 0; |
304 | 0 | } |
305 | 0 | } |
306 | | |
307 | | static int qsm_ready_for_gc(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs) |
308 | 0 | { |
309 | 0 | int recv_stream_fully_drained = 0; /* TODO(QUIC FUTURE): Optimisation */ |
310 | | |
311 | | /* |
312 | | * If sstream has no FIN, we auto-reset it at marked-for-deletion time, so |
313 | | * we don't need to worry about that here. |
314 | | */ |
315 | 0 | assert(!qs->deleted |
316 | 0 | || !ossl_quic_stream_has_send(qs) |
317 | 0 | || ossl_quic_stream_send_is_reset(qs) |
318 | 0 | || ossl_quic_stream_send_get_final_size(qs, NULL)); |
319 | |
|
320 | 0 | return qs->deleted |
321 | 0 | && (!ossl_quic_stream_has_recv(qs) |
322 | 0 | || recv_stream_fully_drained |
323 | 0 | || qs->acked_stop_sending) |
324 | 0 | && (!ossl_quic_stream_has_send(qs) |
325 | 0 | || qs->send_state == QUIC_SSTREAM_STATE_DATA_RECVD |
326 | 0 | || qs->send_state == QUIC_SSTREAM_STATE_RESET_RECVD); |
327 | 0 | } |
328 | | |
329 | | int ossl_quic_stream_map_is_local_allowed_by_stream_limit(QUIC_STREAM_MAP *qsm, |
330 | | uint64_t stream_ordinal, |
331 | | int is_uni) |
332 | 0 | { |
333 | 0 | uint64_t stream_limit; |
334 | |
|
335 | 0 | if (qsm->get_stream_limit_cb == NULL) |
336 | 0 | return 1; |
337 | | |
338 | 0 | stream_limit = qsm->get_stream_limit_cb(is_uni, qsm->get_stream_limit_cb_arg); |
339 | 0 | return stream_ordinal < stream_limit; |
340 | 0 | } |
341 | | |
342 | | void ossl_quic_stream_map_update_state(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s) |
343 | 0 | { |
344 | 0 | int should_be_active, allowed_by_stream_limit = 1; |
345 | |
|
346 | 0 | if (ossl_quic_stream_is_server_init(s) == ossl_quic_channel_is_server(qsm->ch)) { |
347 | 0 | int is_uni = !ossl_quic_stream_is_bidi(s); |
348 | 0 | uint64_t stream_ordinal = s->id >> 2; |
349 | |
|
350 | 0 | allowed_by_stream_limit |
351 | 0 | = ossl_quic_stream_map_is_local_allowed_by_stream_limit(qsm, |
352 | 0 | stream_ordinal, |
353 | 0 | is_uni); |
354 | 0 | } |
355 | |
|
356 | 0 | if (s->send_state == QUIC_SSTREAM_STATE_DATA_SENT |
357 | 0 | && ossl_quic_sstream_is_totally_acked(s->sstream)) |
358 | 0 | ossl_quic_stream_map_notify_totally_acked(qsm, s); |
359 | 0 | else if (s->shutdown_flush |
360 | 0 | && s->send_state == QUIC_SSTREAM_STATE_SEND |
361 | 0 | && ossl_quic_sstream_is_totally_acked(s->sstream)) |
362 | 0 | shutdown_flush_done(qsm, s); |
363 | |
|
364 | 0 | if (!s->ready_for_gc) { |
365 | 0 | s->ready_for_gc = qsm_ready_for_gc(qsm, s); |
366 | 0 | if (s->ready_for_gc) |
367 | 0 | list_insert_tail(&qsm->ready_for_gc_list, &s->ready_for_gc_node); |
368 | 0 | } |
369 | |
|
370 | 0 | should_be_active |
371 | 0 | = allowed_by_stream_limit |
372 | 0 | && !s->ready_for_gc |
373 | 0 | && ((ossl_quic_stream_has_recv(s) |
374 | 0 | && !ossl_quic_stream_recv_is_reset(s) |
375 | 0 | && (s->recv_state == QUIC_RSTREAM_STATE_RECV |
376 | 0 | && (s->want_max_stream_data |
377 | 0 | || ossl_quic_rxfc_has_cwm_changed(&s->rxfc, 0)))) |
378 | 0 | || s->want_stop_sending |
379 | 0 | || s->want_reset_stream |
380 | 0 | || (!s->peer_stop_sending && stream_has_data_to_send(s))); |
381 | |
|
382 | 0 | if (should_be_active) |
383 | 0 | stream_map_mark_active(qsm, s); |
384 | 0 | else |
385 | 0 | stream_map_mark_inactive(qsm, s); |
386 | 0 | } |
387 | | |
388 | | /* |
389 | | * Stream Send Part State Management |
390 | | * ================================= |
391 | | */ |
392 | | |
393 | | int ossl_quic_stream_map_ensure_send_part_id(QUIC_STREAM_MAP *qsm, |
394 | | QUIC_STREAM *qs) |
395 | 0 | { |
396 | 0 | switch (qs->send_state) { |
397 | 0 | case QUIC_SSTREAM_STATE_NONE: |
398 | | /* Stream without send part - caller error. */ |
399 | 0 | return 0; |
400 | | |
401 | 0 | case QUIC_SSTREAM_STATE_READY: |
402 | | /* |
403 | | * We always allocate a stream ID upfront, so we don't need to do it |
404 | | * here. |
405 | | */ |
406 | 0 | qs->send_state = QUIC_SSTREAM_STATE_SEND; |
407 | 0 | return 1; |
408 | | |
409 | 0 | default: |
410 | | /* Nothing to do. */ |
411 | 0 | return 1; |
412 | 0 | } |
413 | 0 | } |
414 | | |
415 | | int ossl_quic_stream_map_notify_all_data_sent(QUIC_STREAM_MAP *qsm, |
416 | | QUIC_STREAM *qs) |
417 | 0 | { |
418 | 0 | switch (qs->send_state) { |
419 | 0 | default: |
420 | | /* Wrong state - caller error. */ |
421 | 0 | case QUIC_SSTREAM_STATE_NONE: |
422 | | /* Stream without send part - caller error. */ |
423 | 0 | return 0; |
424 | | |
425 | 0 | case QUIC_SSTREAM_STATE_SEND: |
426 | 0 | if (!ossl_quic_sstream_get_final_size(qs->sstream, &qs->send_final_size)) |
427 | 0 | return 0; |
428 | | |
429 | 0 | qs->send_state = QUIC_SSTREAM_STATE_DATA_SENT; |
430 | 0 | return 1; |
431 | 0 | } |
432 | 0 | } |
433 | | |
434 | | static void shutdown_flush_done(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs) |
435 | 0 | { |
436 | 0 | if (!qs->shutdown_flush) |
437 | 0 | return; |
438 | | |
439 | 0 | assert(qsm->num_shutdown_flush > 0); |
440 | 0 | qs->shutdown_flush = 0; |
441 | 0 | --qsm->num_shutdown_flush; |
442 | | |
443 | | /* |
444 | | * when num_shutdown_flush becomes zero we need to poke |
445 | | * SSL_poll() it's time to poke to SSL_shutdown() to proceed |
446 | | * with shutdown process as all streams are gone (flushed). |
447 | | */ |
448 | 0 | if (qsm->num_shutdown_flush == 0) |
449 | 0 | ossl_quic_channel_notify_flush_done(qsm->ch); |
450 | 0 | } |
451 | | |
452 | | int ossl_quic_stream_map_notify_totally_acked(QUIC_STREAM_MAP *qsm, |
453 | | QUIC_STREAM *qs) |
454 | 0 | { |
455 | 0 | switch (qs->send_state) { |
456 | 0 | default: |
457 | | /* Wrong state - caller error. */ |
458 | 0 | case QUIC_SSTREAM_STATE_NONE: |
459 | | /* Stream without send part - caller error. */ |
460 | 0 | return 0; |
461 | | |
462 | 0 | case QUIC_SSTREAM_STATE_DATA_SENT: |
463 | 0 | qs->send_state = QUIC_SSTREAM_STATE_DATA_RECVD; |
464 | | /* |
465 | | * Remember final size in case SSL_get_stream_write_state() |
466 | | * gets called. |
467 | | */ |
468 | 0 | qs->have_final_size = ossl_quic_sstream_get_final_size(qs->sstream, |
469 | 0 | NULL); |
470 | | |
471 | | /* We no longer need a QUIC_SSTREAM in this state. */ |
472 | 0 | ossl_quic_sstream_free(qs->sstream); |
473 | 0 | qs->sstream = NULL; |
474 | |
|
475 | 0 | shutdown_flush_done(qsm, qs); |
476 | 0 | return 1; |
477 | 0 | } |
478 | 0 | } |
479 | | |
480 | | int ossl_quic_stream_map_reset_stream_send_part(QUIC_STREAM_MAP *qsm, |
481 | | QUIC_STREAM *qs, |
482 | | uint64_t aec) |
483 | 0 | { |
484 | 0 | switch (qs->send_state) { |
485 | 0 | default: |
486 | 0 | case QUIC_SSTREAM_STATE_NONE: |
487 | | /* |
488 | | * RESET_STREAM pertains to sending part only, so we cannot reset a |
489 | | * receive-only stream. |
490 | | */ |
491 | 0 | case QUIC_SSTREAM_STATE_DATA_RECVD: |
492 | | /* |
493 | | * RFC 9000 s. 3.3: A sender MUST NOT [...] send RESET_STREAM from a |
494 | | * terminal state. If the stream has already finished normally and the |
495 | | * peer has acknowledged this, we cannot reset it. |
496 | | */ |
497 | 0 | return 0; |
498 | | |
499 | 0 | case QUIC_SSTREAM_STATE_READY: |
500 | 0 | if (!ossl_quic_stream_map_ensure_send_part_id(qsm, qs)) |
501 | 0 | return 0; |
502 | | |
503 | | /* FALLTHROUGH */ |
504 | 0 | case QUIC_SSTREAM_STATE_SEND: |
505 | | /* |
506 | | * If we already have a final size (e.g. because we are coming from |
507 | | * DATA_SENT), we have to be consistent with that, so don't change it. |
508 | | * If we don't already have a final size, determine a final size value. |
509 | | * This is the value which we will end up using for a RESET_STREAM frame |
510 | | * for flow control purposes. We could send the stream size (total |
511 | | * number of bytes appended to QUIC_SSTREAM by the application), but it |
512 | | * is in our interest to exclude any bytes we have not actually |
513 | | * transmitted yet, to avoid unnecessarily consuming flow control |
514 | | * credit. We can get this from the TXFC. |
515 | | */ |
516 | 0 | qs->send_final_size = ossl_quic_txfc_get_swm(&qs->txfc); |
517 | | |
518 | | /* FALLTHROUGH */ |
519 | 0 | case QUIC_SSTREAM_STATE_DATA_SENT: |
520 | 0 | qs->reset_stream_aec = aec; |
521 | 0 | qs->want_reset_stream = 1; |
522 | 0 | qs->send_state = QUIC_SSTREAM_STATE_RESET_SENT; |
523 | |
|
524 | 0 | ossl_quic_sstream_free(qs->sstream); |
525 | 0 | qs->sstream = NULL; |
526 | |
|
527 | 0 | shutdown_flush_done(qsm, qs); |
528 | 0 | ossl_quic_stream_map_update_state(qsm, qs); |
529 | 0 | return 1; |
530 | | |
531 | 0 | case QUIC_SSTREAM_STATE_RESET_SENT: |
532 | 0 | case QUIC_SSTREAM_STATE_RESET_RECVD: |
533 | | /* |
534 | | * Idempotent - no-op. In any case, do not send RESET_STREAM again - as |
535 | | * mentioned, we must not send it from a terminal state. |
536 | | */ |
537 | 0 | return 1; |
538 | 0 | } |
539 | 0 | } |
540 | | |
541 | | int ossl_quic_stream_map_notify_reset_stream_acked(QUIC_STREAM_MAP *qsm, |
542 | | QUIC_STREAM *qs) |
543 | 0 | { |
544 | 0 | switch (qs->send_state) { |
545 | 0 | default: |
546 | | /* Wrong state - caller error. */ |
547 | 0 | case QUIC_SSTREAM_STATE_NONE: |
548 | | /* Stream without send part - caller error. */ |
549 | 0 | return 0; |
550 | | |
551 | 0 | case QUIC_SSTREAM_STATE_RESET_SENT: |
552 | 0 | qs->send_state = QUIC_SSTREAM_STATE_RESET_RECVD; |
553 | 0 | return 1; |
554 | | |
555 | 0 | case QUIC_SSTREAM_STATE_RESET_RECVD: |
556 | | /* Already in the correct state. */ |
557 | 0 | return 1; |
558 | 0 | } |
559 | 0 | } |
560 | | |
561 | | /* |
562 | | * Stream Receive Part State Management |
563 | | * ==================================== |
564 | | */ |
565 | | |
566 | | int ossl_quic_stream_map_notify_size_known_recv_part(QUIC_STREAM_MAP *qsm, |
567 | | QUIC_STREAM *qs, |
568 | | uint64_t final_size) |
569 | 0 | { |
570 | 0 | switch (qs->recv_state) { |
571 | 0 | default: |
572 | | /* Wrong state - caller error. */ |
573 | 0 | case QUIC_RSTREAM_STATE_NONE: |
574 | | /* Stream without receive part - caller error. */ |
575 | 0 | return 0; |
576 | | |
577 | 0 | case QUIC_RSTREAM_STATE_RECV: |
578 | 0 | qs->recv_state = QUIC_RSTREAM_STATE_SIZE_KNOWN; |
579 | 0 | return 1; |
580 | 0 | } |
581 | 0 | } |
582 | | |
583 | | int ossl_quic_stream_map_notify_totally_received(QUIC_STREAM_MAP *qsm, |
584 | | QUIC_STREAM *qs) |
585 | 0 | { |
586 | 0 | switch (qs->recv_state) { |
587 | 0 | default: |
588 | | /* Wrong state - caller error. */ |
589 | 0 | case QUIC_RSTREAM_STATE_NONE: |
590 | | /* Stream without receive part - caller error. */ |
591 | 0 | return 0; |
592 | | |
593 | 0 | case QUIC_RSTREAM_STATE_SIZE_KNOWN: |
594 | 0 | qs->recv_state = QUIC_RSTREAM_STATE_DATA_RECVD; |
595 | 0 | qs->want_stop_sending = 0; |
596 | 0 | return 1; |
597 | 0 | } |
598 | 0 | } |
599 | | |
600 | | int ossl_quic_stream_map_notify_totally_read(QUIC_STREAM_MAP *qsm, |
601 | | QUIC_STREAM *qs) |
602 | 0 | { |
603 | 0 | switch (qs->recv_state) { |
604 | 0 | default: |
605 | | /* Wrong state - caller error. */ |
606 | 0 | case QUIC_RSTREAM_STATE_NONE: |
607 | | /* Stream without receive part - caller error. */ |
608 | 0 | return 0; |
609 | | |
610 | 0 | case QUIC_RSTREAM_STATE_DATA_RECVD: |
611 | 0 | qs->recv_state = QUIC_RSTREAM_STATE_DATA_READ; |
612 | | |
613 | | /* QUIC_RSTREAM is no longer needed */ |
614 | 0 | ossl_quic_rstream_free(qs->rstream); |
615 | 0 | qs->rstream = NULL; |
616 | 0 | return 1; |
617 | 0 | } |
618 | 0 | } |
619 | | |
620 | | int ossl_quic_stream_map_notify_reset_recv_part(QUIC_STREAM_MAP *qsm, |
621 | | QUIC_STREAM *qs, |
622 | | uint64_t app_error_code, |
623 | | uint64_t final_size) |
624 | 0 | { |
625 | 0 | uint64_t prev_final_size; |
626 | |
|
627 | 0 | switch (qs->recv_state) { |
628 | 0 | default: |
629 | 0 | case QUIC_RSTREAM_STATE_NONE: |
630 | | /* Stream without receive part - caller error. */ |
631 | 0 | return 0; |
632 | | |
633 | 0 | case QUIC_RSTREAM_STATE_RECV: |
634 | 0 | case QUIC_RSTREAM_STATE_SIZE_KNOWN: |
635 | 0 | case QUIC_RSTREAM_STATE_DATA_RECVD: |
636 | 0 | if (ossl_quic_stream_recv_get_final_size(qs, &prev_final_size) |
637 | 0 | && prev_final_size != final_size) |
638 | | /* Cannot change previous final size. */ |
639 | 0 | return 0; |
640 | | |
641 | 0 | qs->recv_state = QUIC_RSTREAM_STATE_RESET_RECVD; |
642 | 0 | qs->peer_reset_stream_aec = app_error_code; |
643 | | |
644 | | /* RFC 9000 s. 3.3: No point sending STOP_SENDING if already reset. */ |
645 | 0 | qs->want_stop_sending = 0; |
646 | | |
647 | | /* QUIC_RSTREAM is no longer needed */ |
648 | 0 | ossl_quic_rstream_free(qs->rstream); |
649 | 0 | qs->rstream = NULL; |
650 | |
|
651 | 0 | ossl_quic_stream_map_update_state(qsm, qs); |
652 | 0 | return 1; |
653 | | |
654 | 0 | case QUIC_RSTREAM_STATE_DATA_READ: |
655 | | /* |
656 | | * If we already retired the FIN to the application this is moot |
657 | | * - just ignore. |
658 | | */ |
659 | 0 | case QUIC_RSTREAM_STATE_RESET_RECVD: |
660 | 0 | case QUIC_RSTREAM_STATE_RESET_READ: |
661 | | /* Could be a reordered/retransmitted frame - just ignore. */ |
662 | 0 | return 1; |
663 | 0 | } |
664 | 0 | } |
665 | | |
666 | | int ossl_quic_stream_map_notify_app_read_reset_recv_part(QUIC_STREAM_MAP *qsm, |
667 | | QUIC_STREAM *qs) |
668 | 0 | { |
669 | 0 | switch (qs->recv_state) { |
670 | 0 | default: |
671 | | /* Wrong state - caller error. */ |
672 | 0 | case QUIC_RSTREAM_STATE_NONE: |
673 | | /* Stream without receive part - caller error. */ |
674 | 0 | return 0; |
675 | | |
676 | 0 | case QUIC_RSTREAM_STATE_RESET_RECVD: |
677 | 0 | qs->recv_state = QUIC_RSTREAM_STATE_RESET_READ; |
678 | 0 | return 1; |
679 | 0 | } |
680 | 0 | } |
681 | | |
682 | | int ossl_quic_stream_map_stop_sending_recv_part(QUIC_STREAM_MAP *qsm, |
683 | | QUIC_STREAM *qs, |
684 | | uint64_t aec) |
685 | 0 | { |
686 | 0 | if (qs->stop_sending) |
687 | 0 | return 0; |
688 | | |
689 | 0 | switch (qs->recv_state) { |
690 | 0 | default: |
691 | 0 | case QUIC_RSTREAM_STATE_NONE: |
692 | | /* Send-only stream, so this makes no sense. */ |
693 | 0 | case QUIC_RSTREAM_STATE_DATA_RECVD: |
694 | 0 | case QUIC_RSTREAM_STATE_DATA_READ: |
695 | | /* |
696 | | * Not really any point in STOP_SENDING if we already received all data. |
697 | | */ |
698 | 0 | case QUIC_RSTREAM_STATE_RESET_RECVD: |
699 | 0 | case QUIC_RSTREAM_STATE_RESET_READ: |
700 | | /* |
701 | | * RFC 9000 s. 3.5: "STOP_SENDING SHOULD only be sent for a stream that |
702 | | * has not been reset by the peer." |
703 | | * |
704 | | * No point in STOP_SENDING if the peer already reset their send part. |
705 | | */ |
706 | 0 | return 0; |
707 | | |
708 | 0 | case QUIC_RSTREAM_STATE_RECV: |
709 | 0 | case QUIC_RSTREAM_STATE_SIZE_KNOWN: |
710 | | /* |
711 | | * RFC 9000 s. 3.5: "If the stream is in the Recv or Size Known state, |
712 | | * the transport SHOULD signal this by sending a STOP_SENDING frame to |
713 | | * prompt closure of the stream in the opposite direction." |
714 | | * |
715 | | * Note that it does make sense to send STOP_SENDING for a receive part |
716 | | * of a stream which has a known size (because we have received a FIN) |
717 | | * but which still has other (previous) stream data yet to be received. |
718 | | */ |
719 | 0 | break; |
720 | 0 | } |
721 | | |
722 | 0 | qs->stop_sending = 1; |
723 | 0 | qs->stop_sending_aec = aec; |
724 | 0 | return ossl_quic_stream_map_schedule_stop_sending(qsm, qs); |
725 | 0 | } |
726 | | |
727 | | /* Called to mark STOP_SENDING for generation, or regeneration after loss. */ |
728 | | int ossl_quic_stream_map_schedule_stop_sending(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs) |
729 | 0 | { |
730 | 0 | if (!qs->stop_sending) |
731 | 0 | return 0; |
732 | | |
733 | | /* |
734 | | * Ignore the call as a no-op if already scheduled, or in a state |
735 | | * where it makes no sense to send STOP_SENDING. |
736 | | */ |
737 | 0 | if (qs->want_stop_sending) |
738 | 0 | return 1; |
739 | | |
740 | 0 | switch (qs->recv_state) { |
741 | 0 | default: |
742 | 0 | return 1; /* ignore */ |
743 | 0 | case QUIC_RSTREAM_STATE_RECV: |
744 | 0 | case QUIC_RSTREAM_STATE_SIZE_KNOWN: |
745 | | /* |
746 | | * RFC 9000 s. 3.5: "An endpoint is expected to send another |
747 | | * STOP_SENDING frame if a packet containing a previous STOP_SENDING is |
748 | | * lost. However, once either all stream data or a RESET_STREAM frame |
749 | | * has been received for the stream -- that is, the stream is in any |
750 | | * state other than "Recv" or "Size Known" -- sending a STOP_SENDING |
751 | | * frame is unnecessary." |
752 | | */ |
753 | 0 | break; |
754 | 0 | } |
755 | | |
756 | 0 | qs->want_stop_sending = 1; |
757 | 0 | ossl_quic_stream_map_update_state(qsm, qs); |
758 | 0 | return 1; |
759 | 0 | } |
760 | | |
761 | | QUIC_STREAM *ossl_quic_stream_map_peek_accept_queue(QUIC_STREAM_MAP *qsm) |
762 | 0 | { |
763 | 0 | return accept_head(&qsm->accept_list); |
764 | 0 | } |
765 | | |
766 | | QUIC_STREAM *ossl_quic_stream_map_find_in_accept_queue(QUIC_STREAM_MAP *qsm, |
767 | | int is_uni) |
768 | 0 | { |
769 | 0 | QUIC_STREAM *qs; |
770 | |
|
771 | 0 | if (ossl_quic_stream_map_get_accept_queue_len(qsm, is_uni) == 0) |
772 | 0 | return NULL; |
773 | | |
774 | 0 | qs = ossl_quic_stream_map_peek_accept_queue(qsm); |
775 | 0 | while (qs != NULL) { |
776 | 0 | if ((is_uni && !ossl_quic_stream_is_bidi(qs)) |
777 | 0 | || (!is_uni && ossl_quic_stream_is_bidi(qs))) |
778 | 0 | break; |
779 | 0 | qs = accept_next(&qsm->accept_list, qs); |
780 | 0 | } |
781 | 0 | return qs; |
782 | 0 | } |
783 | | |
784 | | void ossl_quic_stream_map_push_accept_queue(QUIC_STREAM_MAP *qsm, |
785 | | QUIC_STREAM *s) |
786 | 0 | { |
787 | 0 | list_insert_tail(&qsm->accept_list, &s->accept_node); |
788 | 0 | if (ossl_quic_stream_is_bidi(s)) |
789 | 0 | ++qsm->num_accept_bidi; |
790 | 0 | else |
791 | 0 | ++qsm->num_accept_uni; |
792 | 0 | } |
793 | | |
794 | | static QUIC_RXFC *qsm_get_max_streams_rxfc(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s) |
795 | 0 | { |
796 | 0 | return ossl_quic_stream_is_bidi(s) |
797 | 0 | ? qsm->max_streams_bidi_rxfc |
798 | 0 | : qsm->max_streams_uni_rxfc; |
799 | 0 | } |
800 | | |
801 | | void ossl_quic_stream_map_retire_stream_credit(QUIC_STREAM_MAP *qsm, |
802 | | QUIC_STREAM *s, |
803 | | OSSL_TIME rtt) |
804 | 0 | { |
805 | 0 | QUIC_RXFC *max_streams_rxfc; |
806 | |
|
807 | 0 | if ((max_streams_rxfc = qsm_get_max_streams_rxfc(qsm, s)) != NULL) |
808 | 0 | (void)ossl_quic_rxfc_on_retire(max_streams_rxfc, 1, rtt); |
809 | 0 | } |
810 | | |
811 | | void ossl_quic_stream_map_remove_from_accept_queue(QUIC_STREAM_MAP *qsm, |
812 | | QUIC_STREAM *s, |
813 | | OSSL_TIME rtt) |
814 | 0 | { |
815 | 0 | list_remove(&qsm->accept_list, &s->accept_node); |
816 | 0 | if (ossl_quic_stream_is_bidi(s)) |
817 | 0 | --qsm->num_accept_bidi; |
818 | 0 | else |
819 | 0 | --qsm->num_accept_uni; |
820 | |
|
821 | 0 | ossl_quic_stream_map_retire_stream_credit(qsm, s, rtt); |
822 | 0 | } |
823 | | |
824 | | size_t ossl_quic_stream_map_get_accept_queue_len(QUIC_STREAM_MAP *qsm, int is_uni) |
825 | 0 | { |
826 | 0 | return is_uni ? qsm->num_accept_uni : qsm->num_accept_bidi; |
827 | 0 | } |
828 | | |
829 | | size_t ossl_quic_stream_map_get_total_accept_queue_len(QUIC_STREAM_MAP *qsm) |
830 | 0 | { |
831 | 0 | return ossl_quic_stream_map_get_accept_queue_len(qsm, /*is_uni=*/0) |
832 | 0 | + ossl_quic_stream_map_get_accept_queue_len(qsm, /*is_uni=*/1); |
833 | 0 | } |
834 | | |
835 | | void ossl_quic_stream_map_gc(QUIC_STREAM_MAP *qsm) |
836 | 0 | { |
837 | 0 | QUIC_STREAM *qs; |
838 | |
|
839 | 0 | while ((qs = ready_for_gc_head(&qsm->ready_for_gc_list)) != NULL) { |
840 | 0 | ossl_quic_stream_map_release(qsm, qs); |
841 | 0 | } |
842 | 0 | } |
843 | | |
844 | | static int eligible_for_shutdown_flush(QUIC_STREAM *qs) |
845 | 0 | { |
846 | | /* |
847 | | * We only care about servicing the send part of a stream (if any) during |
848 | | * shutdown flush. We make sure we flush a stream if it is either |
849 | | * non-terminated or was terminated normally such as via |
850 | | * SSL_stream_conclude. A stream which was terminated via a reset is not |
851 | | * flushed, and we will have thrown away the send buffer in that case |
852 | | * anyway. |
853 | | */ |
854 | 0 | switch (qs->send_state) { |
855 | 0 | case QUIC_SSTREAM_STATE_SEND: |
856 | 0 | case QUIC_SSTREAM_STATE_DATA_SENT: |
857 | 0 | return !ossl_quic_sstream_is_totally_acked(qs->sstream); |
858 | 0 | default: |
859 | 0 | return 0; |
860 | 0 | } |
861 | 0 | } |
862 | | |
863 | | static void begin_shutdown_flush_each(QUIC_STREAM *qs, void *arg) |
864 | 0 | { |
865 | 0 | QUIC_STREAM_MAP *qsm = arg; |
866 | |
|
867 | 0 | if (!eligible_for_shutdown_flush(qs) || qs->shutdown_flush) |
868 | 0 | return; |
869 | | |
870 | 0 | qs->shutdown_flush = 1; |
871 | 0 | ++qsm->num_shutdown_flush; |
872 | 0 | } |
873 | | |
874 | | void ossl_quic_stream_map_begin_shutdown_flush(QUIC_STREAM_MAP *qsm) |
875 | 0 | { |
876 | 0 | qsm->num_shutdown_flush = 0; |
877 | |
|
878 | 0 | ossl_quic_stream_map_visit(qsm, begin_shutdown_flush_each, qsm); |
879 | 0 | } |
880 | | |
881 | | int ossl_quic_stream_map_is_shutdown_flush_finished(QUIC_STREAM_MAP *qsm) |
882 | 0 | { |
883 | 0 | return qsm->num_shutdown_flush == 0; |
884 | 0 | } |
885 | | |
886 | | /* |
887 | | * QUIC Stream Iterator |
888 | | * ==================== |
889 | | */ |
890 | | void ossl_quic_stream_iter_init(QUIC_STREAM_ITER *it, QUIC_STREAM_MAP *qsm, |
891 | | int advance_rr) |
892 | 0 | { |
893 | 0 | it->qsm = qsm; |
894 | 0 | it->stream = it->first_stream = qsm->rr_cur; |
895 | 0 | if (advance_rr && it->stream != NULL |
896 | 0 | && ++qsm->rr_counter >= qsm->rr_stepping) { |
897 | 0 | qsm->rr_counter = 0; |
898 | 0 | qsm->rr_cur = active_next(&qsm->active_list, qsm->rr_cur); |
899 | 0 | } |
900 | 0 | } |
901 | | |
902 | | void ossl_quic_stream_iter_next(QUIC_STREAM_ITER *it) |
903 | 0 | { |
904 | 0 | if (it->stream == NULL) |
905 | 0 | return; |
906 | | |
907 | 0 | it->stream = active_next(&it->qsm->active_list, it->stream); |
908 | 0 | if (it->stream == it->first_stream) |
909 | 0 | it->stream = NULL; |
910 | 0 | } |