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