frame.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 "frame_types.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#include <span>
#include <utility>
#include <vector>
 
namespace kcenon::network::protocols::quic
{
 
class frame_parser
{
public:
    [[nodiscard]] static auto parse(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_all(std::span<const uint8_t> data)
        -> Result<std::vector<frame>>;
 
    [[nodiscard]] static auto peek_type(std::span<const uint8_t> data)
        -> Result<std::pair<uint64_t, size_t>>;
 
private:
    // Individual frame parsers
    [[nodiscard]] static auto parse_padding(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_ping(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_ack(std::span<const uint8_t> data, bool has_ecn)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_reset_stream(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_stop_sending(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_crypto(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_new_token(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_stream(std::span<const uint8_t> data, uint8_t flags)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_max_data(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_max_stream_data(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_max_streams(std::span<const uint8_t> data, bool bidi)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_data_blocked(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_stream_data_blocked(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_streams_blocked(std::span<const uint8_t> data, bool bidi)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_new_connection_id(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_retire_connection_id(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_path_challenge(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_path_response(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_connection_close(std::span<const uint8_t> data,
                                                      bool is_app)
        -> Result<std::pair<frame, size_t>>;
 
    [[nodiscard]] static auto parse_handshake_done(std::span<const uint8_t> data)
        -> Result<std::pair<frame, size_t>>;
};
 
class frame_builder
{
public:
    [[nodiscard]] static auto build(const frame& f) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_padding(size_t count = 1) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_ping() -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_ack(const ack_frame& f) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_reset_stream(const reset_stream_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_stop_sending(const stop_sending_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_crypto(const crypto_frame& f) -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_new_token(const new_token_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_stream(const stream_frame& f,
                                            bool include_length = true)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_max_data(const max_data_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_max_stream_data(const max_stream_data_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_max_streams(const max_streams_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_data_blocked(const data_blocked_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_stream_data_blocked(const stream_data_blocked_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_streams_blocked(const streams_blocked_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_new_connection_id(const new_connection_id_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_retire_connection_id(const retire_connection_id_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_path_challenge(const path_challenge_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_path_response(const path_response_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_connection_close(const connection_close_frame& f)
        -> std::vector<uint8_t>;
 
    [[nodiscard]] static auto build_handshake_done() -> std::vector<uint8_t>;
 
private:
    // Helper to append varint-encoded value
    static void append_varint(std::vector<uint8_t>& buffer, uint64_t value);
 
    // Helper to append raw bytes
    static void append_bytes(std::vector<uint8_t>& buffer,
                             std::span<const uint8_t> data);
};
 
} // namespace kcenon::network::protocols::quic