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 84 matching lines @@
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       GetMinAckFrameSize();
 }
 
 // static
 size_t QuicFramer::GetMinGoAwayFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       kQuicStreamIdSize;
 }
 
+// static
+// TODO(satyamshekhar): 16 - Crypto hash for integrity. Not a static value. Use
+// QuicEncrypter::GetMaxPlaintextSize.
+size_t QuicFramer::GetMaxUnackedPackets(bool include_version) {
+  return (kMaxPacketSize - GetPacketHeaderSize(include_version) -
+          GetMinAckFrameSize() - 16) / kSequenceNumberSize;
+}
+
 bool QuicFramer::IsSupportedVersion(QuicTag version) {
   return version == kQuicVersion1;
 }
 
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
   return kQuicGuidSize + kPublicFlagsSize +
       number_versions * kQuicVersionSize;
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
@@ skipping 191 matching lines @@
   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) {
+  // TODO(satyamshekhar): Don't RaiseError (and close the connection) for
+  // invalid (unauthenticated) packets.
   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);
@@ skipping 76 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;
+    return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
   }
   // 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;
+    return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
   }
   visitor_->OnPublicResetPacket(packet);
   return true;
 }
 
 bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header,
                                       StringPiece payload) {
   DCHECK(!reader_.get());
 
   visitor_->OnRevivedPacket();
 
   header->entropy_hash = GetPacketEntropyHash(*header);
 
-  // TODO(satyamshekhar): Don't process if the visitor refuses the header.
-  visitor_->OnPacketHeader(*header);
+  if (!visitor_->OnPacketHeader(*header)) {
+    return true;
+  }
 
   if (payload.length() > kMaxPacketSize) {
     set_detailed_error("Revived packet too large.");
     return RaiseError(QUIC_PACKET_TOO_LARGE);
   }
 
   reader_.reset(new QuicDataReader(payload.data(), payload.length()));
   if (!ProcessFrameData()) {
     DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
     DLOG(WARNING) << "Unable to process frame data.";
@@ skipping 251 matching lines @@
           // Returning true since there was no parsing error.
           return true;
         }
         break;
       }
       case CONNECTION_CLOSE_FRAME: {
         QuicConnectionCloseFrame frame;
         if (!ProcessConnectionCloseFrame(&frame)) {
           return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA);
         }
+
+        if (!visitor_->OnAckFrame(frame.ack_frame)) {
+          DLOG(INFO) << "Visitor asked to stopped further processing.";
+          // Returning true since there was no parsing error.
+          return true;
+        }
+
         if (!visitor_->OnConnectionCloseFrame(frame)) {
           DLOG(INFO) << "Visitor asked to stopped further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         break;
       }
       case GOAWAY_FRAME: {
         QuicGoAwayFrame goaway_frame;
         if (!ProcessGoAwayFrame(&goaway_frame)) {
@@ skipping 264 matching lines @@
     set_detailed_error("Unable to read connection close error details.");
     return false;
   }
   frame->error_details = error_details.as_string();
 
   if (!ProcessAckFrame(&frame->ack_frame)) {
     DLOG(WARNING) << "Unable to process ack frame.";
     return false;
   }
 
-  if (!visitor_->OnAckFrame(frame->ack_frame)) {
-    DLOG(INFO) << "Visitor asked to stopped further processing.";
-    // Returning true since there was no parsing error.
-    return true;
-  }
-
   return true;
 }
 
 bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) {
   uint32 error_code;
   if (!reader_->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read go away error code.");
     return false;
   }
   frame->error_code = static_cast<QuicErrorCode>(error_code);
@@ skipping 478 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net