Land Recent QUIC Changes

net/quic/quic_framer_test.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 <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/port.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
+#include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 
 using base::hash_set;
 using base::StringPiece;
 using std::make_pair;
 using std::map;
 using std::numeric_limits;
 using std::string;
 using std::vector;
 
@@ skipping 27 matching lines @@
 }
 
 // Index into the nonce proof of the public reset packet.
 const size_t kPublicResetPacketNonceProofOffset =
                                                           kPublicFlagsOffset +
                                                           kPublicFlagsSize;
 // Index into the rejected sequence number of the public reset packet.
 const size_t kPublicResetPacketRejectedSequenceNumberOffset =
     kPublicResetPacketNonceProofOffset + kPublicResetNonceSize;
 
-class QuicFramerPeer {
- public:
-  static QuicPacketSequenceNumber CalculatePacketSequenceNumberFromWire(
-      QuicFramer* framer,
-      QuicPacketSequenceNumber packet_sequence_number) {
-    return framer->CalculatePacketSequenceNumberFromWire(
-        packet_sequence_number);
-  }
-  static void SetLastSequenceNumber(
-      QuicFramer* framer,
-      QuicPacketSequenceNumber packet_sequence_number) {
-    framer->last_sequence_number_ = packet_sequence_number;
-  }
-};
-
 class TestEncrypter : public QuicEncrypter {
  public:
   virtual ~TestEncrypter() {}
   virtual bool SetKey(StringPiece key) OVERRIDE {
     return true;
   }
   virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
     return true;
   }
   virtual QuicData* Encrypt(QuicPacketSequenceNumber sequence_number,
                             StringPiece associated_data,
                             StringPiece plaintext) OVERRIDE {
     sequence_number_ = sequence_number;
     associated_data_ = associated_data.as_string();
     plaintext_ = plaintext.as_string();
     return new QuicData(plaintext.data(), plaintext.length());
   }
   virtual size_t GetKeySize() const OVERRIDE {
     return 0;
   }
   virtual size_t GetNoncePrefixSize() const OVERRIDE {
     return 0;
   }
   virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE {
     return ciphertext_size;
   }
   virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE {
     return plaintext_size;
   }
+  virtual StringPiece GetKey() const {
+    return StringPiece();
+  }
+  virtual StringPiece GetNoncePrefix() const {
+    return StringPiece();
+  }
   QuicPacketSequenceNumber sequence_number_;
   string associated_data_;
   string plaintext_;
 };
 
 class TestDecrypter : public QuicDecrypter {
  public:
   virtual ~TestDecrypter() {}
   virtual bool SetKey(StringPiece key) OVERRIDE {
     return true;
   }
   virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
     return true;
   }
   virtual QuicData* Decrypt(QuicPacketSequenceNumber sequence_number,
                             StringPiece associated_data,
                             StringPiece ciphertext) OVERRIDE {
     sequence_number_ = sequence_number;
     associated_data_ = associated_data.as_string();
     ciphertext_ = ciphertext.as_string();
     return new QuicData(ciphertext.data(), ciphertext.length());
   }
+  virtual StringPiece GetKey() const {
+    return StringPiece();
+  }
+  virtual StringPiece GetNoncePrefix() const {
+    return StringPiece();
+  }
   QuicPacketSequenceNumber sequence_number_;
   string associated_data_;
   string ciphertext_;
 };
 
 class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
  public:
   TestQuicVisitor()
       : error_count_(0),
         packet_count_(0),
@@ skipping 17 matching lines @@
     error_count_++;
   }
 
   virtual void OnPacket() OVERRIDE {}
 
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) OVERRIDE {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
 
+  virtual void OnVersionNegotiationPacket(
+      const QuicVersionNegotiationPacket& packet) OVERRIDE {
+    version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
+  }
+
   virtual void OnRevivedPacket() OVERRIDE {
     revived_packets_++;
   }
 
+  virtual bool OnProtocolVersionMismatch(
+      QuicVersionTag version) OVERRIDE {
+    DCHECK(false);
+    return true;
+  }
+
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
     packet_count_++;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
   virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
     frame_count_++;
     stream_frames_.push_back(new QuicStreamFrame(frame));
   }
@@ skipping 40 matching lines @@
   int error_count_;
   int packet_count_;
   int frame_count_;
   int fec_count_;
   int complete_packets_;
   int revived_packets_;
   bool accept_packet_;
 
   scoped_ptr<QuicPacketHeader> header_;
   scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
