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/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::map;
 using std::numeric_limits;
 using std::string;
 
 namespace net {
 
 namespace {
 
 // Mask to select the lowest 48 bits of a sequence number.
 const QuicPacketSequenceNumber kSequenceNumberMask =
     GG_UINT64_C(0x0000FFFFFFFFFFFF);
 
+const QuicGuid k1ByteGuidMask = GG_UINT64_C(0x00000000000000FF);
+const QuicGuid k4ByteGuidMask = GG_UINT64_C(0x00000000FFFFFFFF);
+
 const uint32 kInvalidDeltaTime = 0xffffffff;
 
 // Returns the absolute value of the difference between |a| and |b|.
 QuicPacketSequenceNumber Delta(QuicPacketSequenceNumber a,
                                QuicPacketSequenceNumber b) {
   // Since these are unsigned numbers, we can't just return abs(a - b)
   if (a < b) {
     return b - a;
   }
   return a - b;
 }
 
 QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target,
                                    QuicPacketSequenceNumber a,
                                    QuicPacketSequenceNumber b) {
   return (Delta(target, a) < Delta(target, b)) ? a : b;
 }
 
 }  // namespace
 
 QuicFramer::QuicFramer(QuicTag 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),
       is_server_(is_server),
       creation_time_(creation_time) {
   DCHECK(IsSupportedVersion(version));
   encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
 }
 
 QuicFramer::~QuicFramer() {}
@@ skipping 35 matching lines @@
 size_t QuicFramer::GetMinGoAwayFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       kQuicStreamIdSize;
 }
 
 // static
 // TODO(satyamshekhar): 16 - Crypto hash for integrity. Not a static value. Use
 // QuicEncrypter::GetMaxPlaintextSize.
 // 16 is a conservative estimate in the case of AEAD_AES_128_GCM_12, which uses
 // 12-byte tags.
-size_t QuicFramer::GetMaxUnackedPackets(bool include_version) {
-  return (kMaxPacketSize - GetPacketHeaderSize(include_version) -
+size_t QuicFramer::GetMaxUnackedPackets(QuicPacketHeader header) {
+  return (kMaxPacketSize - GetPacketHeaderSize(header) -
           GetMinAckFrameSize() - 16) / kSequenceNumberSize;
 }
 
 bool QuicFramer::IsSupportedVersion(QuicTag version) {
   return version == kQuicVersion1;
 }
 
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
-  return kPublicFlagsSize + kQuicGuidSize +
+  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) {
     // PADDING implies end of packet.
     return free_bytes;
   }
   size_t frame_len = ComputeFrameLength(frame);
@@ skipping 23 matching lines @@
     // is not a constant).
     return 0;
   }
   return 1 << (header.packet_sequence_number % 8);
 }
 
 SerializedPacket QuicFramer::ConstructFrameDataPacket(
     const QuicPacketHeader& header,
     const QuicFrames& frames) {
   const size_t max_plaintext_size = GetMaxPlaintextSize(kMaxPacketSize);
-  size_t packet_size = GetPacketHeaderSize(header.public_header.version_flag);
+  size_t packet_size = GetPacketHeaderSize(header);
   for (size_t i = 0; i < frames.size(); ++i) {
     DCHECK_LE(packet_size, max_plaintext_size);
     const size_t frame_size = GetSerializedFrameLength(
         frames[i], max_plaintext_size - packet_size, i == 0);
     DCHECK(frame_size);
     packet_size += frame_size;
   }
   return ConstructFrameDataPacket(header, frames, packet_size);
 }
 
@@ skipping 54 matching lines @@
         return kNoPacket;
     }
   }
 
   // Save the length before writing, because take clears it.
   const size_t len = writer.length();
   // Less than or equal because truncated acks end up with max_plaintex_size
   // length, even though they're typically slightly shorter.
   DCHECK_LE(len, packet_size);
   QuicPacket* packet = QuicPacket::NewDataPacket(
-      writer.take(), len, true, header.public_header.version_flag);
+      writer.take(), len, true, header.public_header.guid_length,
+      header.public_header.version_flag);
 
   if (fec_builder_) {
     fec_builder_->OnBuiltFecProtectedPayload(header,
                                              packet->FecProtectedData());
   }
 
   return SerializedPacket(header.packet_sequence_number, packet,
                           GetPacketEntropyHash(header), NULL);
 }
 
