connection_id_manager.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "kcenon/network/detail/protocols/quic/connection_id.h"
#include "frame_types.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#include <array>
#include <cstdint>
#include <vector>
 
namespace kcenon::network::protocols::quic
{
 
// ============================================================================
// Connection ID Manager Error Codes
// ============================================================================
 
namespace cid_manager_error
{
    constexpr int duplicate_sequence = -740;
    constexpr int sequence_too_low = -741;
    constexpr int no_available_cid = -742;
    constexpr int cid_not_found = -743;
    constexpr int invalid_retire_prior_to = -744;
    constexpr int active_cid_limit_exceeded = -745;
} // namespace cid_manager_error
 
// ============================================================================
// Connection ID Entry
// ============================================================================
 
struct connection_id_entry
{
    connection_id cid;
    uint64_t sequence_number{0};
    std::array<uint8_t, 16> stateless_reset_token{};
    bool retired{false};
};
 
// ============================================================================
// Connection ID Manager
// ============================================================================
 
class connection_id_manager
{
public:
    explicit connection_id_manager(uint64_t active_cid_limit = 8);
 
    ~connection_id_manager() = default;
 
    // Non-copyable but movable
    connection_id_manager(const connection_id_manager&) = delete;
    auto operator=(const connection_id_manager&) -> connection_id_manager& = delete;
    connection_id_manager(connection_id_manager&&) = default;
    auto operator=(connection_id_manager&&) -> connection_id_manager& = default;
 
    // ========================================================================
    // Peer Connection ID Management
    // ========================================================================
 
    void set_initial_peer_cid(const connection_id& cid);
 
    [[nodiscard]] auto add_peer_cid(const connection_id& cid,
                                     uint64_t sequence,
                                     uint64_t retire_prior_to,
                                     const std::array<uint8_t, 16>& reset_token) -> VoidResult;
 
    [[nodiscard]] auto get_active_peer_cid() const -> const connection_id&;
 
    [[nodiscard]] auto rotate_peer_cid() -> VoidResult;
 
    [[nodiscard]] auto available_peer_cids() const -> size_t;
 
    [[nodiscard]] auto is_stateless_reset_token(
        const std::array<uint8_t, 16>& token) const -> bool;
 
    // ========================================================================
    // Retirement Management
    // ========================================================================
 
    void retire_cids_prior_to(uint64_t prior_to);
 
    [[nodiscard]] auto get_pending_retire_frames() -> std::vector<retire_connection_id_frame>;
 
    void clear_pending_retire_frames();
 
    [[nodiscard]] auto retire_peer_cid(uint64_t sequence) -> VoidResult;
 
    // ========================================================================
    // State Queries
    // ========================================================================
 
    [[nodiscard]] auto largest_retire_prior_to() const -> uint64_t
    {
        return largest_retire_prior_to_;
    }
 
    [[nodiscard]] auto peer_cid_count() const -> size_t { return peer_cids_.size(); }
 
    [[nodiscard]] auto active_cid_limit() const -> uint64_t { return active_cid_limit_; }
 
    void set_active_cid_limit(uint64_t limit) { active_cid_limit_ = limit; }
 
    [[nodiscard]] auto has_peer_cid(const connection_id& cid) const -> bool;
 
private:
    uint64_t active_cid_limit_;
 
    std::vector<connection_id_entry> peer_cids_;
 
    size_t active_index_{0};
 
    uint64_t largest_retire_prior_to_{0};
 
    std::vector<retire_connection_id_frame> pending_retire_frames_;
 
    static const connection_id empty_cid_;
 
    [[nodiscard]] auto find_by_sequence(uint64_t sequence)
        -> std::vector<connection_id_entry>::iterator;
 
    [[nodiscard]] auto count_active_cids() const -> size_t;
};
 
} // namespace kcenon::network::protocols::quic