Add PeerIssuedConnectionIdManager that handles NewConnectionId Frame.
PiperOrigin-RevId: 353019787
Change-Id: I6b9e38c357165759503e17be03599d696b4e44f5
diff --git a/quic/core/quic_connection_id_manager.cc b/quic/core/quic_connection_id_manager.cc
new file mode 100644
index 0000000..d4380b7
--- /dev/null
+++ b/quic/core/quic_connection_id_manager.cc
@@ -0,0 +1,207 @@
+// 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 "quic/core/quic_connection_id_manager.h"
+#include <cstdio>
+
+#include "quic/core/quic_clock.h"
+#include "quic/core/quic_connection_id.h"
+#include "quic/core/quic_error_codes.h"
+#include "quic/platform/api/quic_uint128.h"
+
+namespace quic {
+
+QuicConnectionIdData::QuicConnectionIdData(
+ const QuicConnectionId& connection_id,
+ uint64_t sequence_number,
+ QuicUint128 stateless_reset_token)
+ : connection_id(connection_id),
+ sequence_number(sequence_number),
+ stateless_reset_token(stateless_reset_token) {}
+
+namespace {
+
+class RetirePeerIssuedConnectionIdAlarm : public QuicAlarm::Delegate {
+ public:
+ explicit RetirePeerIssuedConnectionIdAlarm(
+ QuicConnectionIdManagerVisitorInterface* visitor)
+ : visitor_(visitor) {}
+ RetirePeerIssuedConnectionIdAlarm(const RetirePeerIssuedConnectionIdAlarm&) =
+ delete;
+ RetirePeerIssuedConnectionIdAlarm& operator=(
+ const RetirePeerIssuedConnectionIdAlarm&) = delete;
+
+ void OnAlarm() override { visitor_->OnPeerIssuedConnectionIdRetired(); }
+
+ private:
+ QuicConnectionIdManagerVisitorInterface* visitor_;
+};
+
+std::vector<QuicConnectionIdData>::const_iterator FindConnectionIdData(
+ const std::vector<QuicConnectionIdData>& cid_data_vector,
+ const QuicConnectionId& cid) {
+ return std::find_if(cid_data_vector.begin(), cid_data_vector.end(),
+ [&cid](const QuicConnectionIdData& cid_data) {
+ return cid == cid_data.connection_id;
+ });
+}
+
+} // namespace
+
+QuicPeerIssuedConnectionIdManager::QuicPeerIssuedConnectionIdManager(
+ size_t active_connection_id_limit,
+ const QuicConnectionId& initial_peer_issued_connection_id,
+ const QuicClock* clock,
+ QuicAlarmFactory* alarm_factory,
+ QuicConnectionIdManagerVisitorInterface* visitor)
+ : active_connection_id_limit_(active_connection_id_limit),
+ clock_(clock),
+ retire_connection_id_alarm_(alarm_factory->CreateAlarm(
+ new RetirePeerIssuedConnectionIdAlarm(visitor))) {
+ DCHECK(!initial_peer_issued_connection_id.IsEmpty());
+ active_connection_id_data_.emplace_back(initial_peer_issued_connection_id,
+ /*sequence_number=*/0u,
+ QuicUint128());
+ recent_new_connection_id_sequence_numbers_.Add(0u, 1u);
+}
+
+QuicPeerIssuedConnectionIdManager::~QuicPeerIssuedConnectionIdManager() {
+ retire_connection_id_alarm_->Cancel();
+}
+
+bool QuicPeerIssuedConnectionIdManager::IsConnectionIdNew(
+ const QuicNewConnectionIdFrame& frame) {
+ auto is_old_connection_id = [&frame](const QuicConnectionIdData& cid_data) {
+ return cid_data.connection_id == frame.connection_id;
+ };
+ if (std::any_of(active_connection_id_data_.begin(),
+ active_connection_id_data_.end(), is_old_connection_id)) {
+ return false;
+ }
+ if (std::any_of(unused_connection_id_data_.begin(),
+ unused_connection_id_data_.end(), is_old_connection_id)) {
+ return false;
+ }
+ if (std::any_of(to_be_retired_connection_id_data_.begin(),
+ to_be_retired_connection_id_data_.end(),
+ is_old_connection_id)) {
+ return false;
+ }
+ return true;
+}
+
+void QuicPeerIssuedConnectionIdManager::PrepareToRetireConnectionIdPriorTo(
+ uint64_t retire_prior_to,
+ std::vector<QuicConnectionIdData>* cid_data_vector) {
+ auto it2 = cid_data_vector->begin();
+ for (auto it = cid_data_vector->begin(); it != cid_data_vector->end(); ++it) {
+ if (it->sequence_number >= retire_prior_to) {
+ *it2++ = *it;
+ } else {
+ to_be_retired_connection_id_data_.push_back(*it);
+ if (!retire_connection_id_alarm_->IsSet()) {
+ retire_connection_id_alarm_->Set(clock_->ApproximateNow());
+ }
+ }
+ }
+ cid_data_vector->erase(it2, cid_data_vector->end());
+}
+
+QuicErrorCode QuicPeerIssuedConnectionIdManager::OnNewConnectionIdFrame(
+ const QuicNewConnectionIdFrame& frame,
+ std::string* error_detail) {
+ if (recent_new_connection_id_sequence_numbers_.Contains(
+ frame.sequence_number)) {
+ // This frame has a recently seen sequence number. Ignore.
+ return QUIC_NO_ERROR;
+ }
+ if (!IsConnectionIdNew(frame)) {
+ *error_detail =
+ "Received a NEW_CONNECTION_ID frame that reuses a previously seen Id.";
+ return IETF_QUIC_PROTOCOL_VIOLATION;
+ }
+
+ recent_new_connection_id_sequence_numbers_.AddOptimizedForAppend(
+ frame.sequence_number, frame.sequence_number + 1);
+
+ if (recent_new_connection_id_sequence_numbers_.Size() >
+ kMaxNumConnectionIdSequenceNumberIntervals) {
+ *error_detail =
+ "Too many disjoint connection Id sequence number intervals.";
+ return IETF_QUIC_PROTOCOL_VIOLATION;
+ }
+
+ // QuicFramer::ProcessNewConnectionIdFrame guarantees that
+ // frame.sequence_number >= frame.retire_prior_to, and hence there is no need
+ // to check that.
+ if (frame.sequence_number < max_new_connection_id_frame_retire_prior_to_) {
+ // Later frames have asked for retirement of the current frame.
+ to_be_retired_connection_id_data_.emplace_back(frame.connection_id,
+ frame.sequence_number,
+ frame.stateless_reset_token);
+ if (!retire_connection_id_alarm_->IsSet()) {
+ retire_connection_id_alarm_->Set(clock_->ApproximateNow());
+ }
+ return QUIC_NO_ERROR;
+ }
+ if (frame.retire_prior_to > max_new_connection_id_frame_retire_prior_to_) {
+ max_new_connection_id_frame_retire_prior_to_ = frame.retire_prior_to;
+ PrepareToRetireConnectionIdPriorTo(frame.retire_prior_to,
+ &active_connection_id_data_);
+ PrepareToRetireConnectionIdPriorTo(frame.retire_prior_to,
+ &unused_connection_id_data_);
+ }
+
+ if (active_connection_id_data_.size() + unused_connection_id_data_.size() >=
+ active_connection_id_limit_) {
+ *error_detail = "Peer provides more connection IDs than the limit.";
+ return QUIC_CONNECTION_ID_LIMIT_ERROR;
+ }
+
+ unused_connection_id_data_.emplace_back(
+ frame.connection_id, frame.sequence_number, frame.stateless_reset_token);
+ return QUIC_NO_ERROR;
+}
+
+const QuicConnectionIdData*
+QuicPeerIssuedConnectionIdManager::ConsumeOneUnusedConnectionId() {
+ if (unused_connection_id_data_.empty()) {
+ return nullptr;
+ }
+ active_connection_id_data_.push_back(unused_connection_id_data_.back());
+ unused_connection_id_data_.pop_back();
+ return &active_connection_id_data_.back();
+}
+
+void QuicPeerIssuedConnectionIdManager::PrepareToRetireActiveConnectionId(
+ const QuicConnectionId& cid) {
+ auto it = FindConnectionIdData(active_connection_id_data_, cid);
+ if (it == active_connection_id_data_.end()) {
+ // The cid has already been retired.
+ return;
+ }
+ to_be_retired_connection_id_data_.push_back(*it);
+ active_connection_id_data_.erase(it);
+ if (!retire_connection_id_alarm_->IsSet()) {
+ retire_connection_id_alarm_->Set(clock_->ApproximateNow());
+ }
+}
+
+bool QuicPeerIssuedConnectionIdManager::IsConnectionIdActive(
+ const QuicConnectionId& cid) const {
+ return FindConnectionIdData(active_connection_id_data_, cid) !=
+ active_connection_id_data_.end();
+}
+
+std::vector<uint64_t> QuicPeerIssuedConnectionIdManager::
+ ConsumeToBeRetiredConnectionIdSequenceNumbers() {
+ std::vector<uint64_t> result;
+ for (auto const& cid_data : to_be_retired_connection_id_data_) {
+ result.push_back(cid_data.sequence_number);
+ }
+ to_be_retired_connection_id_data_.clear();
+ return result;
+}
+
+} // namespace quic
diff --git a/quic/core/quic_connection_id_manager.h b/quic/core/quic_connection_id_manager.h
new file mode 100644
index 0000000..1977740
--- /dev/null
+++ b/quic/core/quic_connection_id_manager.h
@@ -0,0 +1,96 @@
+// 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.
+
+// QuicPeerIssuedConnectionIdManager handles the states associated with receving
+// and retiring peer issued connection Ids.
+// TODO(haoyuewang) Implements QuicSelfIssuedConnectionIdManager.
+// QuicConnectionIdManager handles the states associated with connection Ids
+// issued by the current end point.
+
+#ifndef QUICHE_QUIC_CORE_QUIC_CONNECTION_ID_MANAGER_H_
+#define QUICHE_QUIC_CORE_QUIC_CONNECTION_ID_MANAGER_H_
+
+#include <memory>
+#include "quic/core/frames/quic_new_connection_id_frame.h"
+#include "quic/core/quic_alarm.h"
+#include "quic/core/quic_alarm_factory.h"
+#include "quic/core/quic_connection_id.h"
+#include "quic/core/quic_interval_set.h"
+#include "quic/platform/api/quic_uint128.h"
+#include "net/quic/platform/impl/quic_export_impl.h"
+
+namespace quic {
+
+struct QUIC_EXPORT_PRIVATE QuicConnectionIdData {
+ QuicConnectionIdData(const QuicConnectionId& connection_id,
+ uint64_t sequence_number,
+ QuicUint128 stateless_reset_token);
+
+ QuicConnectionId connection_id;
+ uint64_t sequence_number;
+ QuicUint128 stateless_reset_token;
+};
+
+// Used by QuicSelfIssuedConnectionIdManager
+// and QuicPeerIssuedConnectionIdManager.
+class QUIC_EXPORT_PRIVATE QuicConnectionIdManagerVisitorInterface {
+ public:
+ virtual ~QuicConnectionIdManagerVisitorInterface() = default;
+ virtual void OnPeerIssuedConnectionIdRetired() = 0;
+};
+
+class QUIC_EXPORT_PRIVATE QuicPeerIssuedConnectionIdManager {
+ public:
+ // QuicPeerIssuedConnectionIdManager should be instantiated only when a peer
+ // issued-non empty connection ID is received.
+ QuicPeerIssuedConnectionIdManager(
+ size_t active_connection_id_limit,
+ const QuicConnectionId& initial_peer_issued_connection_id,
+ const QuicClock* clock,
+ QuicAlarmFactory* alarm_factory,
+ QuicConnectionIdManagerVisitorInterface* visitor);
+
+ ~QuicPeerIssuedConnectionIdManager();
+
+ QuicErrorCode OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame,
+ std::string* error_detail);
+
+ // Returns the data associated with an unused connection Id. After the call,
+ // the Id is marked as used. Returns nullptr if there is no unused connection
+ // Id.
+ const QuicConnectionIdData* ConsumeOneUnusedConnectionId();
+
+ // Add the connection Id to the pending retirement connection Id list.
+ void PrepareToRetireActiveConnectionId(const QuicConnectionId& cid);
+
+ bool IsConnectionIdActive(const QuicConnectionId& cid) const;
+
+ // Get the sequence numbers of all the connection Ids pending retirement when
+ // it is safe to retires these Ids.
+ std::vector<uint64_t> ConsumeToBeRetiredConnectionIdSequenceNumbers();
+
+ private:
+ friend class QuicConnectionIdManagerPeer;
+
+ bool IsConnectionIdNew(const QuicNewConnectionIdFrame& frame);
+
+ void PrepareToRetireConnectionIdPriorTo(
+ uint64_t retire_prior_to,
+ std::vector<QuicConnectionIdData>* cid_data_vector);
+
+ size_t active_connection_id_limit_;
+ const QuicClock* clock_;
+ std::unique_ptr<QuicAlarm> retire_connection_id_alarm_;
+ std::vector<QuicConnectionIdData> active_connection_id_data_;
+ std::vector<QuicConnectionIdData> unused_connection_id_data_;
+ std::vector<QuicConnectionIdData> to_be_retired_connection_id_data_;
+ // Track sequence numbers of recent NEW_CONNECTION_ID frames received from
+ // the peer.
+ QuicIntervalSet<uint64_t> recent_new_connection_id_sequence_numbers_;
+ uint64_t max_new_connection_id_frame_retire_prior_to_ = 0u;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_CORE_QUIC_CONNECTION_ID_MANAGER_H_
diff --git a/quic/core/quic_connection_id_manager_test.cc b/quic/core/quic_connection_id_manager_test.cc
new file mode 100644
index 0000000..47d3dea
--- /dev/null
+++ b/quic/core/quic_connection_id_manager_test.cc
@@ -0,0 +1,505 @@
+// Copyright 2013 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 "quic/core/quic_connection_id_manager.h"
+#include <cstddef>
+
+#include "quic/core/quic_connection_id.h"
+#include "quic/core/quic_error_codes.h"
+#include "quic/platform/api/quic_test.h"
+#include "quic/test_tools/mock_clock.h"
+#include "quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+
+class QuicConnectionIdManagerPeer {
+ public:
+ static QuicAlarm* GetRetirePeerIssuedConnectionIdAlarm(
+ QuicPeerIssuedConnectionIdManager* manager) {
+ return manager->retire_connection_id_alarm_.get();
+ }
+};
+
+namespace {
+
+using ::quic::test::IsError;
+using ::quic::test::IsQuicNoError;
+using ::quic::test::TestConnectionId;
+using ::testing::ElementsAre;
+using ::testing::IsNull;
+
+class TestPeerIssuedConnectionIdManagerVisitor
+ : public QuicConnectionIdManagerVisitorInterface {
+ public:
+ void SetPeerIssuedConnectionIdManager(
+ QuicPeerIssuedConnectionIdManager* peer_issued_connection_id_manager) {
+ peer_issued_connection_id_manager_ = peer_issued_connection_id_manager;
+ }
+
+ void OnPeerIssuedConnectionIdRetired() override {
+ // Replace current connection Id if it has been retired.
+ if (!peer_issued_connection_id_manager_->IsConnectionIdActive(
+ current_peer_issued_connection_id_)) {
+ current_peer_issued_connection_id_ =
+ peer_issued_connection_id_manager_->ConsumeOneUnusedConnectionId()
+ ->connection_id;
+ }
+ // Retire all the to-be-retired connection Ids.
+ most_recent_retired_connection_id_sequence_numbers_ =
+ peer_issued_connection_id_manager_
+ ->ConsumeToBeRetiredConnectionIdSequenceNumbers();
+ }
+
+ const std::vector<uint64_t>&
+ most_recent_retired_connection_id_sequence_numbers() {
+ return most_recent_retired_connection_id_sequence_numbers_;
+ }
+
+ void SetCurrentPeerConnectionId(QuicConnectionId cid) {
+ current_peer_issued_connection_id_ = cid;
+ }
+
+ const QuicConnectionId& GetCurrentPeerConnectionId() {
+ return current_peer_issued_connection_id_;
+ }
+
+ private:
+ QuicPeerIssuedConnectionIdManager* peer_issued_connection_id_manager_ =
+ nullptr;
+ QuicConnectionId current_peer_issued_connection_id_;
+ std::vector<uint64_t> most_recent_retired_connection_id_sequence_numbers_;
+};
+
+class QuicPeerIssuedConnectionIdManagerTest : public QuicTest {
+ public:
+ QuicPeerIssuedConnectionIdManagerTest()
+ : peer_issued_cid_manager_(/*active_connection_id_limit=*/2,
+ initial_connection_id,
+ &clock_,
+ &alarm_factory_,
+ &cid_manager_visitor_) {
+ clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
+ cid_manager_visitor_.SetPeerIssuedConnectionIdManager(
+ &peer_issued_cid_manager_);
+ cid_manager_visitor_.SetCurrentPeerConnectionId(initial_connection_id);
+ retire_peer_issued_cid_alarm_ =
+ QuicConnectionIdManagerPeer::GetRetirePeerIssuedConnectionIdAlarm(
+ &peer_issued_cid_manager_);
+ }
+
+ protected:
+ MockClock clock_;
+ test::MockAlarmFactory alarm_factory_;
+ TestPeerIssuedConnectionIdManagerVisitor cid_manager_visitor_;
+ QuicConnectionId initial_connection_id = TestConnectionId(0);
+ QuicPeerIssuedConnectionIdManager peer_issued_cid_manager_;
+ QuicAlarm* retire_peer_issued_cid_alarm_ = nullptr;
+ std::string error_details_;
+};
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ ConnectionIdSequenceWhenMigrationSucceed) {
+ {
+ // Receives CID #1 from peer.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+
+ // Start to use CID #1 for alternative path.
+ const QuicConnectionIdData* aternative_connection_id_data =
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ ASSERT_THAT(aternative_connection_id_data, testing::NotNull());
+ EXPECT_EQ(aternative_connection_id_data->connection_id,
+ TestConnectionId(1));
+ EXPECT_EQ(aternative_connection_id_data->stateless_reset_token,
+ frame.stateless_reset_token);
+
+ // Connection migration succeed. Prepares to retire CID #0.
+ peer_issued_cid_manager_.PrepareToRetireActiveConnectionId(
+ TestConnectionId(0));
+ cid_manager_visitor_.SetCurrentPeerConnectionId(TestConnectionId(1));
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(cid_manager_visitor_
+ .most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(0u));
+ }
+
+ {
+ // Receives CID #2 from peer since CID #0 is retired.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(2);
+ frame.sequence_number = 2u;
+ frame.retire_prior_to = 1u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ // Start to use CID #2 for alternative path.
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ // Connection migration succeed. Prepares to retire CID #1.
+ peer_issued_cid_manager_.PrepareToRetireActiveConnectionId(
+ TestConnectionId(1));
+ cid_manager_visitor_.SetCurrentPeerConnectionId(TestConnectionId(2));
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(cid_manager_visitor_
+ .most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(1u));
+ }
+
+ {
+ // Receives CID #3 from peer since CID #1 is retired.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(3);
+ frame.sequence_number = 3u;
+ frame.retire_prior_to = 2u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ // Start to use CID #3 for alternative path.
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ // Connection migration succeed. Prepares to retire CID #2.
+ peer_issued_cid_manager_.PrepareToRetireActiveConnectionId(
+ TestConnectionId(2));
+ cid_manager_visitor_.SetCurrentPeerConnectionId(TestConnectionId(3));
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(cid_manager_visitor_
+ .most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(2u));
+ }
+
+ {
+ // Receives CID #4 from peer since CID #2 is retired.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(4);
+ frame.sequence_number = 4u;
+ frame.retire_prior_to = 3u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ }
+}
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ ConnectionIdSequenceWhenMigrationFail) {
+ {
+ // Receives CID #1 from peer.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ // Start to use CID #1 for alternative path.
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ // Connection migration fails. Prepares to retire CID #1.
+ peer_issued_cid_manager_.PrepareToRetireActiveConnectionId(
+ TestConnectionId(1));
+ // Actually retires CID #1.
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(cid_manager_visitor_
+ .most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(1u));
+ }
+
+ {
+ // Receives CID #2 from peer since CID #1 is retired.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(2);
+ frame.sequence_number = 2u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ // Start to use CID #2 for alternative path.
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ // Connection migration fails again. Prepares to retire CID #2.
+ peer_issued_cid_manager_.PrepareToRetireActiveConnectionId(
+ TestConnectionId(2));
+ // Actually retires CID #2.
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(cid_manager_visitor_
+ .most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(2u));
+ }
+
+ {
+ // Receives CID #3 from peer since CID #2 is retired.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(3);
+ frame.sequence_number = 3u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ // Start to use CID #3 for alternative path.
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ // Connection migration succeed. Prepares to retire CID #0.
+ peer_issued_cid_manager_.PrepareToRetireActiveConnectionId(
+ TestConnectionId(0));
+ // After CID #3 is default (i.e., when there is no pending frame to write
+ // associated with CID #0), #0 can actually be retired.
+ cid_manager_visitor_.SetCurrentPeerConnectionId(TestConnectionId(3));
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(cid_manager_visitor_
+ .most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(0u));
+ }
+
+ {
+ // Receives CID #4 from peer since CID #0 is retired.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(4);
+ frame.sequence_number = 4u;
+ frame.retire_prior_to = 3u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ EXPECT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ EXPECT_FALSE(retire_peer_issued_cid_alarm_->IsSet());
+ }
+}
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ ReceivesNewConnectionIdOutOfOrder) {
+ {
+ // Receives new CID #1 that retires prior to #0.
+ // Outcome: (active: #0 unused: #1)
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ // Start to use CID #1 for alternative path.
+ // Outcome: (active: #0 #1 unused: None)
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ }
+
+ {
+ // Receives new CID #3 that retires prior to #2.
+ // Outcome: (active: None unused: #3)
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(3);
+ frame.sequence_number = 3u;
+ frame.retire_prior_to = 2u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ }
+
+ {
+ // Receives new CID #2 that retires prior to #1.
+ // Outcome: (active: None unused: #3, #2)
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(2);
+ frame.sequence_number = 2u;
+ frame.retire_prior_to = 1u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ }
+
+ {
+ EXPECT_FALSE(
+ peer_issued_cid_manager_.IsConnectionIdActive(TestConnectionId(0)));
+ EXPECT_FALSE(
+ peer_issued_cid_manager_.IsConnectionIdActive(TestConnectionId(1)));
+ // When there is no frame associated with #0 and #1 to write, replace the
+ // in-use CID with an unused CID (#2) and retires #0 & #1.
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(cid_manager_visitor_
+ .most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(0u, 1u));
+ EXPECT_EQ(cid_manager_visitor_.GetCurrentPeerConnectionId(),
+ TestConnectionId(2));
+ // Get another unused CID for path validation.
+ EXPECT_EQ(
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId()->connection_id,
+ TestConnectionId(3));
+ }
+}
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ VisitedNewConnectionIdFrameIsIgnored) {
+ // Receives new CID #1 that retires prior to #0.
+ // Outcome: (active: #0 unused: #1)
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ // Start to use CID #1 for alternative path.
+ // Outcome: (active: #0 #1 unused: None)
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId();
+ // Prepare to retire CID #1 as path validation fails.
+ peer_issued_cid_manager_.PrepareToRetireActiveConnectionId(
+ TestConnectionId(1));
+ // Actually retires CID #1.
+ ASSERT_TRUE(retire_peer_issued_cid_alarm_->IsSet());
+ alarm_factory_.FireAlarm(retire_peer_issued_cid_alarm_);
+ EXPECT_THAT(
+ cid_manager_visitor_.most_recent_retired_connection_id_sequence_numbers(),
+ ElementsAre(1u));
+ // Receives the same frame again. Should be a no-op.
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ EXPECT_THAT(peer_issued_cid_manager_.ConsumeOneUnusedConnectionId(),
+ testing::IsNull());
+}
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ ErrorWhenActiveConnectionIdLimitExceeded) {
+ {
+ // Receives new CID #1 that retires prior to #0.
+ // Outcome: (active: #0 unused: #1)
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ }
+
+ {
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(2);
+ frame.sequence_number = 2u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsError(QUIC_CONNECTION_ID_LIMIT_ERROR));
+ }
+}
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ ErrorWhenTheSameConnectionIdIsSeenWithDifferentSequenceNumbers) {
+ {
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ }
+
+ {
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 2u;
+ frame.retire_prior_to = 1u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(TestConnectionId(2));
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsError(IETF_QUIC_PROTOCOL_VIOLATION));
+ }
+}
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ NewConnectionIdFrameWithTheSameSequenceNumberIsIgnored) {
+ {
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(1);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ }
+
+ {
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(2);
+ frame.sequence_number = 1u;
+ frame.retire_prior_to = 0u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(TestConnectionId(2));
+ EXPECT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ EXPECT_EQ(
+ peer_issued_cid_manager_.ConsumeOneUnusedConnectionId()->connection_id,
+ TestConnectionId(1));
+ EXPECT_THAT(peer_issued_cid_manager_.ConsumeOneUnusedConnectionId(),
+ IsNull());
+ }
+}
+
+TEST_F(QuicPeerIssuedConnectionIdManagerTest,
+ ErrorWhenThereAreTooManyGapsInIssuedConnectionIdSequenceNumbers) {
+ // Add 20 intervals: [0, 1), [2, 3), ..., [38,39)
+ for (int i = 2; i <= 38; i += 2) {
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(i);
+ frame.sequence_number = i;
+ frame.retire_prior_to = i;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsQuicNoError());
+ }
+
+ // Interval [40, 41) goes over the limit.
+ QuicNewConnectionIdFrame frame;
+ frame.connection_id = TestConnectionId(40);
+ frame.sequence_number = 40u;
+ frame.retire_prior_to = 40u;
+ frame.stateless_reset_token =
+ QuicUtils::GenerateStatelessResetToken(frame.connection_id);
+ ASSERT_THAT(
+ peer_issued_cid_manager_.OnNewConnectionIdFrame(frame, &error_details_),
+ IsError(IETF_QUIC_PROTOCOL_VIOLATION));
+}
+
+} // namespace
+} // namespace quic
diff --git a/quic/core/quic_constants.h b/quic/core/quic_constants.h
index a2ead36..619ed32 100644
--- a/quic/core/quic_constants.h
+++ b/quic/core/quic_constants.h
@@ -209,6 +209,10 @@
// This will likely have to be tuned.
const QuicPacketCount kMaxPacketGap = 5000;
+// The max number of sequence number intervals that
+// QuicPeerIssuedConnetionIdManager can maintain.
+const size_t kMaxNumConnectionIdSequenceNumberIntervals = 20;
+
// The maximum number of random padding bytes to add.
const QuicByteCount kMaxNumRandomPaddingBytes = 256;
diff --git a/quic/core/quic_error_codes.cc b/quic/core/quic_error_codes.cc
index 8363dc1..9d7d610 100644
--- a/quic/core/quic_error_codes.cc
+++ b/quic/core/quic_error_codes.cc
@@ -167,6 +167,7 @@
RETURN_STRING_LITERAL(QUIC_STREAMS_BLOCKED_DATA);
RETURN_STRING_LITERAL(QUIC_INVALID_NEW_CONNECTION_ID_DATA);
RETURN_STRING_LITERAL(QUIC_INVALID_RETIRE_CONNECTION_ID_DATA);
+ RETURN_STRING_LITERAL(QUIC_CONNECTION_ID_LIMIT_ERROR);
RETURN_STRING_LITERAL(QUIC_INVALID_STOP_SENDING_FRAME_DATA);
RETURN_STRING_LITERAL(QUIC_INVALID_PATH_CHALLENGE_DATA);
RETURN_STRING_LITERAL(QUIC_INVALID_PATH_RESPONSE_DATA);
@@ -758,7 +759,8 @@
case QUIC_TLS_CERTIFICATE_REQUIRED:
return {true, static_cast<uint64_t>(CRYPTO_ERROR_FIRST +
SSL_AD_CERTIFICATE_REQUIRED)};
-
+ case QUIC_CONNECTION_ID_LIMIT_ERROR:
+ return {true, static_cast<uint64_t>(CONNECTION_ID_LIMIT_ERROR)};
case QUIC_LAST_ERROR:
return {false, static_cast<uint64_t>(QUIC_LAST_ERROR)};
}
diff --git a/quic/core/quic_error_codes.h b/quic/core/quic_error_codes.h
index 885e088..737c1ef 100644
--- a/quic/core/quic_error_codes.h
+++ b/quic/core/quic_error_codes.h
@@ -348,6 +348,8 @@
QUIC_INVALID_STREAM_BLOCKED_DATA = 106,
// NEW CONNECTION ID frame data is malformed.
QUIC_INVALID_NEW_CONNECTION_ID_DATA = 107,
+ // More connection IDs than allowed are issued.
+ QUIC_CONNECTION_ID_LIMIT_ERROR = 203,
// Received a MAX STREAM DATA frame with errors.
QUIC_INVALID_STOP_SENDING_FRAME_DATA = 108,
// Error deframing PATH CHALLENGE or PATH RESPONSE frames.
@@ -584,7 +586,7 @@
QUIC_TLS_CERTIFICATE_REQUIRED = 202,
// No error. Used as bound while iterating.
- QUIC_LAST_ERROR = 203,
+ QUIC_LAST_ERROR = 204,
};
// QuicErrorCodes is encoded as four octets on-the-wire when doing Google QUIC,
// or a varint62 when doing IETF QUIC. Ensure that its value does not exceed
