Index: net/quic/quic_protocol.h |
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h |
deleted file mode 100644 |
index 2b57eafc995b8f743022ad53f3c7506f2e4c4b68..0000000000000000000000000000000000000000 |
--- a/net/quic/quic_protocol.h |
+++ /dev/null |
@@ -1,1515 +0,0 @@ |
-// Copyright (c) 2012 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 NET_QUIC_QUIC_PROTOCOL_H_ |
-#define NET_QUIC_QUIC_PROTOCOL_H_ |
- |
-#include <stddef.h> |
-#include <stdint.h> |
- |
-#include <limits> |
-#include <list> |
-#include <map> |
-#include <memory> |
-#include <ostream> |
-#include <set> |
-#include <string> |
-#include <utility> |
-#include <vector> |
- |
-#include "base/logging.h" |
-#include "base/macros.h" |
-#include "base/memory/ref_counted.h" |
-#include "base/strings/string_piece.h" |
-#include "net/base/int128.h" |
-#include "net/base/iovec.h" |
-#include "net/base/ip_endpoint.h" |
-#include "net/base/net_export.h" |
-#include "net/quic/interval_set.h" |
-#include "net/quic/quic_bandwidth.h" |
-#include "net/quic/quic_time.h" |
-#include "net/quic/quic_types.h" |
- |
-namespace net { |
- |
-class QuicPacket; |
-struct QuicPacketHeader; |
-class QuicAckListenerInterface; |
- |
-typedef uint64_t QuicConnectionId; |
-typedef uint32_t QuicStreamId; |
-typedef uint64_t QuicStreamOffset; |
-typedef uint64_t QuicPacketNumber; |
-typedef uint8_t QuicPathId; |
-typedef uint64_t QuicPublicResetNonceProof; |
-typedef uint8_t QuicPacketEntropyHash; |
-typedef uint32_t QuicHeaderId; |
-// QuicTag is the type of a tag in the wire protocol. |
-typedef uint32_t QuicTag; |
-typedef std::vector<QuicTag> QuicTagVector; |
-typedef std::map<QuicTag, std::string> QuicTagValueMap; |
-typedef uint16_t QuicPacketLength; |
- |
-// Default initial maximum size in bytes of a QUIC packet. |
-const QuicByteCount kDefaultMaxPacketSize = 1350; |
-// Default initial maximum size in bytes of a QUIC packet for servers. |
-const QuicByteCount kDefaultServerMaxPacketSize = 1000; |
-// The maximum packet size of any QUIC packet, based on ethernet's max size, |
-// minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an |
-// additional 8 bytes. This is a total overhead of 48 bytes. Ethernet's |
-// max packet size is 1500 bytes, 1500 - 48 = 1452. |
-const QuicByteCount kMaxPacketSize = 1452; |
-// Default maximum packet size used in the Linux TCP implementation. |
-// Used in QUIC for congestion window computations in bytes. |
-const QuicByteCount kDefaultTCPMSS = 1460; |
- |
-// We match SPDY's use of 32 (since we'd compete with SPDY). |
-const QuicPacketCount kInitialCongestionWindow = 32; |
- |
-// Minimum size of initial flow control window, for both stream and session. |
-const uint32_t kMinimumFlowControlSendWindow = 16 * 1024; // 16 KB |
- |
-// Maximum flow control receive window limits for connection and stream. |
-const QuicByteCount kStreamReceiveWindowLimit = 16 * 1024 * 1024; // 16 MB |
-const QuicByteCount kSessionReceiveWindowLimit = 24 * 1024 * 1024; // 24 MB |
- |
-// Minimum size of the CWND, in packets, when doing bandwidth resumption. |
-const QuicPacketCount kMinCongestionWindowForBandwidthResumption = 10; |
- |
-// Maximum number of tracked packets. |
-const QuicPacketCount kMaxTrackedPackets = 10000; |
- |
-// Default size of the socket receive buffer in bytes. |
-const QuicByteCount kDefaultSocketReceiveBuffer = 1024 * 1024; |
-// Minimum size of the socket receive buffer in bytes. |
-// Smaller values are ignored. |
-const QuicByteCount kMinSocketReceiveBuffer = 16 * 1024; |
- |
-// Fraction of the receive buffer that can be used, based on conservative |
-// estimates and testing on Linux. |
-// An alternative to kUsableRecieveBufferFraction. |
-static const float kConservativeReceiveBufferFraction = 0.6f; |
- |
-// Don't allow a client to suggest an RTT shorter than 10ms. |
-const uint32_t kMinInitialRoundTripTimeUs = 10 * kNumMicrosPerMilli; |
- |
-// Don't allow a client to suggest an RTT longer than 15 seconds. |
-const uint32_t kMaxInitialRoundTripTimeUs = 15 * kNumMicrosPerSecond; |
- |
-// Maximum number of open streams per connection. |
-const size_t kDefaultMaxStreamsPerConnection = 100; |
- |
-// Number of bytes reserved for public flags in the packet header. |
-const size_t kPublicFlagsSize = 1; |
-// Number of bytes reserved for version number in the packet header. |
-const size_t kQuicVersionSize = 4; |
-// Number of bytes reserved for path id in the packet header. |
-const size_t kQuicPathIdSize = 1; |
-// Number of bytes reserved for private flags in the packet header. |
-const size_t kPrivateFlagsSize = 1; |
- |
-// Signifies that the QuicPacket will contain version of the protocol. |
-const bool kIncludeVersion = true; |
-// Signifies that the QuicPacket will contain path id. |
-const bool kIncludePathId = true; |
-// Signifies that the QuicPacket will include a diversification nonce. |
-const bool kIncludeDiversificationNonce = true; |
- |
-// Stream ID is reserved to denote an invalid ID. |
-const QuicStreamId kInvalidStreamId = 0; |
- |
-// Reserved ID for the crypto stream. |
-const QuicStreamId kCryptoStreamId = 1; |
- |
-// Reserved ID for the headers stream. |
-const QuicStreamId kHeadersStreamId = 3; |
- |
-// Header key used to identify final offset on data stream when sending HTTP/2 |
-// trailing headers over QUIC. |
-NET_EXPORT_PRIVATE extern const char* const kFinalOffsetHeaderKey; |
- |
-// Maximum delayed ack time, in ms. |
-const int64_t kMaxDelayedAckTimeMs = 25; |
- |
-// Minimum tail loss probe time in ms. |
-static const int64_t kMinTailLossProbeTimeoutMs = 10; |
- |
-// The timeout before the handshake succeeds. |
-const int64_t kInitialIdleTimeoutSecs = 5; |
-// The default idle timeout. |
-const int64_t kDefaultIdleTimeoutSecs = 30; |
-// The maximum idle timeout that can be negotiated. |
-const int64_t kMaximumIdleTimeoutSecs = 60 * 10; // 10 minutes. |
-// The default timeout for a connection until the crypto handshake succeeds. |
-const int64_t kMaxTimeForCryptoHandshakeSecs = 10; // 10 secs. |
- |
-// Default limit on the number of undecryptable packets the connection buffers |
-// before the CHLO/SHLO arrive. |
-const size_t kDefaultMaxUndecryptablePackets = 10; |
- |
-// Default ping timeout. |
-const int64_t kPingTimeoutSecs = 15; // 15 secs. |
- |
-// Minimum number of RTTs between Server Config Updates (SCUP) sent to client. |
-const int kMinIntervalBetweenServerConfigUpdatesRTTs = 10; |
- |
-// Minimum time between Server Config Updates (SCUP) sent to client. |
-const int kMinIntervalBetweenServerConfigUpdatesMs = 1000; |
- |
-// Minimum number of packets between Server Config Updates (SCUP). |
-const int kMinPacketsBetweenServerConfigUpdates = 100; |
- |
-// The number of open streams that a server will accept is set to be slightly |
-// larger than the negotiated limit. Immediately closing the connection if the |
-// client opens slightly too many streams is not ideal: the client may have sent |
-// a FIN that was lost, and simultaneously opened a new stream. The number of |
-// streams a server accepts is a fixed increment over the negotiated limit, or a |
-// percentage increase, whichever is larger. |
-const float kMaxStreamsMultiplier = 1.1f; |
-const int kMaxStreamsMinimumIncrement = 10; |
- |
-// Available streams are ones with IDs less than the highest stream that has |
-// been opened which have neither been opened or reset. The limit on the number |
-// of available streams is 10 times the limit on the number of open streams. |
-const int kMaxAvailableStreamsMultiplier = 10; |
- |
-// Track the number of promises that are not yet claimed by a |
-// corresponding get. This must be smaller than |
-// kMaxAvailableStreamsMultiplier, because RST on a promised stream my |
-// create available streams entries. |
-const int kMaxPromisedStreamsMultiplier = kMaxAvailableStreamsMultiplier - 1; |
- |
-// TCP RFC calls for 1 second RTO however Linux differs from this default and |
-// define the minimum RTO to 200ms, we will use the same until we have data to |
-// support a higher or lower value. |
-static const int64_t kMinRetransmissionTimeMs = 200; |
- |
-// We define an unsigned 16-bit floating point value, inspired by IEEE floats |
-// (http://en.wikipedia.org/wiki/Half_precision_floating-point_format), |
-// with 5-bit exponent (bias 1), 11-bit mantissa (effective 12 with hidden |
-// bit) and denormals, but without signs, transfinites or fractions. Wire format |
-// 16 bits (little-endian byte order) are split into exponent (high 5) and |
-// mantissa (low 11) and decoded as: |
-// uint64_t value; |
-// if (exponent == 0) value = mantissa; |
-// else value = (mantissa | 1 << 11) << (exponent - 1) |
-const int kUFloat16ExponentBits = 5; |
-const int kUFloat16MaxExponent = (1 << kUFloat16ExponentBits) - 2; // 30 |
-const int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits; // 11 |
-const int kUFloat16MantissaEffectiveBits = kUFloat16MantissaBits + 1; // 12 |
-const uint64_t kUFloat16MaxValue = // 0x3FFC0000000 |
- ((UINT64_C(1) << kUFloat16MantissaEffectiveBits) - 1) |
- << kUFloat16MaxExponent; |
- |
-// Default path ID. |
-const QuicPathId kDefaultPathId = 0; |
-// Invalid path ID. |
-const QuicPathId kInvalidPathId = 0xff; |
- |
-// kDiversificationNonceSize is the size, in bytes, of the nonce that a server |
-// may set in the packet header to ensure that its INITIAL keys are not |
-// duplicated. |
-const size_t kDiversificationNonceSize = 32; |
- |
-enum TransmissionType : int8_t { |
- NOT_RETRANSMISSION, |
- FIRST_TRANSMISSION_TYPE = NOT_RETRANSMISSION, |
- HANDSHAKE_RETRANSMISSION, // Retransmits due to handshake timeouts. |
- ALL_UNACKED_RETRANSMISSION, // Retransmits all unacked packets. |
- ALL_INITIAL_RETRANSMISSION, // Retransmits all initially encrypted packets. |
- LOSS_RETRANSMISSION, // Retransmits due to loss detection. |
- RTO_RETRANSMISSION, // Retransmits due to retransmit time out. |
- TLP_RETRANSMISSION, // Tail loss probes. |
- LAST_TRANSMISSION_TYPE = TLP_RETRANSMISSION, |
-}; |
- |
-enum HasRetransmittableData : int8_t { |
- NO_RETRANSMITTABLE_DATA, |
- HAS_RETRANSMITTABLE_DATA, |
-}; |
- |
-enum IsHandshake : int8_t { NOT_HANDSHAKE, IS_HANDSHAKE }; |
- |
-enum class Perspective { IS_SERVER, IS_CLIENT }; |
- |
-// Describes whether a ConnectionClose was originated by the peer. |
-enum class ConnectionCloseSource { FROM_PEER, FROM_SELF }; |
- |
-// Should a connection be closed silently or not. |
-enum class ConnectionCloseBehavior { |
- SILENT_CLOSE, |
- SEND_CONNECTION_CLOSE_PACKET |
-}; |
- |
-NET_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, |
- const Perspective& s); |
-enum QuicFrameType { |
- // 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, |
- PATH_CLOSE_FRAME = 8, |
- |
- // 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, |
- NUM_FRAME_TYPES |
-}; |
- |
-enum QuicConnectionIdLength { |
- PACKET_0BYTE_CONNECTION_ID = 0, |
- PACKET_8BYTE_CONNECTION_ID = 8 |
-}; |
- |
-enum QuicPacketNumberLength : int8_t { |
- PACKET_1BYTE_PACKET_NUMBER = 1, |
- PACKET_2BYTE_PACKET_NUMBER = 2, |
- PACKET_4BYTE_PACKET_NUMBER = 4, |
- PACKET_6BYTE_PACKET_NUMBER = 6 |
-}; |
- |
-// 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_6BYTE_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 that public 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, |
- |
- // QUIC_VERSION_32 and earlier use two bits for an 8 byte |
- // connection id. |
- 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_6BYTE_PACKET << 4, |
- |
- // Bit 6: Does the packet header contain a path id? |
- PACKET_PUBLIC_FLAGS_MULTIPATH = 1 << 6, |
- |
- // 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 (bit 7 is not currently used): 01111111 |
- PACKET_PUBLIC_FLAGS_MAX = (1 << 7) - 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, |
- |
- // Bit 1: Payload is part of an FEC group? |
- PACKET_PRIVATE_FLAGS_FEC_GROUP = 1 << 1, |
- |
- // Bit 2: Payload is FEC as opposed to frames? |
- PACKET_PRIVATE_FLAGS_FEC = 1 << 2, |
- |
- // All bits set (bits 3-7 are not currently used): 00000111 |
- PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1, |
- |
- // For version 32 (bits 1-7 are not used): 00000001 |
- PACKET_PRIVATE_FLAGS_MAX_VERSION_32 = (1 << 1) - 1 |
-}; |
- |
-// The available versions of QUIC. Guaranteed that the integer value of the enum |
-// will match the version number. |
-// When adding a new version to this enum you should add it to |
-// kSupportedQuicVersions (if appropriate), and also add a new case to the |
-// helper methods QuicVersionToQuicTag, QuicTagToQuicVersion, and |
-// QuicVersionToString. |
-enum QuicVersion { |
- // Special case to indicate unknown/unsupported QUIC version. |
- QUIC_VERSION_UNSUPPORTED = 0, |
- |
- QUIC_VERSION_30 = 30, // Add server side support of cert transparency. |
- QUIC_VERSION_31 = 31, // Adds a hash of the client hello to crypto proof. |
- QUIC_VERSION_32 = 32, // FEC related fields are removed from wire format. |
- QUIC_VERSION_33 = 33, // Adds diversification nonces. |
- QUIC_VERSION_34 = 34, // Deprecates entropy, removes private flag from packet |
- // header, uses new ack and stop waiting wire format. |
- QUIC_VERSION_35 = 35, // Allows endpoints to independently set stream limit. |
- QUIC_VERSION_36 = 36, // Add support to force HOL blocking. |
-}; |
- |
-// This vector contains QUIC versions which we currently support. |
-// This should be ordered such that the highest supported version is the first |
-// element, with subsequent elements in descending order (versions can be |
-// skipped as necessary). |
-// |
-// IMPORTANT: if you are adding to this list, follow the instructions at |
-// http://sites/quic/adding-and-removing-versions |
-static const QuicVersion kSupportedQuicVersions[] = { |
- QUIC_VERSION_36, QUIC_VERSION_35, QUIC_VERSION_34, QUIC_VERSION_33, |
- QUIC_VERSION_32, QUIC_VERSION_31, QUIC_VERSION_30}; |
- |
-typedef std::vector<QuicVersion> QuicVersionVector; |
- |
-// Returns a vector of QUIC versions in kSupportedQuicVersions. |
-NET_EXPORT_PRIVATE QuicVersionVector QuicSupportedVersions(); |
- |
-// Returns a vector of QUIC versions from |versions| which exclude any versions |
-// which are disabled by flags. |
-NET_EXPORT_PRIVATE QuicVersionVector |
-FilterSupportedVersions(QuicVersionVector versions); |
- |
-// QuicTag is written to and read from the wire, but we prefer to use |
-// the more readable QuicVersion at other levels. |
-// Helper function which translates from a QuicVersion to a QuicTag. Returns 0 |
-// if QuicVersion is unsupported. |
-NET_EXPORT_PRIVATE QuicTag QuicVersionToQuicTag(const QuicVersion version); |
- |
-// Returns appropriate QuicVersion from a QuicTag. |
-// Returns QUIC_VERSION_UNSUPPORTED if version_tag cannot be understood. |
-NET_EXPORT_PRIVATE QuicVersion QuicTagToQuicVersion(const QuicTag version_tag); |
- |
-// Helper function which translates from a QuicVersion to a string. |
-// Returns strings corresponding to enum names (e.g. QUIC_VERSION_6). |
-NET_EXPORT_PRIVATE std::string QuicVersionToString(const QuicVersion version); |
- |
-// Returns comma separated list of string representations of QuicVersion enum |
-// values in the supplied |versions| vector. |
-NET_EXPORT_PRIVATE std::string QuicVersionVectorToString( |
- const QuicVersionVector& versions); |
- |
-// Version and Crypto tags are written to the wire with a big-endian |
-// representation of the name of the tag. For example |
-// the client hello tag (CHLO) will be written as the |
-// following 4 bytes: 'C' 'H' 'L' 'O'. Since it is |
-// stored in memory as a little endian uint32_t, we need |
-// to reverse the order of the bytes. |
- |
-// MakeQuicTag returns a value given the four bytes. For example: |
-// MakeQuicTag('C', 'H', 'L', 'O'); |
-NET_EXPORT_PRIVATE QuicTag MakeQuicTag(char a, char b, char c, char d); |
- |
-// Returns true if the tag vector contains the specified tag. |
-NET_EXPORT_PRIVATE bool ContainsQuicTag(const QuicTagVector& tag_vector, |
- QuicTag tag); |
- |
-// Size in bytes of the data packet header. |
-NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicVersion version, |
- const QuicPacketHeader& header); |
- |
-NET_EXPORT_PRIVATE size_t |
-GetPacketHeaderSize(QuicVersion version, |
- QuicConnectionIdLength connection_id_length, |
- bool include_version, |
- bool include_path_id, |
- bool include_diversification_nonce, |
- QuicPacketNumberLength packet_number_length); |
- |
-// Index of the first byte in a QUIC packet of encrypted data. |
-NET_EXPORT_PRIVATE size_t |
-GetStartOfEncryptedData(QuicVersion version, const QuicPacketHeader& header); |
- |
-NET_EXPORT_PRIVATE size_t |
-GetStartOfEncryptedData(QuicVersion version, |
- QuicConnectionIdLength connection_id_length, |
- bool include_version, |
- bool include_path_id, |
- bool include_diversification_nonce, |
- QuicPacketNumberLength packet_number_length); |
- |
-enum QuicRstStreamErrorCode { |
- // Complete response has been sent, sending a RST to ask the other endpoint |
- // to stop sending request data without discarding the response. |
- QUIC_STREAM_NO_ERROR = 0, |
- |
- // There was some error which halted stream processing. |
- QUIC_ERROR_PROCESSING_STREAM, |
- // We got two fin or reset offsets which did not match. |
- QUIC_MULTIPLE_TERMINATION_OFFSETS, |
- // We got bad payload and can not respond to it at the protocol level. |
- QUIC_BAD_APPLICATION_PAYLOAD, |
- // Stream closed due to connection error. No reset frame is sent when this |
- // happens. |
- QUIC_STREAM_CONNECTION_ERROR, |
- // GoAway frame sent. No more stream can be created. |
- QUIC_STREAM_PEER_GOING_AWAY, |
- // The stream has been cancelled. |
- QUIC_STREAM_CANCELLED, |
- // Closing stream locally, sending a RST to allow for proper flow control |
- // accounting. Sent in response to a RST from the peer. |
- QUIC_RST_ACKNOWLEDGEMENT, |
- // Receiver refused to create the stream (because its limit on open streams |
- // has been reached). The sender should retry the request later (using |
- // another stream). |
- QUIC_REFUSED_STREAM, |
- // Invalid URL in PUSH_PROMISE request header. |
- QUIC_INVALID_PROMISE_URL, |
- // Server is not authoritative for this URL. |
- QUIC_UNAUTHORIZED_PROMISE_URL, |
- // Can't have more than one active PUSH_PROMISE per URL. |
- QUIC_DUPLICATE_PROMISE_URL, |
- // Vary check failed. |
- QUIC_PROMISE_VARY_MISMATCH, |
- // Only GET and HEAD methods allowed. |
- QUIC_INVALID_PROMISE_METHOD, |
- // No error. Used as bound while iterating. |
- QUIC_STREAM_LAST_ERROR, |
-}; |
-// QUIC error codes are encoded to a single octet on-the-wire. |
-static_assert(static_cast<int>(QUIC_STREAM_LAST_ERROR) <= |
- std::numeric_limits<uint8_t>::max(), |
- "QuicErrorCode exceeds single octet"); |
- |
-// Because receiving an unknown QuicRstStreamErrorCode results in connection |
-// teardown, we use this to make sure any errors predating a given version are |
-// downgraded to the most appropriate existing error. |
-NET_EXPORT_PRIVATE QuicRstStreamErrorCode |
-AdjustErrorForVersion(QuicRstStreamErrorCode error_code, QuicVersion version); |
- |
-// These values must remain stable as they are uploaded to UMA histograms. |
-// To add a new error code, use the current value of QUIC_LAST_ERROR and |
-// increment QUIC_LAST_ERROR. |
-enum QuicErrorCode { |
- QUIC_NO_ERROR = 0, |
- |
- // Connection has reached an invalid state. |
- QUIC_INTERNAL_ERROR = 1, |
- // There were data frames after the a fin or reset. |
- QUIC_STREAM_DATA_AFTER_TERMINATION = 2, |
- // Control frame is malformed. |
- QUIC_INVALID_PACKET_HEADER = 3, |
- // Frame data is malformed. |
- QUIC_INVALID_FRAME_DATA = 4, |
- // The packet contained no payload. |
- QUIC_MISSING_PAYLOAD = 48, |
- // FEC data is malformed. |
- QUIC_INVALID_FEC_DATA = 5, |
- // STREAM frame data is malformed. |
- QUIC_INVALID_STREAM_DATA = 46, |
- // STREAM frame data overlaps with buffered data. |
- QUIC_OVERLAPPING_STREAM_DATA = 87, |
- // Received STREAM frame data is not encrypted. |
- QUIC_UNENCRYPTED_STREAM_DATA = 61, |
- // Attempt to send unencrypted STREAM frame. |
- QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA = 88, |
- // Received a frame which is likely the result of memory corruption. |
- QUIC_MAYBE_CORRUPTED_MEMORY = 89, |
- // FEC frame data is not encrypted. |
- QUIC_UNENCRYPTED_FEC_DATA = 77, |
- // RST_STREAM frame data is malformed. |
- QUIC_INVALID_RST_STREAM_DATA = 6, |
- // CONNECTION_CLOSE frame data is malformed. |
- QUIC_INVALID_CONNECTION_CLOSE_DATA = 7, |
- // GOAWAY frame data is malformed. |
- QUIC_INVALID_GOAWAY_DATA = 8, |
- // WINDOW_UPDATE frame data is malformed. |
- QUIC_INVALID_WINDOW_UPDATE_DATA = 57, |
- // BLOCKED frame data is malformed. |
- QUIC_INVALID_BLOCKED_DATA = 58, |
- // STOP_WAITING frame data is malformed. |
- QUIC_INVALID_STOP_WAITING_DATA = 60, |
- // PATH_CLOSE frame data is malformed. |
- QUIC_INVALID_PATH_CLOSE_DATA = 78, |
- // ACK frame data is malformed. |
- QUIC_INVALID_ACK_DATA = 9, |
- |
- // Version negotiation packet is malformed. |
- QUIC_INVALID_VERSION_NEGOTIATION_PACKET = 10, |
- // Public RST packet is malformed. |
- QUIC_INVALID_PUBLIC_RST_PACKET = 11, |
- // There was an error decrypting. |
- QUIC_DECRYPTION_FAILURE = 12, |
- // There was an error encrypting. |
- QUIC_ENCRYPTION_FAILURE = 13, |
- // The packet exceeded kMaxPacketSize. |
- QUIC_PACKET_TOO_LARGE = 14, |
- // The peer is going away. May be a client or server. |
- QUIC_PEER_GOING_AWAY = 16, |
- // A stream ID was invalid. |
- QUIC_INVALID_STREAM_ID = 17, |
- // A priority was invalid. |
- QUIC_INVALID_PRIORITY = 49, |
- // Too many streams already open. |
- QUIC_TOO_MANY_OPEN_STREAMS = 18, |
- // The peer created too many available streams. |
- QUIC_TOO_MANY_AVAILABLE_STREAMS = 76, |
- // Received public reset for this connection. |
- QUIC_PUBLIC_RESET = 19, |
- // Invalid protocol version. |
- QUIC_INVALID_VERSION = 20, |
- |
- // The Header ID for a stream was too far from the previous. |
- QUIC_INVALID_HEADER_ID = 22, |
- // Negotiable parameter received during handshake had invalid value. |
- QUIC_INVALID_NEGOTIATED_VALUE = 23, |
- // There was an error decompressing data. |
- QUIC_DECOMPRESSION_FAILURE = 24, |
- // The connection timed out due to no network activity. |
- QUIC_NETWORK_IDLE_TIMEOUT = 25, |
- // The connection timed out waiting for the handshake to complete. |
- QUIC_HANDSHAKE_TIMEOUT = 67, |
- // There was an error encountered migrating addresses. |
- QUIC_ERROR_MIGRATING_ADDRESS = 26, |
- // There was an error encountered migrating port only. |
- QUIC_ERROR_MIGRATING_PORT = 86, |
- // There was an error while writing to the socket. |
- QUIC_PACKET_WRITE_ERROR = 27, |
- // There was an error while reading from the socket. |
- QUIC_PACKET_READ_ERROR = 51, |
- // We received a STREAM_FRAME with no data and no fin flag set. |
- QUIC_EMPTY_STREAM_FRAME_NO_FIN = 50, |
- // We received invalid data on the headers stream. |
- QUIC_INVALID_HEADERS_STREAM_DATA = 56, |
- // The peer received too much data, violating flow control. |
- QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA = 59, |
- // The peer sent too much data, violating flow control. |
- QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA = 63, |
- // The peer received an invalid flow control window. |
- QUIC_FLOW_CONTROL_INVALID_WINDOW = 64, |
- // The connection has been IP pooled into an existing connection. |
- QUIC_CONNECTION_IP_POOLED = 62, |
- // The connection has too many outstanding sent packets. |
- QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS = 68, |
- // The connection has too many outstanding received packets. |
- QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS = 69, |
- // The quic connection has been cancelled. |
- QUIC_CONNECTION_CANCELLED = 70, |
- // Disabled QUIC because of high packet loss rate. |
- QUIC_BAD_PACKET_LOSS_RATE = 71, |
- // Disabled QUIC because of too many PUBLIC_RESETs post handshake. |
- QUIC_PUBLIC_RESETS_POST_HANDSHAKE = 73, |
- // Disabled QUIC because of too many timeouts with streams open. |
- QUIC_TIMEOUTS_WITH_OPEN_STREAMS = 74, |
- // Closed because we failed to serialize a packet. |
- QUIC_FAILED_TO_SERIALIZE_PACKET = 75, |
- // QUIC timed out after too many RTOs. |
- QUIC_TOO_MANY_RTOS = 85, |
- |
- // Crypto errors. |
- |
- // Hanshake failed. |
- QUIC_HANDSHAKE_FAILED = 28, |
- // Handshake message contained out of order tags. |
- QUIC_CRYPTO_TAGS_OUT_OF_ORDER = 29, |
- // Handshake message contained too many entries. |
- QUIC_CRYPTO_TOO_MANY_ENTRIES = 30, |
- // Handshake message contained an invalid value length. |
- QUIC_CRYPTO_INVALID_VALUE_LENGTH = 31, |
- // A crypto message was received after the handshake was complete. |
- QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE = 32, |
- // A crypto message was received with an illegal message tag. |
- QUIC_INVALID_CRYPTO_MESSAGE_TYPE = 33, |
- // A crypto message was received with an illegal parameter. |
- QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER = 34, |
- // An invalid channel id signature was supplied. |
- QUIC_INVALID_CHANNEL_ID_SIGNATURE = 52, |
- // A crypto message was received with a mandatory parameter missing. |
- QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND = 35, |
- // A crypto message was received with a parameter that has no overlap |
- // with the local parameter. |
- QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP = 36, |
- // A crypto message was received that contained a parameter with too few |
- // values. |
- QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND = 37, |
- // An internal error occured in crypto processing. |
- QUIC_CRYPTO_INTERNAL_ERROR = 38, |
- // A crypto handshake message specified an unsupported version. |
- QUIC_CRYPTO_VERSION_NOT_SUPPORTED = 39, |
- // A crypto handshake message resulted in a stateless reject. |
- QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT = 72, |
- // There was no intersection between the crypto primitives supported by the |
- // peer and ourselves. |
- QUIC_CRYPTO_NO_SUPPORT = 40, |
- // The server rejected our client hello messages too many times. |
- QUIC_CRYPTO_TOO_MANY_REJECTS = 41, |
- // The client rejected the server's certificate chain or signature. |
- QUIC_PROOF_INVALID = 42, |
- // A crypto message was received with a duplicate tag. |
- QUIC_CRYPTO_DUPLICATE_TAG = 43, |
- // A crypto message was received with the wrong encryption level (i.e. it |
- // should have been encrypted but was not.) |
- QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT = 44, |
- // The server config for a server has expired. |
- QUIC_CRYPTO_SERVER_CONFIG_EXPIRED = 45, |
- // We failed to setup the symmetric keys for a connection. |
- QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED = 53, |
- // A handshake message arrived, but we are still validating the |
- // previous handshake message. |
- QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO = 54, |
- // A server config update arrived before the handshake is complete. |
- QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE = 65, |
- // CHLO cannot fit in one packet. |
- QUIC_CRYPTO_CHLO_TOO_LARGE = 90, |
- // This connection involved a version negotiation which appears to have been |
- // tampered with. |
- QUIC_VERSION_NEGOTIATION_MISMATCH = 55, |
- |
- // Multipath errors. |
- // Multipath is not enabled, but a packet with multipath flag on is received. |
- QUIC_BAD_MULTIPATH_FLAG = 79, |
- // A path is supposed to exist but does not. |
- QUIC_MULTIPATH_PATH_DOES_NOT_EXIST = 91, |
- // A path is supposed to be active but is not. |
- QUIC_MULTIPATH_PATH_NOT_ACTIVE = 92, |
- |
- // IP address changed causing connection close. |
- QUIC_IP_ADDRESS_CHANGED = 80, |
- |
- // Connection migration errors. |
- // Network changed, but connection had no migratable streams. |
- QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS = 81, |
- // Connection changed networks too many times. |
- QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES = 82, |
- // Connection migration was attempted, but there was no new network to |
- // migrate to. |
- QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK = 83, |
- // Network changed, but connection had one or more non-migratable streams. |
- QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM = 84, |
- |
- // No error. Used as bound while iterating. |
- QUIC_LAST_ERROR = 93, |
-}; |
- |
-typedef char DiversificationNonce[32]; |
- |
-struct NET_EXPORT_PRIVATE QuicPacketPublicHeader { |
- QuicPacketPublicHeader(); |
- explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other); |
- ~QuicPacketPublicHeader(); |
- |
- // Universal header. All QuicPacket headers will have a connection_id and |
- // public flags. |
- QuicConnectionId connection_id; |
- QuicConnectionIdLength connection_id_length; |
- bool multipath_flag; |
- bool reset_flag; |
- bool version_flag; |
- QuicPacketNumberLength packet_number_length; |
- QuicVersionVector versions; |
- // nonce contains an optional, 32-byte nonce value. If not included in the |
- // packet, |nonce| will be empty. |
- DiversificationNonce* nonce; |
-}; |
- |
-// An integer which cannot be a packet number. |
-const QuicPacketNumber kInvalidPacketNumber = 0; |
- |
-// Header for Data packets. |
-struct NET_EXPORT_PRIVATE QuicPacketHeader { |
- QuicPacketHeader(); |
- explicit QuicPacketHeader(const QuicPacketPublicHeader& header); |
- QuicPacketHeader(const QuicPacketHeader& other); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os, |
- const QuicPacketHeader& s); |
- |
- QuicPacketPublicHeader public_header; |
- QuicPacketNumber packet_number; |
- QuicPathId path_id; |
- bool entropy_flag; |
- QuicPacketEntropyHash entropy_hash; |
- bool fec_flag; |
-}; |
- |
-struct NET_EXPORT_PRIVATE QuicPublicResetPacket { |
- QuicPublicResetPacket(); |
- explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header); |
- |
- QuicPacketPublicHeader public_header; |
- QuicPublicResetNonceProof nonce_proof; |
- QuicPacketNumber rejected_packet_number; |
- IPEndPoint client_address; |
-}; |
- |
-enum QuicVersionNegotiationState { |
- START_NEGOTIATION = 0, |
- // Server-side this implies we've sent a version negotiation packet and are |
- // waiting on the client to select a compatible version. Client-side this |
- // implies we've gotten a version negotiation packet, are retransmitting the |
- // initial packets with a supported version and are waiting for our first |
- // packet from the server. |
- NEGOTIATION_IN_PROGRESS, |
- // This indicates this endpoint has received a packet from the peer with a |
- // version this endpoint supports. Version negotiation is complete, and the |
- // version number will no longer be sent with future packets. |
- NEGOTIATED_VERSION |
-}; |
- |
-typedef QuicPacketPublicHeader QuicVersionNegotiationPacket; |
- |
-// A padding frame contains no payload. |
-struct NET_EXPORT_PRIVATE QuicPaddingFrame { |
- QuicPaddingFrame() : num_padding_bytes(-1) {} |
- explicit QuicPaddingFrame(int num_padding_bytes) |
- : num_padding_bytes(num_padding_bytes) {} |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os, |
- const QuicPaddingFrame& s); |
- |
- // -1: full padding to the end of a max-sized packet |
- // otherwise: only pad up to num_padding_bytes bytes |
- int num_padding_bytes; |
-}; |
- |
-// A ping frame contains no payload, though it is retransmittable, |
-// and ACK'd just like other normal frames. |
-struct NET_EXPORT_PRIVATE QuicPingFrame {}; |
- |
-// A path MTU discovery frame contains no payload and is serialized as a ping |
-// frame. |
-struct NET_EXPORT_PRIVATE QuicMtuDiscoveryFrame {}; |
- |
-class NET_EXPORT_PRIVATE QuicBufferAllocator { |
- public: |
- virtual ~QuicBufferAllocator(); |
- |
- // Returns or allocates a new buffer of |size|. Never returns null. |
- virtual char* New(size_t size) = 0; |
- |
- // Returns or allocates a new buffer of |size| if |flag_enable| is true. |
- // Otherwise, returns a buffer that is compatible with this class directly |
- // with operator new. Never returns null. |
- virtual char* New(size_t size, bool flag_enable) = 0; |
- |
- // Releases a buffer. |
- virtual void Delete(char* buffer) = 0; |
- |
- // Marks the allocator as being idle. Serves as a hint to notify the allocator |
- // that it should release any resources it's still holding on to. |
- virtual void MarkAllocatorIdle() {} |
-}; |
- |
-// Deleter for stream buffers. Copyable to support platforms where the deleter |
-// of a unique_ptr must be copyable. Otherwise it would be nice for this to be |
-// move-only. |
-class NET_EXPORT_PRIVATE StreamBufferDeleter { |
- public: |
- StreamBufferDeleter() : allocator_(nullptr) {} |
- explicit StreamBufferDeleter(QuicBufferAllocator* allocator) |
- : allocator_(allocator) {} |
- |
- // Deletes |buffer| using |allocator_|. |
- void operator()(char* buffer) const; |
- |
- private: |
- // Not owned; must be valid so long as the buffer stored in the unique_ptr |
- // that owns |this| is valid. |
- QuicBufferAllocator* allocator_; |
-}; |
- |
-using UniqueStreamBuffer = std::unique_ptr<char[], StreamBufferDeleter>; |
- |
-// Allocates memory of size |size| using |allocator| for a QUIC stream buffer. |
-NET_EXPORT_PRIVATE UniqueStreamBuffer |
-NewStreamBuffer(QuicBufferAllocator* allocator, size_t size); |
- |
-struct NET_EXPORT_PRIVATE QuicStreamFrame { |
- QuicStreamFrame(); |
- QuicStreamFrame(QuicStreamId stream_id, |
- bool fin, |
- QuicStreamOffset offset, |
- base::StringPiece data); |
- QuicStreamFrame(QuicStreamId stream_id, |
- bool fin, |
- QuicStreamOffset offset, |
- QuicPacketLength data_length, |
- UniqueStreamBuffer buffer); |
- ~QuicStreamFrame(); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os, |
- const QuicStreamFrame& s); |
- |
- QuicStreamId stream_id; |
- bool fin; |
- QuicPacketLength data_length; |
- const char* data_buffer; |
- QuicStreamOffset offset; // Location of this data in the stream. |
- // nullptr when the QuicStreamFrame is received, and non-null when sent. |
- UniqueStreamBuffer buffer; |
- |
- private: |
- QuicStreamFrame(QuicStreamId stream_id, |
- bool fin, |
- QuicStreamOffset offset, |
- const char* data_buffer, |
- QuicPacketLength data_length, |
- UniqueStreamBuffer buffer); |
- |
- DISALLOW_COPY_AND_ASSIGN(QuicStreamFrame); |
-}; |
-static_assert(sizeof(QuicStreamFrame) <= 64, |
- "Keep the QuicStreamFrame size to a cacheline."); |
- |
-typedef std::vector<std::pair<QuicPacketNumber, QuicTime>> PacketTimeVector; |
- |
-struct NET_EXPORT_PRIVATE QuicStopWaitingFrame { |
- QuicStopWaitingFrame(); |
- ~QuicStopWaitingFrame(); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const QuicStopWaitingFrame& s); |
- // Path which this stop waiting frame belongs to. |
- QuicPathId path_id; |
- // Entropy hash of all packets up to, but not including, the least unacked |
- // packet. |
- QuicPacketEntropyHash entropy_hash; |
- // The lowest packet we've sent which is unacked, and we expect an ack for. |
- QuicPacketNumber least_unacked; |
-}; |
- |
-// A sequence of packet numbers where each number is unique. Intended to be used |
-// in a sliding window fashion, where smaller old packet numbers are removed and |
-// larger new packet numbers are added, with the occasional random access. |
-class NET_EXPORT_PRIVATE PacketNumberQueue { |
- public: |
- using const_interval_iterator = IntervalSet<QuicPacketNumber>::const_iterator; |
- using const_reverse_interval_iterator = |
- IntervalSet<QuicPacketNumber>::const_reverse_iterator; |
- // TODO(jdorfman): remove const_iterator and change the callers to iterate |
- // over the intervals. |
- class NET_EXPORT_PRIVATE const_iterator |
- : public std::iterator<std::input_iterator_tag, |
- QuicPacketNumber, |
- std::ptrdiff_t, |
- const QuicPacketNumber*, |
- const QuicPacketNumber&> { |
- public: |
- const_iterator( |
- IntervalSet<QuicPacketNumber>::const_iterator interval_set_iter, |
- QuicPacketNumber first, |
- QuicPacketNumber last); |
- const_iterator(const const_iterator& other); |
- const_iterator& operator=(const const_iterator& other); |
- // TODO(rtenneti): on windows RValue reference gives errors. |
- // const_iterator(const_iterator&& other); |
- ~const_iterator(); |
- |
- // TODO(rtenneti): on windows RValue reference gives errors. |
- // const_iterator& operator=(const_iterator&& other); |
- bool operator!=(const const_iterator& other) const; |
- bool operator==(const const_iterator& other) const; |
- value_type operator*() const; |
- const_iterator& operator++(); |
- const_iterator operator++(int /* postincrement */); |
- |
- private: |
- IntervalSet<QuicPacketNumber>::const_iterator interval_set_iter_; |
- QuicPacketNumber current_; |
- QuicPacketNumber last_; |
- }; |
- |
- PacketNumberQueue(); |
- PacketNumberQueue(const PacketNumberQueue& other); |
- // TODO(rtenneti): on windows RValue reference gives errors. |
- // PacketNumberQueue(PacketNumberQueue&& other); |
- ~PacketNumberQueue(); |
- |
- PacketNumberQueue& operator=(const PacketNumberQueue& other); |
- // PacketNumberQueue& operator=(PacketNumberQueue&& other); |
- |
- // Adds |packet_number| to the set of packets in the queue. |
- void Add(QuicPacketNumber packet_number); |
- |
- // Adds packets between [lower, higher) to the set of packets in the queue. It |
- // is undefined behavior to call this with |higher| < |lower|. |
- void Add(QuicPacketNumber lower, QuicPacketNumber higher); |
- |
- // Removes |packet_number| from the set of packets in the queue. |
- void Remove(QuicPacketNumber packet_number); |
- |
- // Removes packets numbers between [lower, higher) to the set of packets in |
- // the queue. It is undefined behavior to call this with |higher| < |lower|. |
- void Remove(QuicPacketNumber lower, QuicPacketNumber higher); |
- |
- // Removes packets with values less than |higher| from the set of packets in |
- // the queue. Returns true if packets were removed. |
- bool RemoveUpTo(QuicPacketNumber higher); |
- |
- // Mutates packet number set so that it contains only those packet numbers |
- // from minimum to maximum packet number not currently in the set. Do nothing |
- // if packet number set is empty. |
- void Complement(); |
- |
- // Returns true if the queue contains |packet_number|. |
- bool Contains(QuicPacketNumber packet_number) const; |
- |
- // Returns true if the queue is empty. |
- bool Empty() const; |
- |
- // Returns the minimum packet number stored in the queue. It is undefined |
- // behavior to call this if the queue is empty. |
- QuicPacketNumber Min() const; |
- |
- // Returns the maximum packet number stored in the queue. It is undefined |
- // behavior to call this if the queue is empty. |
- QuicPacketNumber Max() const; |
- |
- // Returns the number of unique packets stored in the queue. Inefficient; only |
- // exposed for testing. |
- size_t NumPacketsSlow() const; |
- |
- // Returns the number of disjoint packet number intervals contained in the |
- // queue. |
- size_t NumIntervals() const; |
- |
- // Returns the length of last interval. |
- QuicPacketNumber LastIntervalLength() const; |
- |
- // Returns iterators over the individual packet numbers. |
- const_iterator begin() const; |
- const_iterator end() const; |
- const_iterator lower_bound(QuicPacketNumber packet_number) const; |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const PacketNumberQueue& q); |
- |
- // Returns iterators over the packet number intervals. |
- const_interval_iterator begin_intervals() const; |
- const_interval_iterator end_intervals() const; |
- const_reverse_interval_iterator rbegin_intervals() const; |
- const_reverse_interval_iterator rend_intervals() const; |
- |
- private: |
- IntervalSet<QuicPacketNumber> packet_number_intervals_; |
-}; |
- |
-struct NET_EXPORT_PRIVATE QuicAckFrame { |
- QuicAckFrame(); |
- QuicAckFrame(const QuicAckFrame& other); |
- ~QuicAckFrame(); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os, |
- const QuicAckFrame& s); |
- |
- // The highest packet number we've observed from the peer. |
- // |
- // In general, this should be the largest packet number we've received. In |
- // the case of truncated acks, we may have to advertise a lower "upper bound" |
- // than largest received, to avoid implicitly acking missing packets that |
- // don't fit in the missing packet list due to size limitations. In this |
- // case, largest_observed may be a packet which is also in the missing packets |
- // list. |
- QuicPacketNumber largest_observed; |
- |
- // Time elapsed since largest_observed was received until this Ack frame was |
- // sent. |
- QuicTime::Delta ack_delay_time; |
- |
- // Vector of <packet_number, time> for when packets arrived. |
- PacketTimeVector received_packet_times; |
- |
- // Set of packets. |
- PacketNumberQueue packets; |
- |
- // Path which this ack belongs to. |
- QuicPathId path_id; |
- |
- // Entropy hash of all packets up to largest observed not including missing |
- // packets. |
- QuicPacketEntropyHash entropy_hash; |
- |
- // Whether the ack had to be truncated when sent. |
- bool is_truncated; |
- |
- // If true, |packets| express missing packets. Otherwise, |packets| express |
- // received packets. |
- bool missing; |
-}; |
- |
-// True if the packet number is greater than largest_observed or is listed |
-// as missing. |
-// Always returns false for packet numbers less than least_unacked. |
-bool NET_EXPORT_PRIVATE |
-IsAwaitingPacket(const QuicAckFrame& ack_frame, |
- QuicPacketNumber packet_number, |
- QuicPacketNumber peer_least_packet_awaiting_ack); |
- |
-// 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 { |
- kCubic, |
- kCubicBytes, |
- kReno, |
- kRenoBytes, |
- kBBR, |
-}; |
- |
-enum LossDetectionType { |
- kNack, // Used to mimic TCP's loss detection. |
- kTime, // Time based loss detection. |
- kAdaptiveTime, // Adaptive time based loss detection. |
-}; |
- |
-struct NET_EXPORT_PRIVATE QuicRstStreamFrame { |
- QuicRstStreamFrame(); |
- QuicRstStreamFrame(QuicStreamId stream_id, |
- QuicRstStreamErrorCode error_code, |
- QuicStreamOffset bytes_written); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const QuicRstStreamFrame& r); |
- |
- QuicStreamId stream_id; |
- QuicRstStreamErrorCode error_code; |
- |
- // Used to update flow control windows. On termination of a stream, both |
- // endpoints must inform the peer of the number of bytes they have sent on |
- // that stream. This can be done through normal termination (data packet with |
- // FIN) or through a RST. |
- QuicStreamOffset byte_offset; |
-}; |
- |
-struct NET_EXPORT_PRIVATE QuicConnectionCloseFrame { |
- QuicConnectionCloseFrame(); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const QuicConnectionCloseFrame& c); |
- |
- QuicErrorCode error_code; |
- std::string error_details; |
-}; |
- |
-struct NET_EXPORT_PRIVATE QuicGoAwayFrame { |
- QuicGoAwayFrame(); |
- QuicGoAwayFrame(QuicErrorCode error_code, |
- QuicStreamId last_good_stream_id, |
- const std::string& reason); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os, |
- const QuicGoAwayFrame& g); |
- |
- QuicErrorCode error_code; |
- QuicStreamId last_good_stream_id; |
- std::string reason_phrase; |
-}; |
- |
-// Flow control updates per-stream and at the connection levoel. |
-// Based on SPDY's WINDOW_UPDATE frame, but uses an absolute byte offset rather |
-// than a window delta. |
-// TODO(rjshade): A possible future optimization is to make stream_id and |
-// byte_offset variable length, similar to stream frames. |
-struct NET_EXPORT_PRIVATE QuicWindowUpdateFrame { |
- QuicWindowUpdateFrame() {} |
- QuicWindowUpdateFrame(QuicStreamId stream_id, QuicStreamOffset byte_offset); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const QuicWindowUpdateFrame& w); |
- |
- // The stream this frame applies to. 0 is a special case meaning the overall |
- // connection rather than a specific stream. |
- QuicStreamId stream_id; |
- |
- // Byte offset in the stream or connection. The receiver of this frame must |
- // not send data which would result in this offset being exceeded. |
- QuicStreamOffset byte_offset; |
-}; |
- |
-// The BLOCKED frame is used to indicate to the remote endpoint that this |
-// endpoint believes itself to be flow-control blocked but otherwise ready to |
-// send data. The BLOCKED frame is purely advisory and optional. |
-// Based on SPDY's BLOCKED frame (undocumented as of 2014-01-28). |
-struct NET_EXPORT_PRIVATE QuicBlockedFrame { |
- QuicBlockedFrame() {} |
- explicit QuicBlockedFrame(QuicStreamId stream_id); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os, |
- const QuicBlockedFrame& b); |
- |
- // The stream this frame applies to. 0 is a special case meaning the overall |
- // connection rather than a specific stream. |
- QuicStreamId stream_id; |
-}; |
- |
-// The PATH_CLOSE frame is used to explicitly close a path. Both endpoints can |
-// send a PATH_CLOSE frame to initiate a path termination. A path is considered |
-// to be closed either a PATH_CLOSE frame is sent or received. An endpoint drops |
-// receive side of a closed path, and packets with retransmittable frames on a |
-// closed path are marked as retransmissions which will be transmitted on other |
-// paths. |
-struct NET_EXPORT_PRIVATE QuicPathCloseFrame { |
- QuicPathCloseFrame() {} |
- explicit QuicPathCloseFrame(QuicPathId path_id); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const QuicPathCloseFrame& p); |
- |
- QuicPathId path_id; |
-}; |
- |
-// 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_NONE = 0, |
- ENCRYPTION_INITIAL = 1, |
- ENCRYPTION_FORWARD_SECURE = 2, |
- |
- NUM_ENCRYPTION_LEVELS, |
-}; |
- |
-enum PeerAddressChangeType { |
- // 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, |
- // 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, |
- // All other peer address changes. |
- UNSPECIFIED_CHANGE, |
-}; |
- |
-struct NET_EXPORT_PRIVATE QuicFrame { |
- QuicFrame(); |
- explicit QuicFrame(QuicPaddingFrame padding_frame); |
- explicit QuicFrame(QuicMtuDiscoveryFrame frame); |
- explicit QuicFrame(QuicPingFrame frame); |
- |
- explicit QuicFrame(QuicStreamFrame* stream_frame); |
- explicit QuicFrame(QuicAckFrame* frame); |
- explicit QuicFrame(QuicRstStreamFrame* frame); |
- explicit QuicFrame(QuicConnectionCloseFrame* frame); |
- explicit QuicFrame(QuicStopWaitingFrame* frame); |
- explicit QuicFrame(QuicGoAwayFrame* frame); |
- explicit QuicFrame(QuicWindowUpdateFrame* frame); |
- explicit QuicFrame(QuicBlockedFrame* frame); |
- explicit QuicFrame(QuicPathCloseFrame* frame); |
- |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os, |
- const QuicFrame& frame); |
- |
- QuicFrameType type; |
- union { |
- // Frames smaller than a pointer are inline. |
- QuicPaddingFrame padding_frame; |
- QuicMtuDiscoveryFrame mtu_discovery_frame; |
- QuicPingFrame ping_frame; |
- |
- // Frames larger than a pointer. |
- QuicStreamFrame* stream_frame; |
- QuicAckFrame* ack_frame; |
- QuicStopWaitingFrame* stop_waiting_frame; |
- QuicRstStreamFrame* rst_stream_frame; |
- QuicConnectionCloseFrame* connection_close_frame; |
- QuicGoAwayFrame* goaway_frame; |
- QuicWindowUpdateFrame* window_update_frame; |
- QuicBlockedFrame* blocked_frame; |
- QuicPathCloseFrame* path_close_frame; |
- }; |
-}; |
-// QuicFrameType consumes 8 bytes with padding. |
-static_assert(sizeof(QuicFrame) <= 16, |
- "Frames larger than 8 bytes should be referenced by pointer."); |
- |
-typedef std::vector<QuicFrame> QuicFrames; |
- |
-class NET_EXPORT_PRIVATE QuicData { |
- public: |
- QuicData(const char* buffer, size_t length); |
- QuicData(char* buffer, size_t length, bool owns_buffer); |
- virtual ~QuicData(); |
- |
- base::StringPiece AsStringPiece() const { |
- return base::StringPiece(data(), length()); |
- } |
- |
- const char* data() const { return buffer_; } |
- size_t length() const { return length_; } |
- bool owns_buffer() const { return owns_buffer_; } |
- |
- private: |
- const char* buffer_; |
- size_t length_; |
- bool owns_buffer_; |
- |
- DISALLOW_COPY_AND_ASSIGN(QuicData); |
-}; |
- |
-class NET_EXPORT_PRIVATE QuicPacket : public QuicData { |
- public: |
- // TODO(fayang): 4 fields from public header are passed in as arguments. |
- // Consider to add a convenience method which directly accepts the entire |
- // public header. |
- QuicPacket(char* buffer, |
- size_t length, |
- bool owns_buffer, |
- QuicConnectionIdLength connection_id_length, |
- bool includes_version, |
- bool includes_path_id, |
- bool includes_diversification_nonce, |
- QuicPacketNumberLength packet_number_length); |
- |
- base::StringPiece AssociatedData(QuicVersion version) const; |
- base::StringPiece Plaintext(QuicVersion version) const; |
- |
- char* mutable_data() { return buffer_; } |
- |
- private: |
- char* buffer_; |
- const QuicConnectionIdLength connection_id_length_; |
- const bool includes_version_; |
- const bool includes_path_id_; |
- const bool includes_diversification_nonce_; |
- const QuicPacketNumberLength packet_number_length_; |
- |
- DISALLOW_COPY_AND_ASSIGN(QuicPacket); |
-}; |
- |
-class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData { |
- public: |
- QuicEncryptedPacket(const char* buffer, size_t length); |
- QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer); |
- |
- // Clones the packet into a new packet which owns the buffer. |
- QuicEncryptedPacket* Clone() const; |
- |
- // By default, gtest prints the raw bytes of an object. The bool data |
- // member (in the base class QuicData) 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. |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const QuicEncryptedPacket& s); |
- |
- private: |
- DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket); |
-}; |
- |
-// A received encrypted QUIC packet, with a recorded time of receipt. |
-class NET_EXPORT_PRIVATE QuicReceivedPacket : public QuicEncryptedPacket { |
- public: |
- QuicReceivedPacket(const char* buffer, size_t length, QuicTime receipt_time); |
- QuicReceivedPacket(char* buffer, |
- size_t length, |
- QuicTime receipt_time, |
- bool owns_buffer); |
- |
- // Clones the packet into a new packet which owns the buffer. |
- QuicReceivedPacket* Clone() const; |
- |
- // Returns the time at which the packet was received. |
- QuicTime receipt_time() const { return receipt_time_; } |
- |
- // By default, gtest prints the raw bytes of an object. The bool data |
- // member (in the base class QuicData) 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. |
- NET_EXPORT_PRIVATE friend std::ostream& operator<<( |
- std::ostream& os, |
- const QuicReceivedPacket& s); |
- |
- private: |
- const QuicTime receipt_time_; |
- |
- DISALLOW_COPY_AND_ASSIGN(QuicReceivedPacket); |
-}; |
- |
-// Pure virtual class to listen for packet acknowledgements. |
-class NET_EXPORT_PRIVATE QuicAckListenerInterface |
- : public base::RefCounted<QuicAckListenerInterface> { |
- public: |
- QuicAckListenerInterface() {} |
- |
- // Called when a packet is acked. Called once per packet. |
- // |acked_bytes| is the number of data bytes acked. |
- virtual void OnPacketAcked(int acked_bytes, |
- QuicTime::Delta ack_delay_time) = 0; |
- |
- // Called when a packet is retransmitted. Called once per packet. |
- // |retransmitted_bytes| is the number of data bytes retransmitted. |
- virtual void OnPacketRetransmitted(int retransmitted_bytes) = 0; |
- |
- protected: |
- friend class base::RefCounted<QuicAckListenerInterface>; |
- |
- // Delegates are ref counted. |
- virtual ~QuicAckListenerInterface() {} |
-}; |
- |
-// Pure virtual class to close connection on unrecoverable errors. |
-class NET_EXPORT_PRIVATE QuicConnectionCloseDelegateInterface { |
- public: |
- virtual ~QuicConnectionCloseDelegateInterface() {} |
- |
- // Called when an unrecoverable error is encountered. |
- virtual void OnUnrecoverableError(QuicErrorCode error, |
- const std::string& error_details, |
- ConnectionCloseSource source) = 0; |
-}; |
- |
-struct NET_EXPORT_PRIVATE AckListenerWrapper { |
- AckListenerWrapper(QuicAckListenerInterface* listener, |
- QuicPacketLength data_length); |
- AckListenerWrapper(const AckListenerWrapper& other); |
- ~AckListenerWrapper(); |
- |
- scoped_refptr<QuicAckListenerInterface> ack_listener; |
- QuicPacketLength length; |
-}; |
- |
-struct NET_EXPORT_PRIVATE SerializedPacket { |
- SerializedPacket(QuicPathId path_id, |
- QuicPacketNumber packet_number, |
- QuicPacketNumberLength packet_number_length, |
- const char* encrypted_buffer, |
- QuicPacketLength encrypted_length, |
- QuicPacketEntropyHash entropy_hash, |
- bool has_ack, |
- bool has_stop_waiting); |
- SerializedPacket(const SerializedPacket& other); |
- ~SerializedPacket(); |
- |
- // Not owned. |
- const char* encrypted_buffer; |
- QuicPacketLength encrypted_length; |
- QuicFrames retransmittable_frames; |
- IsHandshake has_crypto_handshake; |
- // -1: full padding to the end of a max-sized packet |
- // 0: no padding |
- // otherwise: only pad up to num_padding_bytes bytes |
- int16_t num_padding_bytes; |
- QuicPathId path_id; |
- QuicPacketNumber packet_number; |
- QuicPacketNumberLength packet_number_length; |
- EncryptionLevel encryption_level; |
- QuicPacketEntropyHash entropy_hash; |
- bool has_ack; |
- bool has_stop_waiting; |
- TransmissionType transmission_type; |
- QuicPathId original_path_id; |
- QuicPacketNumber original_packet_number; |
- |
- // Optional notifiers which will be informed when this packet has been ACKed. |
- std::list<AckListenerWrapper> listeners; |
-}; |
- |
-struct NET_EXPORT_PRIVATE TransmissionInfo { |
- // Used by STL when assigning into a map. |
- TransmissionInfo(); |
- |
- // Constructs a Transmission with a new all_transmissions set |
- // containing |packet_number|. |
- TransmissionInfo(EncryptionLevel level, |
- QuicPacketNumberLength packet_number_length, |
- TransmissionType transmission_type, |
- QuicTime sent_time, |
- QuicPacketLength bytes_sent, |
- bool has_crypto_handshake, |
- int num_padding_bytes); |
- |
- TransmissionInfo(const TransmissionInfo& other); |
- |
- ~TransmissionInfo(); |
- |
- QuicFrames retransmittable_frames; |
- EncryptionLevel encryption_level; |
- QuicPacketNumberLength packet_number_length; |
- QuicPacketLength bytes_sent; |
- QuicTime sent_time; |
- // Reason why this packet was transmitted. |
- TransmissionType transmission_type; |
- // In flight packets have not been abandoned or lost. |
- bool in_flight; |
- // True if the packet can never be acked, so it can be removed. Occurs when |
- // a packet is never sent, after it is acknowledged once, or if it's a crypto |
- // packet we never expect to receive an ack for. |
- bool is_unackable; |
- // True if the packet contains stream data from the crypto stream. |
- bool has_crypto_handshake; |
- // Non-zero if the packet needs padding if it's retransmitted. |
- int16_t num_padding_bytes; |
- // Stores the packet number of the next retransmission of this packet. |
- // Zero if the packet has not been retransmitted. |
- QuicPacketNumber retransmission; |
- // Non-empty if there is a listener for this packet. |
- std::list<AckListenerWrapper> ack_listeners; |
-}; |
- |
-// Struct to store the pending retransmission information. |
-struct PendingRetransmission { |
- PendingRetransmission(QuicPathId path_id, |
- QuicPacketNumber packet_number, |
- TransmissionType transmission_type, |
- const QuicFrames& retransmittable_frames, |
- bool has_crypto_handshake, |
- int num_padding_bytes, |
- EncryptionLevel encryption_level, |
- QuicPacketNumberLength packet_number_length) |
- : packet_number(packet_number), |
- retransmittable_frames(retransmittable_frames), |
- transmission_type(transmission_type), |
- path_id(path_id), |
- has_crypto_handshake(has_crypto_handshake), |
- num_padding_bytes(num_padding_bytes), |
- encryption_level(encryption_level), |
- packet_number_length(packet_number_length) {} |
- |
- QuicPacketNumber packet_number; |
- const QuicFrames& retransmittable_frames; |
- TransmissionType transmission_type; |
- QuicPathId path_id; |
- bool has_crypto_handshake; |
- int num_padding_bytes; |
- EncryptionLevel encryption_level; |
- QuicPacketNumberLength packet_number_length; |
-}; |
- |
-// Convenience wrapper to wrap an iovec array and the total length, which must |
-// be less than or equal to the actual total length of the iovecs. |
-struct NET_EXPORT_PRIVATE QuicIOVector { |
- QuicIOVector(const struct iovec* iov, int iov_count, size_t total_length) |
- : iov(iov), iov_count(iov_count), total_length(total_length) {} |
- |
- const struct iovec* iov; |
- const int iov_count; |
- const size_t total_length; |
-}; |
- |
-} // namespace net |
- |
-#endif // NET_QUIC_QUIC_PROTOCOL_H_ |