Project: Pipy (Orchestration & Management / Service Proxy)
File: glossary.md

Glossary of QUIC Terms ====================== ACKM: ACK Manager. Responsible for tracking packets in flight and generating notifications when they are lost, or when they are successfully delivered. Active Stream: A stream which has data or control frames ready for transmission. Active stream status is managed by the QSM. AEC: Application error code. An error code provided by a local or remote application to be signalled as an error code value by QUIC. See QUIC RFCs (`STOPSENDING`, `RESETSTREAM`, `CONNECTION_CLOSE`). APL: API Personality Layer. The QUIC API Personality Layer lives in `quicimpl.c` and implements the libssl API personality (`SSLread`, etc.) in terms of an underlying `QUIC_CHANNEL` object. Bidi: Abbreviation of bidirectional, referring to a QUIC bidirectional stream. CC: Congestion controller. Estimates network channel capacity and imposes limits on transmissions accordingly. CFQ: Control Frame Queue. Considered part of the FIFM, this implements the CFQ strategy for frame in flight management. For details, see FIFM design document. Channel: Core QUIC connection handling object and connection state machine implementation. This is fused tightly with the RXDP. CID: Connection ID. CMPL: The maximum number of bytes left to serialize another QUIC packet into the same datagram as one or more previous packets. This is just the MDPL minus the total size of all previous packets already serialized into to the same datagram. CMPPL: The maximum number of payload bytes we can put in the payload of another QUIC packet which is to be coalesced with one or more previous QUIC packets and placed into the same datagram. Essentially, this is the room we have left for another packet payload. CSM: Connection state machine. Refers to some aspects of a QUIC channel. Not implemented as an explicit state machine. DCID: Destination Connection ID. Found in most QUIC packet headers. DEMUX: The demuxer routes incoming packets to the correct connection QRX by DCID. DGRAM: (UDP) datagram. DISPATCH: Refers to the QUIC-specific dispatch code in `ssl_lib.c`. This dispatches calls to libssl public APIs to the APL. EL: Encryption level. See RFC 9000. FC: Flow control. Comprises TXFC and RXFC. FIFD: Frame-in-flight dispatcher. Ties together the CFQ and TXPIM to handle frame tracking and retransmission on loss. FIFM: Frame-in-flight manager. Tracks frames in flight until their containing packets are deemed delivered or lost, so that frames can be retransmitted if necessary. Comprises the CFQ, TXPIM and FIFD. GCR: Generic Control Frame Retransmission. A strategy for regenerating lost frames. Stores raw frame in a queue so that it can be retransmitted if lost. See FIFM design document for details. Key epoch: Non-negative number designating a generation of QUIC keys used to encrypt or decrypt packets, starting at 0. This increases by 1 when a QUIC key update occurs. Key Phase: Key phase bit in QUIC packet headers. See RFC 9000. Keyslot: A set of cryptographic state used to encrypt or decrypt QUIC packets by a QRX or QTX. Due to the QUIC key update mechanism, multiple keyslots may be maintained at a given time. See `quicrecordrx.h` for details. KP: See Key Phase. KS: See Keyslot. KU: Key update. See also TXKU, RXKU. Locally-initiated: Refers to a QUIC stream which was initiated by the local application rather than the remote peer. MDPL: Maximum Datagram Payload Length. The maximum number of UDP payload bytes we can put in a UDP packet. This is derived from the applicable

