net/tools/quic/quic_time_wait_list_manager_test.cc

   1 // Copyright 2013 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/tools/quic/quic_time_wait_list_manager.h"
   6
   7 #include <errno.h>
   8
   9 #include "net/quic/crypto/crypto_protocol.h"
  10 #include "net/quic/crypto/null_encrypter.h"
  11 #include "net/quic/crypto/quic_decrypter.h"
  12 #include "net/quic/crypto/quic_encrypter.h"
  13 #include "net/quic/quic_data_reader.h"
  14 #include "net/quic/quic_framer.h"
  15 #include "net/quic/quic_packet_writer.h"
  16 #include "net/quic/quic_protocol.h"
  17 #include "net/quic/quic_utils.h"
  18 #include "net/quic/test_tools/quic_test_utils.h"
  19 #include "net/tools/quic/test_tools/mock_epoll_server.h"
  20 #include "net/tools/quic/test_tools/quic_test_utils.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 using net::test::BuildUnsizedDataPacket;
  25 using net::test::NoOpFramerVisitor;
  26 using net::test::QuicVersionMax;
  27 using net::test::QuicVersionMin;
  28 using testing::Args;
  29 using testing::Assign;
  30 using testing::DoAll;
  31 using testing::Matcher;
  32 using testing::MatcherInterface;
  33 using testing::NiceMock;
  34 using testing::Return;
  35 using testing::ReturnPointee;
  36 using testing::SetArgPointee;
  37 using testing::StrictMock;
  38 using testing::Truly;
  39 using testing::_;
  40
  41 namespace net {
  42 namespace tools {
  43 namespace test {
  44
  45 class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
  46  public:
  47   FramerVisitorCapturingPublicReset() {}
  48   virtual ~FramerVisitorCapturingPublicReset() OVERRIDE {}
  49
  50   virtual void OnPublicResetPacket(
  51       const QuicPublicResetPacket& public_reset) OVERRIDE {
  52     public_reset_packet_ = public_reset;
  53   }
  54
  55   const QuicPublicResetPacket public_reset_packet() {
  56     return public_reset_packet_;
  57   }
  58
  59  private:
  60   QuicPublicResetPacket public_reset_packet_;
  61 };
  62
  63 class QuicTimeWaitListManagerPeer {
  64  public:
  65   static bool ShouldSendResponse(QuicTimeWaitListManager* manager,
  66                                  int received_packet_count) {
  67     return manager->ShouldSendResponse(received_packet_count);
  68   }
  69
  70   static QuicTime::Delta time_wait_period(QuicTimeWaitListManager* manager) {
  71     return manager->kTimeWaitPeriod_;
  72   }
  73
  74   static QuicVersion GetQuicVersionFromConnectionId(
  75       QuicTimeWaitListManager* manager,
  76       QuicConnectionId connection_id) {
  77     return manager->GetQuicVersionFromConnectionId(connection_id);
  78   }
  79 };
  80
  81 namespace {
  82
  83 class MockFakeTimeEpollServer : public FakeTimeEpollServer {
  84  public:
  85   MOCK_METHOD2(RegisterAlarm, void(int64 timeout_in_us,
  86                                    EpollAlarmCallbackInterface* alarm));
  87 };
  88
  89 class QuicTimeWaitListManagerTest : public ::testing::Test {
  90  protected:
  91   QuicTimeWaitListManagerTest()
  92       : time_wait_list_manager_(&writer_, &visitor_,
  93                                 &epoll_server_, QuicSupportedVersions()),
  94         framer_(QuicSupportedVersions(), QuicTime::Zero(), true),
  95         connection_id_(45),
  96         client_address_(net::test::TestPeerIPAddress(), kTestPort),
  97         writer_is_blocked_(false) {}
  98
  99   virtual ~QuicTimeWaitListManagerTest() OVERRIDE {}
 100
 101   virtual void SetUp() OVERRIDE {
 102     EXPECT_CALL(writer_, IsWriteBlocked())
 103         .WillRepeatedly(ReturnPointee(&writer_is_blocked_));
 104     EXPECT_CALL(writer_, IsWriteBlockedDataBuffered())
 105         .WillRepeatedly(Return(false));
 106   }
 107
 108   void AddConnectionId(QuicConnectionId connection_id) {
 109     AddConnectionId(connection_id, QuicVersionMax(), nullptr);
 110   }
 111
 112   void AddConnectionId(QuicConnectionId connection_id,
 113                        QuicVersion version,
 114                        QuicEncryptedPacket* packet) {
 115     time_wait_list_manager_.AddConnectionIdToTimeWait(
 116         connection_id, version, packet);
 117   }
 118
 119   bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) {
 120     return time_wait_list_manager_.IsConnectionIdInTimeWait(connection_id);
 121   }
 122
 123   void ProcessPacket(QuicConnectionId connection_id,
 124                      QuicPacketSequenceNumber sequence_number) {
 125     QuicEncryptedPacket packet(nullptr, 0);
 126     time_wait_list_manager_.ProcessPacket(server_address_,
 127                                           client_address_,
 128                                           connection_id,
 129                                           sequence_number,
 130                                           packet);
 131   }
 132
 133   QuicEncryptedPacket* ConstructEncryptedPacket(
 134       EncryptionLevel level,
 135       QuicConnectionId connection_id,
 136       QuicPacketSequenceNumber sequence_number) {
 137     QuicPacketHeader header;
 138     header.public_header.connection_id = connection_id;
 139     header.public_header.connection_id_length = PACKET_8BYTE_CONNECTION_ID;
 140     header.public_header.version_flag = false;
 141     header.public_header.reset_flag = false;
 142     header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
 143     header.packet_sequence_number = sequence_number;
 144     header.entropy_flag = false;
 145     header.entropy_hash = 0;
 146     header.fec_flag = false;
 147     header.is_in_fec_group = NOT_IN_FEC_GROUP;
 148     header.fec_group = 0;
 149     QuicStreamFrame stream_frame(1, false, 0, MakeIOVector("data"));
 150     QuicFrame frame(&stream_frame);
 151     QuicFrames frames;
 152     frames.push_back(frame);
 153     scoped_ptr<QuicPacket> packet(
 154         BuildUnsizedDataPacket(&framer_, header, frames).packet);
 155     EXPECT_TRUE(packet != nullptr);
 156     QuicEncryptedPacket* encrypted = framer_.EncryptPacket(ENCRYPTION_NONE,
 157                                                            sequence_number,
 158                                                            *packet);
 159     EXPECT_TRUE(encrypted != nullptr);
 160     return encrypted;
 161   }
 162
 163   NiceMock<MockFakeTimeEpollServer> epoll_server_;
 164   StrictMock<MockPacketWriter> writer_;
 165   StrictMock<MockQuicServerSessionVisitor> visitor_;
 166   QuicTimeWaitListManager time_wait_list_manager_;
 167   QuicFramer framer_;
 168   QuicConnectionId connection_id_;
 169   IPEndPoint server_address_;
 170   IPEndPoint client_address_;
 171   bool writer_is_blocked_;
 172 };
 173
 174 class ValidatePublicResetPacketPredicate
 175     : public MatcherInterface<const std::tr1::tuple<const char*, int> > {
 176  public:
 177   explicit ValidatePublicResetPacketPredicate(QuicConnectionId connection_id,
 178                                               QuicPacketSequenceNumber number)
 179       : connection_id_(connection_id), sequence_number_(number) {
 180   }
 181
 182   virtual bool MatchAndExplain(
 183       const std::tr1::tuple<const char*, int> packet_buffer,
 184       testing::MatchResultListener* /* listener */) const OVERRIDE {
 185     FramerVisitorCapturingPublicReset visitor;
 186     QuicFramer framer(QuicSupportedVersions(),
 187                       QuicTime::Zero(),
 188                       false);
 189     framer.set_visitor(&visitor);
 190     QuicEncryptedPacket encrypted(std::tr1::get<0>(packet_buffer),
 191                                   std::tr1::get<1>(packet_buffer));
 192     framer.ProcessPacket(encrypted);
 193     QuicPublicResetPacket packet = visitor.public_reset_packet();
 194     return connection_id_ == packet.public_header.connection_id &&
 195         packet.public_header.reset_flag && !packet.public_header.version_flag &&
 196         sequence_number_ == packet.rejected_sequence_number &&
 197         net::test::TestPeerIPAddress() == packet.client_address.address() &&
 198         kTestPort == packet.client_address.port();
 199   }
 200
 201   virtual void DescribeTo(::std::ostream* os) const OVERRIDE {}
 202
 203   virtual void DescribeNegationTo(::std::ostream* os) const OVERRIDE {}
 204
 205  private:
 206   QuicConnectionId connection_id_;
 207   QuicPacketSequenceNumber sequence_number_;
 208 };
 209
 210
 211 Matcher<const std::tr1::tuple<const char*, int> > PublicResetPacketEq(
 212     QuicConnectionId connection_id,
 213     QuicPacketSequenceNumber sequence_number) {
 214   return MakeMatcher(new ValidatePublicResetPacketPredicate(connection_id,
 215                                                             sequence_number));
 216 }
 217
 218 TEST_F(QuicTimeWaitListManagerTest, CheckConnectionIdInTimeWait) {
 219   EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_));
 220   AddConnectionId(connection_id_);
 221   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
 222 }
 223
 224 TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
 225   size_t kConnectionCloseLength = 100;
 226   AddConnectionId(
 227       connection_id_,
 228       QuicVersionMax(),
 229       new QuicEncryptedPacket(
 230           new char[kConnectionCloseLength], kConnectionCloseLength, true));
 231   const int kRandomSequenceNumber = 1;
 232   EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
 233                                    server_address_.address(),
 234                                    client_address_))
 235       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 236
 237   ProcessPacket(connection_id_, kRandomSequenceNumber);
 238 }
 239
 240 TEST_F(QuicTimeWaitListManagerTest, SendPublicReset) {
 241   AddConnectionId(connection_id_);
 242   const int kRandomSequenceNumber = 1;
 243   EXPECT_CALL(writer_, WritePacket(_, _,
 244                                    server_address_.address(),
 245                                    client_address_))
 246       .With(Args<0, 1>(PublicResetPacketEq(connection_id_,
 247                                            kRandomSequenceNumber)))
 248       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
 249
 250   ProcessPacket(connection_id_, kRandomSequenceNumber);
 251 }
 252
 253 TEST_F(QuicTimeWaitListManagerTest, SendPublicResetWithExponentialBackOff) {
 254   AddConnectionId(connection_id_);
 255   for (int sequence_number = 1; sequence_number < 101; ++sequence_number) {
 256     if ((sequence_number & (sequence_number - 1)) == 0) {
 257       EXPECT_CALL(writer_, WritePacket(_, _, _, _))
 258           .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 259     }
 260     ProcessPacket(connection_id_, sequence_number);
 261     // Send public reset with exponential back off.
 262     if ((sequence_number & (sequence_number - 1)) == 0) {
 263       EXPECT_TRUE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
 264                       &time_wait_list_manager_, sequence_number));
 265     } else {
 266       EXPECT_FALSE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
 267                        &time_wait_list_manager_, sequence_number));
 268     }
 269   }
 270 }
 271
 272 TEST_F(QuicTimeWaitListManagerTest, CleanUpOldConnectionIds) {
 273   const int kConnectionIdCount = 100;
 274   const int kOldConnectionIdCount = 31;
 275
 276   // Add connection_ids such that their expiry time is kTimeWaitPeriod_.
 277   epoll_server_.set_now_in_usec(0);
 278   for (int connection_id = 1;
 279        connection_id <= kOldConnectionIdCount;
 280        ++connection_id) {
 281     AddConnectionId(connection_id);
 282   }
 283
 284   // Add remaining connection_ids such that their add time is
 285   // 2 * kTimeWaitPeriod.
 286   const QuicTime::Delta time_wait_period =
 287       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
 288   epoll_server_.set_now_in_usec(time_wait_period.ToMicroseconds());
 289   for (int connection_id = kOldConnectionIdCount + 1;
 290        connection_id <= kConnectionIdCount;
 291        ++connection_id) {
 292     AddConnectionId(connection_id);
 293   }
 294
 295   QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39);
 296   // Now set the current time as time_wait_period + offset usecs.
 297   epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds());
 298   // After all the old connection_ids are cleaned up, check the next alarm
 299   // interval.
 300   int64 next_alarm_time = epoll_server_.ApproximateNowInUsec() +
 301       time_wait_period.Subtract(offset).ToMicroseconds();
 302   EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _));
 303
 304   time_wait_list_manager_.CleanUpOldConnectionIds();
 305   for (int connection_id = 1;
 306        connection_id <= kConnectionIdCount;
 307        ++connection_id) {
 308     EXPECT_EQ(connection_id > kOldConnectionIdCount,
 309               IsConnectionIdInTimeWait(connection_id))
 310         << "kOldConnectionIdCount: " << kOldConnectionIdCount
 311         << " connection_id: " <<  connection_id;
 312   }
 313 }
 314
 315 TEST_F(QuicTimeWaitListManagerTest, SendQueuedPackets) {
 316   QuicConnectionId connection_id = 1;
 317   AddConnectionId(connection_id);
 318   QuicPacketSequenceNumber sequence_number = 234;
 319   scoped_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
 320       ENCRYPTION_NONE, connection_id, sequence_number));
 321   // Let first write through.
 322   EXPECT_CALL(writer_, WritePacket(_, _,
 323                                    server_address_.address(),
 324                                    client_address_))
 325       .With(Args<0, 1>(PublicResetPacketEq(connection_id,
 326                                            sequence_number)))
 327       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
 328   ProcessPacket(connection_id, sequence_number);
 329
 330   // write block for the next packet.
 331   EXPECT_CALL(writer_, WritePacket(_, _,
 332                                    server_address_.address(),
 333                                    client_address_))
 334       .With(Args<0, 1>(PublicResetPacketEq(connection_id,
 335                                            sequence_number)))
 336       .WillOnce(DoAll(
 337           Assign(&writer_is_blocked_, true),
 338           Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN))));
 339   EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_));
 340   ProcessPacket(connection_id, sequence_number);
 341   // 3rd packet. No public reset should be sent;
 342   ProcessPacket(connection_id, sequence_number);
 343
 344   // write packet should not be called since we are write blocked but the
 345   // should be queued.
 346   QuicConnectionId other_connection_id = 2;
 347   AddConnectionId(other_connection_id);
 348   QuicPacketSequenceNumber other_sequence_number = 23423;
 349   scoped_ptr<QuicEncryptedPacket> other_packet(
 350       ConstructEncryptedPacket(
 351           ENCRYPTION_NONE, other_connection_id, other_sequence_number));
 352   EXPECT_CALL(writer_, WritePacket(_, _, _, _))
 353       .Times(0);
 354   EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_));
 355   ProcessPacket(other_connection_id, other_sequence_number);
 356
 357   // Now expect all the write blocked public reset packets to be sent again.
 358   writer_is_blocked_ = false;
 359   EXPECT_CALL(writer_, WritePacket(_, _,
 360                                    server_address_.address(),
 361                                    client_address_))
 362       .With(Args<0, 1>(PublicResetPacketEq(connection_id,
 363                                            sequence_number)))
 364       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
 365   EXPECT_CALL(writer_, WritePacket(_, _,
 366                                    server_address_.address(),
 367                                    client_address_))
 368       .With(Args<0, 1>(PublicResetPacketEq(other_connection_id,
 369                                            other_sequence_number)))
 370       .WillOnce(Return(WriteResult(WRITE_STATUS_OK,
 371                                    other_packet->length())));
 372   time_wait_list_manager_.OnCanWrite();
 373 }
 374
 375 TEST_F(QuicTimeWaitListManagerTest, GetQuicVersionFromMap) {
 376   const int kConnectionId1 = 123;
 377   const int kConnectionId2 = 456;
 378   const int kConnectionId3 = 789;
 379
 380   AddConnectionId(kConnectionId1, QuicVersionMin(), nullptr);
 381   AddConnectionId(kConnectionId2, QuicVersionMax(), nullptr);
 382   AddConnectionId(kConnectionId3, QuicVersionMax(), nullptr);
 383
 384   EXPECT_EQ(QuicVersionMin(),
 385             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
 386                 &time_wait_list_manager_, kConnectionId1));
 387   EXPECT_EQ(QuicVersionMax(),
 388             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
 389                 &time_wait_list_manager_, kConnectionId2));
 390   EXPECT_EQ(QuicVersionMax(),
 391             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
 392                 &time_wait_list_manager_, kConnectionId3));
 393 }
 394
 395 TEST_F(QuicTimeWaitListManagerTest, AddConnectionIdTwice) {
 396   // Add connection_ids such that their expiry time is kTimeWaitPeriod_.
 397   epoll_server_.set_now_in_usec(0);
 398   AddConnectionId(connection_id_);
 399   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
 400   size_t kConnectionCloseLength = 100;
 401   AddConnectionId(
 402       connection_id_,
 403       QuicVersionMax(),
 404       new QuicEncryptedPacket(
 405           new char[kConnectionCloseLength], kConnectionCloseLength, true));
 406   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
 407
 408   EXPECT_CALL(writer_, WritePacket(_,
 409                                    kConnectionCloseLength,
 410                                    server_address_.address(),
 411                                    client_address_))
 412       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 413
 414   const int kRandomSequenceNumber = 1;
 415   ProcessPacket(connection_id_, kRandomSequenceNumber);
 416
 417   const QuicTime::Delta time_wait_period =
 418       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
 419
 420   QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39);
 421   // Now set the current time as time_wait_period + offset usecs.
 422   epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds());
 423   // After the connection_ids are cleaned up, check the next alarm interval.
 424   int64 next_alarm_time = epoll_server_.ApproximateNowInUsec() +
 425       time_wait_period.ToMicroseconds();
 426
 427   EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _));
 428   time_wait_list_manager_.CleanUpOldConnectionIds();
 429   EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_));
 430 }
 431
 432 TEST_F(QuicTimeWaitListManagerTest, ConnectionIdsOrderedByTime) {
 433   // Simple randomization: the values of connection_ids are swapped based on the
 434   // current seconds on the clock. If the container is broken, the test will be
 435   // 50% flaky.
 436   int odd_second = static_cast<int>(epoll_server_.ApproximateNowInUsec()) % 2;
 437   EXPECT_TRUE(odd_second == 0 || odd_second == 1);
 438   const QuicConnectionId kConnectionId1 = odd_second;
 439   const QuicConnectionId kConnectionId2 = 1 - odd_second;
 440
 441   // 1 will hash lower than 2, but we add it later. They should come out in the
 442   // add order, not hash order.
 443   epoll_server_.set_now_in_usec(0);
 444   AddConnectionId(kConnectionId1);
 445   epoll_server_.set_now_in_usec(10);
 446   AddConnectionId(kConnectionId2);
 447
 448   const QuicTime::Delta time_wait_period =
 449       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
 450   epoll_server_.set_now_in_usec(time_wait_period.ToMicroseconds() + 1);
 451
 452   EXPECT_CALL(epoll_server_, RegisterAlarm(_, _));
 453
 454   time_wait_list_manager_.CleanUpOldConnectionIds();
 455   EXPECT_FALSE(IsConnectionIdInTimeWait(kConnectionId1));
 456   EXPECT_TRUE(IsConnectionIdInTimeWait(kConnectionId2));
 457 }
 458 }  // namespace
 459 }  // namespace test
 460 }  // namespace tools
 461 }  // namespace net