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 19 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;
 
 // 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 15 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);
 
 // 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;
 
 // Reserved ID for the crypto stream.
 // TODO(rch): ensure that this is not usable by any other streams.
 const QuicStreamId kCryptoStreamId = 1;
@@ skipping 26 matching lines @@
   PACKET_PRIVATE_FLAGS_FEC = 1 << 0,  // Payload is FEC as opposed to frames.
   PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 1,
   PACKET_PRIVATE_FLAGS_FEC_ENTROPY = 1 << 2,
   PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1  // All bits set.
 };
 
 enum QuicErrorCode {
   // Stream errors.
   QUIC_NO_ERROR = 0,
 
+  // Connection has reached an invalid state.
+  QUIC_INTERNAL_ERROR,
+
   // There were data frames after the a fin or reset.
   QUIC_STREAM_DATA_AFTER_TERMINATION,
   // There was some server error which halted stream processing.
   QUIC_SERVER_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,
 
   // Connection errors.
 
   // Control frame is malformed.
   QUIC_INVALID_PACKET_HEADER,
   // Frame data is malformed.
   QUIC_INVALID_FRAME_DATA,
   // FEC data is malformed.
   QUIC_INVALID_FEC_DATA,
   // Stream rst data is malformed
   QUIC_INVALID_RST_STREAM_DATA,
   // Connection close data is malformed.
   QUIC_INVALID_CONNECTION_CLOSE_DATA,
   // GoAway data is malformed.
   QUIC_INVALID_GOAWAY_DATA,
   // Ack data is malformed.
   QUIC_INVALID_ACK_DATA,
+  // Version negotiation packet is malformed.
+  QUIC_INVALID_VERSION_NEGOTIATION_PACKET,
   // There was an error decrypting.
   QUIC_DECRYPTION_FAILURE,
   // There was an error encrypting.
   QUIC_ENCRYPTION_FAILURE,
   // The packet exceeded kMaxPacketSize.
   QUIC_PACKET_TOO_LARGE,
   // Data was sent for a stream which did not exist.
   QUIC_PACKET_FOR_NONEXISTENT_STREAM,
   // The peer is going away.  May be a client or server.
   QUIC_PEER_GOING_AWAY,
   // A stream ID was invalid.
   QUIC_INVALID_STREAM_ID,
   // Too many streams already open.
   QUIC_TOO_MANY_OPEN_STREAMS,
   // Received public reset for this connection.
   QUIC_PUBLIC_RESET,
+  // Invalid protocol version
+  QUIC_INVALID_VERSION,
 
   // We hit our prenegotiated (or default) timeout
   QUIC_CONNECTION_TIMED_OUT,
 
   // Crypto errors.
 
   // Handshake message contained out of order tags.
   QUIC_CRYPTO_TAGS_OUT_OF_ORDER,
   // Handshake message contained too many entries.
   QUIC_CRYPTO_TOO_MANY_ENTRIES,
@@ skipping 16 matching lines @@
 };
 
 // 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.
 #define MAKE_TAG(a, b, c, d) ((d << 24) + (c << 16) + (b << 8) + a)
 
+const QuicVersionTag kUnsupportedVersion = -1;
 const QuicVersionTag kQuicVersion1 = MAKE_TAG('Q', '1', '.', '0');
 
 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;
-  QuicVersionTag version;
+  QuicVersionTagList versions;
 };
 
 // Header for Data or FEC packets.
 struct QuicPacketHeader {
   QuicPacketHeader() {}
   explicit QuicPacketHeader(const QuicPacketPublicHeader& header)
       : public_header(header) {}
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicPacketHeader& s);
 
   QuicPacketPublicHeader public_header;
   bool fec_flag;
   bool fec_entropy_flag;
   bool entropy_flag;
   QuicPacketEntropyHash entropy_hash;
   QuicPacketSequenceNumber packet_sequence_number;
   QuicFecGroupNumber fec_group;
 };
 
 struct QuicPublicResetPacket {
   QuicPublicResetPacket() {}
   explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header)
       : public_header(header) {}
   QuicPacketPublicHeader public_header;
   QuicPacketSequenceNumber rejected_sequence_number;
   QuicPublicResetNonceProof nonce_proof;
 };
 
+enum QuicVersionNegotiationState {
+  START_NEGOTIATION = 0,
+  SENT_NEGOTIATION_PACKET,
+  NEGOTIATED_VERSION
+};
+
+typedef QuicPacketPublicHeader QuicVersionNegotiationPacket;
+
 // A padding frame contains no payload.
 struct NET_EXPORT_PRIVATE QuicPaddingFrame {
 };
 
 struct NET_EXPORT_PRIVATE QuicStreamFrame {
   QuicStreamFrame();
   QuicStreamFrame(QuicStreamId stream_id,
                   bool fin,
                   QuicStreamOffset offset,
                   base::StringPiece data);
@@ skipping 23 matching lines @@
   // The highest packet sequence 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.
   QuicPacketSequenceNumber largest_observed;
 
+  // Time elapsed since largest_observed was received until this Ack frame was
+  // sent.
+  QuicTime::Delta delta_time_largest_observed;
+
   // TODO(satyamshekhar): Can be optimized using an interval set like data
   // structure.
   // The set of packets which we're expecting and have not received.
   SequenceNumberSet missing_packets;
 };
 
 // True if the sequence number is greater than largest_observed or is listed
 // as missing.
 // Always returns false for sequence numbers less than least_unacked.
 bool NET_EXPORT_PRIVATE IsAwaitingPacket(
@@ skipping 17 matching lines @@
   QuicPacketEntropyHash entropy_hash;
   // The lowest packet we've sent which is unacked, and we expect an ack for.
   QuicPacketSequenceNumber least_unacked;
 };
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame() {}
   // Testing convenience method to construct a QuicAckFrame with all packets
   // from least_unacked to largest_observed acked.
   QuicAckFrame(QuicPacketSequenceNumber largest_observed,
+               QuicTime largest_observed_receive_time,
                QuicPacketSequenceNumber least_unacked);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicAckFrame& s);
 
   SentPacketInfo sent_info;
   ReceivedPacketInfo received_info;
 };
 
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
@@ skipping 274 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_