1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
6 #define NET_QUIC_QUIC_PROTOCOL_H_
17 #include "base/basictypes.h"
18 #include "base/containers/hash_tables.h"
19 #include "base/logging.h"
20 #include "base/strings/string_piece.h"
21 #include "net/base/int128.h"
22 #include "net/base/ip_endpoint.h"
23 #include "net/base/net_export.h"
24 #include "net/quic/iovector.h"
25 #include "net/quic/quic_bandwidth.h"
26 #include "net/quic/quic_time.h"
30 class QuicAckNotifier;
32 struct QuicPacketHeader;
34 typedef uint64 QuicConnectionId;
35 typedef uint32 QuicStreamId;
36 typedef uint64 QuicStreamOffset;
37 typedef uint64 QuicPacketSequenceNumber;
38 typedef QuicPacketSequenceNumber QuicFecGroupNumber;
39 typedef uint64 QuicPublicResetNonceProof;
40 typedef uint8 QuicPacketEntropyHash;
41 typedef uint32 QuicHeaderId;
42 // QuicTag is the type of a tag in the wire protocol.
43 typedef uint32 QuicTag;
44 typedef std::vector<QuicTag> QuicTagVector;
45 typedef std::map<QuicTag, std::string> QuicTagValueMap;
46 // TODO(rtenneti): Didn't use SpdyPriority because SpdyPriority is uint8 and
47 // QuicPriority is uint32. Use SpdyPriority when we change the QUIC_VERSION.
48 typedef uint32 QuicPriority;
50 // TODO(rch): Consider Quic specific names for these constants.
51 // Default and initial maximum size in bytes of a QUIC packet.
52 const QuicByteCount kDefaultMaxPacketSize = 1350;
53 // The maximum packet size of any QUIC packet, based on ethernet's max size,
54 // minus the IP and UDP headers. IPv6 has a 40 byte header, UPD adds an
55 // additional 8 bytes. This is a total overhead of 48 bytes. Ethernet's
56 // max packet size is 1500 bytes, 1500 - 48 = 1452.
57 const QuicByteCount kMaxPacketSize = 1452;
58 // Default maximum packet size used in Linux TCP implementations.
59 const QuicByteCount kDefaultTCPMSS = 1460;
61 // Maximum size of the initial congestion window in packets.
62 const size_t kDefaultInitialWindow = 10;
63 const uint32 kMaxInitialWindow = 100;
65 // Default size of initial flow control window, for both stream and session.
66 const uint32 kDefaultFlowControlSendWindow = 16 * 1024; // 16 KB
68 // Maximum size of the congestion window, in packets, for TCP congestion control
70 const size_t kMaxTcpCongestionWindow = 200;
72 // Size of the socket receive buffer in bytes.
73 const QuicByteCount kDefaultSocketReceiveBuffer = 256 * 1024;
75 // Don't allow a client to suggest an RTT longer than 15 seconds.
76 const uint32 kMaxInitialRoundTripTimeUs = 15 * kNumMicrosPerSecond;
78 // Maximum number of open streams per connection.
79 const size_t kDefaultMaxStreamsPerConnection = 100;
81 // Number of bytes reserved for public flags in the packet header.
82 const size_t kPublicFlagsSize = 1;
83 // Number of bytes reserved for version number in the packet header.
84 const size_t kQuicVersionSize = 4;
85 // Number of bytes reserved for private flags in the packet header.
86 const size_t kPrivateFlagsSize = 1;
87 // Number of bytes reserved for FEC group in the packet header.
88 const size_t kFecGroupSize = 1;
90 // Signifies that the QuicPacket will contain version of the protocol.
91 const bool kIncludeVersion = true;
93 // Index of the first byte in a QUIC packet which is used in hash calculation.
94 const size_t kStartOfHashData = 0;
96 // Limit on the delta between stream IDs.
97 const QuicStreamId kMaxStreamIdDelta = 200;
98 // Limit on the delta between header IDs.
99 const QuicHeaderId kMaxHeaderIdDelta = 200;
101 // Reserved ID for the crypto stream.
102 const QuicStreamId kCryptoStreamId = 1;
104 // Reserved ID for the headers stream.
105 const QuicStreamId kHeadersStreamId = 3;
107 // Maximum delayed ack time, in ms.
108 const int kMaxDelayedAckTime = 25;
110 // This is the default network timeout a for connection till the crypto
111 // handshake succeeds and the negotiated timeout from the handshake is received.
112 const int64 kDefaultInitialTimeoutSecs = 120; // 2 mins.
113 const int64 kDefaultTimeoutSecs = 60 * 10; // 10 minutes.
114 const int64 kDefaultMaxTimeForCryptoHandshakeSecs = 5; // 5 secs.
116 // Default ping timeout.
117 const int64 kPingTimeoutSecs = 15; // 15 secs.
119 // We define an unsigned 16-bit floating point value, inspired by IEEE floats
120 // (http://en.wikipedia.org/wiki/Half_precision_floating-point_format),
121 // with 5-bit exponent (bias 1), 11-bit mantissa (effective 12 with hidden
122 // bit) and denormals, but without signs, transfinites or fractions. Wire format
123 // 16 bits (little-endian byte order) are split into exponent (high 5) and
124 // mantissa (low 11) and decoded as:
126 // if (exponent == 0) value = mantissa;
127 // else value = (mantissa | 1 << 11) << (exponent - 1)
128 const int kUFloat16ExponentBits = 5;
129 const int kUFloat16MaxExponent = (1 << kUFloat16ExponentBits) - 2; // 30
130 const int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits; // 11
131 const int kUFloat16MantissaEffectiveBits = kUFloat16MantissaBits + 1; // 12
132 const uint64 kUFloat16MaxValue = // 0x3FFC0000000
133 ((GG_UINT64_C(1) << kUFloat16MantissaEffectiveBits) - 1) <<
134 kUFloat16MaxExponent;
136 enum TransmissionType {
138 FIRST_TRANSMISSION_TYPE = NOT_RETRANSMISSION,
139 HANDSHAKE_RETRANSMISSION, // Retransmits due to handshake timeouts.
140 ALL_UNACKED_RETRANSMISSION, // Retransmits of all unacked packets.
141 LOSS_RETRANSMISSION, // Retransmits due to loss detection.
142 RTO_RETRANSMISSION, // Retransmits due to retransmit time out.
143 TLP_RETRANSMISSION, // Tail loss probes.
144 LAST_TRANSMISSION_TYPE = TLP_RETRANSMISSION,
147 enum RetransmissionType {
148 INITIAL_ENCRYPTION_ONLY,
152 enum HasRetransmittableData {
153 NO_RETRANSMITTABLE_DATA,
154 HAS_RETRANSMITTABLE_DATA,
162 // Indicates FEC protection level for data being written.
164 MUST_FEC_PROTECT, // Callee must FEC protect this data.
165 MAY_FEC_PROTECT // Callee does not have to but may FEC protect this data.
168 // Indicates FEC policy.
170 FEC_PROTECT_ALWAYS, // All data in the stream should be FEC protected.
171 FEC_PROTECT_OPTIONAL // Data in the stream does not need FEC protection.
175 // Regular frame types. The values set here cannot change without the
176 // introduction of a new QUIC version.
178 RST_STREAM_FRAME = 1,
179 CONNECTION_CLOSE_FRAME = 2,
181 WINDOW_UPDATE_FRAME = 4,
183 STOP_WAITING_FRAME = 6,
186 // STREAM, ACK, and CONGESTION_FEEDBACK frames are special frames. They are
187 // encoded differently on the wire and their values do not need to be stable.
190 CONGESTION_FEEDBACK_FRAME,
194 enum QuicConnectionIdLength {
195 PACKET_0BYTE_CONNECTION_ID = 0,
196 PACKET_1BYTE_CONNECTION_ID = 1,
197 PACKET_4BYTE_CONNECTION_ID = 4,
198 PACKET_8BYTE_CONNECTION_ID = 8
206 enum QuicSequenceNumberLength {
207 PACKET_1BYTE_SEQUENCE_NUMBER = 1,
208 PACKET_2BYTE_SEQUENCE_NUMBER = 2,
209 PACKET_4BYTE_SEQUENCE_NUMBER = 4,
210 PACKET_6BYTE_SEQUENCE_NUMBER = 6
213 // Used to indicate a QuicSequenceNumberLength using two flag bits.
214 enum QuicSequenceNumberLengthFlags {
215 PACKET_FLAGS_1BYTE_SEQUENCE = 0, // 00
216 PACKET_FLAGS_2BYTE_SEQUENCE = 1, // 01
217 PACKET_FLAGS_4BYTE_SEQUENCE = 1 << 1, // 10
218 PACKET_FLAGS_6BYTE_SEQUENCE = 1 << 1 | 1, // 11
221 // The public flags are specified in one byte.
222 enum QuicPacketPublicFlags {
223 PACKET_PUBLIC_FLAGS_NONE = 0,
225 // Bit 0: Does the packet header contains version info?
226 PACKET_PUBLIC_FLAGS_VERSION = 1 << 0,
228 // Bit 1: Is this packet a public reset packet?
229 PACKET_PUBLIC_FLAGS_RST = 1 << 1,
231 // Bits 2 and 3 specify the length of the ConnectionId as follows:
236 PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID = 0,
237 PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID = 1 << 2,
238 PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID = 1 << 3,
239 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID = 1 << 3 | 1 << 2,
241 // Bits 4 and 5 describe the packet sequence number length as follows:
246 PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE = PACKET_FLAGS_1BYTE_SEQUENCE << 4,
247 PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE = PACKET_FLAGS_2BYTE_SEQUENCE << 4,
248 PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE = PACKET_FLAGS_4BYTE_SEQUENCE << 4,
249 PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE = PACKET_FLAGS_6BYTE_SEQUENCE << 4,
251 // All bits set (bits 6 and 7 are not currently used): 00111111
252 PACKET_PUBLIC_FLAGS_MAX = (1 << 6) - 1
255 // The private flags are specified in one byte.
256 enum QuicPacketPrivateFlags {
257 PACKET_PRIVATE_FLAGS_NONE = 0,
259 // Bit 0: Does this packet contain an entropy bit?
260 PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 0,
262 // Bit 1: Payload is part of an FEC group?
263 PACKET_PRIVATE_FLAGS_FEC_GROUP = 1 << 1,
265 // Bit 2: Payload is FEC as opposed to frames?
266 PACKET_PRIVATE_FLAGS_FEC = 1 << 2,
268 // All bits set (bits 3-7 are not currently used): 00000111
269 PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1
272 // The available versions of QUIC. Guaranteed that the integer value of the enum
273 // will match the version number.
274 // When adding a new version to this enum you should add it to
275 // kSupportedQuicVersions (if appropriate), and also add a new case to the
276 // helper methods QuicVersionToQuicTag, QuicTagToQuicVersion, and
277 // QuicVersionToString.
279 // Special case to indicate unknown/unsupported QUIC version.
280 QUIC_VERSION_UNSUPPORTED = 0,
282 QUIC_VERSION_16 = 16, // STOP_WAITING frame.
283 QUIC_VERSION_18 = 18, // PING frame.
284 QUIC_VERSION_19 = 19, // Connection level flow control.
285 QUIC_VERSION_20 = 20, // Independent stream/connection flow control windows.
286 QUIC_VERSION_21 = 21, // Headers/crypto streams are flow controlled.
287 QUIC_VERSION_22 = 22, // Send Server Config Update messages on crypto stream.
290 // This vector contains QUIC versions which we currently support.
291 // This should be ordered such that the highest supported version is the first
292 // element, with subsequent elements in descending order (versions can be
293 // skipped as necessary).
295 // IMPORTANT: if you are adding to this list, follow the instructions at
296 // http://sites/quic/adding-and-removing-versions
297 static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_22,
304 typedef std::vector<QuicVersion> QuicVersionVector;
306 // Returns a vector of QUIC versions in kSupportedQuicVersions.
307 NET_EXPORT_PRIVATE QuicVersionVector QuicSupportedVersions();
309 // QuicTag is written to and read from the wire, but we prefer to use
310 // the more readable QuicVersion at other levels.
311 // Helper function which translates from a QuicVersion to a QuicTag. Returns 0
312 // if QuicVersion is unsupported.
313 NET_EXPORT_PRIVATE QuicTag QuicVersionToQuicTag(const QuicVersion version);
315 // Returns appropriate QuicVersion from a QuicTag.
316 // Returns QUIC_VERSION_UNSUPPORTED if version_tag cannot be understood.
317 NET_EXPORT_PRIVATE QuicVersion QuicTagToQuicVersion(const QuicTag version_tag);
319 // Helper function which translates from a QuicVersion to a string.
320 // Returns strings corresponding to enum names (e.g. QUIC_VERSION_6).
321 NET_EXPORT_PRIVATE std::string QuicVersionToString(const QuicVersion version);
323 // Returns comma separated list of string representations of QuicVersion enum
324 // values in the supplied |versions| vector.
325 NET_EXPORT_PRIVATE std::string QuicVersionVectorToString(
326 const QuicVersionVector& versions);
328 // Version and Crypto tags are written to the wire with a big-endian
329 // representation of the name of the tag. For example
330 // the client hello tag (CHLO) will be written as the
331 // following 4 bytes: 'C' 'H' 'L' 'O'. Since it is
332 // stored in memory as a little endian uint32, we need
333 // to reverse the order of the bytes.
335 // MakeQuicTag returns a value given the four bytes. For example:
336 // MakeQuicTag('C', 'H', 'L', 'O');
337 NET_EXPORT_PRIVATE QuicTag MakeQuicTag(char a, char b, char c, char d);
339 // Returns true if the tag vector contains the specified tag.
340 NET_EXPORT_PRIVATE bool ContainsQuicTag(const QuicTagVector& tag_vector,
343 // Size in bytes of the data or fec packet header.
344 NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(const QuicPacketHeader& header);
346 NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(
347 QuicConnectionIdLength connection_id_length,
348 bool include_version,
349 QuicSequenceNumberLength sequence_number_length,
350 InFecGroup is_in_fec_group);
352 // Index of the first byte in a QUIC packet of FEC protected data.
353 NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(
354 QuicConnectionIdLength connection_id_length,
355 bool include_version,
356 QuicSequenceNumberLength sequence_number_length);
357 // Index of the first byte in a QUIC packet of encrypted data.
358 NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
359 QuicConnectionIdLength connection_id_length,
360 bool include_version,
361 QuicSequenceNumberLength sequence_number_length);
363 enum QuicRstStreamErrorCode {
364 QUIC_STREAM_NO_ERROR = 0,
366 // There was some error which halted stream processing.
367 QUIC_ERROR_PROCESSING_STREAM,
368 // We got two fin or reset offsets which did not match.
369 QUIC_MULTIPLE_TERMINATION_OFFSETS,
370 // We got bad payload and can not respond to it at the protocol level.
371 QUIC_BAD_APPLICATION_PAYLOAD,
372 // Stream closed due to connection error. No reset frame is sent when this
374 QUIC_STREAM_CONNECTION_ERROR,
375 // GoAway frame sent. No more stream can be created.
376 QUIC_STREAM_PEER_GOING_AWAY,
377 // The stream has been cancelled.
378 QUIC_STREAM_CANCELLED,
379 // Sending a RST to allow for proper flow control accounting.
380 QUIC_RST_FLOW_CONTROL_ACCOUNTING,
382 // No error. Used as bound while iterating.
383 QUIC_STREAM_LAST_ERROR,
386 // Because receiving an unknown QuicRstStreamErrorCode results in connection
387 // teardown, we use this to make sure any errors predating a given version are
388 // downgraded to the most appropriate existing error.
389 NET_EXPORT_PRIVATE QuicRstStreamErrorCode AdjustErrorForVersion(
390 QuicRstStreamErrorCode error_code,
391 QuicVersion version);
393 // These values must remain stable as they are uploaded to UMA histograms.
394 // To add a new error code, use the current value of QUIC_LAST_ERROR and
395 // increment QUIC_LAST_ERROR.
399 // Connection has reached an invalid state.
400 QUIC_INTERNAL_ERROR = 1,
401 // There were data frames after the a fin or reset.
402 QUIC_STREAM_DATA_AFTER_TERMINATION = 2,
403 // Control frame is malformed.
404 QUIC_INVALID_PACKET_HEADER = 3,
405 // Frame data is malformed.
406 QUIC_INVALID_FRAME_DATA = 4,
407 // The packet contained no payload.
408 QUIC_MISSING_PAYLOAD = 48,
409 // FEC data is malformed.
410 QUIC_INVALID_FEC_DATA = 5,
411 // STREAM frame data is malformed.
412 QUIC_INVALID_STREAM_DATA = 46,
413 // STREAM frame data is not encrypted.
414 QUIC_UNENCRYPTED_STREAM_DATA = 61,
415 // RST_STREAM frame data is malformed.
416 QUIC_INVALID_RST_STREAM_DATA = 6,
417 // CONNECTION_CLOSE frame data is malformed.
418 QUIC_INVALID_CONNECTION_CLOSE_DATA = 7,
419 // GOAWAY frame data is malformed.
420 QUIC_INVALID_GOAWAY_DATA = 8,
421 // WINDOW_UPDATE frame data is malformed.
422 QUIC_INVALID_WINDOW_UPDATE_DATA = 57,
423 // BLOCKED frame data is malformed.
424 QUIC_INVALID_BLOCKED_DATA = 58,
425 // STOP_WAITING frame data is malformed.
426 QUIC_INVALID_STOP_WAITING_DATA = 60,
427 // ACK frame data is malformed.
428 QUIC_INVALID_ACK_DATA = 9,
429 // CONGESTION_FEEDBACK frame data is malformed.
430 QUIC_INVALID_CONGESTION_FEEDBACK_DATA = 47,
431 // Version negotiation packet is malformed.
432 QUIC_INVALID_VERSION_NEGOTIATION_PACKET = 10,
433 // Public RST packet is malformed.
434 QUIC_INVALID_PUBLIC_RST_PACKET = 11,
435 // There was an error decrypting.
436 QUIC_DECRYPTION_FAILURE = 12,
437 // There was an error encrypting.
438 QUIC_ENCRYPTION_FAILURE = 13,
439 // The packet exceeded kMaxPacketSize.
440 QUIC_PACKET_TOO_LARGE = 14,
441 // Data was sent for a stream which did not exist.
442 QUIC_PACKET_FOR_NONEXISTENT_STREAM = 15,
443 // The peer is going away. May be a client or server.
444 QUIC_PEER_GOING_AWAY = 16,
445 // A stream ID was invalid.
446 QUIC_INVALID_STREAM_ID = 17,
447 // A priority was invalid.
448 QUIC_INVALID_PRIORITY = 49,
449 // Too many streams already open.
450 QUIC_TOO_MANY_OPEN_STREAMS = 18,
451 // The peer must send a FIN/RST for each stream, and has not been doing so.
452 QUIC_TOO_MANY_UNFINISHED_STREAMS = 66,
453 // Received public reset for this connection.
454 QUIC_PUBLIC_RESET = 19,
455 // Invalid protocol version.
456 QUIC_INVALID_VERSION = 20,
458 // deprecated: QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED = 21
460 // The Header ID for a stream was too far from the previous.
461 QUIC_INVALID_HEADER_ID = 22,
462 // Negotiable parameter received during handshake had invalid value.
463 QUIC_INVALID_NEGOTIATED_VALUE = 23,
464 // There was an error decompressing data.
465 QUIC_DECOMPRESSION_FAILURE = 24,
466 // We hit our prenegotiated (or default) timeout
467 QUIC_CONNECTION_TIMED_OUT = 25,
468 // There was an error encountered migrating addresses
469 QUIC_ERROR_MIGRATING_ADDRESS = 26,
470 // There was an error while writing to the socket.
471 QUIC_PACKET_WRITE_ERROR = 27,
472 // There was an error while reading from the socket.
473 QUIC_PACKET_READ_ERROR = 51,
474 // We received a STREAM_FRAME with no data and no fin flag set.
475 QUIC_INVALID_STREAM_FRAME = 50,
476 // We received invalid data on the headers stream.
477 QUIC_INVALID_HEADERS_STREAM_DATA = 56,
478 // The peer received too much data, violating flow control.
479 QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA = 59,
480 // The peer sent too much data, violating flow control.
481 QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA = 63,
482 // The peer received an invalid flow control window.
483 QUIC_FLOW_CONTROL_INVALID_WINDOW = 64,
484 // The connection has been IP pooled into an existing connection.
485 QUIC_CONNECTION_IP_POOLED = 62,
490 QUIC_HANDSHAKE_FAILED = 28,
491 // Handshake message contained out of order tags.
492 QUIC_CRYPTO_TAGS_OUT_OF_ORDER = 29,
493 // Handshake message contained too many entries.
494 QUIC_CRYPTO_TOO_MANY_ENTRIES = 30,
495 // Handshake message contained an invalid value length.
496 QUIC_CRYPTO_INVALID_VALUE_LENGTH = 31,
497 // A crypto message was received after the handshake was complete.
498 QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE = 32,
499 // A crypto message was received with an illegal message tag.
500 QUIC_INVALID_CRYPTO_MESSAGE_TYPE = 33,
501 // A crypto message was received with an illegal parameter.
502 QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER = 34,
503 // An invalid channel id signature was supplied.
504 QUIC_INVALID_CHANNEL_ID_SIGNATURE = 52,
505 // A crypto message was received with a mandatory parameter missing.
506 QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND = 35,
507 // A crypto message was received with a parameter that has no overlap
508 // with the local parameter.
509 QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP = 36,
510 // A crypto message was received that contained a parameter with too few
512 QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND = 37,
513 // An internal error occured in crypto processing.
514 QUIC_CRYPTO_INTERNAL_ERROR = 38,
515 // A crypto handshake message specified an unsupported version.
516 QUIC_CRYPTO_VERSION_NOT_SUPPORTED = 39,
517 // There was no intersection between the crypto primitives supported by the
518 // peer and ourselves.
519 QUIC_CRYPTO_NO_SUPPORT = 40,
520 // The server rejected our client hello messages too many times.
521 QUIC_CRYPTO_TOO_MANY_REJECTS = 41,
522 // The client rejected the server's certificate chain or signature.
523 QUIC_PROOF_INVALID = 42,
524 // A crypto message was received with a duplicate tag.
525 QUIC_CRYPTO_DUPLICATE_TAG = 43,
526 // A crypto message was received with the wrong encryption level (i.e. it
527 // should have been encrypted but was not.)
528 QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT = 44,
529 // The server config for a server has expired.
530 QUIC_CRYPTO_SERVER_CONFIG_EXPIRED = 45,
531 // We failed to setup the symmetric keys for a connection.
532 QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED = 53,
533 // A handshake message arrived, but we are still validating the
534 // previous handshake message.
535 QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO = 54,
536 // A server config update arrived before the handshake is complete.
537 QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE = 65,
538 // This connection involved a version negotiation which appears to have been
540 QUIC_VERSION_NEGOTIATION_MISMATCH = 55,
542 // No error. Used as bound while iterating.
543 QUIC_LAST_ERROR = 67,
546 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
547 QuicPacketPublicHeader();
548 explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);
549 ~QuicPacketPublicHeader();
551 // Universal header. All QuicPacket headers will have a connection_id and
553 QuicConnectionId connection_id;
554 QuicConnectionIdLength connection_id_length;
557 QuicSequenceNumberLength sequence_number_length;
558 QuicVersionVector versions;
561 // Header for Data or FEC packets.
562 struct NET_EXPORT_PRIVATE QuicPacketHeader {
564 explicit QuicPacketHeader(const QuicPacketPublicHeader& header);
566 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
567 std::ostream& os, const QuicPacketHeader& s);
569 QuicPacketPublicHeader public_header;
572 QuicPacketEntropyHash entropy_hash;
573 QuicPacketSequenceNumber packet_sequence_number;
574 InFecGroup is_in_fec_group;
575 QuicFecGroupNumber fec_group;
578 struct NET_EXPORT_PRIVATE QuicPublicResetPacket {
579 QuicPublicResetPacket();
580 explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header);
582 QuicPacketPublicHeader public_header;
583 QuicPublicResetNonceProof nonce_proof;
584 QuicPacketSequenceNumber rejected_sequence_number;
585 IPEndPoint client_address;
588 enum QuicVersionNegotiationState {
589 START_NEGOTIATION = 0,
590 // Server-side this implies we've sent a version negotiation packet and are
591 // waiting on the client to select a compatible version. Client-side this
592 // implies we've gotten a version negotiation packet, are retransmitting the
593 // initial packets with a supported version and are waiting for our first
594 // packet from the server.
595 NEGOTIATION_IN_PROGRESS,
596 // This indicates this endpoint has received a packet from the peer with a
597 // version this endpoint supports. Version negotiation is complete, and the
598 // version number will no longer be sent with future packets.
602 typedef QuicPacketPublicHeader QuicVersionNegotiationPacket;
604 // A padding frame contains no payload.
605 struct NET_EXPORT_PRIVATE QuicPaddingFrame {
608 // A ping frame contains no payload, though it is retransmittable,
609 // and ACK'd just like other normal frames.
610 struct NET_EXPORT_PRIVATE QuicPingFrame {
613 struct NET_EXPORT_PRIVATE QuicStreamFrame {
615 QuicStreamFrame(const QuicStreamFrame& frame);
616 QuicStreamFrame(QuicStreamId stream_id,
618 QuicStreamOffset offset,
621 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
622 std::ostream& os, const QuicStreamFrame& s);
624 // Returns a copy of the IOVector |data| as a heap-allocated string.
625 // Caller must take ownership of the returned string.
626 std::string* GetDataAsString() const;
628 QuicStreamId stream_id;
630 QuicStreamOffset offset; // Location of this data in the stream.
633 // If this is set, then when this packet is ACKed the AckNotifier will be
635 QuicAckNotifier* notifier;
638 // TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing
640 typedef std::set<QuicPacketSequenceNumber> SequenceNumberSet;
641 // TODO(pwestin): Add a way to enforce the max size of this map.
642 typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap;
644 struct NET_EXPORT_PRIVATE QuicStopWaitingFrame {
645 QuicStopWaitingFrame();
646 ~QuicStopWaitingFrame();
648 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
649 std::ostream& os, const QuicStopWaitingFrame& s);
650 // Entropy hash of all packets up to, but not including, the least unacked
652 QuicPacketEntropyHash entropy_hash;
653 // The lowest packet we've sent which is unacked, and we expect an ack for.
654 QuicPacketSequenceNumber least_unacked;
657 struct NET_EXPORT_PRIVATE QuicAckFrame {
661 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
662 std::ostream& os, const QuicAckFrame& s);
664 // Entropy hash of all packets up to largest observed not including missing
666 QuicPacketEntropyHash entropy_hash;
668 // The highest packet sequence number we've observed from the peer.
670 // In general, this should be the largest packet number we've received. In
671 // the case of truncated acks, we may have to advertise a lower "upper bound"
672 // than largest received, to avoid implicitly acking missing packets that
673 // don't fit in the missing packet list due to size limitations. In this
674 // case, largest_observed may be a packet which is also in the missing packets
676 QuicPacketSequenceNumber largest_observed;
678 // Time elapsed since largest_observed was received until this Ack frame was
680 QuicTime::Delta delta_time_largest_observed;
682 // TODO(satyamshekhar): Can be optimized using an interval set like data
684 // The set of packets which we're expecting and have not received.
685 SequenceNumberSet missing_packets;
687 // Whether the ack had to be truncated when sent.
690 // Packets which have been revived via FEC.
691 // All of these must also be in missing_packets.
692 SequenceNumberSet revived_packets;
695 // True if the sequence number is greater than largest_observed or is listed
697 // Always returns false for sequence numbers less than least_unacked.
698 bool NET_EXPORT_PRIVATE IsAwaitingPacket(
699 const QuicAckFrame& ack_frame,
700 QuicPacketSequenceNumber sequence_number);
702 // Inserts missing packets between [lower, higher).
703 void NET_EXPORT_PRIVATE InsertMissingPacketsBetween(
704 QuicAckFrame* ack_frame,
705 QuicPacketSequenceNumber lower,
706 QuicPacketSequenceNumber higher);
708 // Defines for all types of congestion feedback that will be negotiated in QUIC,
709 // kTCP MUST be supported by all QUIC implementations to guarantee 100%
711 enum CongestionFeedbackType {
712 kTCP, // Used to mimic TCP.
713 kTimestamp, // Use additional inter arrival timestamp information.
716 // Defines for all types of congestion control algorithms that can be used in
717 // QUIC. Note that this is separate from the congestion feedback type -
718 // some congestion control algorithms may use the same feedback type
719 // (Reno and Cubic are the classic example for that).
720 enum CongestionControlType {
726 enum LossDetectionType {
727 kNack, // Used to mimic TCP's loss detection.
728 kTime, // Time based loss detection.
731 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP {
732 CongestionFeedbackMessageTCP();
734 QuicByteCount receive_window;
737 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTimestamp {
738 CongestionFeedbackMessageTimestamp();
739 ~CongestionFeedbackMessageTimestamp();
741 // The set of received packets since the last feedback was sent, along with
742 // their arrival times.
743 TimeMap received_packet_times;
746 struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame {
747 QuicCongestionFeedbackFrame();
748 ~QuicCongestionFeedbackFrame();
750 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
751 std::ostream& os, const QuicCongestionFeedbackFrame& c);
753 CongestionFeedbackType type;
754 // This should really be a union, but since the timestamp struct
755 // is non-trivial, C++ prohibits it.
756 CongestionFeedbackMessageTCP tcp;
757 CongestionFeedbackMessageTimestamp timestamp;
760 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
761 QuicRstStreamFrame();
762 QuicRstStreamFrame(QuicStreamId stream_id,
763 QuicRstStreamErrorCode error_code,
764 QuicStreamOffset bytes_written);
766 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
767 std::ostream& os, const QuicRstStreamFrame& r);
769 QuicStreamId stream_id;
770 QuicRstStreamErrorCode error_code;
771 std::string error_details;
773 // Used to update flow control windows. On termination of a stream, both
774 // endpoints must inform the peer of the number of bytes they have sent on
775 // that stream. This can be done through normal termination (data packet with
776 // FIN) or through a RST.
777 QuicStreamOffset byte_offset;
780 struct NET_EXPORT_PRIVATE QuicConnectionCloseFrame {
781 QuicConnectionCloseFrame();
783 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
784 std::ostream& os, const QuicConnectionCloseFrame& c);
786 QuicErrorCode error_code;
787 std::string error_details;
790 struct NET_EXPORT_PRIVATE QuicGoAwayFrame {
792 QuicGoAwayFrame(QuicErrorCode error_code,
793 QuicStreamId last_good_stream_id,
794 const std::string& reason);
796 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
797 std::ostream& os, const QuicGoAwayFrame& g);
799 QuicErrorCode error_code;
800 QuicStreamId last_good_stream_id;
801 std::string reason_phrase;
804 // Flow control updates per-stream and at the connection levoel.
805 // Based on SPDY's WINDOW_UPDATE frame, but uses an absolute byte offset rather
806 // than a window delta.
807 // TODO(rjshade): A possible future optimization is to make stream_id and
808 // byte_offset variable length, similar to stream frames.
809 struct NET_EXPORT_PRIVATE QuicWindowUpdateFrame {
810 QuicWindowUpdateFrame() {}
811 QuicWindowUpdateFrame(QuicStreamId stream_id, QuicStreamOffset byte_offset);
813 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
814 std::ostream& os, const QuicWindowUpdateFrame& w);
816 // The stream this frame applies to. 0 is a special case meaning the overall
817 // connection rather than a specific stream.
818 QuicStreamId stream_id;
820 // Byte offset in the stream or connection. The receiver of this frame must
821 // not send data which would result in this offset being exceeded.
822 QuicStreamOffset byte_offset;
825 // The BLOCKED frame is used to indicate to the remote endpoint that this
826 // endpoint believes itself to be flow-control blocked but otherwise ready to
827 // send data. The BLOCKED frame is purely advisory and optional.
828 // Based on SPDY's BLOCKED frame (undocumented as of 2014-01-28).
829 struct NET_EXPORT_PRIVATE QuicBlockedFrame {
830 QuicBlockedFrame() {}
831 explicit QuicBlockedFrame(QuicStreamId stream_id);
833 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
834 std::ostream& os, const QuicBlockedFrame& b);
836 // The stream this frame applies to. 0 is a special case meaning the overall
837 // connection rather than a specific stream.
838 QuicStreamId stream_id;
841 // EncryptionLevel enumerates the stages of encryption that a QUIC connection
842 // progresses through. When retransmitting a packet, the encryption level needs
843 // to be specified so that it is retransmitted at a level which the peer can
845 enum EncryptionLevel {
847 ENCRYPTION_INITIAL = 1,
848 ENCRYPTION_FORWARD_SECURE = 2,
850 NUM_ENCRYPTION_LEVELS,
853 struct NET_EXPORT_PRIVATE QuicFrame {
855 explicit QuicFrame(QuicPaddingFrame* padding_frame);
856 explicit QuicFrame(QuicStreamFrame* stream_frame);
857 explicit QuicFrame(QuicAckFrame* frame);
858 explicit QuicFrame(QuicCongestionFeedbackFrame* frame);
859 explicit QuicFrame(QuicRstStreamFrame* frame);
860 explicit QuicFrame(QuicConnectionCloseFrame* frame);
861 explicit QuicFrame(QuicStopWaitingFrame* frame);
862 explicit QuicFrame(QuicPingFrame* frame);
863 explicit QuicFrame(QuicGoAwayFrame* frame);
864 explicit QuicFrame(QuicWindowUpdateFrame* frame);
865 explicit QuicFrame(QuicBlockedFrame* frame);
867 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
868 std::ostream& os, const QuicFrame& frame);
872 QuicPaddingFrame* padding_frame;
873 QuicStreamFrame* stream_frame;
874 QuicAckFrame* ack_frame;
875 QuicCongestionFeedbackFrame* congestion_feedback_frame;
876 QuicStopWaitingFrame* stop_waiting_frame;
877 QuicPingFrame* ping_frame;
878 QuicRstStreamFrame* rst_stream_frame;
879 QuicConnectionCloseFrame* connection_close_frame;
880 QuicGoAwayFrame* goaway_frame;
881 QuicWindowUpdateFrame* window_update_frame;
882 QuicBlockedFrame* blocked_frame;
886 typedef std::vector<QuicFrame> QuicFrames;
888 struct NET_EXPORT_PRIVATE QuicFecData {
891 // The FEC group number is also the sequence number of the first
892 // FEC protected packet. The last protected packet's sequence number will
893 // be one less than the sequence number of the FEC packet.
894 QuicFecGroupNumber fec_group;
895 base::StringPiece redundancy;
898 class NET_EXPORT_PRIVATE QuicData {
900 QuicData(const char* buffer, size_t length);
901 QuicData(char* buffer, size_t length, bool owns_buffer);
904 base::StringPiece AsStringPiece() const {
905 return base::StringPiece(data(), length());
908 const char* data() const { return buffer_; }
909 size_t length() const { return length_; }
916 DISALLOW_COPY_AND_ASSIGN(QuicData);
919 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
921 static QuicPacket* NewDataPacket(
925 QuicConnectionIdLength connection_id_length,
926 bool includes_version,
927 QuicSequenceNumberLength sequence_number_length) {
928 return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
929 includes_version, sequence_number_length, false);
932 static QuicPacket* NewFecPacket(
936 QuicConnectionIdLength connection_id_length,
937 bool includes_version,
938 QuicSequenceNumberLength sequence_number_length) {
939 return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
940 includes_version, sequence_number_length, true);
943 base::StringPiece FecProtectedData() const;
944 base::StringPiece AssociatedData() const;
945 base::StringPiece BeforePlaintext() const;
946 base::StringPiece Plaintext() const;
948 bool is_fec_packet() const { return is_fec_packet_; }
950 char* mutable_data() { return buffer_; }
953 QuicPacket(char* buffer,
956 QuicConnectionIdLength connection_id_length,
957 bool includes_version,
958 QuicSequenceNumberLength sequence_number_length,
962 const bool is_fec_packet_;
963 const QuicConnectionIdLength connection_id_length_;
964 const bool includes_version_;
965 const QuicSequenceNumberLength sequence_number_length_;
967 DISALLOW_COPY_AND_ASSIGN(QuicPacket);
970 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
972 QuicEncryptedPacket(const char* buffer, size_t length);
973 QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer);
975 // Clones the packet into a new packet which owns the buffer.
976 QuicEncryptedPacket* Clone() const;
978 // By default, gtest prints the raw bytes of an object. The bool data
979 // member (in the base class QuicData) causes this object to have padding
980 // bytes, which causes the default gtest object printer to read
981 // uninitialize memory. So we need to teach gtest how to print this object.
982 NET_EXPORT_PRIVATE friend std::ostream& operator<<(
983 std::ostream& os, const QuicEncryptedPacket& s);
986 DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
989 class NET_EXPORT_PRIVATE RetransmittableFrames {
991 RetransmittableFrames();
992 ~RetransmittableFrames();
994 // Allocates a local copy of the referenced StringPiece has QuicStreamFrame
996 // Takes ownership of |stream_frame|.
997 const QuicFrame& AddStreamFrame(QuicStreamFrame* stream_frame);
998 // Takes ownership of the frame inside |frame|.
999 const QuicFrame& AddNonStreamFrame(const QuicFrame& frame);
1000 const QuicFrames& frames() const { return frames_; }
1002 IsHandshake HasCryptoHandshake() const;
1004 void set_encryption_level(EncryptionLevel level);
1005 EncryptionLevel encryption_level() const {
1006 return encryption_level_;
1011 EncryptionLevel encryption_level_;
1012 // Data referenced by the StringPiece of a QuicStreamFrame.
1013 std::vector<std::string*> stream_data_;
1015 DISALLOW_COPY_AND_ASSIGN(RetransmittableFrames);
1018 struct NET_EXPORT_PRIVATE SerializedPacket {
1019 SerializedPacket(QuicPacketSequenceNumber sequence_number,
1020 QuicSequenceNumberLength sequence_number_length,
1022 QuicPacketEntropyHash entropy_hash,
1023 RetransmittableFrames* retransmittable_frames);
1024 ~SerializedPacket();
1026 QuicPacketSequenceNumber sequence_number;
1027 QuicSequenceNumberLength sequence_number_length;
1029 QuicPacketEntropyHash entropy_hash;
1030 RetransmittableFrames* retransmittable_frames;
1032 // If set, these will be called when this packet is ACKed by the peer.
1033 std::set<QuicAckNotifier*> notifiers;
1036 struct NET_EXPORT_PRIVATE TransmissionInfo {
1037 // Used by STL when assigning into a map.
1040 // Constructs a Transmission with a new all_tranmissions set
1041 // containing |sequence_number|.
1042 TransmissionInfo(RetransmittableFrames* retransmittable_frames,
1043 QuicPacketSequenceNumber sequence_number,
1044 QuicSequenceNumberLength sequence_number_length);
1046 // Constructs a Transmission with the specified |all_tranmissions| set
1047 // and inserts |sequence_number| into it.
1048 TransmissionInfo(RetransmittableFrames* retransmittable_frames,
1049 QuicPacketSequenceNumber sequence_number,
1050 QuicSequenceNumberLength sequence_number_length,
1051 TransmissionType transmission_type,
1052 SequenceNumberSet* all_transmissions);
1054 RetransmittableFrames* retransmittable_frames;
1055 QuicSequenceNumberLength sequence_number_length;
1056 // Zero when the packet is serialized, non-zero once it's sent.
1058 // Zero when the packet is serialized, non-zero once it's sent.
1059 QuicByteCount bytes_sent;
1061 // Reason why this packet was transmitted.
1062 TransmissionType transmission_type;
1063 // Stores the sequence numbers of all transmissions of this packet.
1064 // Can never be null.
1065 SequenceNumberSet* all_transmissions;
1066 // In flight packets have not been abandoned or lost.
1072 #endif // NET_QUIC_QUIC_PROTOCOL_H_