src/net/quic/test_tools/quic_test_utils.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/test_tools/quic_test_utils.h"
   6
   7 #include "base/stl_util.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "net/quic/crypto/crypto_framer.h"
  10 #include "net/quic/crypto/crypto_handshake.h"
  11 #include "net/quic/crypto/crypto_utils.h"
  12 #include "net/quic/crypto/null_encrypter.h"
  13 #include "net/quic/crypto/quic_decrypter.h"
  14 #include "net/quic/crypto/quic_encrypter.h"
  15 #include "net/quic/quic_framer.h"
  16 #include "net/quic/quic_packet_creator.h"
  17 #include "net/quic/quic_utils.h"
  18 #include "net/quic/test_tools/quic_connection_peer.h"
  19 #include "net/spdy/spdy_frame_builder.h"
  20
  21 using base::StringPiece;
  22 using std::max;
  23 using std::min;
  24 using std::string;
  25 using testing::_;
  26
  27 namespace net {
  28 namespace test {
  29 namespace {
  30
  31 // No-op alarm implementation used by MockHelper.
  32 class TestAlarm : public QuicAlarm {
  33  public:
  34   explicit TestAlarm(QuicAlarm::Delegate* delegate)
  35       : QuicAlarm(delegate) {
  36   }
  37
  38   virtual void SetImpl() OVERRIDE {}
  39   virtual void CancelImpl() OVERRIDE {}
  40 };
  41
  42 }  // namespace
  43
  44 MockFramerVisitor::MockFramerVisitor() {
  45   // By default, we want to accept packets.
  46   ON_CALL(*this, OnProtocolVersionMismatch(_))
  47       .WillByDefault(testing::Return(false));
  48
  49   // By default, we want to accept packets.
  50   ON_CALL(*this, OnUnauthenticatedHeader(_))
  51       .WillByDefault(testing::Return(true));
  52
  53   ON_CALL(*this, OnUnauthenticatedPublicHeader(_))
  54       .WillByDefault(testing::Return(true));
  55
  56   ON_CALL(*this, OnPacketHeader(_))
  57       .WillByDefault(testing::Return(true));
  58
  59   ON_CALL(*this, OnStreamFrame(_))
  60       .WillByDefault(testing::Return(true));
  61
  62   ON_CALL(*this, OnAckFrame(_))
  63       .WillByDefault(testing::Return(true));
  64
  65   ON_CALL(*this, OnCongestionFeedbackFrame(_))
  66       .WillByDefault(testing::Return(true));
  67
  68   ON_CALL(*this, OnRstStreamFrame(_))
  69       .WillByDefault(testing::Return(true));
  70
  71   ON_CALL(*this, OnConnectionCloseFrame(_))
  72       .WillByDefault(testing::Return(true));
  73
  74   ON_CALL(*this, OnGoAwayFrame(_))
  75       .WillByDefault(testing::Return(true));
  76 }
  77
  78 MockFramerVisitor::~MockFramerVisitor() {
  79 }
  80
  81 bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersion version) {
  82   return false;
  83 }
  84
  85 bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader(
  86     const QuicPacketPublicHeader& header) {
  87   return true;
  88 }
  89
  90 bool NoOpFramerVisitor::OnUnauthenticatedHeader(
  91     const QuicPacketHeader& header) {
  92   return true;
  93 }
  94
  95 bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
  96   return true;
  97 }
  98
  99 bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
 100   return true;
 101 }
 102
 103 bool NoOpFramerVisitor::OnAckFrame(const QuicAckFrame& frame) {
 104   return true;
 105 }
 106
 107 bool NoOpFramerVisitor::OnCongestionFeedbackFrame(
 108     const QuicCongestionFeedbackFrame& frame) {
 109   return true;
 110 }
 111
 112 bool NoOpFramerVisitor::OnRstStreamFrame(
 113     const QuicRstStreamFrame& frame) {
 114   return true;
 115 }
 116
 117 bool NoOpFramerVisitor::OnConnectionCloseFrame(
 118     const QuicConnectionCloseFrame& frame) {
 119   return true;
 120 }
 121
 122 bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
 123   return true;
 124 }
 125
 126 FramerVisitorCapturingFrames::FramerVisitorCapturingFrames() : frame_count_(0) {
 127 }
 128
 129 FramerVisitorCapturingFrames::~FramerVisitorCapturingFrames() {
 130   Reset();
 131 }
 132
 133 void FramerVisitorCapturingFrames::Reset() {
 134   STLDeleteElements(&stream_data_);
 135   stream_frames_.clear();
 136   frame_count_ = 0;
 137   ack_.reset();
 138   feedback_.reset();
 139   rst_.reset();
 140   close_.reset();
 141   goaway_.reset();
 142   version_negotiation_packet_.reset();
 143 }
 144
 145 bool FramerVisitorCapturingFrames::OnPacketHeader(
 146     const QuicPacketHeader& header) {
 147   header_ = header;
 148   frame_count_ = 0;
 149   return true;
 150 }
 151
 152 bool FramerVisitorCapturingFrames::OnStreamFrame(const QuicStreamFrame& frame) {
 153   // Make a copy of the frame and store a copy of underlying string, since
 154   // frame.data may not exist outside this callback.
 155   stream_data_.push_back(frame.GetDataAsString());
 156   QuicStreamFrame frame_copy = frame;
 157   frame_copy.data.Clear();
 158   frame_copy.data.Append(const_cast<char*>(stream_data_.back()->data()),
 159                          stream_data_.back()->size());
 160   stream_frames_.push_back(frame_copy);
 161   ++frame_count_;
 162   return true;
 163 }
 164
 165 bool FramerVisitorCapturingFrames::OnAckFrame(const QuicAckFrame& frame) {
 166   ack_.reset(new QuicAckFrame(frame));
 167   ++frame_count_;
 168   return true;
 169 }
 170
 171 bool FramerVisitorCapturingFrames::OnCongestionFeedbackFrame(
 172     const QuicCongestionFeedbackFrame& frame) {
 173   feedback_.reset(new QuicCongestionFeedbackFrame(frame));
 174   ++frame_count_;
 175   return true;
 176 }
 177
 178 bool FramerVisitorCapturingFrames::OnRstStreamFrame(
 179     const QuicRstStreamFrame& frame) {
 180   rst_.reset(new QuicRstStreamFrame(frame));
 181   ++frame_count_;
 182   return true;
 183 }
 184
 185 bool FramerVisitorCapturingFrames::OnConnectionCloseFrame(
 186     const QuicConnectionCloseFrame& frame) {
 187   close_.reset(new QuicConnectionCloseFrame(frame));
 188   ++frame_count_;
 189   return true;
 190 }
 191
 192 bool FramerVisitorCapturingFrames::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
 193   goaway_.reset(new QuicGoAwayFrame(frame));
 194   ++frame_count_;
 195   return true;
 196 }
 197
 198 void FramerVisitorCapturingFrames::OnVersionNegotiationPacket(
 199     const QuicVersionNegotiationPacket& packet) {
 200   version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
 201   frame_count_ = 0;
 202 }
 203
 204 FramerVisitorCapturingPublicReset::FramerVisitorCapturingPublicReset() {
 205 }
 206
 207 FramerVisitorCapturingPublicReset::~FramerVisitorCapturingPublicReset() {
 208 }
 209
 210 void FramerVisitorCapturingPublicReset::OnPublicResetPacket(
 211     const QuicPublicResetPacket& public_reset) {
 212   public_reset_packet_ = public_reset;
 213 }
 214
 215 MockConnectionVisitor::MockConnectionVisitor() {
 216 }
 217
 218 MockConnectionVisitor::~MockConnectionVisitor() {
 219 }
 220
 221 MockHelper::MockHelper() {
 222 }
 223
 224 MockHelper::~MockHelper() {
 225 }
 226
 227 const QuicClock* MockHelper::GetClock() const {
 228   return &clock_;
 229 }
 230
 231 QuicRandom* MockHelper::GetRandomGenerator() {
 232   return &random_generator_;
 233 }
 234
 235 QuicAlarm* MockHelper::CreateAlarm(QuicAlarm::Delegate* delegate) {
 236   return new TestAlarm(delegate);
 237 }
 238
 239 void MockHelper::AdvanceTime(QuicTime::Delta delta) {
 240   clock_.AdvanceTime(delta);
 241 }
 242
 243 MockConnection::MockConnection(bool is_server)
 244     : QuicConnection(kTestGuid,
 245                      IPEndPoint(TestPeerIPAddress(), kTestPort),
 246                      new testing::NiceMock<MockHelper>(),
 247                      new testing::NiceMock<MockPacketWriter>(),
 248                      is_server, QuicSupportedVersions()),
 249       writer_(QuicConnectionPeer::GetWriter(this)),
 250       helper_(helper()) {
 251 }
 252
 253 MockConnection::MockConnection(IPEndPoint address,
 254                                bool is_server)
 255     : QuicConnection(kTestGuid, address,
 256                      new testing::NiceMock<MockHelper>(),
 257                      new testing::NiceMock<MockPacketWriter>(),
 258                      is_server, QuicSupportedVersions()),
 259       writer_(QuicConnectionPeer::GetWriter(this)),
 260       helper_(helper()) {
 261 }
 262
 263 MockConnection::MockConnection(QuicGuid guid,
 264                                bool is_server)
 265     : QuicConnection(guid, IPEndPoint(TestPeerIPAddress(), kTestPort),
 266                      new testing::NiceMock<MockHelper>(),
 267                      new testing::NiceMock<MockPacketWriter>(),
 268                      is_server, QuicSupportedVersions()),
 269       writer_(QuicConnectionPeer::GetWriter(this)),
 270       helper_(helper()) {
 271 }
 272
 273 MockConnection::MockConnection(bool is_server,
 274                                const QuicVersionVector& supported_versions)
 275     : QuicConnection(kTestGuid,
 276                      IPEndPoint(TestPeerIPAddress(), kTestPort),
 277                      new testing::NiceMock<MockHelper>(),
 278                      new testing::NiceMock<MockPacketWriter>(),
 279                      is_server, supported_versions),
 280       writer_(QuicConnectionPeer::GetWriter(this)),
 281       helper_(helper()) {
 282 }
 283
 284 MockConnection::~MockConnection() {
 285 }
 286
 287 void MockConnection::AdvanceTime(QuicTime::Delta delta) {
 288   static_cast<MockHelper*>(helper())->AdvanceTime(delta);
 289 }
 290
 291 PacketSavingConnection::PacketSavingConnection(bool is_server)
 292     : MockConnection(is_server) {
 293 }
 294
 295 PacketSavingConnection::PacketSavingConnection(
 296     bool is_server,
 297     const QuicVersionVector& supported_versions)
 298     : MockConnection(is_server, supported_versions) {
 299 }
 300
 301 PacketSavingConnection::~PacketSavingConnection() {
 302   STLDeleteElements(&packets_);
 303   STLDeleteElements(&encrypted_packets_);
 304 }
 305
 306 bool PacketSavingConnection::SendOrQueuePacket(
 307     EncryptionLevel level,
 308     const SerializedPacket& packet,
 309     TransmissionType transmission_type) {
 310   packets_.push_back(packet.packet);
 311   QuicEncryptedPacket* encrypted = QuicConnectionPeer::GetFramer(this)->
 312       EncryptPacket(level, packet.sequence_number, *packet.packet);
 313   encrypted_packets_.push_back(encrypted);
 314   return true;
 315 }
 316
 317 MockSession::MockSession(QuicConnection* connection)
 318     : QuicSession(connection, DefaultQuicConfig()) {
 319   ON_CALL(*this, WritevData(_, _, _, _, _, _))
 320       .WillByDefault(testing::Return(QuicConsumedData(0, false)));
 321 }
 322
 323 MockSession::~MockSession() {
 324 }
 325
 326 TestSession::TestSession(QuicConnection* connection,
 327                          const QuicConfig& config)
 328     : QuicSession(connection, config),
 329       crypto_stream_(NULL) {
 330 }
 331
 332 TestSession::~TestSession() {}
 333
 334 void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
 335   crypto_stream_ = stream;
 336 }
 337
 338 QuicCryptoStream* TestSession::GetCryptoStream() {
 339   return crypto_stream_;
 340 }
 341
 342 MockPacketWriter::MockPacketWriter() {
 343 }
 344
 345 MockPacketWriter::~MockPacketWriter() {
 346 }
 347
 348 MockSendAlgorithm::MockSendAlgorithm() {
 349 }
 350
 351 MockSendAlgorithm::~MockSendAlgorithm() {
 352 }
 353
 354 MockAckNotifierDelegate::MockAckNotifierDelegate() {
 355 }
 356
 357 MockAckNotifierDelegate::~MockAckNotifierDelegate() {
 358 }
 359
 360 namespace {
 361
 362 string HexDumpWithMarks(const char* data, int length,
 363                         const bool* marks, int mark_length) {
 364   static const char kHexChars[] = "0123456789abcdef";
 365   static const int kColumns = 4;
 366
 367   const int kSizeLimit = 1024;
 368   if (length > kSizeLimit || mark_length > kSizeLimit) {
 369     LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
 370     length = min(length, kSizeLimit);
 371     mark_length = min(mark_length, kSizeLimit);
 372   }
 373
 374   string hex;
 375   for (const char* row = data; length > 0;
 376        row += kColumns, length -= kColumns) {
 377     for (const char *p = row; p < row + 4; ++p) {
 378       if (p < row + length) {
 379         const bool mark =
 380             (marks && (p - data) < mark_length && marks[p - data]);
 381         hex += mark ? '*' : ' ';
 382         hex += kHexChars[(*p & 0xf0) >> 4];
 383         hex += kHexChars[*p & 0x0f];
 384         hex += mark ? '*' : ' ';
 385       } else {
 386         hex += "    ";
 387       }
 388     }
 389     hex = hex + "  ";
 390
 391     for (const char *p = row; p < row + 4 && p < row + length; ++p)
 392       hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
 393
 394     hex = hex + '\n';
 395   }
 396   return hex;
 397 }
 398
 399 }  // namespace
 400
 401 IPAddressNumber TestPeerIPAddress() { return Loopback4(); }
 402
 403 QuicVersion QuicVersionMax() { return QuicSupportedVersions().front(); }
 404
 405 QuicVersion QuicVersionMin() { return QuicSupportedVersions().back(); }
 406
 407 IPAddressNumber Loopback4() {
 408   IPAddressNumber addr;
 409   CHECK(ParseIPLiteralToNumber("127.0.0.1", &addr));
 410   return addr;
 411 }
 412
 413 void CompareCharArraysWithHexError(
 414     const string& description,
 415     const char* actual,
 416     const int actual_len,
 417     const char* expected,
 418     const int expected_len) {
 419   EXPECT_EQ(actual_len, expected_len);
 420   const int min_len = min(actual_len, expected_len);
 421   const int max_len = max(actual_len, expected_len);
 422   scoped_ptr<bool[]> marks(new bool[max_len]);
 423   bool identical = (actual_len == expected_len);
 424   for (int i = 0; i < min_len; ++i) {
 425     if (actual[i] != expected[i]) {
 426       marks[i] = true;
 427       identical = false;
 428     } else {
 429       marks[i] = false;
 430     }
 431   }
 432   for (int i = min_len; i < max_len; ++i) {
 433     marks[i] = true;
 434   }
 435   if (identical) return;
 436   ADD_FAILURE()
 437       << "Description:\n"
 438       << description
 439       << "\n\nExpected:\n"
 440       << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
 441       << "\nActual:\n"
 442       << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 443 }
 444
 445 bool DecodeHexString(const base::StringPiece& hex, std::string* bytes) {
 446   bytes->clear();
 447   if (hex.empty())
 448     return true;
 449   std::vector<uint8> v;
 450   if (!base::HexStringToBytes(hex.as_string(), &v))
 451     return false;
 452   if (!v.empty())
 453     bytes->assign(reinterpret_cast<const char*>(&v[0]), v.size());
 454   return true;
 455 }
 456
 457 static QuicPacket* ConstructPacketFromHandshakeMessage(
 458     QuicGuid guid,
 459     const CryptoHandshakeMessage& message,
 460     bool should_include_version) {
 461   CryptoFramer crypto_framer;
 462   scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
 463   QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(), false);
 464
 465   QuicPacketHeader header;
 466   header.public_header.guid = guid;
 467   header.public_header.reset_flag = false;
 468   header.public_header.version_flag = should_include_version;
 469   header.packet_sequence_number = 1;
 470   header.entropy_flag = false;
 471   header.entropy_hash = 0;
 472   header.fec_flag = false;
 473   header.fec_group = 0;
 474
 475   QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
 476                                MakeIOVector(data->AsStringPiece()));
 477
 478   QuicFrame frame(&stream_frame);
 479   QuicFrames frames;
 480   frames.push_back(frame);
 481   return quic_framer.BuildUnsizedDataPacket(header, frames).packet;
 482 }
 483
 484 QuicPacket* ConstructHandshakePacket(QuicGuid guid, QuicTag tag) {
 485   CryptoHandshakeMessage message;
 486   message.set_tag(tag);
 487   return ConstructPacketFromHandshakeMessage(guid, message, false);
 488 }
 489
 490 size_t GetPacketLengthForOneStream(
 491     QuicVersion version,
 492     bool include_version,
 493     QuicSequenceNumberLength sequence_number_length,
 494     InFecGroup is_in_fec_group,
 495     size_t* payload_length) {
 496   *payload_length = 1;
 497   const size_t stream_length =
 498       NullEncrypter().GetCiphertextSize(*payload_length) +
 499       QuicPacketCreator::StreamFramePacketOverhead(
 500           version, PACKET_8BYTE_GUID, include_version,
 501           sequence_number_length, is_in_fec_group);
 502   const size_t ack_length = NullEncrypter().GetCiphertextSize(
 503       QuicFramer::GetMinAckFrameSize(
 504           version, sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) +
 505       GetPacketHeaderSize(PACKET_8BYTE_GUID, include_version,
 506                           sequence_number_length, is_in_fec_group);
 507   if (stream_length < ack_length) {
 508     *payload_length = 1 + ack_length - stream_length;
 509   }
 510
 511   return NullEncrypter().GetCiphertextSize(*payload_length) +
 512       QuicPacketCreator::StreamFramePacketOverhead(
 513           version, PACKET_8BYTE_GUID, include_version,
 514           sequence_number_length, is_in_fec_group);
 515 }
 516
 517 TestEntropyCalculator::TestEntropyCalculator() { }
 518
 519 TestEntropyCalculator::~TestEntropyCalculator() { }
 520
 521 QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
 522     QuicPacketSequenceNumber sequence_number) const {
 523   return 1u;
 524 }
 525
 526 MockEntropyCalculator::MockEntropyCalculator() { }
 527
 528 MockEntropyCalculator::~MockEntropyCalculator() { }
 529
 530 QuicConfig DefaultQuicConfig() {
 531   QuicConfig config;
 532   config.SetDefaults();
 533   return config;
 534 }
 535
 536 QuicVersionVector SupportedVersions(QuicVersion version) {
 537   QuicVersionVector versions;
 538   versions.push_back(version);
 539   return versions;
 540 }
 541
 542 bool TestDecompressorVisitor::OnDecompressedData(StringPiece data) {
 543   data.AppendToString(&data_);
 544   return true;
 545 }
 546
 547 void TestDecompressorVisitor::OnDecompressionError() {
 548   error_ = true;
 549 }
 550
 551 }  // namespace test
 552 }  // namespace net