packet.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 "kcenon/network/detail/utils/result_types.h"
 
#include <cstdint>
#include <span>
#include <utility>
#include <variant>
#include <vector>
 
namespace kcenon::network::protocols::quic
{
 
// ============================================================================
// QUIC Versions
// ============================================================================
 
namespace quic_version
{
    constexpr uint32_t version_1 = 0x00000001;
 
    constexpr uint32_t version_2 = 0x6b3343cf;
 
    constexpr uint32_t negotiation = 0x00000000;
} // namespace quic_version
 
// ============================================================================
// Packet Types
// ============================================================================
 
enum class packet_type : uint8_t
{
    initial = 0x00,
    zero_rtt = 0x01,
    handshake = 0x02,
    retry = 0x03,
    one_rtt = 0xFF,  // Special marker for short header packets
};
 
[[nodiscard]] auto packet_type_to_string(packet_type type) -> std::string;
 
// ============================================================================
// Header Structures
// ============================================================================
 
struct long_header
{
    uint8_t first_byte{0};           
    uint32_t version{0};             
    connection_id dest_conn_id;      
    connection_id src_conn_id;       
 
    // Type-specific fields
    std::vector<uint8_t> token;      
    uint64_t packet_number{0};       
    size_t packet_number_length{0};  
 
    std::array<uint8_t, 16> retry_integrity_tag{};
 
    [[nodiscard]] auto type() const noexcept -> packet_type;
 
    [[nodiscard]] auto is_retry() const noexcept -> bool;
};
 
struct short_header
{
    uint8_t first_byte{0};           
    connection_id dest_conn_id;      
    uint64_t packet_number{0};       
    size_t packet_number_length{0};  
 
    [[nodiscard]] auto spin_bit() const noexcept -> bool;
 
    [[nodiscard]] auto key_phase() const noexcept -> bool;
};
 
using packet_header = std::variant<long_header, short_header>;
 
// ============================================================================
// Packet Number Encoding
// ============================================================================
 
class packet_number
{
public:
    [[nodiscard]] static auto encode(uint64_t full_pn, uint64_t largest_acked)
        -> std::pair<std::vector<uint8_t>, size_t>;
 
    [[nodiscard]] static auto decode(uint64_t truncated_pn, size_t pn_length,
                                      uint64_t largest_pn) noexcept -> uint64_t;
 
    [[nodiscard]] static auto encoded_length(uint64_t full_pn,
                                              uint64_t largest_acked) noexcept -> size_t;
};
 
// ============================================================================
// Packet Parser
// ============================================================================
 
class packet_parser
{
public:
    [[nodiscard]] static constexpr auto is_long_header(uint8_t first_byte) noexcept -> bool
    {
        return (first_byte & 0x80) != 0;
    }
 
    [[nodiscard]] static constexpr auto has_valid_fixed_bit(uint8_t first_byte) noexcept -> bool
    {
        return (first_byte & 0x40) != 0;
    }
 
    [[nodiscard]] static auto parse_header(std::span<const uint8_t> data)
        -> Result<std::pair<packet_header, size_t>>;
 
    [[nodiscard]] static auto parse_long_header(std::span<const uint8_t> data)
        -> Result<std::pair<long_header, size_t>>;
 
    [[nodiscard]] static auto parse_short_header(std::span<const uint8_t> data,
                                                  size_t conn_id_length)
        -> Result<std::pair<short_header, size_t>>;
 
    [[nodiscard]] static constexpr auto get_long_packet_type(uint8_t first_byte) noexcept
        -> packet_type
    {
        return static_cast<packet_type>((first_byte >> 4) & 0x03);
    }
 
    [[nodiscard]] static auto is_version_negotiation(std::span<const uint8_t> data) noexcept
        -> bool;
};
 
// ============================================================================
// Packet Builder
// ============================================================================
 
class packet_builder
{
public:
    [[nodiscard]] static auto build_initial(
        const connection_id& dest_cid,
        const connection_id& src_cid,
        const std::vector<uint8_t>& token,
        uint64_t packet_number,
        uint32_t version = quic_version::version_1) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_handshake(
        const connection_id& dest_cid,
        const connection_id& src_cid,
        uint64_t packet_number,
        uint32_t version = quic_version::version_1) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_zero_rtt(
        const connection_id& dest_cid,
        const connection_id& src_cid,
        uint64_t packet_number,
        uint32_t version = quic_version::version_1) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_retry(
        const connection_id& dest_cid,
        const connection_id& src_cid,
        const std::vector<uint8_t>& token,
        const std::array<uint8_t, 16>& integrity_tag,
        uint32_t version = quic_version::version_1) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_short(
        const connection_id& dest_cid,
        uint64_t packet_number,
        bool key_phase = false,
        bool spin_bit = false) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build(const long_header& header) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build(const short_header& header) -> std::vector<uint8_t>;
 
private:
    static void append_bytes(std::vector<uint8_t>& buffer,
                             std::span<const uint8_t> data);
};
 
} // namespace kcenon::network::protocols::quic