net/quic/quic_time_wait_list_manager.cc

   1 // Copyright 2014 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/quic_time_wait_list_manager.h"
   6
   7 #include <errno.h>
   8
   9 #include "base/containers/hash_tables.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/stl_util.h"
  12 #include "net/base/ip_endpoint.h"
  13 #include "net/quic/crypto/crypto_protocol.h"
  14 #include "net/quic/crypto/quic_decrypter.h"
  15 #include "net/quic/crypto/quic_encrypter.h"
  16 #include "net/quic/quic_clock.h"
  17 #include "net/quic/quic_connection_helper.h"
  18 #include "net/quic/quic_framer.h"
  19 #include "net/quic/quic_protocol.h"
  20 #include "net/quic/quic_server_session.h"
  21 #include "net/quic/quic_utils.h"
  22
  23 using base::StringPiece;
  24 using std::make_pair;
  25
  26 namespace net {
  27
  28 namespace {
  29
  30 // Time period for which the connection_id should live in time wait state..
  31 const int kTimeWaitSeconds = 5;
  32
  33 }  // namespace
  34
  35 // A very simple alarm that just informs the QuicTimeWaitListManager to clean
  36 // up old connection_ids. This alarm should be unregistered and deleted before
  37 // the QuicTimeWaitListManager is deleted.
  38 class ConnectionIdCleanUpAlarm : public QuicAlarm::Delegate {
  39  public:
  40   explicit ConnectionIdCleanUpAlarm(
  41       QuicTimeWaitListManager* time_wait_list_manager)
  42       : time_wait_list_manager_(time_wait_list_manager) {}
  43
  44   virtual QuicTime OnAlarm() OVERRIDE {
  45     time_wait_list_manager_->CleanUpOldConnectionIds();
  46     // Let the time wait manager register the alarm at appropriate time.
  47     return QuicTime::Zero();
  48   }
  49
  50  private:
  51   // Not owned.
  52   QuicTimeWaitListManager* time_wait_list_manager_;
  53 };
  54
  55 // This class stores pending public reset packets to be sent to clients.
  56 // server_address - server address on which a packet what was received for
  57 //                  a connection_id in time wait state.
  58 // client_address - address of the client that sent that packet. Needed to send
  59 //                  the public reset packet back to the client.
  60 // packet - the pending public reset packet that is to be sent to the client.
  61 //          created instance takes the ownership of this packet.
  62 class QuicTimeWaitListManager::QueuedPacket {
  63  public:
  64   QueuedPacket(const IPEndPoint& server_address,
  65                const IPEndPoint& client_address,
  66                QuicEncryptedPacket* packet)
  67       : server_address_(server_address),
  68         client_address_(client_address),
  69         packet_(packet) {}
  70
  71   const IPEndPoint& server_address() const { return server_address_; }
  72   const IPEndPoint& client_address() const { return client_address_; }
  73   QuicEncryptedPacket* packet() { return packet_.get(); }
  74
  75  private:
  76   const IPEndPoint server_address_;
  77   const IPEndPoint client_address_;
  78   scoped_ptr<QuicEncryptedPacket> packet_;
  79
  80   DISALLOW_COPY_AND_ASSIGN(QueuedPacket);
  81 };
  82
  83 QuicTimeWaitListManager::QuicTimeWaitListManager(
  84     QuicPacketWriter* writer,
  85     QuicServerSessionVisitor* visitor,
  86     QuicConnectionHelperInterface* helper,
  87     const QuicVersionVector& supported_versions)
  88     : helper_(helper),
  89       kTimeWaitPeriod_(QuicTime::Delta::FromSeconds(kTimeWaitSeconds)),
  90       connection_id_clean_up_alarm_(
  91           helper_->CreateAlarm(new ConnectionIdCleanUpAlarm(this))),
  92       writer_(writer),
  93       visitor_(visitor) {
  94   SetConnectionIdCleanUpAlarm();
  95 }
  96
  97 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
  98   connection_id_clean_up_alarm_->Cancel();
  99   STLDeleteElements(&pending_packets_queue_);
 100   for (ConnectionIdMap::iterator it = connection_id_map_.begin();
 101        it != connection_id_map_.end();
 102        ++it) {
 103     delete it->second.close_packet;
 104   }
 105 }
 106
 107 void QuicTimeWaitListManager::AddConnectionIdToTimeWait(
 108     QuicConnectionId connection_id,
 109     QuicVersion version,
 110     QuicEncryptedPacket* close_packet) {
 111   DVLOG(1) << "Adding " << connection_id << " to the time wait list.";
 112   int num_packets = 0;
 113   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
 114   if (it != connection_id_map_.end()) {  // Replace record if it is reinserted.
 115     num_packets = it->second.num_packets;
 116     delete it->second.close_packet;
 117     connection_id_map_.erase(it);
 118   }
 119   ConnectionIdData data(num_packets,
 120                         version,
 121                         helper_->GetClock()->ApproximateNow(),
 122                         close_packet);
 123   connection_id_map_.insert(make_pair(connection_id, data));
 124 }
 125
 126 bool QuicTimeWaitListManager::IsConnectionIdInTimeWait(
 127     QuicConnectionId connection_id) const {
 128   return ContainsKey(connection_id_map_, connection_id);
 129 }
 130
 131 QuicVersion QuicTimeWaitListManager::GetQuicVersionFromConnectionId(
 132     QuicConnectionId connection_id) {
 133   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
 134   DCHECK(it != connection_id_map_.end());
 135   return (it->second).version;
 136 }
 137
 138 void QuicTimeWaitListManager::OnCanWrite() {
 139   while (!pending_packets_queue_.empty()) {
 140     QueuedPacket* queued_packet = pending_packets_queue_.front();
 141     if (!WriteToWire(queued_packet)) {
 142       return;
 143     }
 144     pending_packets_queue_.pop_front();
 145     delete queued_packet;
 146   }
 147 }
 148
 149 void QuicTimeWaitListManager::ProcessPacket(
 150     const IPEndPoint& server_address,
 151     const IPEndPoint& client_address,
 152     QuicConnectionId connection_id,
 153     QuicPacketSequenceNumber sequence_number,
 154     const QuicEncryptedPacket& /*packet*/) {
 155   DCHECK(IsConnectionIdInTimeWait(connection_id));
 156   DVLOG(1) << "Processing " << connection_id << " in time wait state.";
 157   // TODO(satyamshekhar): Think about handling packets from different client
 158   // addresses.
 159   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
 160   DCHECK(it != connection_id_map_.end());
 161   // Increment the received packet count.
 162   ++((it->second).num_packets);
 163   if (!ShouldSendResponse((it->second).num_packets)) {
 164     return;
 165   }
 166   if (it->second.close_packet) {
 167     QueuedPacket* queued_packet =
 168         new QueuedPacket(server_address,
 169                          client_address,
 170                          it->second.close_packet->Clone());
 171     // Takes ownership of the packet.
 172     SendOrQueuePacket(queued_packet);
 173   } else {
 174     SendPublicReset(server_address,
 175                     client_address,
 176                     connection_id,
 177                     sequence_number);
 178   }
 179 }
 180
 181 // Returns true if the number of packets received for this connection_id is a
 182 // power of 2 to throttle the number of public reset packets we send to a
 183 // client.
 184 bool QuicTimeWaitListManager::ShouldSendResponse(int received_packet_count) {
 185   return (received_packet_count & (received_packet_count - 1)) == 0;
 186 }
 187
 188 void QuicTimeWaitListManager::SendPublicReset(
 189     const IPEndPoint& server_address,
 190     const IPEndPoint& client_address,
 191     QuicConnectionId connection_id,
 192     QuicPacketSequenceNumber rejected_sequence_number) {
 193   QuicPublicResetPacket packet;
 194   packet.public_header.connection_id = connection_id;
 195   packet.public_header.reset_flag = true;
 196   packet.public_header.version_flag = false;
 197   packet.rejected_sequence_number = rejected_sequence_number;
 198   // TODO(satyamshekhar): generate a valid nonce for this connection_id.
 199   packet.nonce_proof = 1010101;
 200   packet.client_address = client_address;
 201   QueuedPacket* queued_packet = new QueuedPacket(
 202       server_address,
 203       client_address,
 204       BuildPublicReset(packet));
 205   // Takes ownership of the packet.
 206   SendOrQueuePacket(queued_packet);
 207 }
 208
 209 QuicEncryptedPacket* QuicTimeWaitListManager::BuildPublicReset(
 210     const QuicPublicResetPacket& packet) {
 211   return QuicFramer::BuildPublicResetPacket(packet);
 212 }
 213
 214 // Either sends the packet and deletes it or makes pending queue the
 215 // owner of the packet.
 216 void QuicTimeWaitListManager::SendOrQueuePacket(QueuedPacket* packet) {
 217   if (WriteToWire(packet)) {
 218     delete packet;
 219   } else {
 220     // pending_packets_queue takes the ownership of the queued packet.
 221     pending_packets_queue_.push_back(packet);
 222   }
 223 }
 224
 225 bool QuicTimeWaitListManager::WriteToWire(QueuedPacket* queued_packet) {
 226   if (writer_->IsWriteBlocked()) {
 227     visitor_->OnWriteBlocked(this);
 228     return false;
 229   }
 230   WriteResult result = writer_->WritePacket(
 231       queued_packet->packet()->data(),
 232       queued_packet->packet()->length(),
 233       queued_packet->server_address().address(),
 234       queued_packet->client_address());
 235   if (result.status == WRITE_STATUS_BLOCKED) {
 236     // If blocked and unbuffered, return false to retry sending.
 237     DCHECK(writer_->IsWriteBlocked());
 238     visitor_->OnWriteBlocked(this);
 239     return writer_->IsWriteBlockedDataBuffered();
 240   } else if (result.status == WRITE_STATUS_ERROR) {
 241     LOG(WARNING) << "Received unknown error while sending reset packet to "
 242                  << queued_packet->client_address().ToString() << ": "
 243                  << strerror(result.error_code);
 244   }
 245   return true;
 246 }
 247
 248 void QuicTimeWaitListManager::SetConnectionIdCleanUpAlarm() {
 249   connection_id_clean_up_alarm_->Cancel();
 250   QuicTime now = helper_->GetClock()->ApproximateNow();
 251   QuicTime next_alarm_time = now;
 252   if (!connection_id_map_.empty()) {
 253     QuicTime oldest_connection_id =
 254         connection_id_map_.begin()->second.time_added;
 255     if (now.Subtract(oldest_connection_id) < kTimeWaitPeriod_) {
 256       next_alarm_time = oldest_connection_id.Add(kTimeWaitPeriod_);
 257     } else {
 258       LOG(ERROR) << "ConnectionId lingered for longer than kTimeWaitPeriod";
 259     }
 260   } else {
 261     // No connection_ids added so none will expire before kTimeWaitPeriod_.
 262     next_alarm_time = now.Add(kTimeWaitPeriod_);
 263   }
 264
 265   connection_id_clean_up_alarm_->Set(next_alarm_time);
 266 }
 267
 268 void QuicTimeWaitListManager::CleanUpOldConnectionIds() {
 269   QuicTime now = helper_->GetClock()->ApproximateNow();
 270   while (!connection_id_map_.empty()) {
 271     ConnectionIdMap::iterator it = connection_id_map_.begin();
 272     QuicTime oldest_connection_id = it->second.time_added;
 273     if (now.Subtract(oldest_connection_id) < kTimeWaitPeriod_) {
 274       break;
 275     }
 276     // This connection_id has lived its age, retire it now.
 277     delete it->second.close_packet;
 278     connection_id_map_.erase(it);
 279   }
 280   SetConnectionIdCleanUpAlarm();
 281 }
 282
 283 }  // namespace net