+  scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
   vector<QuicStreamFrame*> stream_frames_;
   vector<QuicAckFrame*> ack_frames_;
   vector<QuicCongestionFeedbackFrame*> congestion_feedback_frames_;
   vector<QuicFecData*> fec_data_;
   string fec_protected_payload_;
   QuicRstStreamFrame rst_stream_frame_;
   QuicConnectionCloseFrame connection_close_frame_;
   QuicGoAwayFrame goaway_frame_;
 };
 
 class QuicFramerTest : public ::testing::Test {
  public:
   QuicFramerTest()
       : encrypter_(new test::TestEncrypter()),
         decrypter_(new test::TestDecrypter()),
-        framer_(kQuicVersion1, decrypter_, encrypter_) {
+        framer_(kQuicVersion1, decrypter_, encrypter_, true) {
     framer_.set_visitor(&visitor_);
     framer_.set_entropy_calculator(&entropy_calculator_);
   }
 
   bool CheckEncryption(QuicPacketSequenceNumber sequence_number,
                        QuicPacket* packet) {
     if (sequence_number != encrypter_->sequence_number_) {
       LOG(ERROR) << "Encrypted incorrect packet sequence number.  expected "
                  << sequence_number << " actual: "
                  << encrypter_->sequence_number_;
@@ skipping 288 matching lines @@
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
             visitor_.header_->public_header.guid);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
-  EXPECT_EQ(kQuicVersion1, visitor_.header_->public_header.version);
+  EXPECT_EQ(kQuicVersion1, visitor_.header_->public_header.versions[0]);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_FALSE(visitor_.header_->fec_entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
             visitor_.header_->packet_sequence_number);
   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 
   // Now test framing boundaries
   for (size_t i = 0; i < GetPacketHeaderSize(kIncludeVersion); ++i) {
@@ skipping 238 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(visitor_.header_.get()->public_header.version_flag);
-  EXPECT_EQ(kQuicVersion1, visitor_.header_.get()->public_header.version);
+  EXPECT_EQ(kQuicVersion1, visitor_.header_.get()->public_header.versions[0]);
   EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(static_cast<uint64>(0x01020304),
             visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
             visitor_.stream_frames_[0]->offset);
   EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data);
@@ skipping 727 matching lines @@
   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789),
             visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
             visitor_.public_reset_packet_->rejected_sequence_number);
 
   // Now test framing boundaries
   for (size_t i = 0; i < GetPublicResetPacketSize(); ++i) {
     string expected_error;
+    DLOG(INFO) << "iteration: " << i;
     if (i < kPublicFlagsOffset) {
       expected_error = "Unable to read GUID.";
     } else if (i < kPublicResetPacketNonceProofOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < kPublicResetPacketRejectedSequenceNumberOffset) {
       expected_error = "Unable to read nonce proof.";
     } else {
       expected_error = "Unable to read rejected sequence number.";
     }
     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
+TEST_F(QuicFramerTest, VersionNegotiationPacket) {
+  unsigned char packet[] = {
+    0x10, 0x32, 0x54, 0x76,
+    0x98, 0xBA, 0xDC, 0xFE,
+    // public flags (version)
+    0x01,
+    // version tag
+    'Q', '1', '.', '0',
+    'Q', '2', '.', '0',
+  };
+
+  QuicFramerPeer::SetIsServer(&framer_, false);
+
+  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
+  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
+  ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
+  EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size());
+  EXPECT_EQ(kQuicVersion1,
+            visitor_.version_negotiation_packet_->versions[0]);
+
+  for (size_t i = 0; i <= kQuicGuidSize + kPublicFlagsSize; ++i) {
+    string expected_error;
+    QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER;
+    if (i < kPublicFlagsOffset) {
+      expected_error = "Unable to read GUID.";
+    } else if (i < kVersionOffset) {
+      expected_error = "Unable to read public flags.";
+    } else {
+      expected_error = "Unable to read supported version in negotiation.";
+      error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET;
+    }
+    CheckProcessingFails(packet, i, expected_error, error_code);
+  }
+}
+
 TEST_F(QuicFramerTest, FecPacket) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // public flags
     0x00,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
@@ skipping 176 matching lines @@
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
 
+  QuicFramerPeer::SetIsServer(&framer_, false);
   scoped_ptr<QuicPacket> data(
       framer_.ConstructFrameDataPacket(header, frames).packet);
   ASSERT_TRUE(data != NULL);
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 }
 
+TEST_F(QuicFramerTest, ConstructVersionNegotiationPacket) {
+  QuicPacketPublicHeader header;
+  header.guid = GG_UINT64_C(0xFEDCBA9876543210);
+  header.reset_flag = false;
+  header.version_flag = true;
+
+  unsigned char packet[] = {
+    0x10, 0x32, 0x54, 0x76,
+    0x98, 0xBA, 0xDC, 0xFE,
+    // public flags (version)
+    0x01,
+    // version tag
+    'Q', '1', '.', '0',
+    'Q', '2', '.', '0',
+  };
+
+  const int kQuicVersion2 = MAKE_TAG('Q', '2', '.', '0');
+  QuicVersionTagList versions;
+  versions.push_back(kQuicVersion1);
+  versions.push_back(kQuicVersion2);
+  scoped_ptr<QuicEncryptedPacket> data(
+      framer_.ConstructVersionNegotiationPacket(header, versions));
+
+  test::CompareCharArraysWithHexError("constructed packet",
+                                      data->data(), data->length(),
+                                      AsChars(packet), arraysize(packet));
+}
 
 TEST_F(QuicFramerTest, ConstructAckFramePacket) {
   QuicPacketHeader header;
   header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
   header.fec_entropy_flag = true;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
@@ skipping 820 matching lines @@
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(visitor_.header_->fec_flag);
   EXPECT_TRUE(visitor_.header_->entropy_flag);
   EXPECT_TRUE(visitor_.header_->fec_entropy_flag);
   EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
 };
 
 }  // namespace test
 }  // namespace net