1Glossary of QUIC Terms 2====================== 3 4**ACKM:** ACK Manager. Responsible for tracking packets in flight and generating 5notifications when they are lost, or when they are successfully delivered. 6 7**Active Stream:** A stream which has data or control frames ready for 8transmission. Active stream status is managed by the QSM. 9 10**AEC:** Application error code. An error code provided by a local or remote 11application to be signalled as an error code value by QUIC. See QUIC RFCs 12(`STOP_SENDING`, `RESET_STREAM`, `CONNECTION_CLOSE`). 13 14**APL:** API Personality Layer. The QUIC API Personality Layer lives in 15`quic_impl.c` and implements the libssl API personality (`SSL_read`, etc.) in 16terms of an underlying `QUIC_CHANNEL` object. 17 18**Bidi:** Abbreviation of bidirectional, referring to a QUIC bidirectional 19stream. 20 21**CC:** Congestion controller. Estimates network channel capacity and imposes 22limits on transmissions accordingly. 23 24**CFQ:** Control Frame Queue. Considered part of the FIFM, this implements the 25GCR strategy for frame in flight management. For details, see FIFM design 26document. 27 28**Channel:** See `QUIC_CHANNEL`. 29 30**CID:** Connection ID. 31 32**CMPL:** Coalescing Maximum Packet Length. The maximum number of bytes left to 33serialize another QUIC packet into the same datagram as one or more previous 34packets. This is just the MDPL minus the total size of all previous packets 35already serialized into to the same datagram. 36 37**CMPPL:** Coalescing Maximum Packet Payload Length. The maximum number of 38payload bytes we can put in the payload of another QUIC packet which is to be 39coalesced with one or more previous QUIC packets and placed into the same 40datagram. Essentially, this is the room we have left for another packet payload. 41 42**CSM:** Connection state machine. Refers to some aspects of a QUIC channel. Not 43implemented as an explicit state machine. 44 45**DCID:** Destination Connection ID. Found in all QUIC packet headers. 46 47**DEMUX:** The demuxer routes incoming packets to the correct connection QRX by 48DCID. 49 50**DGRAM:** (UDP) datagram. 51 52**DISPATCH:** Refers to the QUIC-specific dispatch code in `ssl_lib.c`. This 53dispatches calls to libssl public APIs to the APL. 54 55**EL:** Encryption level. See RFC 9000. 56 57**Engine:** See `QUIC_ENGINE`. 58 59**Event Leader:** The QSO which is is the top-level QSO in a hierarchy of QSOs, 60and which is responsible for event processing for all QSOs in that hierarchy. 61This may be a QLSO or QCSO. See [the server API 62design](server/quic-server-api.md). 63 64**FC:** Flow control. Comprises TXFC and RXFC. 65 66**FIFD:** Frame-in-flight dispatcher. Ties together the CFQ and TXPIM to handle 67frame tracking and retransmission on loss. 68 69**FIFM:** Frame-in-flight manager. Tracks frames in flight until their 70containing packets are deemed delivered or lost, so that frames can be 71retransmitted if necessary. Comprises the CFQ, TXPIM and FIFD. 72 73**GCR:** Generic Control Frame Retransmission. A strategy for regenerating lost 74frames. Stores raw frame in a queue so that it can be retransmitted if lost. See 75FIFM design document for details. Implemented by the CFQ. 76 77**Key epoch:** Non-negative number designating a generation of QUIC keys used to 78encrypt or decrypt packets, starting at 0. This increases by 1 when a QUIC key 79update occurs. 80 81**Key Phase:** Key phase bit in QUIC packet headers. See RFC 9000. 82 83**Keyslot**: A set of cryptographic state used to encrypt or decrypt QUIC 84packets by a QRX or QTX. Due to the QUIC key update mechanism, multiple keyslots 85may be maintained at a given time. See `quic_record_rx.h` for details. 86 87**KP:** See Key Phase. 88 89**KS:** See Keyslot. 90 91**KU:** Key update. See also TXKU, RXKU. 92 93**LCID:** Local CID. Refers to a CID which will be recognised as identifying a 94connection if found in the DCID field of an incoming packet. See also RCID. 95 96**LCIDM:** Local CID Manager. Tracks LCIDs which have been advertised to a peer. 97See also RCIDM. 98 99**Locally-initiated:** Refers to a QUIC stream which was initiated by the local 100application rather than the remote peer. 101 102**MDPL:** Maximum Datagram Payload Length. The maximum number of UDP payload 103bytes we can put in a UDP packet. This is derived from the applicable PMTU. This 104is also the maximum size of a single QUIC packet if we place only one packet in 105a datagram. The MDPL may vary based on both local source IP and destination IP 106due to different path MTUs. 107 108**MinDPL:** Minimum Datagram Payload Length. In some cases we must ensure a 109datagram has a minimum size of a certain number of bytes. This does not need to 110be accomplished with a single packet, but we may need to add PADDING frames to 111the final packet added to a datagram in this case. 112 113**MinPL:** Minimum Packet Length. The minimum serialized packet length we are 114using while serializing a given packet. May often be 0. Used to meet MinDPL 115requirements, and thus equal to MinDPL minus the length of any packets we have 116already encoded into the datagram. 117 118**MinPPL:** Minimum Packet Payload Length. The minimum number of bytes which 119must be placed into a packet payload in order to meet the MinPL minimum size 120when the packet is encoded. 121 122**MPL:** Maximum Packet Length. The maximum size of a fully encrypted and 123serialized QUIC packet in bytes in some given context. Typically equal to the 124MDPL and never greater than it. 125 126**MPPL:** Maximum Packet Payload Length. The maximum number of plaintext bytes 127we can put in the payload of a QUIC packet. This is related to the MDPL by the 128size of the encoded header and the size of any AEAD authentication tag which 129will be attached to the ciphertext. 130 131**MSMT:** Multi-stream multi-thread. Refers to a type of multi-stream QUIC usage 132in which API calls can be made on different threads. 133 134**MSST:** Multi-stream single-thread. Refers to a type of multi-stream QUIC 135usage in which API calls must not be made concurrently. 136 137**NCID:** New Connection ID. Refers to a QUIC `NEW_CONNECTION_ID` frame. 138 139**Numbered CID:** Refers to a Connection ID which has a sequence number assigned 140to it. All CIDs other than Initial ODCIDs and Retry ODCIDs have a sequence 141number assigned. See also Unnumbered CID. 142 143**ODCID:** Original Destination CID. This is the DCID found in the first Initial 144packet sent by a client, and is used to generate the secrets for encrypting 145Initial packets. It is only used temporarily. 146 147**PN:** Packet number. Most QUIC packet types have a packet number (PN); see RFC 1489000. 149 150**Port:** See `QUIC_PORT`. 151 152**Port Leader:** The QSO which is responsible for servicing a given UDP socket. 153This may be a QCSO or a QLSO. See [the server API design](server/quic-server-api.md). 154 155**PTO:** Probe timeout. See RFC 9000. 156 157**QC:** See `QUIC_CONNECTION`. 158 159**QCSO:** QUIC Connection SSL Object. This is an SSL object created using 160`SSL_new` using a QUIC method, or by a QLSO. 161 162**QCTX**: QUIC Context. This is a utility object defined within the QUIC APL 163which helps to unwrap an SSL object pointer (a QLSO, QCSO or QSSO) into the 164relevant structure pointers such as `QUIC_LISTENER`, `QUIC_CONNECTION` or 165`QUIC_XSO`. 166 167**QL:** See `QUIC_LISTENER`. 168 169**QLSO:** QUIC Listener SSL Object. An object created to represent a socket 170which can accept one or more incoming QUIC connections and/or make multiple 171outgoing QUIC connections. Parent of zero or more QCSOs. 172 173**QUIC_LISTENER:** QUIC listener. This is the APL object representing a QUIC 174listener (QLSO) in the APL. 175 176**QP:** See `QUIC_PORT`. 177 178**QUIC_PORT:** Internal object owning the network socket BIO which services a 179QLSO. This is the QUIC core object corresponding to the APL's `QUIC_LISTENER` 180object (a QLSO). Owns zero more `QUIC_CHANNEL` instances. 181 182**QRL:** QUIC record layer. Refers collectively to the QRX and QTX. 183 184**QRX:** QUIC Record Layer RX. Receives incoming datagrams and decrypts the 185packets contained in them. Manages decrypted packets in a queue pending 186processing by upper layers. 187 188**QS:** See `QUIC_STREAM`. 189 190**QSM:** QUIC Streams Mapper. Manages internal `QUIC_STREAM` objects and maps 191IDs to those objects. Allows iteration of active streams. 192 193**QSO:** QUIC SSL Object. May be a QLSO, QCSO or QSSO. 194 195**QSSO:** QUIC Stream SSL Object. This is an SSL object which is subsidiary to a 196given QCSO, obtained using (for example) `SSL_new_stream` or 197`SSL_accept_stream`. 198 199**QTLS**, **QUIC_TLS**: Implements the QUIC handshake layer using TLS 1.3, 200wrapping libssl TLS code to implement the QUIC-specific aspects of QUIC TLS. 201 202**QTX:** QUIC Record Layer TX. Encrypts and sends packets in datagrams. 203 204**QUIC_CHANNEL:** Internal object in the QUIC core implementation corresponding 205to a QUIC connection. Ties together other components and provides connection 206handling and state machine implementation. Belongs to a `QUIC_PORT` representing 207a UDP socket/BIO, which in turn belongs to a `QUIC_ENGINE`. Owns some number of 208`QUIC_STREAM` instances. The `QUIC_CHANNEL` code is fused tightly with the RXDP. 209 210**QUIC_CONNECTION:** QUIC connection. This is the object representing a QUIC 211connection in the APL. It internally corresponds to a `QUIC_CHANNEL` object in 212the QUIC core implementation. 213 214**QUIC_ENGINE:** Internal object in the QUIC core implementation constituting 215the top-level object of a QUIC event and I/O processing domain. Owns zero or 216more `QUIC_PORT` instances, each of which owns zero or more `QUIC_CHANNEL` 217objects representing QUIC connections. 218 219**QUIC_PORT:** Internal object in the QUIC core implementation corresponding to 220a listening port/network BIO. Has zero or more child `QUIC_CHANNEL` objects 221associated with it and belongs to a `QUIC_ENGINE`. 222 223**QUIC_STREAM**: Internal object tracking a QUIC stream. Unlike an XSO this is 224not part of the APL. An XSO wraps a QUIC_STREAM once that stream is exposed as 225an API object. As such, a `QUIC_CONNECTION` is to a `QUIC_CHANNEL` what a 226`QUIC_XSO` is to a `QUIC_STREAM`. 227 228**RCID:** Remote CID. Refers to a CID which has been provided to us by a peer 229and which we can place in the DCID field of an outgoing packet. See also LCID, 230Unnumbered CID and Numbered CID. 231 232**RCIDM:** Remote CID Manager. Tracks RCIDs which have been provided to us by a 233peer. See also LCIDM. 234 235**REGEN:** A strategy for regenerating lost frames. This strategy regenerates 236the frame from canonical data sources without having to store a copy of the 237frame which was transmitted. See FIFM design document for details. 238 239**Remotely-initiated:** Refers to a QUIC stream which was initiated by the 240remote peer, rather than by the local application. 241 242**RIO:** Reactive I/O subsystem. Refers to the generic, non-QUIC specific parts 243of the asynchronous I/O handling code which the OpenSSL QUIC stack is built on. 244 245**RSTREAM:** Receive stream. Internal receive buffer management object used to 246store data which has been RX'd but not yet read by the application. 247 248**RTT:** Round trip time. Time for a datagram to reach a given peer and a reply 249to reach the local machine, assuming the peer responds immediately. 250 251**RXDP:** RX depacketiser. Handles frames in packets which have been decrypted 252by a QRX. 253 254**RXE:** RX entry. Structure containing decrypted received packets awaiting 255processing. Stored in a queue known as the RXL. These structures belong to a 256QRX. 257 258**RXFC:** RX flow control. This determines how much a peer may send to us and 259provides indication of when flow control frames increasing a peer's flow control 260budget should be generated. Exists in both connection-level and stream-level 261instances. 262 263**RXKU:** RX key update. The detected condition whereby a received packet 264has a flipped Key Phase bit, meaning the peer has initiated a key update. 265Causes a solicited TXKU. See also TXKU. 266 267**RXL:** RXE list. See RXE. 268 269**RCMPPL:** Remaining CMPPL. The number of bytes left in a packet whose payload 270we are currently forming. This is the CMPPL minus any bytes we have already put 271into the payload. 272 273**SCID:** Source Connection ID. Found in some QUIC packet headers. 274 275**SRT:** Stateless reset token. 276 277**SRTM:** Stateless reset token manager. Object which tracks SRTs we have 278received. 279 280**SSTREAM:** Send stream. Internal send buffer management object used to store 281data which has been passed to libssl for sending but which has not yet been 282transmitted, or not yet been acknowledged. 283 284**STATM:** Statistics manager. Measures estimated connection RTT. 285 286**TA:** Thread assisted mode. 287 288**TPARAM:** Transport parameter. See RFC 9000. 289 290**TSERVER:** Test server. Internal test server object built around a channel. 291 292**TXE:** TX entry. Structure containing encrypted data pending transmission. 293Owned by the QTX. 294 295**TXFC:** TX flow control. This determines how much can be transmitted to the 296peer. Exists in both connection-level and stream-level instances. 297 298**TXKU:** TX key update. This refers to when a QTX signals a key update for the 299TX direction by flipping the Key Phase bit in an outgoing packet. A TXKU can be 300either spontaneous (locally initiated) or in solicited (in response to receiving 301an RXKU). See also RXKU. 302 303**TXL:** TXE list. See TXE. 304 305**TXP:** TX packetiser. This is responsible for generating yet-unencrypted 306packets and passing them to a QTX for encryption and transmission. It must 307decide how to spend the space available in a datagram. 308 309**TXPIM:** Transmitted Packet Information Manager. Stores information about 310transmitted packets and the frames contained within them. This information 311is needed to facilitate retransmission of frames if the packets they are in 312are lost. Note that the ACKM records only receipt or loss of entire packets, 313whereas TXPIM tracks information about individual frames in those packets. 314 315**TX/RX v. Send/Receive:** The terms *TX* and *RX* are used for *network-level* 316communication, whereas *send* and *receive* are used for application-level 317communication. An application *sends* on a stream (causing data to be appended 318to a *send stream buffer*, and that data is eventually TX'd by the TXP and QTX.) 319 320**Uni:** Abbreviation of unidirectional, referring to a QUIC unidirectional 321stream. 322 323**Unnumbered CID:** Refers to a CID which does not have a sequence number 324associated with it and therefore cannot be referred to by a `NEW_CONNECTION_ID` 325or `RETIRE_CONNECTION_ID` frame's sequence number fields. The only unnumbered 326CIDs are Initial ODCIDs and Retry ODCIDs. These CIDs are exceptionally retired 327automatically during handshake confirmation. See also Numbered CID. 328 329**URXE:** Unprocessed RX entry. Structure containing yet-undecrypted received 330datagrams pending processing. Stored in a queue known as the URXL. 331Ownership of URXEs is shared between DEMUX and QRX. 332 333**URXL:** URXE list. See URXE. 334 335**XSO:** External Stream Object. This is the API object representing a QUIC 336stream in the APL. Internally, it is the `QUIC_XSO` structure, externally it is 337a `SSL *` (and is a QSSO). 338