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