Coverage Report

Created: 2026-11-16 07:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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
}