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"
@@ skipping 27 matching lines @@
 QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target,
                                    QuicPacketSequenceNumber a,
                                    QuicPacketSequenceNumber b) {
   return (Delta(target, a) < Delta(target, b)) ? a : b;
 }
 
 }  // namespace
 
 QuicFramer::QuicFramer(QuicVersionTag version,
                        QuicDecrypter* decrypter,
-                       QuicEncrypter* encrypter)
+                       QuicEncrypter* encrypter,
+                       bool is_server)
     : visitor_(NULL),
       fec_builder_(NULL),
       error_(QUIC_NO_ERROR),
       last_sequence_number_(0),
       quic_version_(version),
       decrypter_(decrypter),
-      encrypter_(encrypter) {
-  DCHECK_EQ(kQuicVersion1, version);
+      encrypter_(encrypter),
+      is_server_(is_server) {
+  DCHECK(IsSupportedVersion(version));
 }
 
 QuicFramer::~QuicFramer() {}
 
 bool CanTruncate(const QuicFrame& frame) {
   if (frame.type == ACK_FRAME ||
       frame.type == CONNECTION_CLOSE_FRAME) {
     return true;
   }
   return false;
@@ skipping 22 matching lines @@
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       GetMinAckFrameSize();
 }
 
 // static
 size_t QuicFramer::GetMinGoAwayFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       kQuicStreamIdSize;
 }
 
+bool QuicFramer::IsSupportedVersion(QuicVersionTag version) {
+  return version == kQuicVersion1;
+}
+
+size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
+  return kQuicGuidSize + kPublicFlagsSize +
+      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);
   if (frame_len > free_bytes) {
     // Only truncate the first frame in a packet, so if subsequent ones go
     // over, stop including more frames.
@@ skipping 129 matching lines @@
                           QuicPacket::NewFecPacket(
                               writer.take(), len, true,
                               header.public_header.version_flag),
                           GetPacketEntropyHash(header), NULL);
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::ConstructPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
-  DCHECK(!packet.public_header.version_flag);
   size_t len = GetPublicResetPacketSize();
   QuicDataWriter writer(len);
 
   if (!writer.WriteUInt64(packet.public_header.guid)) {
     return NULL;
   }
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(packet.nonce_proof)) {
     return NULL;
   }
 
   if (!AppendPacketSequenceNumber(packet.rejected_sequence_number,
                                   &writer)) {
     return NULL;
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
+QuicEncryptedPacket* QuicFramer::ConstructVersionNegotiationPacket(
+    const QuicPacketPublicHeader& header,
+    const QuicVersionTagList& supported_versions) {
+  DCHECK(header.version_flag);
+  size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
+  QuicDataWriter writer(len);
+
+  if (!writer.WriteUInt64(header.guid)) {
+    return NULL;
+  }
+
+  uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION);
+  if (!writer.WriteUInt8(flags)) {
+    return NULL;
+  }
+
+  for (size_t i = 0; i < supported_versions.size(); ++i) {
+    if (!writer.WriteUInt32(supported_versions[i])) {
+      return NULL;
+    }
+  }
+
+  return new QuicEncryptedPacket(writer.take(), len, true);
+}
+
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   DCHECK(!reader_.get());
   reader_.reset(new QuicDataReader(packet.data(), packet.length()));
 