This is also the maximum size of a single QUIC packet if we place only one packet in a datagram. The MDPL may vary based on both local source IP and destination IP due to different path MTUs. MinDPL: In some cases we must ensure a datagram has a minimum size of a certain number of bytes. This does not need to be accomplished with a single packet, but we may need to add PADDING frames to the final packet added to a datagram in this case. MinPL: The minimum serialized packet length we are using while serializing a given packet. May often be 0. Used to meet MinDPL requirements, and thus equal to MinDPL minus the length of any packets we have already encoded into the datagram. MinPPL: The minimum number of bytes which must be placed into a packet payload in order to meet the MinPL minimum size when the packet is encoded. MPL: Maximum Packet Length. The maximum size of a fully encrypted and serialized QUIC packet in bytes in some given context. Typically equal to the MDPL and never greater than it. MPPL: The maximum number of plaintext bytes we can put in the payload of a QUIC packet. This is related to the MDPL by the size of the encoded header and the size of any AEAD authentication tag which will be attached to the ciphertext. MSMT: Multi-stream multi-thread. Refers to a type of multi-stream QUIC usage in which API calls can be made on different threads. MSST: Multi-stream single-thread. Refers to a type of multi-stream QUIC usage in which API calls must not be made concurrently. PN: Packet number. Most QUIC packet types have a packet number (PN); see RFC PTO: Probe timeout. See RFC 9000. QC: See `QUIC_CONNECTION`. QCSO: QUIC Connection SSL Object. This is an SSL object created using `SSL_new` using a QUIC method. QCTX: QUIC Context. This is a utility object defined within the QUIC APL which helps to unwrap a SSL object pointer (a QCSO or QSSO) into the relevant structure pointers such as `QUICCONNECTION` or `QUICXSO`. QRL: QUIC record layer. Refers collectively to the QRX and QTX. QRX: QUIC Record Layer RX. Receives incoming datagrams and decrypts the packets contained in them. Manages decrypted packets in a queue pending processing by upper layers. QS: See `QUIC_STREAM`. QSM: QUIC Streams Mapper. Manages internal `QUIC_STREAM` objects and maps IDs to those objects. Allows iteration of active streams. QSO: QUIC SSL Object. May be a QCSO or a QSSO. QSSO: QUIC Stream SSL Object. This is an SSL object which is subsidiary to a given QCSO, obtained using (for example) `SSLnewstream` or `SSLacceptstream`. QTLS, QUIC_TLS: Implements the QUIC handshake layer using TLS 1.3, wrapping libssl TLS code to implement the QUIC-specific aspects of QUIC TLS. QTX: QUIC Record Layer TX. Encrypts and sends packets in datagrams. QUIC_CONNECTION: QUIC connection. This is the object representing a QUIC connection in the APL. QUIC_STREAM: Internal object tracking a QUIC stream. Unlike an XSO this is not part of the APL. An XSO wraps a QUIC_STREAM once that stream is exposed as an API object. As such, a `QUICCONNECTION` is to a `QUICCHANNEL` what a `QUICXSO` is to a `QUICSTREAM`. REGEN: A strategy for regenerating lost frames. This strategy regenerates the frame from canonical data sources without having to store a copy of the frame which was transmitted. See FIFM design document for

Remotely-initiated: Refers to a QUIC stream which was initiated by the remote peer, rather than by the local application. RSTREAM: Receive stream. Internal receive buffer management object used to store data which has been RX'd but not yet read by the application. RTT: Round trip time. Time for a datagram to reach a given peer and a reply to reach the local machine, assuming the peer responds immediately. RXDP: RX depacketiser. Handles frames in packets which have been decrypted by a QRX. RXE: RX entry. Structure containing decrypted received packets awaiting processing. Stored in a queue known as the RXL. These structures belong to a QRX. RXFC: RX flow control. This determines how much a peer may send to us and provides indication of when flow control frames increasing a peer's flow control budget should be generated. Exists in both connection-level and stream-level instances. RXKU: RX key update. The detected condition whereby a received packet has a flipped Key Phase bit, meaning the peer has initiated a key update. Causes a solicited TXKU. See also TXKU. RXL: RXE list. See RXE. RCMPPL: The number of bytes left in a packet whose payload we are currently forming. This is the CMPPL minus any bytes we have already put into the payload. SCID: Source Connection ID. Found in some QUIC packet headers. SSTREAM: Send stream. Internal send buffer management object used to store data which has been passed to libssl for sending but which has not yet been transmitted, or not yet been acknowledged. STATM: Statistics manager. Measures estimated connection RTT. TA: Thread assisted mode. TPARAM: Transport parameter. See RFC 9000. TSERVER: Test server. Internal test server object built around a channel. TXE: TX entry. Structure containing encrypted data pending transmission. Owned by the QTX. TXFC: TX flow control. This determines how much can be transmitted to the peer. Exists in both connection-level and stream-level instances. TXKU: TX key update. This refers to when a QTX signals a key update for the TX direction by flipping the Key Phase bit in an outgoing packet. A TXKU can be either spontaneous (locally initiated) or in solicited (in response to receiving an RXKU). See also RXKU. TXL: TXE list. See TXE. TXP: TX packetiser. This is responsible for generating yet-unencrypted packets and passing them to a QTX for encryption and transmission. It must decide how to spend the space available in a datagram. TXPIM: Transmitted Packet Information Manager. Stores information about transmitted packets and the frames contained within them. This information is needed to facilitate retransmission of frames if the packets they are in are lost. Note that the ACKM records only receipt or loss of entire packets, whereas TXPIM tracks information about individual frames in those packets. TX/RX v. Send/Receive: The terms TX and RX are used for network-level communication, whereas send and receive are used for application-level communication. An application sends on a stream (causing data to be appended to a send stream buffer, and that data is eventually TX'd by the TXP and QTX.) Uni: Abbreviation of unidirectional, referring to a QUIC unidirectional stream. URXE: Unprocessed RX entry. Structure containing yet-undecrypted received datagrams pending processing. Stored in a queue known as the URXL. Ownership of URXEs is shared between DEMUX and QRX. URXL: URXE list. See URXE. XSO: External Stream Object. This is the API object representing a QUIC stream in the APL. Internally, it is the `QUIC_XSO` structure, externally it is a `SSL *` (and is a QSSO).