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