blob: ffaf6c61490895a9689b9cc2484c89815e4d6698 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef QUICHE_QUIC_CORE_QUIC_TYPES_H_
#define QUICHE_QUIC_CORE_QUIC_TYPES_H_
#include <array>
#include <cstddef>
#include <cstdint>
#include <map>
#include <ostream>
#include <vector>
#include "absl/container/inlined_vector.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "quiche/quic/core/quic_connection_id.h"
#include "quiche/quic/core/quic_error_codes.h"
#include "quiche/quic/core/quic_packet_number.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/platform/api/quic_export.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/common/quiche_endian.h"
namespace quic {
using QuicPacketLength = uint16_t;
using QuicControlFrameId = uint32_t;
using QuicMessageId = uint32_t;
// IMPORTANT: IETF QUIC defines stream IDs and stream counts as being unsigned
// 62-bit numbers. However, we have decided to only support up to 2^32-1 streams
// in order to reduce the size of data structures such as QuicStreamFrame
// and QuicTransmissionInfo, as that allows them to fit in cache lines and has
// visible perfomance impact.
using QuicStreamId = uint32_t;
// Count of stream IDs. Used in MAX_STREAMS and STREAMS_BLOCKED frames.
using QuicStreamCount = QuicStreamId;
using QuicByteCount = uint64_t;
using QuicPacketCount = uint64_t;
using QuicPublicResetNonceProof = uint64_t;
using QuicStreamOffset = uint64_t;
using DiversificationNonce = std::array<char, 32>;
using PacketTimeVector = std::vector<std::pair<QuicPacketNumber, QuicTime>>;
enum : size_t { kStatelessResetTokenLength = 16 };
using StatelessResetToken = std::array<char, kStatelessResetTokenLength>;
// WebTransport session IDs are stream IDs.
using WebTransportSessionId = uint64_t;
// WebTransport stream reset codes are 8-bit.
using WebTransportStreamError = uint8_t;
// WebTransport session error codes are 32-bit.
using WebTransportSessionError = uint32_t;
enum : size_t { kQuicPathFrameBufferSize = 8 };
using QuicPathFrameBuffer = std::array<uint8_t, kQuicPathFrameBufferSize>;
// The connection id sequence number specifies the order that connection
// ids must be used in. This is also the sequence number carried in
// the IETF QUIC NEW_CONNECTION_ID and RETIRE_CONNECTION_ID frames.
using QuicConnectionIdSequenceNumber = uint64_t;
// A custom data that represents application-specific settings.
// In HTTP/3 for example, it includes the encoded SETTINGS.
using ApplicationState = std::vector<uint8_t>;
// A struct for functions which consume data payloads and fins.
struct QUIC_EXPORT_PRIVATE QuicConsumedData {
constexpr QuicConsumedData(size_t bytes_consumed, bool fin_consumed)
: bytes_consumed(bytes_consumed), fin_consumed(fin_consumed) {}
// By default, gtest prints the raw bytes of an object. The bool data
// member causes this object to have padding bytes, which causes the
// default gtest object printer to read uninitialize memory. So we need
// to teach gtest how to print this object.
QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
std::ostream& os, const QuicConsumedData& s);
// How many bytes were consumed.
size_t bytes_consumed;
// True if an incoming fin was consumed.
bool fin_consumed;
};
// QuicAsyncStatus enumerates the possible results of an asynchronous
// operation.
enum QuicAsyncStatus {
QUIC_SUCCESS = 0,
QUIC_FAILURE = 1,
// QUIC_PENDING results from an operation that will occur asynchronously. When
// the operation is complete, a callback's |Run| method will be called.
QUIC_PENDING = 2,
};
// TODO(wtc): see if WriteStatus can be replaced by QuicAsyncStatus.
enum WriteStatus : int16_t {
WRITE_STATUS_OK,
// Write is blocked, caller needs to retry.
WRITE_STATUS_BLOCKED,
// Write is blocked but the packet data is buffered, caller should not retry.
WRITE_STATUS_BLOCKED_DATA_BUFFERED,
// To make the IsWriteError(WriteStatus) function work properly:
// - Non-errors MUST be added before WRITE_STATUS_ERROR.
// - Errors MUST be added after WRITE_STATUS_ERROR.
WRITE_STATUS_ERROR,
WRITE_STATUS_MSG_TOO_BIG,
WRITE_STATUS_FAILED_TO_COALESCE_PACKET,
WRITE_STATUS_NUM_VALUES,
};
std::string HistogramEnumString(WriteStatus enum_value);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const WriteStatus& status);
inline std::string HistogramEnumDescription(WriteStatus /*dummy*/) {
return "status";
}
inline bool IsWriteBlockedStatus(WriteStatus status) {
return status == WRITE_STATUS_BLOCKED ||
status == WRITE_STATUS_BLOCKED_DATA_BUFFERED;
}
inline bool IsWriteError(WriteStatus status) {
return status >= WRITE_STATUS_ERROR;
}
// A struct used to return the result of write calls including either the number
// of bytes written or the error code, depending upon the status.
struct QUIC_EXPORT_PRIVATE WriteResult {
constexpr WriteResult(WriteStatus status, int bytes_written_or_error_code)
: status(status), bytes_written(bytes_written_or_error_code) {}
constexpr WriteResult() : WriteResult(WRITE_STATUS_ERROR, 0) {}
bool operator==(const WriteResult& other) const {
if (status != other.status) {
return false;
}
switch (status) {
case WRITE_STATUS_OK:
return bytes_written == other.bytes_written;
case WRITE_STATUS_BLOCKED:
case WRITE_STATUS_BLOCKED_DATA_BUFFERED:
return true;
default:
return error_code == other.error_code;
}
}
QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
const WriteResult& s);
WriteStatus status;
// Number of packets dropped as a result of this write.
// Only used by batch writers. Otherwise always 0.
uint16_t dropped_packets = 0;
// The delta between a packet's ideal and actual send time:
// actual_send_time = ideal_send_time + send_time_offset
// = (now + release_time_delay) + send_time_offset
// Only valid if |status| is WRITE_STATUS_OK.
QuicTime::Delta send_time_offset = QuicTime::Delta::Zero();
// TODO(wub): In some cases, WRITE_STATUS_ERROR may set an error_code and
// WRITE_STATUS_BLOCKED_DATA_BUFFERED may set bytes_written. This may need
// some cleaning up so that perhaps both values can be set and valid.
union {
int bytes_written; // only valid when status is WRITE_STATUS_OK
int error_code; // only valid when status is WRITE_STATUS_ERROR
};
};
enum TransmissionType : int8_t {
NOT_RETRANSMISSION,
FIRST_TRANSMISSION_TYPE = NOT_RETRANSMISSION,
HANDSHAKE_RETRANSMISSION, // Retransmits due to handshake timeouts.
ALL_ZERO_RTT_RETRANSMISSION, // Retransmits all packets encrypted with 0-RTT
// key.
LOSS_RETRANSMISSION, // Retransmits due to loss detection.
PTO_RETRANSMISSION, // Retransmission due to probe timeout.
PATH_RETRANSMISSION, // Retransmission proactively due to underlying
// network change.
ALL_INITIAL_RETRANSMISSION, // Retransmit all packets encrypted with INITIAL
// key.
LAST_TRANSMISSION_TYPE = ALL_INITIAL_RETRANSMISSION,
};
QUIC_EXPORT_PRIVATE std::string TransmissionTypeToString(
TransmissionType transmission_type);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, TransmissionType transmission_type);
enum HasRetransmittableData : uint8_t {
NO_RETRANSMITTABLE_DATA,
HAS_RETRANSMITTABLE_DATA,
};
enum IsHandshake : uint8_t { NOT_HANDSHAKE, IS_HANDSHAKE };
enum class Perspective : uint8_t { IS_SERVER, IS_CLIENT };
QUIC_EXPORT_PRIVATE std::string PerspectiveToString(Perspective perspective);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const Perspective& perspective);
// Describes whether a ConnectionClose was originated by the peer.
enum class ConnectionCloseSource { FROM_PEER, FROM_SELF };
QUIC_EXPORT_PRIVATE std::string ConnectionCloseSourceToString(
ConnectionCloseSource connection_close_source);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, const ConnectionCloseSource& connection_close_source);
// Should a connection be closed silently or not.
enum class ConnectionCloseBehavior {
SILENT_CLOSE,
SILENT_CLOSE_WITH_CONNECTION_CLOSE_PACKET_SERIALIZED,
SEND_CONNECTION_CLOSE_PACKET
};
QUIC_EXPORT_PRIVATE std::string ConnectionCloseBehaviorToString(
ConnectionCloseBehavior connection_close_behavior);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, const ConnectionCloseBehavior& connection_close_behavior);
enum QuicFrameType : uint8_t {
// Regular frame types. The values set here cannot change without the
// introduction of a new QUIC version.
PADDING_FRAME = 0,
RST_STREAM_FRAME = 1,
CONNECTION_CLOSE_FRAME = 2,
GOAWAY_FRAME = 3,
WINDOW_UPDATE_FRAME = 4,
BLOCKED_FRAME = 5,
STOP_WAITING_FRAME = 6,
PING_FRAME = 7,
CRYPTO_FRAME = 8,
// TODO(b/157935330): stop hard coding this when deprecate T050.
HANDSHAKE_DONE_FRAME = 9,
// STREAM and ACK frames are special frames. They are encoded differently on
// the wire and their values do not need to be stable.
STREAM_FRAME,
ACK_FRAME,
// The path MTU discovery frame is encoded as a PING frame on the wire.
MTU_DISCOVERY_FRAME,
// These are for IETF-specific frames for which there is no mapping
// from Google QUIC frames. These are valid/allowed if and only if IETF-
// QUIC has been negotiated. Values are not important, they are not
// the values that are in the packets (see QuicIetfFrameType, below).
NEW_CONNECTION_ID_FRAME,
MAX_STREAMS_FRAME,
STREAMS_BLOCKED_FRAME,
PATH_RESPONSE_FRAME,
PATH_CHALLENGE_FRAME,
STOP_SENDING_FRAME,
MESSAGE_FRAME,
NEW_TOKEN_FRAME,
RETIRE_CONNECTION_ID_FRAME,
ACK_FREQUENCY_FRAME,
NUM_FRAME_TYPES
};
// Human-readable string suitable for logging.
QUIC_EXPORT_PRIVATE std::string QuicFrameTypeToString(QuicFrameType t);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const QuicFrameType& t);
// Ietf frame types. These are defined in the IETF QUIC Specification.
// Explicit values are given in the enum so that we can be sure that
// the symbol will map to the correct stream type.
// All types are defined here, even if we have not yet implmented the
// quic/core/stream/.... stuff needed.
// Note: The protocol specifies that frame types are varint-62 encoded,
// further stating that the shortest encoding must be used. The current set of
// frame types all have values less than 0x40 (64) so can be encoded in a single
// byte, with the two most significant bits being 0. Thus, the following
// enumerations are valid as both the numeric values of frame types AND their
// encodings.
enum QuicIetfFrameType : uint64_t {
IETF_PADDING = 0x00,
IETF_PING = 0x01,
IETF_ACK = 0x02,
IETF_ACK_ECN = 0x03,
IETF_RST_STREAM = 0x04,
IETF_STOP_SENDING = 0x05,
IETF_CRYPTO = 0x06,
IETF_NEW_TOKEN = 0x07,
// the low-3 bits of the stream frame type value are actually flags
// declaring what parts of the frame are/are-not present, as well as
// some other control information. The code would then do something
// along the lines of "if ((frame_type & 0xf8) == 0x08)" to determine
// whether the frame is a stream frame or not, and then examine each
// bit specifically when/as needed.
IETF_STREAM = 0x08,
// 0x09 through 0x0f are various flag settings of the IETF_STREAM frame.
IETF_MAX_DATA = 0x10,
IETF_MAX_STREAM_DATA = 0x11,
IETF_MAX_STREAMS_BIDIRECTIONAL = 0x12,
IETF_MAX_STREAMS_UNIDIRECTIONAL = 0x13,
IETF_DATA_BLOCKED = 0x14,
IETF_STREAM_DATA_BLOCKED = 0x15,
IETF_STREAMS_BLOCKED_BIDIRECTIONAL = 0x16,
IETF_STREAMS_BLOCKED_UNIDIRECTIONAL = 0x17,
IETF_NEW_CONNECTION_ID = 0x18,
IETF_RETIRE_CONNECTION_ID = 0x19,
IETF_PATH_CHALLENGE = 0x1a,
IETF_PATH_RESPONSE = 0x1b,
// Both of the following are "Connection Close" frames,
// the first signals transport-layer errors, the second application-layer
// errors.
IETF_CONNECTION_CLOSE = 0x1c,
IETF_APPLICATION_CLOSE = 0x1d,
IETF_HANDSHAKE_DONE = 0x1e,
// The MESSAGE frame type has not yet been fully standardized.
// QUIC versions starting with 46 and before 99 use 0x20-0x21.
// IETF QUIC (v99) uses 0x30-0x31, see draft-pauly-quic-datagram.
IETF_EXTENSION_MESSAGE_NO_LENGTH = 0x20,
IETF_EXTENSION_MESSAGE = 0x21,
IETF_EXTENSION_MESSAGE_NO_LENGTH_V99 = 0x30,
IETF_EXTENSION_MESSAGE_V99 = 0x31,
// An QUIC extension frame for sender control of acknowledgement delays
IETF_ACK_FREQUENCY = 0xaf,
// A QUIC extension frame which augments the IETF_ACK frame definition with
// packet receive timestamps.
// TODO(ianswett): Determine a proper value to replace this temporary value.
IETF_ACK_RECEIVE_TIMESTAMPS = 0x22,
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const QuicIetfFrameType& c);
QUIC_EXPORT_PRIVATE std::string QuicIetfFrameTypeString(QuicIetfFrameType t);
// Masks for the bits that indicate the frame is a Stream frame vs the
// bits used as flags.
#define IETF_STREAM_FRAME_TYPE_MASK 0xfffffffffffffff8
#define IETF_STREAM_FRAME_FLAG_MASK 0x07
#define IS_IETF_STREAM_FRAME(_stype_) \
(((_stype_)&IETF_STREAM_FRAME_TYPE_MASK) == IETF_STREAM)
// These are the values encoded in the low-order 3 bits of the
// IETF_STREAMx frame type.
#define IETF_STREAM_FRAME_FIN_BIT 0x01
#define IETF_STREAM_FRAME_LEN_BIT 0x02
#define IETF_STREAM_FRAME_OFF_BIT 0x04
enum QuicPacketNumberLength : uint8_t {
PACKET_1BYTE_PACKET_NUMBER = 1,
PACKET_2BYTE_PACKET_NUMBER = 2,
PACKET_3BYTE_PACKET_NUMBER = 3, // Used in versions 45+.
PACKET_4BYTE_PACKET_NUMBER = 4,
IETF_MAX_PACKET_NUMBER_LENGTH = 4,
// TODO(b/145819870): Remove 6 and 8 when we remove Q043 since these values
// are not representable with later versions.
PACKET_6BYTE_PACKET_NUMBER = 6,
PACKET_8BYTE_PACKET_NUMBER = 8
};
// Used to indicate a QuicSequenceNumberLength using two flag bits.
enum QuicPacketNumberLengthFlags {
PACKET_FLAGS_1BYTE_PACKET = 0, // 00
PACKET_FLAGS_2BYTE_PACKET = 1, // 01
PACKET_FLAGS_4BYTE_PACKET = 1 << 1, // 10
PACKET_FLAGS_8BYTE_PACKET = 1 << 1 | 1, // 11
};
// The public flags are specified in one byte.
enum QuicPacketPublicFlags {
PACKET_PUBLIC_FLAGS_NONE = 0,
// Bit 0: Does the packet header contains version info?
PACKET_PUBLIC_FLAGS_VERSION = 1 << 0,
// Bit 1: Is this packet a public reset packet?
PACKET_PUBLIC_FLAGS_RST = 1 << 1,
// Bit 2: indicates the header includes a nonce.
PACKET_PUBLIC_FLAGS_NONCE = 1 << 2,
// Bit 3: indicates whether a ConnectionID is included.
PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID = 0,
PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID = 1 << 3,
// Deprecated version 32 and earlier used two bits to indicate an 8-byte
// connection ID. We send this from the client because of some broken
// middleboxes that are still checking this bit.
PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD = 1 << 3 | 1 << 2,
// Bits 4 and 5 describe the packet number length as follows:
// --00----: 1 byte
// --01----: 2 bytes
// --10----: 4 bytes
// --11----: 6 bytes
PACKET_PUBLIC_FLAGS_1BYTE_PACKET = PACKET_FLAGS_1BYTE_PACKET << 4,
PACKET_PUBLIC_FLAGS_2BYTE_PACKET = PACKET_FLAGS_2BYTE_PACKET << 4,
PACKET_PUBLIC_FLAGS_4BYTE_PACKET = PACKET_FLAGS_4BYTE_PACKET << 4,
PACKET_PUBLIC_FLAGS_6BYTE_PACKET = PACKET_FLAGS_8BYTE_PACKET << 4,
// Reserved, unimplemented flags:
// Bit 7: indicates the presence of a second flags byte.
PACKET_PUBLIC_FLAGS_TWO_OR_MORE_BYTES = 1 << 7,
// All bits set (bits 6 and 7 are not currently used): 00111111
PACKET_PUBLIC_FLAGS_MAX = (1 << 6) - 1,
};
// The private flags are specified in one byte.
enum QuicPacketPrivateFlags {
PACKET_PRIVATE_FLAGS_NONE = 0,
// Bit 0: Does this packet contain an entropy bit?
PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 0,
// (bits 1-7 are not used): 00000001
PACKET_PRIVATE_FLAGS_MAX = (1 << 1) - 1
};
// Defines for all types of congestion control algorithms that can be used in
// QUIC. Note that this is separate from the congestion feedback type -
// some congestion control algorithms may use the same feedback type
// (Reno and Cubic are the classic example for that).
enum CongestionControlType {
kCubicBytes,
kRenoBytes,
kBBR,
kPCC,
kGoogCC,
kBBRv2,
};
QUIC_EXPORT_PRIVATE std::string CongestionControlTypeToString(
CongestionControlType cc_type);
// EncryptionLevel enumerates the stages of encryption that a QUIC connection
// progresses through. When retransmitting a packet, the encryption level needs
// to be specified so that it is retransmitted at a level which the peer can
// understand.
enum EncryptionLevel : int8_t {
ENCRYPTION_INITIAL = 0,
ENCRYPTION_HANDSHAKE = 1,
ENCRYPTION_ZERO_RTT = 2,
ENCRYPTION_FORWARD_SECURE = 3,
NUM_ENCRYPTION_LEVELS,
};
inline bool EncryptionLevelIsValid(EncryptionLevel level) {
return ENCRYPTION_INITIAL <= level && level < NUM_ENCRYPTION_LEVELS;
}
QUIC_EXPORT_PRIVATE std::string EncryptionLevelToString(EncryptionLevel level);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
EncryptionLevel level);
// Enumeration of whether a server endpoint will request a client certificate,
// and whether that endpoint requires a valid client certificate to establish a
// connection.
enum class ClientCertMode : uint8_t {
kNone, // Do not request a client certificate. Default server behavior.
kRequest, // Request a certificate, but allow unauthenticated connections.
kRequire, // Require clients to provide a valid certificate.
};
QUIC_EXPORT_PRIVATE absl::string_view ClientCertModeToString(
ClientCertMode mode);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
ClientCertMode mode);
enum AddressChangeType : uint8_t {
// IP address and port remain unchanged.
NO_CHANGE,
// Port changed, but IP address remains unchanged.
PORT_CHANGE,
// IPv4 address changed, but within the /24 subnet (port may have changed.)
IPV4_SUBNET_CHANGE,
// IPv4 address changed, excluding /24 subnet change (port may have changed.)
IPV4_TO_IPV4_CHANGE,
// IP address change from an IPv4 to an IPv6 address (port may have changed.)
IPV4_TO_IPV6_CHANGE,
// IP address change from an IPv6 to an IPv4 address (port may have changed.)
IPV6_TO_IPV4_CHANGE,
// IP address change from an IPv6 to an IPv6 address (port may have changed.)
IPV6_TO_IPV6_CHANGE,
};
QUIC_EXPORT_PRIVATE std::string AddressChangeTypeToString(
AddressChangeType type);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
AddressChangeType type);
enum StreamSendingState {
// Sender has more data to send on this stream.
NO_FIN,
// Sender is done sending on this stream.
FIN,
// Sender is done sending on this stream and random padding needs to be
// appended after all stream frames.
FIN_AND_PADDING,
};
enum SentPacketState : uint8_t {
// The packet is in flight and waiting to be acked.
OUTSTANDING,
FIRST_PACKET_STATE = OUTSTANDING,
// The packet was never sent.
NEVER_SENT,
// The packet has been acked.
ACKED,
// This packet is not expected to be acked.
UNACKABLE,
// This packet has been delivered or unneeded.
NEUTERED,
// States below are corresponding to retransmission types in TransmissionType.
// This packet has been retransmitted when retransmission timer fires in
// HANDSHAKE mode.
HANDSHAKE_RETRANSMITTED,
// This packet is considered as lost, this is used for LOST_RETRANSMISSION.
LOST,
// This packet has been retransmitted when PTO fires.
PTO_RETRANSMITTED,
// This packet is sent on a different path or is a PING only packet.
// Do not update RTT stats and congestion control if the packet is the
// largest_acked of an incoming ACK.
NOT_CONTRIBUTING_RTT,
LAST_PACKET_STATE = NOT_CONTRIBUTING_RTT,
};
enum PacketHeaderFormat : uint8_t {
IETF_QUIC_LONG_HEADER_PACKET,
IETF_QUIC_SHORT_HEADER_PACKET,
GOOGLE_QUIC_PACKET,
};
QUIC_EXPORT_PRIVATE std::string PacketHeaderFormatToString(
PacketHeaderFormat format);
// Information about a newly acknowledged packet.
struct QUIC_EXPORT_PRIVATE AckedPacket {
constexpr AckedPacket(QuicPacketNumber packet_number,
QuicPacketLength bytes_acked,
QuicTime receive_timestamp)
: packet_number(packet_number),
bytes_acked(bytes_acked),
receive_timestamp(receive_timestamp) {}
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, const AckedPacket& acked_packet);
QuicPacketNumber packet_number;
// Number of bytes sent in the packet that was acknowledged.
QuicPacketLength bytes_acked;
// The time |packet_number| was received by the peer, according to the
// optional timestamp the peer included in the ACK frame which acknowledged
// |packet_number|. Zero if no timestamp was available for this packet.
QuicTime receive_timestamp;
};
// A vector of acked packets.
using AckedPacketVector = absl::InlinedVector<AckedPacket, 2>;
// Information about a newly lost packet.
struct QUIC_EXPORT_PRIVATE LostPacket {
LostPacket(QuicPacketNumber packet_number, QuicPacketLength bytes_lost)
: packet_number(packet_number), bytes_lost(bytes_lost) {}
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, const LostPacket& lost_packet);
QuicPacketNumber packet_number;
// Number of bytes sent in the packet that was lost.
QuicPacketLength bytes_lost;
};
// A vector of lost packets.
using LostPacketVector = absl::InlinedVector<LostPacket, 2>;
// Please note, this value cannot used directly for packet serialization.
enum QuicLongHeaderType : uint8_t {
VERSION_NEGOTIATION,
INITIAL,
ZERO_RTT_PROTECTED,
HANDSHAKE,
RETRY,
INVALID_PACKET_TYPE,
};
QUIC_EXPORT_PRIVATE std::string QuicLongHeaderTypeToString(
QuicLongHeaderType type);
enum QuicPacketHeaderTypeFlags : uint8_t {
// Bit 2: Key phase bit for IETF QUIC short header packets.
FLAGS_KEY_PHASE_BIT = 1 << 2,
// Bit 3: Google QUIC Demultiplexing bit, the short header always sets this
// bit to 0, allowing to distinguish Google QUIC packets from short header
// packets.
FLAGS_DEMULTIPLEXING_BIT = 1 << 3,
// Bits 4 and 5: Reserved bits for short header.
FLAGS_SHORT_HEADER_RESERVED_1 = 1 << 4,
FLAGS_SHORT_HEADER_RESERVED_2 = 1 << 5,
// Bit 6: the 'QUIC' bit.
FLAGS_FIXED_BIT = 1 << 6,
// Bit 7: Indicates the header is long or short header.
FLAGS_LONG_HEADER = 1 << 7,
};
enum MessageStatus {
MESSAGE_STATUS_SUCCESS,
MESSAGE_STATUS_ENCRYPTION_NOT_ESTABLISHED, // Failed to send message because
// encryption is not established
// yet.
MESSAGE_STATUS_UNSUPPORTED, // Failed to send message because MESSAGE frame
// is not supported by the connection.
MESSAGE_STATUS_BLOCKED, // Failed to send message because connection is
// congestion control blocked or underlying socket is
// write blocked.
MESSAGE_STATUS_TOO_LARGE, // Failed to send message because the message is
// too large to fit into a single packet.
MESSAGE_STATUS_INTERNAL_ERROR, // Failed to send message because connection
// reaches an invalid state.
};
QUIC_EXPORT_PRIVATE std::string MessageStatusToString(
MessageStatus message_status);
// Used to return the result of SendMessage calls
struct QUIC_EXPORT_PRIVATE MessageResult {
MessageResult(MessageStatus status, QuicMessageId message_id);
bool operator==(const MessageResult& other) const {
return status == other.status && message_id == other.message_id;
}
QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
const MessageResult& mr);
MessageStatus status;
// Only valid when status is MESSAGE_STATUS_SUCCESS.
QuicMessageId message_id;
};
QUIC_EXPORT_PRIVATE std::string MessageResultToString(
MessageResult message_result);
enum WriteStreamDataResult {
WRITE_SUCCESS,
STREAM_MISSING, // Trying to write data of a nonexistent stream (e.g.
// closed).
WRITE_FAILED, // Trying to write nonexistent data of a stream
};
enum StreamType : uint8_t {
// Bidirectional streams allow for data to be sent in both directions.
BIDIRECTIONAL,
// Unidirectional streams carry data in one direction only.
WRITE_UNIDIRECTIONAL,
READ_UNIDIRECTIONAL,
// Not actually a stream type. Used only by QuicCryptoStream when it uses
// CRYPTO frames and isn't actually a QuicStream.
CRYPTO,
};
// A packet number space is the context in which a packet can be processed and
// acknowledged.
enum PacketNumberSpace : uint8_t {
INITIAL_DATA = 0, // Only used in IETF QUIC.
HANDSHAKE_DATA = 1,
APPLICATION_DATA = 2,
NUM_PACKET_NUMBER_SPACES,
};
QUIC_EXPORT_PRIVATE std::string PacketNumberSpaceToString(
PacketNumberSpace packet_number_space);
// Used to return the result of processing a received ACK frame.
enum AckResult {
PACKETS_NEWLY_ACKED,
NO_PACKETS_NEWLY_ACKED,
UNSENT_PACKETS_ACKED, // Peer acks unsent packets.
UNACKABLE_PACKETS_ACKED, // Peer acks packets that are not expected to be
// acked. For example, encryption is reestablished,
// and all sent encrypted packets cannot be
// decrypted by the peer. Version gets negotiated,
// and all sent packets in the different version
// cannot be processed by the peer.
PACKETS_ACKED_IN_WRONG_PACKET_NUMBER_SPACE,
};
// Indicates the fate of a serialized packet in WritePacket().
enum SerializedPacketFate : uint8_t {
DISCARD, // Discard the packet.
COALESCE, // Try to coalesce packet.
BUFFER, // Buffer packet in buffered_packets_.
SEND_TO_WRITER, // Send packet to writer.
LEGACY_VERSION_ENCAPSULATE, // Perform Legacy Version Encapsulation on this
// packet.
};
QUIC_EXPORT_PRIVATE std::string SerializedPacketFateToString(
SerializedPacketFate fate);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const SerializedPacketFate fate);
// There are three different forms of CONNECTION_CLOSE.
enum QuicConnectionCloseType {
GOOGLE_QUIC_CONNECTION_CLOSE = 0,
IETF_QUIC_TRANSPORT_CONNECTION_CLOSE = 1,
IETF_QUIC_APPLICATION_CONNECTION_CLOSE = 2
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, const QuicConnectionCloseType type);
QUIC_EXPORT_PRIVATE std::string QuicConnectionCloseTypeString(
QuicConnectionCloseType type);
// Indicate handshake state of a connection.
enum HandshakeState {
// Initial state.
HANDSHAKE_START,
// Only used in IETF QUIC with TLS handshake. State proceeds to
// HANDSHAKE_PROCESSED after a packet of HANDSHAKE packet number space
// gets successfully processed, and the initial key can be dropped.
HANDSHAKE_PROCESSED,
// In QUIC crypto, state proceeds to HANDSHAKE_COMPLETE if client receives
// SHLO or server successfully processes an ENCRYPTION_FORWARD_SECURE
// packet, such that the handshake packets can be neutered. In IETF QUIC
// with TLS handshake, state proceeds to HANDSHAKE_COMPLETE once the client
// has both 1-RTT send and receive keys.
HANDSHAKE_COMPLETE,
// Only used in IETF QUIC with TLS handshake. State proceeds to
// HANDSHAKE_CONFIRMED if 1) a client receives HANDSHAKE_DONE frame or
// acknowledgment for 1-RTT packet or 2) server has
// 1-RTT send and receive keys.
HANDSHAKE_CONFIRMED,
};
struct QUIC_NO_EXPORT NextReleaseTimeResult {
// The ideal release time of the packet being sent.
QuicTime release_time;
// Whether it is allowed to send the packet before release_time.
bool allow_burst;
};
// QuicPacketBuffer bundles a buffer and a function that releases it. Note
// it does not assume ownership of buffer, i.e. it doesn't release the buffer on
// destruction.
struct QUIC_NO_EXPORT QuicPacketBuffer {
QuicPacketBuffer() = default;
QuicPacketBuffer(char* buffer,
std::function<void(const char*)> release_buffer)
: buffer(buffer), release_buffer(std::move(release_buffer)) {}
char* buffer = nullptr;
std::function<void(const char*)> release_buffer;
};
// QuicOwnedPacketBuffer is a QuicPacketBuffer that assumes buffer ownership.
struct QUIC_NO_EXPORT QuicOwnedPacketBuffer : public QuicPacketBuffer {
QuicOwnedPacketBuffer(const QuicOwnedPacketBuffer&) = delete;
QuicOwnedPacketBuffer& operator=(const QuicOwnedPacketBuffer&) = delete;
QuicOwnedPacketBuffer(char* buffer,
std::function<void(const char*)> release_buffer)
: QuicPacketBuffer(buffer, std::move(release_buffer)) {}
QuicOwnedPacketBuffer(QuicOwnedPacketBuffer&& owned_buffer)
: QuicPacketBuffer(std::move(owned_buffer)) {
// |owned_buffer| does not own a buffer any more.
owned_buffer.buffer = nullptr;
}
explicit QuicOwnedPacketBuffer(QuicPacketBuffer&& packet_buffer)
: QuicPacketBuffer(std::move(packet_buffer)) {}
~QuicOwnedPacketBuffer() {
if (release_buffer != nullptr && buffer != nullptr) {
release_buffer(buffer);
}
}
};
// These values must remain stable as they are uploaded to UMA histograms.
enum class KeyUpdateReason {
kInvalid = 0,
kRemote = 1,
kLocalForTests = 2,
kLocalForInteropRunner = 3,
kLocalAeadConfidentialityLimit = 4,
kLocalKeyUpdateLimitOverride = 5,
kMaxValue = kLocalKeyUpdateLimitOverride,
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const KeyUpdateReason reason);
QUIC_EXPORT_PRIVATE std::string KeyUpdateReasonString(KeyUpdateReason reason);
using QuicSignatureAlgorithmVector = absl::InlinedVector<uint16_t, 8>;
// QuicSSLConfig contains configurations to be applied on a SSL object, which
// overrides the configurations in SSL_CTX.
struct QUIC_NO_EXPORT QuicSSLConfig {
// Whether TLS early data should be enabled. If not set, default to enabled.
absl::optional<bool> early_data_enabled;
// Whether TLS session tickets are supported. If not set, default to
// supported.
absl::optional<bool> disable_ticket_support;
// If set, used to configure the SSL object with
// SSL_set_signing_algorithm_prefs.
absl::optional<QuicSignatureAlgorithmVector> signing_algorithm_prefs;
// Client certificate mode for mTLS support. Only used at server side.
ClientCertMode client_cert_mode = ClientCertMode::kNone;
};
// QuicDelayedSSLConfig contains a subset of SSL config that can be applied
// after BoringSSL's early select certificate callback. This overwrites all SSL
// configs applied before cert selection.
struct QUIC_NO_EXPORT QuicDelayedSSLConfig {
// Client certificate mode for mTLS support. Only used at server side.
// absl::nullopt means do not change client certificate mode.
absl::optional<ClientCertMode> client_cert_mode;
};
// ParsedClientHello contains client hello information extracted from a fully
// received client hello.
struct QUIC_NO_EXPORT ParsedClientHello {
std::string sni; // QUIC crypto and TLS.
std::string uaid; // QUIC crypto only.
std::vector<std::string> alpns; // QUIC crypto and TLS.
std::string legacy_version_encapsulation_inner_packet; // QUIC crypto only.
// The unvalidated retry token from the last received packet of a potentially
// multi-packet client hello. TLS only.
std::string retry_token;
bool resumption_attempted = false; // TLS only.
bool early_data_attempted = false; // TLS only.
};
QUIC_EXPORT_PRIVATE bool operator==(const ParsedClientHello& a,
const ParsedClientHello& b);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, const ParsedClientHello& parsed_chlo);
} // namespace quic
#endif // QUICHE_QUIC_CORE_QUIC_TYPES_H_