openssl/doc/designs/quic-design/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 (STOP_SENDING, RESET_STREAM, CONNECTION_CLOSE).

APL: API Personality Layer. The QUIC API Personality Layer lives in quic_impl.c and implements the libssl API personality (SSL_read, 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: See QUIC_CHANNEL.

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.

Engine: See QUIC_ENGINE.

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 quic_record_rx.h for details.

KP: See Key Phase.

KS: See Keyslot.

KU: Key update. See also TXKU, RXKU.

LCID: Local CID. Refers to a CID which will be recognised as identifying a connection if found in the DCID field of an incoming packet. See also RCID.

LCIDM: Local CID Manager. Tracks LCIDs which have been advertised to a peer. See also RCIDM.

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 PMTU. 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.

NCID: New Connection ID. Refers to a QUIC NEW_CONNECTION_ID frame.

Numbered CID: Refers to a Connection ID which has a sequence number assigned to it. All CIDs other than Initial ODCIDs and Retry ODCIDs have a sequence number assigned. See also Unnumbered CID.

ODCID: Original Destination CID. This is the DCID found in the first Initial packet sent by a client, and is used to generate the secrets for encrypting Initial packets. It is only used temporarily.

PN: Packet number. Most QUIC packet types have a packet number (PN); see RFC 9000.

Port: See QUIC_PORT.

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 QUIC_CONNECTION or QUIC_XSO.

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) SSL_new_stream or SSL_accept_stream.

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_CHANNEL: Internal object in the QUIC core implementation corresponding to a QUIC connection. Ties together other components and provides connection handling and state machine implementation. Belongs to a QUIC_PORT representing a UDP socket/BIO, which in turn belongs to a QUIC_ENGINE. Owns some number of QUIC_STREAM instances. The QUIC_CHANNEL code is fused tightly with the RXDP.

QUIC_CONNECTION: QUIC connection. This is the object representing a QUIC connection in the APL. It internally corresponds to a QUIC_CHANNEL object in the QUIC core implementation.

QUIC_ENGINE: Internal object in the QUIC core implementation constituting the top-level object of a QUIC event and I/O processing domain. Owns zero or more QUIC_PORT instances, each of which owns zero or more QUIC_CHANNEL objects representing QUIC connections.

QUIC_PORT: Internal object in the QUIC core implementation corresponding to a listening port/network BIO. Has zero or more child QUIC_CHANNEL objects associated with it and belongs to a QUIC_ENGINE.

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 QUIC_CONNECTION is to a QUIC_CHANNEL what a QUIC_XSO is to a QUIC_STREAM.

RCID: Remote CID. Refers to a CID which has been provided to us by a peer and which we can place in the DCID field of an outgoing packet. See also LCID, Unnumbered CID and Numbered CID.

RCIDM: Remote CID Manager. Tracks RCIDs which have been provided to us by a peer. See also LCIDM.

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 details.

Remotely-initiated: Refers to a QUIC stream which was initiated by the remote peer, rather than by the local application.

RIO: Reactive I/O subsystem. Refers to the generic, non-QUIC specific parts of the asynchronous I/O handling code which the OpenSSL QUIC stack is built on.

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.

SRT: Stateless reset token.

SRTM: Stateless reset token manager. Object which tracks SRTs we have received.

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.

Unnumbered CID: Refers to a CID which does not have a sequence number associated with it and therefore cannot be referred to by a NEW_CONNECTION_ID or RETIRE_CONNECTION_ID frame's sequence number fields. The only unnumbered CIDs are Initial ODCIDs and Retry ODCIDs. These CIDs are exceptionally retired automatically during handshake confirmation. See also Numbered CID.

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).