Land Recent QUIC Changes

net/quic/quic_framer.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_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 38 matching lines @@
 
 // This class receives callbacks from the framer when packets
 // are processed.
 class NET_EXPORT_PRIVATE QuicFramerVisitorInterface {
  public:
   virtual ~QuicFramerVisitorInterface() {}
 
   // Called if an error is detected in the QUIC protocol.
   virtual void OnError(QuicFramer* framer) = 0;
 
+  // Called only when |is_server_| is true and the the framer gets a packet with
+  // version flag true and the version on the packet doesn't match
+  // |quic_version_|. The visitor should return true after it updates the
+  // version of the |framer_| to |received_version| or false to stop processing
+  // this packet.
+  virtual bool OnProtocolVersionMismatch(QuicVersionTag received_version) = 0;
+
   // Called when a new packet has been received, before it
   // has been validated or processed.
   virtual void OnPacket() = 0;
 
   // Called when a public reset packet has been parsed but has not yet
   // been validated.
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) = 0;
 
+  // Called only when |is_server_| is false and a version negotiation packet has
+  // been parsed.
+  virtual void OnVersionNegotiationPacket(
+      const QuicVersionNegotiationPacket& packet) = 0;
+
   // Called when a lost packet has been recovered via FEC,
   // before it has been processed.
   virtual void OnRevivedPacket() = 0;
 
-  // Called when the header of a packet had been parsed.
-  // If OnPacketHeader returns false, parsing for this packet will cease.
+  // Called when the complete header of a packet had been parsed.
+  // If OnPacketHeader returns false, framing for this packet will cease.
   virtual bool OnPacketHeader(const QuicPacketHeader& header) = 0;
 
   // Called when a data packet is parsed that is part of an FEC group.
   // |payload| is the non-encrypted FEC protected payload of the packet.
   virtual void OnFecProtectedPayload(base::StringPiece payload) = 0;
 
   // Called when a StreamFrame has been parsed.
   virtual void OnStreamFrame(const QuicStreamFrame& frame) = 0;
 
   // Called when a AckFrame has been parsed.
@@ skipping 47 matching lines @@
 
 // Class for parsing and constructing QUIC packets.  It has a
 // QuicFramerVisitorInterface that is called when packets are parsed.
 // It also has a QuicFecBuilder that is called when packets are constructed
 // in order to generate FEC data for subsequently building FEC packets.
 class NET_EXPORT_PRIVATE QuicFramer {
  public:
   // Constructs a new framer that will own |decrypter| and |encrypter|.
   QuicFramer(QuicVersionTag quic_version,
              QuicDecrypter* decrypter,
-             QuicEncrypter* encrypter);
+             QuicEncrypter* encrypter,
+             bool is_server);
 
   virtual ~QuicFramer();
 
+  // Returns true if |version| is a supported protocol version.
+  bool IsSupportedVersion(QuicVersionTag version);
+
   // Calculates the largest observed packet to advertise in the case an Ack
   // Frame was truncated.  last_written in this case is the iterator for the
   // last missing packet which fit in the outgoing ack.
   static QuicPacketSequenceNumber CalculateLargestObserved(
       const SequenceNumberSet& missing_packets,
       SequenceNumberSet::const_iterator last_written);
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
   // will be used.
   void set_visitor(QuicFramerVisitorInterface* visitor) {
     visitor_ = visitor;
   }
 
   // Set a builder to be called from the framer when building FEC protected
   // packets.  If this is called multiple times, only the last builder
   // will be used.  The builder need not be set.
   void set_fec_builder(QuicFecBuilderInterface* builder) {
     fec_builder_ = builder;
   }
 
   QuicVersionTag version() const {
     return quic_version_;
   }
 
