ssl/quic/quic_stream_map.c

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