/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #ifndef OSSL_INTERNAL_QUIC_STREAM_MAP_H # define OSSL_INTERNAL_QUIC_STREAM_MAP_H # pragma once # include "internal/e_os.h" # include "internal/time.h" # include "internal/common.h" # include "internal/quic_types.h" # include "internal/quic_stream.h" # include "internal/quic_fc.h" # include # ifndef OPENSSL_NO_QUIC /* * QUIC Stream * =========== * * Logical QUIC stream composing all relevant send and receive components. */ typedef struct quic_stream_st QUIC_STREAM; typedef struct quic_stream_list_node_st QUIC_STREAM_LIST_NODE; struct quic_stream_list_node_st { QUIC_STREAM_LIST_NODE *prev, *next; }; /* * QUIC Send Stream States * ----------------------- * * These correspond to the states defined in RFC 9000 s. 3.1, with the * exception of the NONE state which represents the absence of a send stream * part. * * Invariants in each state are noted in comments below. In particular, once all * data has been acknowledged received, or we have reset the stream, we don't * need to keep the QUIC_SSTREAM and data buffers around. Of course, we also * don't have a QUIC_SSTREAM on a receive-only stream. */ #define QUIC_SSTREAM_STATE_NONE 0 /* --- sstream == NULL */ #define QUIC_SSTREAM_STATE_READY 1 /* \ */ #define QUIC_SSTREAM_STATE_SEND 2 /* |-- sstream != NULL */ #define QUIC_SSTREAM_STATE_DATA_SENT 3 /* / */ #define QUIC_SSTREAM_STATE_DATA_RECVD 4 /* \ */ #define QUIC_SSTREAM_STATE_RESET_SENT 5 /* |-- sstream == NULL */ #define QUIC_SSTREAM_STATE_RESET_RECVD 6 /* / */ /* * QUIC Receive Stream States * -------------------------- * * These correspond to the states defined in RFC 9000 s. 3.2, with the exception * of the NONE state which represents the absence of a receive stream part. * * Invariants in each state are noted in comments below. In particular, once all * data has been read by the application, we don't need to keep the QUIC_RSTREAM * and data buffers around. If the receive part is instead reset before it is * finished, we also don't need to keep the QUIC_RSTREAM around. Finally, we * don't need a QUIC_RSTREAM on a send-only stream. */ #define QUIC_RSTREAM_STATE_NONE 0 /* --- rstream == NULL */ #define QUIC_RSTREAM_STATE_RECV 1 /* \ */ #define QUIC_RSTREAM_STATE_SIZE_KNOWN 2 /* |-- rstream != NULL */ #define QUIC_RSTREAM_STATE_DATA_RECVD 3 /* / */ #define QUIC_RSTREAM_STATE_DATA_READ 4 /* \ */ #define QUIC_RSTREAM_STATE_RESET_RECVD 5 /* |-- rstream == NULL */ #define QUIC_RSTREAM_STATE_RESET_READ 6 /* / */ struct quic_stream_st { QUIC_STREAM_LIST_NODE active_node; /* for use by QUIC_STREAM_MAP */ QUIC_STREAM_LIST_NODE accept_node; /* accept queue of remotely-created streams */ QUIC_STREAM_LIST_NODE ready_for_gc_node; /* queue of streams now ready for GC */ /* Temporary link used by TXP. */ QUIC_STREAM *txp_next; /* * QUIC Stream ID. Do not assume that this encodes a type as this is a * version-specific property and may change between QUIC versions; instead, * use the type field. */ uint64_t id; /* * Application Error Code (AEC) used for STOP_SENDING frame. * This is only valid if stop_sending is 1. */ uint64_t stop_sending_aec; /* * Application Error Code (AEC) used for RESET_STREAM frame. * This is only valid if reset_stream is 1. */ uint64_t reset_stream_aec; /* * Application Error Code (AEC) for incoming STOP_SENDING frame. * This is only valid if peer_stop_sending is 1. */ uint64_t peer_stop_sending_aec; /* * Application Error Code (AEC) for incoming RESET_STREAM frame. * This is only valid if peer_reset_stream is 1. */ uint64_t peer_reset_stream_aec; /* Temporary value used by TXP. */ uint64_t txp_txfc_new_credit_consumed; /* * The final size of the send stream. Although this information can be * discerned from a QUIC_SSTREAM, it is stored separately as we need to keep * track of this even if we have thrown away the QUIC_SSTREAM. Use * ossl_quic_stream_send_get_final_size to determine if this contain a * valid value or if there is no final size yet for a sending part. * * For the receive part, the final size is tracked by the stream-level RXFC; * use ossl_quic_stream_recv_get_final_size or * ossl_quic_rxfc_get_final_size. */ uint64_t send_final_size; /* * Send stream part and receive stream part buffer management objects. * * DO NOT test these pointers (sstream, rstream) for NULL. Determine the * state of the send or receive stream part first using the appropriate * function; then the invariant of that state guarantees that sstream or * rstream either is or is not NULL respectively, therefore there is no * valid use case for testing these pointers for NULL. In particular, a * stream with a send part can still have sstream as NULL, and a stream with * a receive part can still have rstream as NULL. QUIC_SSTREAM and * QUIC_RSTREAM are stream buffer resource management objects which exist * only when they need to for buffer management purposes. The existence or * non-existence of a QUIC_SSTREAM or QUIC_RSTREAM object does not * correspond with whether a stream's respective send or receive part * logically exists or not. */ QUIC_SSTREAM *sstream; /* NULL if RX-only */ QUIC_RSTREAM *rstream; /* NULL if TX only */ /* Stream-level flow control managers. */ QUIC_TXFC txfc; /* NULL if RX-only */ QUIC_RXFC rxfc; /* NULL if TX-only */ unsigned int type : 8; /* QUIC_STREAM_INITIATOR_*, QUIC_STREAM_DIR_* */ unsigned int send_state : 8; /* QUIC_SSTREAM_STATE_* */ unsigned int recv_state : 8; /* QUIC_RSTREAM_STATE_* */ /* 1 iff this QUIC_STREAM is on the active queue (invariant). */ unsigned int active : 1; /* * This is a copy of the QUIC connection as_server value, indicating * whether we are locally operating as a server or not. Having this * significantly simplifies stream type determination relative to our * perspective. It never changes after a QUIC_STREAM is created and is the * same for all QUIC_STREAMS under a QUIC_STREAM_MAP. */ unsigned int as_server : 1; /* * Has STOP_SENDING been requested (by us)? Note that this is not the same * as want_stop_sending below, as a STOP_SENDING frame may already have been * sent and fully acknowledged. */ unsigned int stop_sending : 1; /* * Has RESET_STREAM been requested (by us)? Works identically to * STOP_SENDING for transmission purposes. */ /* Has our peer sent a STOP_SENDING frame? */ unsigned int peer_stop_sending : 1; /* Temporary flags used by TXP. */ unsigned int txp_sent_fc : 1; unsigned int txp_sent_stop_sending : 1; unsigned int txp_sent_reset_stream : 1; unsigned int txp_drained : 1; unsigned int txp_blocked : 1; /* Frame regeneration flags. */ unsigned int want_max_stream_data : 1; /* used for regen only */ unsigned int want_stop_sending : 1; /* used for gen or regen */ unsigned int want_reset_stream : 1; /* used for gen or regen */ /* Flags set when frames *we* sent were acknowledged. */ unsigned int acked_stop_sending : 1; /* * The stream's XSO has been deleted. Pending GC. * * Here is how stream deletion works: * * - A QUIC_STREAM cannot be deleted until it is neither in the accept * queue nor has an associated XSO. This condition occurs when and only * when deleted is true. * * - Once this is the case (i.e., no user-facing API object exposing the * stream), we can delete the stream once we determine that all of our * protocol obligations requiring us to keep the QUIC_STREAM around have * been met. * * The following frames relate to the streams layer for a specific * stream: * * STREAM * * RX Obligations: * Ignore for a deleted stream. * * (This is different from our obligation for a * locally-initiated stream ID we have not created yet, * which we must treat as a protocol error. This can be * distinguished via a simple monotonic counter.) * * TX Obligations: * None, once we've decided to (someday) delete the stream. * * STOP_SENDING * * We cannot delete the stream until we have finished informing * the peer that we are not going to be listening to it * anymore. * * RX Obligations: * When we delete a stream we must have already had a FIN * or RESET_STREAM we transmitted acknowledged by the peer. * Thus we can ignore STOP_SENDING frames for deleted * streams (if they occur, they are probably just * retransmissions). * * TX Obligations: * _Acknowledged_ receipt of a STOP_SENDING frame by the * peer (unless the peer's send part has already FIN'd). * * RESET_STREAM * * We cannot delete the stream until we have finished informing * the peer that we are not going to be transmitting on it * anymore. * * RX Obligations: * This indicates the peer is not going to send any more * data on the stream. We don't need to care about this * since once a stream is marked for deletion we don't care * about any data it does send. We can ignore this for * deleted streams. The important criterion is that the * peer has been successfully delivered our STOP_SENDING * frame. * * TX Obligations: * _Acknowledged_ receipt of a RESET_STREAM frame or FIN by * the peer. * * MAX_STREAM_DATA * * RX Obligations: * Ignore. Since we are not going to be sending any more * data on a stream once it has been marked for deletion, * we don't need to care about flow control information. * * TX Obligations: * None. * * In other words, our protocol obligation is simply: * * - either: * - the peer has acknowledged receipt of a STOP_SENDING frame sent * by us; -or- * - we have received a FIN and all preceding segments from the peer * * [NOTE: The actual criterion required here is simply 'we have * received a FIN from the peer'. However, due to reordering and * retransmissions we might subsequently receive non-FIN segments * out of order. The FIN means we know the peer will stop * transmitting on the stream at *some* point, but by sending * STOP_SENDING we can avoid these needless retransmissions we * will just ignore anyway. In actuality we could just handle all * cases by sending a STOP_SENDING. The strategy we choose is to * only avoid sending a STOP_SENDING and rely on a received FIN * when we have received all preceding data, as this makes it * reasonably certain no benefit would be gained by sending * STOP_SENDING.] * * TODO(QUIC FUTURE): Implement the latter case (currently we just always do STOP_SENDING). * * and; * * - we have drained our send stream (for a finished send stream) * and got acknowledgement all parts of it including the FIN, or * sent a RESET_STREAM frame and got acknowledgement of that frame. * * Once these conditions are met, we can GC the QUIC_STREAM. * */ unsigned int deleted : 1; /* Set to 1 once the above conditions are actually met. */ unsigned int ready_for_gc : 1; /* Set to 1 if this is currently counted in the shutdown flush stream count. */ unsigned int shutdown_flush : 1; }; #define QUIC_STREAM_INITIATOR_CLIENT 0 #define QUIC_STREAM_INITIATOR_SERVER 1 #define QUIC_STREAM_INITIATOR_MASK 1 #define QUIC_STREAM_DIR_BIDI 0 #define QUIC_STREAM_DIR_UNI 2 #define QUIC_STREAM_DIR_MASK 2 void ossl_quic_stream_check(const QUIC_STREAM *s); /* * Returns 1 if the QUIC_STREAM was initiated by the endpoint with the server * role. */ static ossl_inline ossl_unused int ossl_quic_stream_is_server_init(const QUIC_STREAM *s) { return (s->type & QUIC_STREAM_INITIATOR_MASK) == QUIC_STREAM_INITIATOR_SERVER; } /* * Returns 1 if the QUIC_STREAM is bidirectional and 0 if it is unidirectional. */ static ossl_inline ossl_unused int ossl_quic_stream_is_bidi(const QUIC_STREAM *s) { return (s->type & QUIC_STREAM_DIR_MASK) == QUIC_STREAM_DIR_BIDI; } /* Returns 1 if the QUIC_STREAM was locally initiated. */ static ossl_inline ossl_unused int ossl_quic_stream_is_local_init(const QUIC_STREAM *s) { return ossl_quic_stream_is_server_init(s) == s->as_server; } /* * Returns 1 if the QUIC_STREAM has a sending part, based on its stream type. * * Do NOT use (s->sstream != NULL) to test this; use this function. Note that * even if this function returns 1, s->sstream might be NULL if the QUIC_SSTREAM * has been deemed no longer needed, for example due to a RESET_STREAM. */ static ossl_inline ossl_unused int ossl_quic_stream_has_send(const QUIC_STREAM *s) { return s->send_state != QUIC_SSTREAM_STATE_NONE; } /* * Returns 1 if the QUIC_STREAM has a receiving part, based on its stream type. * * Do NOT use (s->rstream != NULL) to test this; use this function. Note that * even if this function returns 1, s->rstream might be NULL if the QUIC_RSTREAM * has been deemed no longer needed, for example if the receive stream is * completely finished with. */ static ossl_inline ossl_unused int ossl_quic_stream_has_recv(const QUIC_STREAM *s) { return s->recv_state != QUIC_RSTREAM_STATE_NONE; } /* * Returns 1 if the QUIC_STREAM has a QUIC_SSTREAM send buffer associated with * it. If this returns 1, s->sstream is guaranteed to be non-NULL. The converse * is not necessarily true; erasure of a send stream buffer which is no longer * required is an optimisation which the QSM may, but is not obliged, to * perform. * * This call should be used where it is desired to do something with the send * stream buffer but there is no more specific send state restriction which is * applicable. * * Note: This does NOT indicate whether it is suitable to allow an application * to append to the buffer. DATA_SENT indicates all data (including FIN) has * been *sent*; the absence of DATA_SENT does not mean a FIN has not been queued * (meaning no more application data can be appended). This is enforced by * QUIC_SSTREAM. */ static ossl_inline ossl_unused int ossl_quic_stream_has_send_buffer(const QUIC_STREAM *s) { switch (s->send_state) { case QUIC_SSTREAM_STATE_READY: case QUIC_SSTREAM_STATE_SEND: case QUIC_SSTREAM_STATE_DATA_SENT: return 1; default: return 0; } } /* * Returns 1 if the QUIC_STREAM has a sending part which is in one of the reset * states. */ static ossl_inline ossl_unused int ossl_quic_stream_send_is_reset(const QUIC_STREAM *s) { return s->send_state == QUIC_SSTREAM_STATE_RESET_SENT || s->send_state == QUIC_SSTREAM_STATE_RESET_RECVD; } /* * Returns 1 if the QUIC_STREAM has a QUIC_RSTREAM receive buffer associated * with it. If this returns 1, s->rstream is guaranteed to be non-NULL. The * converse is not necessarily true; erasure of a receive stream buffer which is * no longer required is an optimisation which the QSM may, but is not obliged, * to perform. * * This call should be used where it is desired to do something with the receive * stream buffer but there is no more specific receive state restriction which is * applicable. */ static ossl_inline ossl_unused int ossl_quic_stream_has_recv_buffer(const QUIC_STREAM *s) { switch (s->recv_state) { case QUIC_RSTREAM_STATE_RECV: case QUIC_RSTREAM_STATE_SIZE_KNOWN: case QUIC_RSTREAM_STATE_DATA_RECVD: return 1; default: return 0; } } /* * Returns 1 if the QUIC_STREAM has a receiving part which is in one of the * reset states. */ static ossl_inline ossl_unused int ossl_quic_stream_recv_is_reset(const QUIC_STREAM *s) { return s->recv_state == QUIC_RSTREAM_STATE_RESET_RECVD || s->recv_state == QUIC_RSTREAM_STATE_RESET_READ; } /* * Returns 1 if the stream has a send part and that part has a final size. * * If final_size is non-NULL, *final_size is the final size (on success) or an * undefined value otherwise. */ static ossl_inline ossl_unused int ossl_quic_stream_send_get_final_size(const QUIC_STREAM *s, uint64_t *final_size) { switch (s->send_state) { default: case QUIC_SSTREAM_STATE_NONE: return 0; case QUIC_SSTREAM_STATE_SEND: /* * SEND may or may not have had a FIN - even if we have a FIN we do not * move to DATA_SENT until we have actually sent all the data. So * ask the QUIC_SSTREAM. */ return ossl_quic_sstream_get_final_size(s->sstream, final_size); case QUIC_SSTREAM_STATE_DATA_SENT: case QUIC_SSTREAM_STATE_DATA_RECVD: case QUIC_SSTREAM_STATE_RESET_SENT: case QUIC_SSTREAM_STATE_RESET_RECVD: if (final_size != NULL) *final_size = s->send_final_size; return 1; } } /* * Returns 1 if the stream has a receive part and that part has a final size. * * If final_size is non-NULL, *final_size is the final size (on success) or an * undefined value otherwise. */ static ossl_inline ossl_unused int ossl_quic_stream_recv_get_final_size(const QUIC_STREAM *s, uint64_t *final_size) { switch (s->recv_state) { default: case QUIC_RSTREAM_STATE_NONE: case QUIC_RSTREAM_STATE_RECV: return 0; case QUIC_RSTREAM_STATE_SIZE_KNOWN: case QUIC_RSTREAM_STATE_DATA_RECVD: case QUIC_RSTREAM_STATE_DATA_READ: case QUIC_RSTREAM_STATE_RESET_RECVD: case QUIC_RSTREAM_STATE_RESET_READ: if (!ossl_assert(ossl_quic_rxfc_get_final_size(&s->rxfc, final_size))) return 0; return 1; } } /* * QUIC Stream Map * =============== * * The QUIC stream map: * * - maps stream IDs to QUIC_STREAM objects; * - tracks which streams are 'active' (currently have data for transmission); * - allows iteration over the active streams only. * */ typedef struct quic_stream_map_st { LHASH_OF(QUIC_STREAM) *map; QUIC_STREAM_LIST_NODE active_list; QUIC_STREAM_LIST_NODE accept_list; QUIC_STREAM_LIST_NODE ready_for_gc_list; size_t rr_stepping, rr_counter; size_t num_accept, num_shutdown_flush; QUIC_STREAM *rr_cur; uint64_t (*get_stream_limit_cb)(int uni, void *arg); void *get_stream_limit_cb_arg; QUIC_RXFC *max_streams_bidi_rxfc; QUIC_RXFC *max_streams_uni_rxfc; int is_server; } QUIC_STREAM_MAP; /* * get_stream_limit is a callback which is called to retrieve the current stream * limit for streams created by us. This mechanism is not used for * peer-initiated streams. If a stream's stream ID is x, a stream is allowed if * (x >> 2) < returned limit value; i.e., the returned value is exclusive. * * If uni is 1, get the limit for locally-initiated unidirectional streams, else * get the limit for locally-initiated bidirectional streams. * * If the callback is NULL, stream limiting is not applied. * Stream limiting is used to determine if frames can currently be produced for * a stream. */ int ossl_quic_stream_map_init(QUIC_STREAM_MAP *qsm, uint64_t (*get_stream_limit_cb)(int uni, void *arg), void *get_stream_limit_cb_arg, QUIC_RXFC *max_streams_bidi_rxfc, QUIC_RXFC *max_streams_uni_rxfc, int is_server); /* * Any streams still in the map will be released as though * ossl_quic_stream_map_release was called on them. */ void ossl_quic_stream_map_cleanup(QUIC_STREAM_MAP *qsm); /* * Allocate a new stream. type is a combination of one QUIC_STREAM_INITIATOR_* * value and one QUIC_STREAM_DIR_* value. Note that clients can e.g. allocate * server-initiated streams as they will need to allocate a QUIC_STREAM * structure to track any stream created by the server, etc. * * stream_id must be a valid value. Returns NULL if a stream already exists * with the given ID. */ QUIC_STREAM *ossl_quic_stream_map_alloc(QUIC_STREAM_MAP *qsm, uint64_t stream_id, int type); /* * Releases a stream object. Note that this must only be done once the teardown * process is entirely complete and the object will never be referenced again. */ void ossl_quic_stream_map_release(QUIC_STREAM_MAP *qsm, QUIC_STREAM *stream); /* * Calls visit_cb() for each stream in the map. visit_cb_arg is an opaque * argument which is passed through. */ void ossl_quic_stream_map_visit(QUIC_STREAM_MAP *qsm, void (*visit_cb)(QUIC_STREAM *stream, void *arg), void *visit_cb_arg); /* * Retrieves a stream by stream ID. Returns NULL if it does not exist. */ QUIC_STREAM *ossl_quic_stream_map_get_by_id(QUIC_STREAM_MAP *qsm, uint64_t stream_id); /* * Marks the given stream as active or inactive based on its state. Idempotent. * * When a stream is marked active, it becomes available in the iteration list, * and when a stream is marked inactive, it no longer appears in the iteration * list. * * Calling this function invalidates any iterator currently pointing at the * given stream object, but iterators not currently pointing at the given stream * object are not invalidated. */ void ossl_quic_stream_map_update_state(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s); /* * Sets the RR stepping value, n. The RR rotation will be advanced every n * packets. The default value is 1. */ void ossl_quic_stream_map_set_rr_stepping(QUIC_STREAM_MAP *qsm, size_t stepping); /* * Returns 1 if the stream ordinal given is allowed by the current stream count * flow control limit, assuming a locally initiated stream of a type described * by is_uni. * * Note that stream_ordinal is a stream ordinal, not a stream ID. */ int ossl_quic_stream_map_is_local_allowed_by_stream_limit(QUIC_STREAM_MAP *qsm, uint64_t stream_ordinal, int is_uni); /* * Stream Send Part * ================ */ /* * Ensures that the sending part has transitioned out of the READY state (i.e., * to SEND, or a subsequent state). This function is named as it is because, * while on paper the distinction between READY and SEND is whether we have * started transmitting application data, in practice the meaningful distinction * between the two states is whether we have allocated a stream ID to the stream * or not. QUIC permits us to defer stream ID allocation until first STREAM (or * STREAM_DATA_BLOCKED) frame transmission for locally-initiated streams. * * Our implementation does not currently do this and we allocate stream IDs up * front, however we may revisit this in the future. Calling this represents a * demand for a stream ID by the caller and ensures one has been allocated to * the stream, and causes us to transition to SEND if we are still in the READY * state. * * Returns 0 if there is no send part (caller error) and 1 otherwise. */ int ossl_quic_stream_map_ensure_send_part_id(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Transitions from SEND to the DATA_SENT state. Note that this is NOT the same * as the point in time at which the final size of the stream becomes known * (i.e., the time at which ossl_quic_sstream_fin()) is called as it occurs when * we have SENT all data on a given stream send part, not merely buffered it. * Note that this transition is NOT reversed in the event of some of that data * being lost. * * Returns 1 if the state transition was successfully taken. Returns 0 if there * is no send part (caller error) or if the state transition cannot be taken * because the send part is not in the SEND state. */ int ossl_quic_stream_map_notify_all_data_sent(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Transitions from the DATA_SENT to DATA_RECVD state; should be called * when all transmitted stream data is ACKed by the peer. * * Returns 1 if the state transition was successfully taken. Returns 0 if there * is no send part (caller error) or the state transition cannot be taken * because the send part is not in the DATA_SENT state. Because * ossl_quic_stream_map_notify_all_data_sent() should always be called prior to * this function, the send state must already be in DATA_SENT in order for this * function to succeed. */ int ossl_quic_stream_map_notify_totally_acked(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Resets the sending part of a stream. This is a transition from the READY, * SEND or DATA_SENT send stream states to the RESET_SENT state. * * This function returns 1 if the transition is taken (i.e., if the send stream * part was in one of the states above), or if it is already in the RESET_SENT * state (idempotent operation), or if it has reached the RESET_RECVD state. * * It returns 0 if in the DATA_RECVD state, as a send stream cannot be reset * in this state. It also returns 0 if there is no send part (caller error). */ int ossl_quic_stream_map_reset_stream_send_part(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs, uint64_t aec); /* * Transitions from the RESET_SENT to the RESET_RECVD state. This should be * called when a sent RESET_STREAM frame has been acknowledged by the peer. * * This function returns 1 if the transition is taken (i.e., if the send stream * part was in one of the states above) or if it is already in the RESET_RECVD * state (idempotent operation). * * It returns 0 if not in the RESET_SENT or RESET_RECVD states, as this function * should only be called after we have already sent a RESET_STREAM frame and * entered the RESET_SENT state. It also returns 0 if there is no send part * (caller error). */ int ossl_quic_stream_map_notify_reset_stream_acked(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Stream Receive Part * =================== */ /* * Transitions from the RECV receive stream state to the SIZE_KNOWN state. This * should be called once a STREAM frame is received for the stream with the FIN * bit set. final_size should be the final size of the stream in bytes. * * Returns 1 if the transition was taken. */ int ossl_quic_stream_map_notify_size_known_recv_part(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs, uint64_t final_size); /* * Transitions from the SIZE_KNOWN receive stream state to the DATA_RECVD state. * This should be called once all data for a receive stream is received. * * Returns 1 if the transition was taken. */ int ossl_quic_stream_map_notify_totally_received(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Transitions from the DATA_RECVD receive stream state to the DATA_READ state. * This should be called once all data for a receive stream is read by the * application. * * Returns 1 if the transition was taken. */ int ossl_quic_stream_map_notify_totally_read(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Transitions from the RECV, SIZE_KNOWN or DATA_RECVD receive stream state to * the RESET_RECVD state. This should be called on RESET_STREAM. * * Returns 1 if the transition was taken. */ int ossl_quic_stream_map_notify_reset_recv_part(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs, uint64_t app_error_code, uint64_t final_size); /* * Transitions from the RESET_RECVD receive stream state to the RESET_READ * receive stream state. This should be called when the application is notified * of a stream reset. */ int ossl_quic_stream_map_notify_app_read_reset_recv_part(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Marks the receiving part of a stream for STOP_SENDING. This is orthogonal to * receive stream state as it does not affect it directly. * * Returns 1 if the receiving part of a stream was not already marked for * STOP_SENDING. * Returns 0 otherwise, which need not be considered an error. */ int ossl_quic_stream_map_stop_sending_recv_part(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs, uint64_t aec); /* * Marks the stream as wanting a STOP_SENDING frame transmitted. It is not valid * to call this if ossl_quic_stream_map_stop_sending_recv_part() has not been * called. For TXP use. */ int ossl_quic_stream_map_schedule_stop_sending(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs); /* * Accept Queue Management * ======================= */ /* * Adds a stream to the accept queue. */ void ossl_quic_stream_map_push_accept_queue(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s); /* * Returns the next item to be popped from the accept queue, or NULL if it is * empty. */ QUIC_STREAM *ossl_quic_stream_map_peek_accept_queue(QUIC_STREAM_MAP *qsm); /* * Removes a stream from the accept queue. rtt is the estimated connection RTT. * The stream is retired for the purposes of MAX_STREAMS RXFC. * * Precondition: s is in the accept queue. */ void ossl_quic_stream_map_remove_from_accept_queue(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s, OSSL_TIME rtt); /* Returns the length of the accept queue. */ size_t ossl_quic_stream_map_get_accept_queue_len(QUIC_STREAM_MAP *qsm); /* * Shutdown Flush and GC * ===================== */ /* * Delete streams ready for GC. Pointers to those QUIC_STREAM objects become * invalid. */ void ossl_quic_stream_map_gc(QUIC_STREAM_MAP *qsm); /* * Begins shutdown stream flush triage. Analyses all streams, including deleted * but not yet GC'd streams, to determine if we should wait for that stream to * be fully flushed before shutdown. After calling this, call * ossl_quic_stream_map_is_shutdown_flush_finished() to determine if all * shutdown flush eligible streams have been flushed. */ void ossl_quic_stream_map_begin_shutdown_flush(QUIC_STREAM_MAP *qsm); /* * Returns 1 if all shutdown flush eligible streams have finished flushing, * or if ossl_quic_stream_map_begin_shutdown_flush() has not been called. */ int ossl_quic_stream_map_is_shutdown_flush_finished(QUIC_STREAM_MAP *qsm); /* * QUIC Stream Iterator * ==================== * * Allows the current set of active streams to be walked using a RR-based * algorithm. Each time ossl_quic_stream_iter_init is called, the RR algorithm * is stepped. The RR algorithm rotates the iteration order such that the next * active stream is returned first after n calls to ossl_quic_stream_iter_init, * where n is the stepping value configured via * ossl_quic_stream_map_set_rr_stepping. * * Suppose there are three active streams and the configured stepping is n: * * Iteration 0n: [Stream 1] [Stream 2] [Stream 3] * Iteration 1n: [Stream 2] [Stream 3] [Stream 1] * Iteration 2n: [Stream 3] [Stream 1] [Stream 2] * */ typedef struct quic_stream_iter_st { QUIC_STREAM_MAP *qsm; QUIC_STREAM *first_stream, *stream; } QUIC_STREAM_ITER; /* * Initialise an iterator, advancing the RR algorithm as necessary (if * advance_rr is 1). After calling this, it->stream will be the first stream in * the iteration sequence, or NULL if there are no active streams. */ void ossl_quic_stream_iter_init(QUIC_STREAM_ITER *it, QUIC_STREAM_MAP *qsm, int advance_rr); /* * Advances to next stream in iteration sequence. You do not need to call this * immediately after calling ossl_quic_stream_iter_init(). If the end of the * list is reached, it->stream will be NULL after calling this. */ void ossl_quic_stream_iter_next(QUIC_STREAM_ITER *it); # endif #endif