Land Recent QUIC changes

net/quic/quic_protocol.h

 // 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 <limits>
 #include <map>
@@ skipping 18 matching lines @@
 
 class QuicPacket;
 
 typedef uint64 QuicGuid;
 typedef uint32 QuicStreamId;
 typedef uint64 QuicStreamOffset;
 typedef uint64 QuicPacketSequenceNumber;
 typedef QuicPacketSequenceNumber QuicFecGroupNumber;
 typedef uint64 QuicPublicResetNonceProof;
 typedef uint8 QuicPacketEntropyHash;
-typedef uint32 QuicVersionTag;
-typedef std::vector<QuicVersionTag> QuicVersionTagList;
 typedef uint32 QuicHeaderId;
+// QuicTag is the type of a tag in the wire protocol.
+typedef uint32 QuicTag;
+typedef std::vector<QuicTag> QuicTagVector;
 
 // TODO(rch): Consider Quic specific names for these constants.
 // Maximum size in bytes of a QUIC packet.
 const QuicByteCount kMaxPacketSize = 1200;
 
 // Maximum number of open streams per connection.
 const size_t kDefaultMaxStreamsPerConnection = 100;
 
 // Number of bytes reserved for guid in the packet header.
 const size_t kQuicGuidSize = 8;
@@ skipping 16 matching lines @@
 // Size in bytes of the data or fec packet header.
 NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(bool include_version);
 // Size in bytes of the public reset packet.
 NET_EXPORT_PRIVATE size_t GetPublicResetPacketSize();
 
 // Index of the first byte in a QUIC packet of FEC protected data.
 NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(bool include_version);
 // Index of the first byte in a QUIC packet of encrypted data.
 NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(bool include_version);
 // Returns true if |version| is a supported protocol version.
-NET_EXPORT_PRIVATE bool IsSupportedVersion(QuicVersionTag version);
+NET_EXPORT_PRIVATE bool IsSupportedVersion(QuicTag version);
 
 // Index of the first byte in a QUIC packet which is used in hash calculation.
 const size_t kStartOfHashData = 0;
 
 // Limit on the delta between stream IDs.
 const QuicStreamId kMaxStreamIdDelta = 100;
 // Limit on the delta between header IDs.
 const QuicHeaderId kMaxHeaderIdDelta = 100;
 
 // Reserved ID for the crypto stream.
 // TODO(rch): ensure that this is not usable by any other streams.
 const QuicStreamId kCryptoStreamId = 1;
 
 // Value which indicates this packet is not FEC protected.
 const uint8 kNoFecOffset = 0xFF;
 
 const int64 kDefaultTimeoutUs = 600000000;  // 10 minutes.
 
 enum Retransmission {
-  NOT_RETRANSMISSION = 0,
-  IS_RETRANSMISSION = 1,
+  NOT_RETRANSMISSION,
+  IS_RETRANSMISSION,
 };
 
 enum HasRetransmittableData {
-  HAS_RETRANSMITTABLE_DATA = 0,
-  NO_RETRANSMITTABLE_DATA = 1,
+  NO_RETRANSMITTABLE_DATA,
+  HAS_RETRANSMITTABLE_DATA,
 };
 
 enum QuicFrameType {
   PADDING_FRAME = 0,
   STREAM_FRAME,
   ACK_FRAME,
   CONGESTION_FEEDBACK_FRAME,
   RST_STREAM_FRAME,
   CONNECTION_CLOSE_FRAME,
   GOAWAY_FRAME,
@@ skipping 111 matching lines @@
   QUIC_CRYPTO_VERSION_NOT_SUPPORTED,
   // There was no intersection between the crypto primitives supported by the
   // peer and ourselves.
   QUIC_CRYPTO_NO_SUPPORT,
   // The server rejected our client hello messages too many times.
   QUIC_CRYPTO_TOO_MANY_REJECTS,
   // The client rejected the server's certificate chain or signature.
   QUIC_PROOF_INVALID,
   // A crypto message was received with a duplicate tag.
   QUIC_CRYPTO_DUPLICATE_TAG,
+  // 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,
+  // The server config for a server has expired.
+  QUIC_CRYPTO_SERVER_CONFIG_EXPIRED,
 
   // No error. Used as bound while iterating.
   QUIC_LAST_ERROR,
 };
 
 // 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, we need
 // to reverse the order of the bytes.
 //
 // The TAG macro is used in header files to ensure that we don't create static
 // initialisers. In normal code, the MakeQuicTag function should be used.
 #define TAG(a, b, c, d) ((d << 24) + (c << 16) + (b << 8) + a)
-const QuicVersionTag kUnsupportedVersion = -1;
-const QuicVersionTag kQuicVersion1 = TAG('Q', '1', '.', '0');
+const QuicTag kUnsupportedVersion = -1;
+// Each time the wire format changes, this need needs to be incremented.
+// At some point, we will actually freeze the wire format and make an official
+// version number, but this works for now.
+const QuicTag kQuicVersion1 = TAG('Q', '0', '0', '1');
 #undef TAG
 
 // MakeQuicTag returns a value given the four bytes. For example:
 //   MakeQuicTag('C', 'H', 'L', 'O');
 uint32 NET_EXPORT_PRIVATE MakeQuicTag(char a, char b, char c, char d);
 
 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   QuicPacketPublicHeader();
   explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);
   ~QuicPacketPublicHeader();
 
   QuicPacketPublicHeader& operator=(const QuicPacketPublicHeader& other);
 
   // Universal header. All QuicPacket headers will have a guid and public flags.
   QuicGuid guid;
   bool reset_flag;
   bool version_flag;
-  QuicVersionTagList versions;
+  QuicTagVector versions;
 };
 
 // Header for Data or FEC packets.
 struct NET_EXPORT_PRIVATE QuicPacketHeader {
   QuicPacketHeader();
   explicit QuicPacketHeader(const QuicPacketPublicHeader& header);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicPacketHeader& s);
 
@@ skipping 413 matching lines @@
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicConsumedData& s);
 
   size_t bytes_consumed;
   bool fin_consumed;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_