blob: d4799738cccb90b8f35f0dd1118a9170ff3b6d27 [file] [log] [blame]
// 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