+  void set_version(QuicVersionTag version) {
+    DCHECK(IsSupportedVersion(version));
+    quic_version_ = version;
+  }
+
   // Set entropy calculator to be called from the framer when it needs the
   // entropy of a truncated ack frame. An entropy calculator must be set or else
   // the framer will likely crash. If this is called multiple times, only the
   // last visitor will be used.
   void set_entropy_calculator(
       QuicReceivedEntropyHashCalculatorInterface* entropy_calculator) {
     entropy_calculator_ = entropy_calculator;
   }
 
   QuicErrorCode error() const {
@@ skipping 18 matching lines @@
   static size_t GetMinStreamFrameSize();
   // Size in bytes of all ack frame fields without the missing packets.
   static size_t GetMinAckFrameSize();
   // Size in bytes of all reset stream frame without the error details.
   static size_t GetMinRstStreamFrameSize();
   // Size in bytes of all connection close frame fields without the error
   // details and the missing packets from the enclosed ack frame.
   static size_t GetMinConnectionCloseFrameSize();
   // Size in bytes of all GoAway frame fields without the reason phrase.
   static size_t GetMinGoAwayFrameSize();
+  // Size in bytes required for a serialized version negotiation packet
+  size_t GetVersionNegotiationPacketSize(size_t number_versions);
 
   // Returns the number of bytes added to the packet for the specified frame,
   // and 0 if the frame doesn't fit.  Includes the header size for the first
   // frame.
   size_t GetSerializedFrameLength(
       const QuicFrame& frame, size_t free_bytes, bool first_frame);
 
   // Returns the associated data from the encrypted packet |encrypted| as a
   // stringpiece.
   static base::StringPiece GetAssociatedDataFromEncryptedPacket(
@@ skipping 16 matching lines @@
   // Returns a SerializedPacket whose |packet| member is owned by the caller,
   // and is populated with the fields in |header| and |fec|, or is NULL if the
   // packet could not be created.
   SerializedPacket ConstructFecPacket(const QuicPacketHeader& header,
                                       const QuicFecData& fec);
 
   // Returns a new public reset packet, owned by the caller.
   static QuicEncryptedPacket* ConstructPublicResetPacket(
       const QuicPublicResetPacket& packet);
 
+  QuicEncryptedPacket* ConstructVersionNegotiationPacket(
+      const QuicPacketPublicHeader& header,
+      const QuicVersionTagList& supported_versions);
+
   // Returns a new encrypted packet, owned by the caller.
   QuicEncryptedPacket* EncryptPacket(QuicPacketSequenceNumber sequence_number,
                                      const QuicPacket& packet);
 
   // Returns the maximum length of plaintext that can be encrypted
   // to ciphertext no larger than |ciphertext_size|.
   size_t GetMaxPlaintextSize(size_t ciphertext_size);
 
   const std::string& detailed_error() { return detailed_error_; }
 
   // Read the guid from a packet header.
   // Return true on success, else false.
   static bool ReadGuidFromPacket(const QuicEncryptedPacket& packet,
                                  QuicGuid* guid);
 
  private:
   friend class test::QuicFramerPeer;
 
   QuicPacketEntropyHash GetPacketEntropyHash(
       const QuicPacketHeader& header) const;
 
   bool ProcessDataPacket(const QuicPacketPublicHeader& public_header,
                          const QuicEncryptedPacket& packet);
 
   bool ProcessPublicResetPacket(const QuicPacketPublicHeader& public_header);
 
+  bool ProcessVersionNegotiationPacket(QuicPacketPublicHeader* public_header);
+
   bool WritePacketHeader(const QuicPacketHeader& header,
                          QuicDataWriter* writer);
 
   bool ProcessPublicHeader(QuicPacketPublicHeader* header);
 
   bool ProcessPacketHeader(QuicPacketHeader* header,
                            const QuicEncryptedPacket& packet);
 
   bool ProcessPacketSequenceNumber(QuicPacketSequenceNumber* sequence_number);
   bool ProcessFrameData();
@@ skipping 56 matching lines @@
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketSequenceNumber last_sequence_number_;
   // Buffer containing decrypted payload data during parsing.
   scoped_ptr<QuicData> decrypted_;
   // Version of the protocol being used.
   QuicVersionTag quic_version_;
   // Decrypter used to decrypt packets during parsing.
   scoped_ptr<QuicDecrypter> decrypter_;
   // Encrypter used to encrypt packets via EncryptPacket().
   scoped_ptr<QuicEncrypter> encrypter_;
+  // Tracks if the framer is being used by the entity that received the
+  // connection or the entity that initiated it.
+  bool is_server_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_