+  visitor_->OnPacket();
+
   // First parse the public header.
   QuicPacketPublicHeader public_header;
   if (!ProcessPublicHeader(&public_header)) {
     DLOG(WARNING) << "Unable to process public header.";
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
-  // TODO(satyamshekhar): Handle version negotiation.
-  if (public_header.version_flag && public_header.version != quic_version_) {
-      return false;
+
+  if (is_server_ && public_header.version_flag &&
+      public_header.versions[0] != quic_version_) {
+    if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) {
+      reader_.reset(NULL);
+      return true;
+    }
   }
 
   bool rv;
-  if (public_header.reset_flag) {
+  if (!is_server_ && public_header.version_flag) {
+    rv = ProcessVersionNegotiationPacket(&public_header);
+  } else if (public_header.reset_flag) {
     rv = ProcessPublicResetPacket(public_header);
   } else {
     rv = ProcessDataPacket(public_header, packet);
   }
 
   reader_.reset(NULL);
   return rv;
 }
 
+bool QuicFramer::ProcessVersionNegotiationPacket(
+    QuicPacketPublicHeader* public_header) {
+  DCHECK(!is_server_);
+  // Try reading at least once to raise error if the packet is invalid.
+  do {
+    QuicVersionTag 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);
+  } while (!reader_->IsDoneReading());
+
+  visitor_->OnVersionNegotiationPacket(*public_header);
+  return true;
+}
+
 bool QuicFramer::ProcessDataPacket(
     const QuicPacketPublicHeader& public_header,
     const QuicEncryptedPacket& packet) {
-  visitor_->OnPacket();
-
   QuicPacketHeader header(public_header);
   if (!ProcessPacketHeader(&header, packet)) {
     DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessPacketHeader sets the error.
     DLOG(WARNING) << "Unable to process data packet header.";
     return false;
   }
 
   if (!visitor_->OnPacketHeader(header)) {
     // The visitor suppresses further processing of the packet.
     return true;
@@ skipping 23 matching lines @@
   }
 
   visitor_->OnPacketComplete();
   return true;
 }
 
 bool QuicFramer::ProcessPublicResetPacket(
     const QuicPacketPublicHeader& public_header) {
   QuicPublicResetPacket packet(public_header);
   if (!reader_->ReadUInt64(&packet.nonce_proof)) {
+    // TODO(satyamshekhar): Raise error.
     set_detailed_error("Unable to read nonce proof.");
     return false;
   }
   // TODO(satyamshekhar): validate nonce to protect against DoS.
 
   if (!reader_->ReadUInt48(&packet.rejected_sequence_number)) {
     set_detailed_error("Unable to read rejected sequence number.");
     return false;
   }
   visitor_->OnPublicResetPacket(packet);
@@ skipping 39 matching lines @@
     flags |= PACKET_PUBLIC_FLAGS_RST;
   }
   if (header.public_header.version_flag) {
     flags |= PACKET_PUBLIC_FLAGS_VERSION;
   }
   if (!writer->WriteUInt8(flags)) {
     return false;
   }
 
   if (header.public_header.version_flag) {
+    DCHECK(!is_server_);
     writer->WriteUInt32(quic_version_);
   }
 
   if (!AppendPacketSequenceNumber(header.packet_sequence_number, writer)) {
     return false;
   }
 
   flags = 0;
   if (header.fec_flag) {
     flags |= PACKET_PRIVATE_FLAGS_FEC;
@@ skipping 58 matching lines @@
 
   if (public_flags > PACKET_PUBLIC_FLAGS_MAX) {
     set_detailed_error("Illegal public flags value.");
     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->version_flag &&
-      !reader_->ReadUInt32(&public_header->version)) {
-    set_detailed_error("Unable to read protocol version.");
+  if (public_header->reset_flag && public_header->version_flag) {
+    set_detailed_error("Got version flag in reset packet");
     return false;
   }
 
+  if (public_header->version_flag && is_server_) {
+    QuicVersionTag 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;
+    }
+    public_header->versions.push_back(version);
+  }
   return true;
 }
 
 // static
 bool QuicFramer::ReadGuidFromPacket(const QuicEncryptedPacket& packet,
                                     QuicGuid* guid) {
   QuicDataReader reader(packet.data(), packet.length());
   return reader.ReadUInt64(guid);
 }
 
@@ skipping 166 matching lines @@
 bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
   if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) {
     set_detailed_error("Unable to read entropy hash for received packets.");
     return false;
   }
 
   if (!ProcessPacketSequenceNumber(&received_info->largest_observed)) {
      set_detailed_error("Unable to read largest observed.");
      return false;
   }
+  // TODO(pwestin): read and update delta_time_largest_observed.
 
   uint8 num_missing_packets;
   if (!reader_->ReadBytes(&num_missing_packets, 1)) {
     set_detailed_error("Unable to read num missing packets.");
     return false;
   }
 
   for (int i = 0; i < num_missing_packets; ++i) {
     QuicPacketSequenceNumber sequence_number;
     if (!ProcessPacketSequenceNumber(&sequence_number)) {
@@ skipping 196 matching lines @@
   }
   frame.reason_phrase = reason_phrase.as_string();
 
   visitor_->OnGoAwayFrame(frame);
   return true;
 }
 
 StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
     const QuicEncryptedPacket& encrypted, bool includes_version) {
   return StringPiece(encrypted.data() + kStartOfHashData,
-                     GetStartOfEncryptedData(includes_version)
-                     - kStartOfHashData);
+                     GetStartOfEncryptedData(includes_version) -
+                         kStartOfHashData);
 }
 
 QuicEncryptedPacket* QuicFramer::EncryptPacket(
     QuicPacketSequenceNumber packet_sequence_number,
     const QuicPacket& packet) {
   scoped_ptr<QuicData> out(encrypter_->Encrypt(packet_sequence_number,
                                                packet.AssociatedData(),
                                                packet.Plaintext()));
   if (out.get() == NULL) {
     RaiseError(QUIC_ENCRYPTION_FAILURE);
@@ skipping 165 matching lines @@
   size_t received_entropy_offset = writer->length();
   if (!writer->WriteUInt8(frame.received_info.entropy_hash)) {
     return false;
   }
 
   size_t largest_observed_offset = writer->length();
   if (!AppendPacketSequenceNumber(frame.received_info.largest_observed,
                                   writer)) {
     return false;
   }
+  // TODO(pwestin): calculate and add delta_time_largest_observed to the
+  // message.
 
   // We don't check for overflowing uint8 here, because we only can fit 192 acks
   // per packet, so if we overflow we will be truncated.
   uint8 num_missing_packets = frame.received_info.missing_packets.size();
   size_t num_missing_packets_offset = writer->length();
   if (!writer->WriteBytes(&num_missing_packets, 1)) {
     return false;
   }
 
   SequenceNumberSet::const_iterator it =
@@ skipping 162 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net