| // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "quiche/quic/core/quic_time_wait_list_manager.h" | |
| #include <errno.h> | |
| #include <memory> | |
| #include <utility> | |
| #include "absl/strings/string_view.h" | |
| #include "quiche/quic/core/crypto/crypto_protocol.h" | |
| #include "quiche/quic/core/crypto/quic_decrypter.h" | |
| #include "quiche/quic/core/crypto/quic_encrypter.h" | |
| #include "quiche/quic/core/quic_clock.h" | |
| #include "quiche/quic/core/quic_connection_id.h" | |
| #include "quiche/quic/core/quic_framer.h" | |
| #include "quiche/quic/core/quic_packets.h" | |
| #include "quiche/quic/core/quic_utils.h" | |
| #include "quiche/quic/platform/api/quic_bug_tracker.h" | |
| #include "quiche/quic/platform/api/quic_flag_utils.h" | |
| #include "quiche/quic/platform/api/quic_flags.h" | |
| #include "quiche/quic/platform/api/quic_logging.h" | |
| #include "quiche/quic/platform/api/quic_socket_address.h" | |
| #include "quiche/common/quiche_text_utils.h" | |
| namespace quic { | |
| // A very simple alarm that just informs the QuicTimeWaitListManager to clean | |
| // up old connection_ids. This alarm should be cancelled and deleted before | |
| // the QuicTimeWaitListManager is deleted. | |
| class ConnectionIdCleanUpAlarm : public QuicAlarm::DelegateWithoutContext { | |
| public: | |
| explicit ConnectionIdCleanUpAlarm( | |
| QuicTimeWaitListManager* time_wait_list_manager) | |
| : time_wait_list_manager_(time_wait_list_manager) {} | |
| ConnectionIdCleanUpAlarm(const ConnectionIdCleanUpAlarm&) = delete; | |
| ConnectionIdCleanUpAlarm& operator=(const ConnectionIdCleanUpAlarm&) = delete; | |
| void OnAlarm() override { | |
| time_wait_list_manager_->CleanUpOldConnectionIds(); | |
| } | |
| private: | |
| // Not owned. | |
| QuicTimeWaitListManager* time_wait_list_manager_; | |
| }; | |
| TimeWaitConnectionInfo::TimeWaitConnectionInfo( | |
| bool ietf_quic, | |
| std::vector<std::unique_ptr<QuicEncryptedPacket>>* termination_packets, | |
| std::vector<QuicConnectionId> active_connection_ids) | |
| : TimeWaitConnectionInfo(ietf_quic, termination_packets, | |
| std::move(active_connection_ids), | |
| QuicTime::Delta::Zero()) {} | |
| TimeWaitConnectionInfo::TimeWaitConnectionInfo( | |
| bool ietf_quic, | |
| std::vector<std::unique_ptr<QuicEncryptedPacket>>* termination_packets, | |
| std::vector<QuicConnectionId> active_connection_ids, QuicTime::Delta srtt) | |
| : ietf_quic(ietf_quic), | |
| active_connection_ids(std::move(active_connection_ids)), | |
| srtt(srtt) { | |
| if (termination_packets != nullptr) { | |
| this->termination_packets.swap(*termination_packets); | |
| } | |
| } | |
| QuicTimeWaitListManager::QuicTimeWaitListManager( | |
| QuicPacketWriter* writer, Visitor* visitor, const QuicClock* clock, | |
| QuicAlarmFactory* alarm_factory) | |
| : time_wait_period_(QuicTime::Delta::FromSeconds( | |
| GetQuicFlag(quic_time_wait_list_seconds))), | |
| connection_id_clean_up_alarm_( | |
| alarm_factory->CreateAlarm(new ConnectionIdCleanUpAlarm(this))), | |
| clock_(clock), | |
| writer_(writer), | |
| visitor_(visitor) { | |
| SetConnectionIdCleanUpAlarm(); | |
| } | |
| QuicTimeWaitListManager::~QuicTimeWaitListManager() { | |
| connection_id_clean_up_alarm_->Cancel(); | |
| } | |
| QuicTimeWaitListManager::ConnectionIdMap::iterator | |
| QuicTimeWaitListManager::FindConnectionIdDataInMap( | |
| const QuicConnectionId& connection_id) { | |
| auto it = indirect_connection_id_map_.find(connection_id); | |
| if (it == indirect_connection_id_map_.end()) { | |
| return connection_id_map_.end(); | |
| } | |
| return connection_id_map_.find(it->second); | |
| } | |
| void QuicTimeWaitListManager::AddConnectionIdDataToMap( | |
| const QuicConnectionId& canonical_connection_id, int num_packets, | |
| TimeWaitAction action, TimeWaitConnectionInfo info) { | |
| for (const auto& cid : info.active_connection_ids) { | |
| indirect_connection_id_map_[cid] = canonical_connection_id; | |
| } | |
| ConnectionIdData data(num_packets, clock_->ApproximateNow(), action, | |
| std::move(info)); | |
| connection_id_map_.emplace( | |
| std::make_pair(canonical_connection_id, std::move(data))); | |
| } | |
| void QuicTimeWaitListManager::RemoveConnectionDataFromMap( | |
| ConnectionIdMap::iterator it) { | |
| for (const auto& cid : it->second.info.active_connection_ids) { | |
| indirect_connection_id_map_.erase(cid); | |
| } | |
| connection_id_map_.erase(it); | |
| } | |
| void QuicTimeWaitListManager::AddConnectionIdToTimeWait( | |
| TimeWaitAction action, TimeWaitConnectionInfo info) { | |
| QUICHE_DCHECK(!info.active_connection_ids.empty()); | |
| const QuicConnectionId& canonical_connection_id = | |
| info.active_connection_ids.front(); | |
| QUICHE_DCHECK(action != SEND_TERMINATION_PACKETS || | |
| !info.termination_packets.empty()); | |
| QUICHE_DCHECK(action != DO_NOTHING || info.ietf_quic); | |
| int num_packets = 0; | |
| auto it = FindConnectionIdDataInMap(canonical_connection_id); | |
| const bool new_connection_id = it == connection_id_map_.end(); | |
| if (!new_connection_id) { // Replace record if it is reinserted. | |
| num_packets = it->second.num_packets; | |
| RemoveConnectionDataFromMap(it); | |
| } | |
| TrimTimeWaitListIfNeeded(); | |
| int64_t max_connections = GetQuicFlag(quic_time_wait_list_max_connections); | |
| QUICHE_DCHECK(connection_id_map_.empty() || | |
| num_connections() < static_cast<size_t>(max_connections)); | |
| if (new_connection_id) { | |
| for (const auto& cid : info.active_connection_ids) { | |
| visitor_->OnConnectionAddedToTimeWaitList(cid); | |
| } | |
| } | |
| AddConnectionIdDataToMap(canonical_connection_id, num_packets, action, | |
| std::move(info)); | |
| } | |
| bool QuicTimeWaitListManager::IsConnectionIdInTimeWait( | |
| QuicConnectionId connection_id) const { | |
| return indirect_connection_id_map_.contains(connection_id); | |
| } | |
| void QuicTimeWaitListManager::OnBlockedWriterCanWrite() { | |
| writer_->SetWritable(); | |
| while (!pending_packets_queue_.empty()) { | |
| QueuedPacket* queued_packet = pending_packets_queue_.front().get(); | |
| if (!WriteToWire(queued_packet)) { | |
| return; | |
| } | |
| pending_packets_queue_.pop_front(); | |
| } | |
| } | |
| void QuicTimeWaitListManager::ProcessPacket( | |
| const QuicSocketAddress& self_address, | |
| const QuicSocketAddress& peer_address, QuicConnectionId connection_id, | |
| PacketHeaderFormat header_format, size_t received_packet_length, | |
| std::unique_ptr<QuicPerPacketContext> packet_context) { | |
| QUICHE_DCHECK(IsConnectionIdInTimeWait(connection_id)); | |
| // TODO(satyamshekhar): Think about handling packets from different peer | |
| // addresses. | |
| auto it = FindConnectionIdDataInMap(connection_id); | |
| QUICHE_DCHECK(it != connection_id_map_.end()); | |
| // Increment the received packet count. | |
| ConnectionIdData* connection_data = &it->second; | |
| ++(connection_data->num_packets); | |
| const QuicTime now = clock_->ApproximateNow(); | |
| QuicTime::Delta delta = QuicTime::Delta::Zero(); | |
| if (now > connection_data->time_added) { | |
| delta = now - connection_data->time_added; | |
| } | |
| OnPacketReceivedForKnownConnection(connection_data->num_packets, delta, | |
| connection_data->info.srtt); | |
| if (!ShouldSendResponse(connection_data->num_packets)) { | |
| QUIC_DLOG(INFO) << "Processing " << connection_id << " in time wait state: " | |
| << "throttled"; | |
| return; | |
| } | |
| QUIC_DLOG(INFO) << "Processing " << connection_id << " in time wait state: " | |
| << "header format=" << header_format | |
| << " ietf=" << connection_data->info.ietf_quic | |
| << ", action=" << connection_data->action | |
| << ", number termination packets=" | |
| << connection_data->info.termination_packets.size(); | |
| switch (connection_data->action) { | |
| case SEND_TERMINATION_PACKETS: | |
| if (connection_data->info.termination_packets.empty()) { | |
| QUIC_BUG(quic_bug_10608_1) << "There are no termination packets."; | |
| return; | |
| } | |
| switch (header_format) { | |
| case IETF_QUIC_LONG_HEADER_PACKET: | |
| if (!connection_data->info.ietf_quic) { | |
| QUIC_CODE_COUNT(quic_received_long_header_packet_for_gquic); | |
| } | |
| break; | |
| case IETF_QUIC_SHORT_HEADER_PACKET: | |
| if (!connection_data->info.ietf_quic) { | |
| QUIC_CODE_COUNT(quic_received_short_header_packet_for_gquic); | |
| } | |
| // Send stateless reset in response to short header packets. | |
| SendPublicReset(self_address, peer_address, connection_id, | |
| connection_data->info.ietf_quic, | |
| received_packet_length, std::move(packet_context)); | |
| return; | |
| case GOOGLE_QUIC_PACKET: | |
| if (connection_data->info.ietf_quic) { | |
| QUIC_CODE_COUNT(quic_received_gquic_packet_for_ietf_quic); | |
| } | |
| break; | |
| } | |
| for (const auto& packet : connection_data->info.termination_packets) { | |
| SendOrQueuePacket(std::make_unique<QueuedPacket>( | |
| self_address, peer_address, packet->Clone()), | |
| packet_context.get()); | |
| } | |
| return; | |
| case SEND_CONNECTION_CLOSE_PACKETS: | |
| if (connection_data->info.termination_packets.empty()) { | |
| QUIC_BUG(quic_bug_10608_2) << "There are no termination packets."; | |
| return; | |
| } | |
| for (const auto& packet : connection_data->info.termination_packets) { | |
| SendOrQueuePacket(std::make_unique<QueuedPacket>( | |
| self_address, peer_address, packet->Clone()), | |
| packet_context.get()); | |
| } | |
| return; | |
| case SEND_STATELESS_RESET: | |
| if (header_format == IETF_QUIC_LONG_HEADER_PACKET) { | |
| QUIC_CODE_COUNT(quic_stateless_reset_long_header_packet); | |
| } | |
| SendPublicReset(self_address, peer_address, connection_id, | |
| connection_data->info.ietf_quic, received_packet_length, | |
| std::move(packet_context)); | |
| return; | |
| case DO_NOTHING: | |
| QUIC_CODE_COUNT(quic_time_wait_list_do_nothing); | |
| QUICHE_DCHECK(connection_data->info.ietf_quic); | |
| } | |
| } | |
| void QuicTimeWaitListManager::SendVersionNegotiationPacket( | |
| QuicConnectionId server_connection_id, | |
| QuicConnectionId client_connection_id, bool ietf_quic, | |
| bool use_length_prefix, const ParsedQuicVersionVector& supported_versions, | |
| const QuicSocketAddress& self_address, | |
| const QuicSocketAddress& peer_address, | |
| std::unique_ptr<QuicPerPacketContext> packet_context) { | |
| std::unique_ptr<QuicEncryptedPacket> version_packet = | |
| QuicFramer::BuildVersionNegotiationPacket( | |
| server_connection_id, client_connection_id, ietf_quic, | |
| use_length_prefix, supported_versions); | |
| QUIC_DVLOG(2) << "Dispatcher sending version negotiation packet {" | |
| << ParsedQuicVersionVectorToString(supported_versions) << "}, " | |
| << (ietf_quic ? "" : "!") << "ietf_quic, " | |
| << (use_length_prefix ? "" : "!") | |
| << "use_length_prefix:" << std::endl | |
| << quiche::QuicheTextUtils::HexDump(absl::string_view( | |
| version_packet->data(), version_packet->length())); | |
| SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address, | |
| std::move(version_packet)), | |
| packet_context.get()); | |
| } | |
| // Returns true if the number of packets received for this connection_id is a | |
| // power of 2 to throttle the number of public reset packets we send to a peer. | |
| bool QuicTimeWaitListManager::ShouldSendResponse(int received_packet_count) { | |
| return (received_packet_count & (received_packet_count - 1)) == 0; | |
| } | |
| void QuicTimeWaitListManager::SendPublicReset( | |
| const QuicSocketAddress& self_address, | |
| const QuicSocketAddress& peer_address, QuicConnectionId connection_id, | |
| bool ietf_quic, size_t received_packet_length, | |
| std::unique_ptr<QuicPerPacketContext> packet_context) { | |
| if (ietf_quic) { | |
| std::unique_ptr<QuicEncryptedPacket> ietf_reset_packet = | |
| BuildIetfStatelessResetPacket(connection_id, received_packet_length); | |
| if (ietf_reset_packet == nullptr) { | |
| // This could happen when trying to reject a short header packet of | |
| // a connection which is in the time wait list (and with no termination | |
| // packet). | |
| return; | |
| } | |
| QUIC_DVLOG(2) << "Dispatcher sending IETF reset packet for " | |
| << connection_id << std::endl | |
| << quiche::QuicheTextUtils::HexDump( | |
| absl::string_view(ietf_reset_packet->data(), | |
| ietf_reset_packet->length())); | |
| SendOrQueuePacket( | |
| std::make_unique<QueuedPacket>(self_address, peer_address, | |
| std::move(ietf_reset_packet)), | |
| packet_context.get()); | |
| return; | |
| } | |
| // Google QUIC public resets donot elicit resets in response. | |
| QuicPublicResetPacket packet; | |
| packet.connection_id = connection_id; | |
| // TODO(satyamshekhar): generate a valid nonce for this connection_id. | |
| packet.nonce_proof = 1010101; | |
| // TODO(wub): This is wrong for proxied sessions. Fix it. | |
| packet.client_address = peer_address; | |
| GetEndpointId(&packet.endpoint_id); | |
| // Takes ownership of the packet. | |
| std::unique_ptr<QuicEncryptedPacket> reset_packet = BuildPublicReset(packet); | |
| QUIC_DVLOG(2) << "Dispatcher sending reset packet for " << connection_id | |
| << std::endl | |
| << quiche::QuicheTextUtils::HexDump(absl::string_view( | |
| reset_packet->data(), reset_packet->length())); | |
| SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address, | |
| std::move(reset_packet)), | |
| packet_context.get()); | |
| } | |
| void QuicTimeWaitListManager::SendPacket(const QuicSocketAddress& self_address, | |
| const QuicSocketAddress& peer_address, | |
| const QuicEncryptedPacket& packet) { | |
| SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address, | |
| packet.Clone()), | |
| nullptr); | |
| } | |
| std::unique_ptr<QuicEncryptedPacket> QuicTimeWaitListManager::BuildPublicReset( | |
| const QuicPublicResetPacket& packet) { | |
| return QuicFramer::BuildPublicResetPacket(packet); | |
| } | |
| std::unique_ptr<QuicEncryptedPacket> | |
| QuicTimeWaitListManager::BuildIetfStatelessResetPacket( | |
| QuicConnectionId connection_id, size_t received_packet_length) { | |
| return QuicFramer::BuildIetfStatelessResetPacket( | |
| connection_id, received_packet_length, | |
| GetStatelessResetToken(connection_id)); | |
| } | |
| // Either sends the packet and deletes it or makes pending queue the | |
| // owner of the packet. | |
| bool QuicTimeWaitListManager::SendOrQueuePacket( | |
| std::unique_ptr<QueuedPacket> packet, | |
| const QuicPerPacketContext* /*packet_context*/) { | |
| if (packet == nullptr) { | |
| QUIC_LOG(ERROR) << "Tried to send or queue a null packet"; | |
| return true; | |
| } | |
| if (pending_packets_queue_.size() >= | |
| GetQuicFlag(quic_time_wait_list_max_pending_packets)) { | |
| // There are too many pending packets. | |
| QUIC_CODE_COUNT(quic_too_many_pending_packets_in_time_wait); | |
| return true; | |
| } | |
| if (WriteToWire(packet.get())) { | |
| // Allow the packet to be deleted upon leaving this function. | |
| return true; | |
| } | |
| pending_packets_queue_.push_back(std::move(packet)); | |
| return false; | |
| } | |
| bool QuicTimeWaitListManager::WriteToWire(QueuedPacket* queued_packet) { | |
| if (writer_->IsWriteBlocked()) { | |
| visitor_->OnWriteBlocked(this); | |
| return false; | |
| } | |
| WriteResult result = writer_->WritePacket( | |
| queued_packet->packet()->data(), queued_packet->packet()->length(), | |
| queued_packet->self_address().host(), queued_packet->peer_address(), | |
| nullptr); | |
| // If using a batch writer and the packet is buffered, flush it. | |
| if (writer_->IsBatchMode() && result.status == WRITE_STATUS_OK && | |
| result.bytes_written == 0) { | |
| result = writer_->Flush(); | |
| } | |
| if (IsWriteBlockedStatus(result.status)) { | |
| // If blocked and unbuffered, return false to retry sending. | |
| QUICHE_DCHECK(writer_->IsWriteBlocked()); | |
| visitor_->OnWriteBlocked(this); | |
| return result.status == WRITE_STATUS_BLOCKED_DATA_BUFFERED; | |
| } else if (IsWriteError(result.status)) { | |
| QUIC_LOG_FIRST_N(WARNING, 1) | |
| << "Received unknown error while sending termination packet to " | |
| << queued_packet->peer_address().ToString() << ": " | |
| << strerror(result.error_code); | |
| } | |
| return true; | |
| } | |
| void QuicTimeWaitListManager::SetConnectionIdCleanUpAlarm() { | |
| QuicTime::Delta next_alarm_interval = QuicTime::Delta::Zero(); | |
| if (!connection_id_map_.empty()) { | |
| QuicTime oldest_connection_id = | |
| connection_id_map_.begin()->second.time_added; | |
| QuicTime now = clock_->ApproximateNow(); | |
| if (now - oldest_connection_id < time_wait_period_) { | |
| next_alarm_interval = oldest_connection_id + time_wait_period_ - now; | |
| } else { | |
| QUIC_LOG(ERROR) | |
| << "ConnectionId lingered for longer than time_wait_period_"; | |
| } | |
| } else { | |
| // No connection_ids added so none will expire before time_wait_period_. | |
| next_alarm_interval = time_wait_period_; | |
| } | |
| connection_id_clean_up_alarm_->Update( | |
| clock_->ApproximateNow() + next_alarm_interval, QuicTime::Delta::Zero()); | |
| } | |
| bool QuicTimeWaitListManager::MaybeExpireOldestConnection( | |
| QuicTime expiration_time) { | |
| if (connection_id_map_.empty()) { | |
| return false; | |
| } | |
| auto it = connection_id_map_.begin(); | |
| QuicTime oldest_connection_id_time = it->second.time_added; | |
| if (oldest_connection_id_time > expiration_time) { | |
| // Too recent, don't retire. | |
| return false; | |
| } | |
| // This connection_id has lived its age, retire it now. | |
| QUIC_DLOG(INFO) << "Connection " << it->first | |
| << " expired from time wait list"; | |
| RemoveConnectionDataFromMap(it); | |
| if (expiration_time == QuicTime::Infinite()) { | |
| QUIC_CODE_COUNT(quic_time_wait_list_trim_full); | |
| } else { | |
| QUIC_CODE_COUNT(quic_time_wait_list_expire_connections); | |
| } | |
| return true; | |
| } | |
| void QuicTimeWaitListManager::CleanUpOldConnectionIds() { | |
| QuicTime now = clock_->ApproximateNow(); | |
| QuicTime expiration = now - time_wait_period_; | |
| while (MaybeExpireOldestConnection(expiration)) { | |
| } | |
| SetConnectionIdCleanUpAlarm(); | |
| } | |
| void QuicTimeWaitListManager::TrimTimeWaitListIfNeeded() { | |
| const int64_t kMaxConnections = | |
| GetQuicFlag(quic_time_wait_list_max_connections); | |
| if (kMaxConnections < 0) { | |
| return; | |
| } | |
| while (!connection_id_map_.empty() && | |
| num_connections() >= static_cast<size_t>(kMaxConnections)) { | |
| MaybeExpireOldestConnection(QuicTime::Infinite()); | |
| } | |
| } | |
| QuicTimeWaitListManager::ConnectionIdData::ConnectionIdData( | |
| int num_packets, QuicTime time_added, TimeWaitAction action, | |
| TimeWaitConnectionInfo info) | |
| : num_packets(num_packets), | |
| time_added(time_added), | |
| action(action), | |
| info(std::move(info)) {} | |
| QuicTimeWaitListManager::ConnectionIdData::ConnectionIdData( | |
| ConnectionIdData&& other) = default; | |
| QuicTimeWaitListManager::ConnectionIdData::~ConnectionIdData() = default; | |
| StatelessResetToken QuicTimeWaitListManager::GetStatelessResetToken( | |
| QuicConnectionId connection_id) const { | |
| return QuicUtils::GenerateStatelessResetToken(connection_id); | |
| } | |
| } // namespace quic |