-SerializedPacket QuicFramer::ConstructFecPacket(const QuicPacketHeader& header,
-                                                const QuicFecData& fec) {
-  size_t len = GetPacketHeaderSize(header.public_header.version_flag);
+SerializedPacket QuicFramer::ConstructFecPacket(
+    const QuicPacketHeader& header,
+    const QuicFecData& fec) {
+  DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group);
+  DCHECK_NE(0u, header.fec_group);
+  size_t len = GetPacketHeaderSize(header);
   len += fec.redundancy.length();
 
   QuicDataWriter writer(len);
   SerializedPacket kNoPacket = SerializedPacket(0, NULL, 0, NULL);
   if (!WritePacketHeader(header, &writer)) {
     return kNoPacket;
   }
 
   if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
     return kNoPacket;
   }
 
-  return SerializedPacket(header.packet_sequence_number,
-                          QuicPacket::NewFecPacket(
-                              writer.take(), len, true,
-                              header.public_header.version_flag),
-                          GetPacketEntropyHash(header), NULL);
+  return SerializedPacket(
+      header.packet_sequence_number,
+      QuicPacket::NewFecPacket(writer.take(), len, true,
+                               header.public_header.guid_length,
+                               header.public_header.version_flag),
+      GetPacketEntropyHash(header), NULL);
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::ConstructPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
   size_t len = GetPublicResetPacketSize();
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST |
@@ skipping 112 matching lines @@
     return true;
   }
 
   if (packet.length() > kMaxPacketSize) {
     DLOG(WARNING) << "Packet too large: " << packet.length();
     return RaiseError(QUIC_PACKET_TOO_LARGE);
   }
 
   // Handle the payload.
   if (!header.fec_flag) {
-    if (header.fec_group != 0) {
+    if (header.is_in_fec_group == IN_FEC_GROUP) {
       StringPiece payload = reader_->PeekRemainingPayload();
       visitor_->OnFecProtectedPayload(payload);
     }
     if (!ProcessFrameData()) {
       DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
       DLOG(WARNING) << "Unable to process frame data.";
       return false;
     }
   } else {
     QuicFecData fec_data;
@@ skipping 47 matching lines @@
     return false;
   }
 
   visitor_->OnPacketComplete();
   reader_.reset(NULL);
   return true;
 }
 
 bool QuicFramer::WritePacketHeader(const QuicPacketHeader& header,
                                    QuicDataWriter* writer) {
-  uint8 flags = 0;
+  DCHECK(header.fec_group > 0 || header.is_in_fec_group == NOT_IN_FEC_GROUP);
+  uint8 public_flags = 0;
   if (header.public_header.reset_flag) {
-    flags |= PACKET_PUBLIC_FLAGS_RST;
+    public_flags |= PACKET_PUBLIC_FLAGS_RST;
   }
   if (header.public_header.version_flag) {
-    flags |= PACKET_PUBLIC_FLAGS_VERSION;
+    public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
   }
-  flags |= PACKET_PUBLIC_FLAGS_8BYTE_GUID;
-  if (!writer->WriteUInt8(flags)) {
-    return false;
+  switch (header.public_header.guid_length) {
+    case PACKET_0BYTE_GUID:
+      if (!writer->WriteUInt8(public_flags | PACKET_PUBLIC_FLAGS_0BYTE_GUID)) {
+        return false;
+      }
+      break;
+    case PACKET_1BYTE_GUID:
+      if (!writer->WriteUInt8(public_flags | PACKET_PUBLIC_FLAGS_1BYTE_GUID)) {
+         return false;
+      }
+      if (!writer->WriteUInt8(header.public_header.guid & k1ByteGuidMask)) {
+           return false;
+      }
+      break;
+    case PACKET_4BYTE_GUID:
+      if (!writer->WriteUInt8(public_flags | PACKET_PUBLIC_FLAGS_4BYTE_GUID)) {
+         return false;
+      }
+      if (!writer->WriteUInt32(header.public_header.guid & k4ByteGuidMask)) {
+        return false;
+      }
+      break;
+    case PACKET_8BYTE_GUID:
+      if (!writer->WriteUInt8(public_flags | PACKET_PUBLIC_FLAGS_8BYTE_GUID)) {
+        return false;
+      }
+      if (!writer->WriteUInt64(header.public_header.guid)) {
+        return false;
+      }
+      break;
   }
-
-  if (!writer->WriteUInt64(header.public_header.guid)) {
-    return false;
-  }
+  last_serialized_guid_ = header.public_header.guid;
 
   if (header.public_header.version_flag) {
     DCHECK(!is_server_);
     writer->WriteUInt32(quic_version_);
   }
 
   if (!AppendPacketSequenceNumber(header.packet_sequence_number, writer)) {
     return false;
   }
 
-  flags = 0;
+  uint8 private_flags = 0;
+  if (header.entropy_flag) {
+    private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
+  }
+  if (header.is_in_fec_group == IN_FEC_GROUP) {
+    private_flags |= PACKET_PRIVATE_FLAGS_FEC_GROUP;
+  }
   if (header.fec_flag) {
-    flags |= PACKET_PRIVATE_FLAGS_FEC;
+    private_flags |= PACKET_PRIVATE_FLAGS_FEC;
   }
-  if (header.entropy_flag) {
-    flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
-  }
-  if (header.fec_entropy_flag) {
-    flags |= PACKET_PRIVATE_FLAGS_FEC_ENTROPY;
-  }
-  if (!writer->WriteUInt8(flags)) {
+  if (!writer->WriteUInt8(private_flags)) {
     return false;
   }
 
-  // Offset from the current packet sequence number to the first fec
-  // protected packet, or kNoFecOffset to signal no FEC protection.
-  uint8 first_fec_protected_packet_offset = kNoFecOffset;
-
   // The FEC group number is the sequence number of the first fec
   // protected packet, or 0 if this packet is not protected.
-  if (header.fec_group != 0) {
+  if (header.is_in_fec_group == IN_FEC_GROUP) {
     DCHECK_GE(header.packet_sequence_number, header.fec_group);
     DCHECK_GT(255u, header.packet_sequence_number - header.fec_group);
-    first_fec_protected_packet_offset =
+    // Offset from the current packet sequence number to the first fec
+    // protected packet.
+    uint8 first_fec_protected_packet_offset =
         header.packet_sequence_number - header.fec_group;
-  }
-  if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) {
-    return false;
+    if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) {
+      return false;
+    }
   }
 
   return true;
 }
 
 QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
     QuicPacketSequenceNumber packet_sequence_number) const {
   // The new sequence number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the sequence number closest to the
@@ skipping 14 matching lines @@
   if (!reader_->ReadBytes(&public_flags, 1)) {
     set_detailed_error("Unable to read public flags.");
     return false;
   }
 
   if (public_flags > PACKET_PUBLIC_FLAGS_MAX) {
     set_detailed_error("Illegal public flags value.");
     return false;
   }
 
-  if ((public_flags & PACKET_PUBLIC_FLAGS_8BYTE_GUID) !=
-          PACKET_PUBLIC_FLAGS_8BYTE_GUID) {
-    set_detailed_error("Only full length guids (8 bytes) currently supported.");
-    return false;
-  }
-
   public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
   public_header->version_flag =
       (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
 
   if (public_header->reset_flag && public_header->version_flag) {
     set_detailed_error("Got version flag in reset packet");
     return false;
   }
 
-  if (!reader_->ReadUInt64(&public_header->guid)) {
-    set_detailed_error("Unable to read GUID.");
-    return false;
+  switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_GUID) {
+    case PACKET_PUBLIC_FLAGS_8BYTE_GUID:
+      if (!reader_->ReadUInt64(&public_header->guid)) {
+        set_detailed_error("Unable to read GUID.");
+        return false;
+      }
+      public_header->guid_length = PACKET_8BYTE_GUID;
+      break;
+    case PACKET_PUBLIC_FLAGS_4BYTE_GUID:
+      // If the guid is truncated, expect to read the last serialized guid.
+      if (!reader_->ReadBytes(&public_header->guid, PACKET_4BYTE_GUID)) {
+        set_detailed_error("Unable to read GUID.");
+        return false;
+      }
+      if ((public_header->guid & k4ByteGuidMask) !=
+          (last_serialized_guid_ & k4ByteGuidMask)) {
+        set_detailed_error(
+            "Truncated 4 byte GUID does not match previous guid.");
+        return false;
+      }
+      public_header->guid_length = PACKET_4BYTE_GUID;
+      public_header->guid = last_serialized_guid_;
+      break;
+    case PACKET_PUBLIC_FLAGS_1BYTE_GUID:
+      if (!reader_->ReadBytes(&public_header->guid, PACKET_1BYTE_GUID)) {
+        set_detailed_error("Unable to read GUID.");
+        return false;
+      }
+      if ((public_header->guid & k1ByteGuidMask) !=
+          (last_serialized_guid_ & k1ByteGuidMask)) {
+        set_detailed_error(
+            "Truncated 1 byte GUID does not match previous guid.");
+        return false;
+      }
+      public_header->guid_length = PACKET_1BYTE_GUID;
+      public_header->guid = last_serialized_guid_;
+      break;
+    case PACKET_PUBLIC_FLAGS_0BYTE_GUID:
+      public_header->guid_length = PACKET_0BYTE_GUID;
+      public_header->guid = last_serialized_guid_;
+      break;
   }
 
   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.
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
@@ skipping 26 matching lines @@
     set_detailed_error("Unable to read sequence number.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (header->packet_sequence_number == 0u) {
     set_detailed_error("Packet sequence numbers cannot be 0.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!DecryptPayload(header->packet_sequence_number,
+                      header->public_header.guid_length,
                       header->public_header.version_flag,
                       packet)) {
     set_detailed_error("Unable to decrypt payload.");
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
   uint8 private_flags;
   if (!reader_->ReadBytes(&private_flags, 1)) {
     set_detailed_error("Unable to read private flags.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (private_flags > PACKET_PRIVATE_FLAGS_MAX) {
     set_detailed_error("Illegal private flags value.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
+  header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0;
   header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0;
-  header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0;
-  header->fec_entropy_flag =
-      (private_flags & PACKET_PRIVATE_FLAGS_FEC_ENTROPY) != 0;
 
-  uint8 first_fec_protected_packet_offset;
-  if (!reader_->ReadBytes(&first_fec_protected_packet_offset, 1)) {
-    set_detailed_error("Unable to read first fec protected packet offset.");
-    return RaiseError(QUIC_INVALID_PACKET_HEADER);
+  if ((private_flags & PACKET_PRIVATE_FLAGS_FEC_GROUP) != 0) {
+    header->is_in_fec_group = IN_FEC_GROUP;
+    uint8 first_fec_protected_packet_offset;
+    if (!reader_->ReadBytes(&first_fec_protected_packet_offset, 1)) {
+      set_detailed_error("Unable to read first fec protected packet offset.");
+      return RaiseError(QUIC_INVALID_PACKET_HEADER);
+    }
+    header->fec_group =
+        header->packet_sequence_number - first_fec_protected_packet_offset;
   }
-  header->fec_group = first_fec_protected_packet_offset == kNoFecOffset ? 0 :
-      header->packet_sequence_number - first_fec_protected_packet_offset;
 
   header->entropy_hash = GetPacketEntropyHash(*header);
   // Set the last sequence number after we have decrypted the packet
   // so we are confident is not attacker controlled.
   last_sequence_number_ = header->packet_sequence_number;
   return true;
 }
 
 bool QuicFramer::ProcessPacketSequenceNumber(
     QuicPacketSequenceNumber* sequence_number) {
@@ skipping 395 matching lines @@
     set_detailed_error("Unable to read goaway reason.");
     return false;
   }
   frame->reason_phrase = reason_phrase.as_string();
 
   return true;
 }
 
 // static
 StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
-    const QuicEncryptedPacket& encrypted, bool includes_version) {
+    const QuicEncryptedPacket& encrypted,
+    QuicGuidLength guid_length,
+    bool includes_version) {
   return StringPiece(encrypted.data() + kStartOfHashData,
-                     GetStartOfEncryptedData(includes_version) -
-                         kStartOfHashData);
+                     GetStartOfEncryptedData(
+                         guid_length, includes_version) - kStartOfHashData);
 }
 
 void QuicFramer::SetDecrypter(QuicDecrypter* decrypter) {
   DCHECK(alternative_decrypter_.get() == NULL);
   decrypter_.reset(decrypter);
 }
 
 void QuicFramer::SetAlternativeDecrypter(QuicDecrypter* decrypter,
                                          bool latch_once_used) {
   alternative_decrypter_.reset(decrypter);
@@ skipping 68 matching lines @@
       if (size < min_plaintext_size) {
         min_plaintext_size = size;
       }
     }
   }
 
   return min_plaintext_size;
 }
 
 bool QuicFramer::DecryptPayload(QuicPacketSequenceNumber sequence_number,
+                                QuicGuidLength guid_length,
                                 bool version_flag,
                                 const QuicEncryptedPacket& packet) {
   StringPiece encrypted;
   if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) {
     return false;
   }
   DCHECK(decrypter_.get() != NULL);
   decrypted_.reset(decrypter_->DecryptPacket(
       sequence_number,
-      GetAssociatedDataFromEncryptedPacket(packet, version_flag),
+      GetAssociatedDataFromEncryptedPacket(packet, guid_length, version_flag),
       encrypted));
   if  (decrypted_.get() == NULL && alternative_decrypter_.get() != NULL) {
     decrypted_.reset(alternative_decrypter_->DecryptPacket(
         sequence_number,
-        GetAssociatedDataFromEncryptedPacket(packet, version_flag),
+        GetAssociatedDataFromEncryptedPacket(packet, guid_length, version_flag),
         encrypted));
     if (decrypted_.get() != NULL) {
       if (alternative_decrypter_latch_) {
         // Switch to the alternative decrypter and latch so that we cannot
         // switch back.
         decrypter_.reset(alternative_decrypter_.release());
       } else {
         // Switch the alternative decrypter so that we use it first next time.
         decrypter_.swap(alternative_decrypter_);
       }
@@ skipping 335 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net