Land Recent QUIC changes.

net/quic/quic_framer.cc

 // 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.
 
 #include "net/quic/quic_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
@@ skipping 35 matching lines @@
 }
 
 QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target,
                                    QuicPacketSequenceNumber a,
                                    QuicPacketSequenceNumber b) {
   return (Delta(target, a) < Delta(target, b)) ? a : b;
 }
 
 }  // namespace
 
-QuicFramer::QuicFramer(QuicTag version,
+QuicFramer::QuicFramer(QuicVersion version,
                        QuicTime creation_time,
                        bool is_server)
     : visitor_(NULL),
       fec_builder_(NULL),
       error_(QUIC_NO_ERROR),
       last_sequence_number_(0),
       last_serialized_guid_(0),
       quic_version_(version),
       decrypter_(QuicDecrypter::Create(kNULL)),
       alternative_decrypter_latch_(false),
@@ skipping 68 matching lines @@
 // static
 size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id) {
   return 4;
 }
 
 // static
 size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset) {
   return 8;
 }
 
-bool QuicFramer::IsSupportedVersion(QuicTag version) {
-  return version == kQuicVersion1;
+bool QuicFramer::IsSupportedVersion(const QuicVersion version) const {
+  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
+    if (version == kSupportedQuicVersions[i]) {
+      return true;
+    }
+  }
+  return false;
 }
 
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
   return kPublicFlagsSize + PACKET_8BYTE_GUID +
       number_versions * kQuicVersionSize;
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
     const QuicFrame& frame, size_t free_bytes, bool first_frame) {
   if (frame.type == PADDING_FRAME) {
@@ skipping 178 matching lines @@
                                   packet.rejected_sequence_number,
                                   &writer)) {
     return NULL;
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 QuicEncryptedPacket* QuicFramer::ConstructVersionNegotiationPacket(
     const QuicPacketPublicHeader& header,
-    const QuicTagVector& supported_versions) {
+    const QuicVersionVector& supported_versions) {
   DCHECK(header.version_flag);
   size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION |
                                    PACKET_PUBLIC_FLAGS_8BYTE_GUID |
                                    PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(header.guid)) {
     return NULL;
   }
 
   for (size_t i = 0; i < supported_versions.size(); ++i) {
-    if (!writer.WriteUInt32(supported_versions[i])) {
+    if (!writer.WriteUInt32(QuicVersionToQuicTag(supported_versions[i]))) {
       return NULL;
     }
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   // TODO(satyamshekhar): Don't RaiseError (and close the connection) for
   // invalid (unauthenticated) packets.
@@ skipping 33 matching lines @@
 bool QuicFramer::ProcessVersionNegotiationPacket(
     QuicPacketPublicHeader* public_header) {
   DCHECK(!is_server_);
   // Try reading at least once to raise error if the packet is invalid.
   do {
     QuicTag version;
     if (!reader_->ReadBytes(&version, kQuicVersionSize)) {
       set_detailed_error("Unable to read supported version in negotiation.");
       return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
     }
-    public_header->versions.push_back(version);
+    public_header->versions.push_back(QuicTagToQuicVersion(version));
   } while (!reader_->IsDoneReading());
 
   visitor_->OnVersionNegotiationPacket(*public_header);
   return true;
 }
 
 bool QuicFramer::ProcessDataPacket(
     const QuicPacketPublicHeader& public_header,
     const QuicEncryptedPacket& packet) {
   QuicPacketHeader header(public_header);
@@ skipping 134 matching lines @@
       }
       if (!writer->WriteUInt64(header.public_header.guid)) {
         return false;
       }
       break;
   }
   last_serialized_guid_ = header.public_header.guid;
 
   if (header.public_header.version_flag) {
     DCHECK(!is_server_);
-    writer->WriteUInt32(quic_version_);
+    writer->WriteUInt32(QuicVersionToQuicTag(quic_version_));
   }
 
   if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
                                   header.packet_sequence_number, writer)) {
     return false;
   }
 
   uint8 private_flags = 0;
   if (header.entropy_flag) {
     private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
@@ skipping 123 matching lines @@
       public_header->sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER;
       break;
     case PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE:
       public_header->sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER;
       break;
     case PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE:
       public_header->sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
       break;
   }
 
+  // Read the version only if the packet is from the client.
+  // version flag from the server means version negotiation packet.
   if (public_header->version_flag && is_server_) {
-    QuicTag version;
-    if (!reader_->ReadUInt32(&version)) {
-      // Read the version only if the packet is from the client.
-      // version flag from the server means version negotiation packet.
+    QuicTag version_tag;
+    if (!reader_->ReadUInt32(&version_tag)) {
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
+
+    // If the version from the new packet is the same as the version of this
+    // framer, then the public flags should be set to something we understand.
+    // If not, this raises an error.
+    QuicVersion version = QuicTagToQuicVersion(version_tag);
     if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
       set_detailed_error("Illegal public flags value.");
       return false;
     }
     public_header->versions.push_back(version);
   }
   return true;
 }
 
 // static
@@ skipping 809 matching lines @@
       frame.received_info.missing_packets.begin();
   int num_missing_packets_written = 0;
   for (; it != frame.received_info.missing_packets.end(); ++it) {
     if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
                                     *it, writer)) {
       // We are truncating.
       QuicPacketSequenceNumber largest_observed =
           CalculateLargestObserved(frame.received_info.missing_packets, --it);
       // Overwrite entropy hash for received packets.
       writer->WriteUInt8ToOffset(
-          entropy_calculator_->ReceivedEntropyHash(largest_observed),
+          entropy_calculator_->EntropyHash(largest_observed),
           received_entropy_offset);
       // Overwrite largest_observed.
       writer->WriteUInt48ToOffset(largest_observed & k6ByteSequenceNumberMask,
                                   largest_observed_offset);
       writer->WriteUInt32ToOffset(kInvalidDeltaTime,
                                   delta_time_largest_observed_offset);
       writer->WriteUInt8ToOffset(num_missing_packets_written,
                                  num_missing_packets_offset);
       return true;
     }
@@ skipping 144 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net