kcenon::network::protocols::quic::stream Class Reference

QUIC stream implementation (RFC 9000 Sections 2-4) More...

#include <stream.h>

Collaboration diagram for kcenon::network::protocols::quic::stream:

Public Member Functions
	stream (uint64_t id, bool is_local, uint64_t initial_max_data=65536)
	Construct a stream.
	~stream ()=default
	stream (const stream &)=delete
auto	operator= (const stream &) -> stream &=delete
	stream (stream &&) noexcept=default
auto	operator= (stream &&) noexcept -> stream &=default
auto	id () const noexcept -> uint64_t
	Get stream identifier.
auto	is_local () const noexcept -> bool
	Check if stream is locally initiated.
auto	is_unidirectional () const noexcept -> bool
	Check if stream is unidirectional.
auto	is_bidirectional () const noexcept -> bool
	Check if stream is bidirectional.
auto	send_state () const noexcept -> send_stream_state
	Get send state.
auto	can_send () const noexcept -> bool
	Check if stream can send data.
auto	write (std::span< const uint8_t > data) -> Result< size_t >
	Write data to stream.
auto	finish () -> VoidResult
	Mark stream as finished (send FIN)
auto	reset (uint64_t error_code) -> VoidResult
	Reset the stream with error code.
auto	fin_sent () const noexcept -> bool
	Check if FIN has been sent.
auto	pending_bytes () const noexcept -> size_t
	Get number of bytes pending to send.
auto	next_stream_frame (size_t max_size) -> std::optional< stream_frame >
	Get next STREAM frame to send.
void	acknowledge_data (uint64_t offset, uint64_t length)
	Acknowledge sent data.
auto	recv_state () const noexcept -> recv_stream_state
	Get receive state.
auto	has_data () const noexcept -> bool
	Check if stream has data to read.
auto	read (std::span< uint8_t > buffer) -> Result< size_t >
	Read data from stream.
auto	is_fin_received () const noexcept -> bool
	Check if all data has been received.
auto	stop_sending (uint64_t error_code) -> VoidResult
	Signal that incoming data is no longer wanted.
auto	receive_data (uint64_t offset, std::span< const uint8_t > data, bool fin) -> VoidResult
	Receive STREAM frame data.
auto	receive_reset (uint64_t error_code, uint64_t final_size) -> VoidResult
	Handle received RESET_STREAM frame.
auto	receive_stop_sending (uint64_t error_code) -> VoidResult
	Handle received STOP_SENDING frame.
void	set_max_send_data (uint64_t max)
	Set peer's MAX_STREAM_DATA (our send limit)
auto	max_send_data () const noexcept -> uint64_t
	Get peer's MAX_STREAM_DATA.
auto	available_send_window () const noexcept -> size_t
	Get available send window.
void	set_max_recv_data (uint64_t max)
	Update our MAX_STREAM_DATA (peer's send limit)
auto	max_recv_data () const noexcept -> uint64_t
	Get our MAX_STREAM_DATA.
auto	bytes_consumed () const noexcept -> uint64_t
	Get bytes consumed from receive buffer.
auto	should_send_max_stream_data () const noexcept -> bool
	Check if MAX_STREAM_DATA frame should be sent.
auto	generate_max_stream_data () -> std::optional< uint64_t >
	Generate MAX_STREAM_DATA frame if needed.
auto	reset_error_code () const noexcept -> std::optional< uint64_t >
	Get reset error code (if stream was reset)
auto	stop_sending_error_code () const noexcept -> std::optional< uint64_t >
	Get stop sending error code (if STOP_SENDING received)

Private Member Functions
void	reassemble_data ()
void	update_send_state ()
void	update_recv_state ()

Private Attributes
uint64_t	id_
bool	is_local_
send_stream_state	send_state_ {send_stream_state::ready}
std::deque< uint8_t >	send_buffer_
uint64_t	send_offset_ {0}
uint64_t	acked_offset_ {0}
bool	fin_sent_ {false}
bool	fin_acked_ {false}
recv_stream_state	recv_state_ {recv_stream_state::recv}
std::map< uint64_t, std::vector< uint8_t > >	recv_buffer_
std::deque< uint8_t >	recv_ready_
uint64_t	recv_offset_ {0}
bool	recv_fin_ {false}
std::optional< uint64_t >	final_size_
uint64_t	max_send_offset_ {0}
uint64_t	max_recv_offset_ {65536}
uint64_t	recv_window_size_ {65536}
std::optional< uint64_t >	reset_error_code_
std::optional< uint64_t >	stop_sending_error_code_

Static Private Attributes
static constexpr double	window_update_threshold_ {0.5}

Detailed Description

QUIC stream implementation (RFC 9000 Sections 2-4)

A QUIC stream is an ordered, reliable, bidirectional or unidirectional byte stream within a QUIC connection.

Definition at line 146 of file stream.h.

Constructor & Destructor Documentation

stream() [1/3]

kcenon::network::protocols::quic::stream::stream ( uint64_t id, bool is_local, uint64_t initial_max_data = 65536 )

explicit

Construct a stream.

Parameters

id	Stream identifier
is_local	True if locally initiated
initial_max_data	Initial flow control limit

Definition at line 13 of file stream.cpp.

    : id_{id}
    , is_local_{is_local}
    , max_send_offset_{initial_max_data}
    , max_recv_offset_{initial_max_data}
    , recv_window_size_{initial_max_data}
{
}

~stream()

kcenon::network::protocols::quic::stream::~stream ( )

default

stream() [2/3]

kcenon::network::protocols::quic::stream::stream ( const stream & )

delete

stream() [3/3]

kcenon::network::protocols::quic::stream::stream ( stream && )

defaultnoexcept

Member Function Documentation

acknowledge_data()

void kcenon::network::protocols::quic::stream::acknowledge_data	(	uint64_t	offset,
		uint64_t	length )

Acknowledge sent data.

Parameters

offset	Start offset of acknowledged data
length	Length of acknowledged data

Definition at line 169 of file stream.cpp.

{
    // Track acknowledgments
    if (offset + length > acked_offset_) {
        // Simple implementation: assume in-order ACKs
        acked_offset_ = offset + length;
    }
 
    // Check if FIN is acknowledged
    if (fin_sent_ && send_buffer_.empty() && acked_offset_ >= send_offset_) {
        fin_acked_ = true;
    }
 
    update_send_state();
}

References acked_offset_, fin_acked_, fin_sent_, send_buffer_, send_offset_, and update_send_state().

Here is the call graph for this function:

available_send_window()

auto kcenon::network::protocols::quic::stream::available_send_window ( ) const -> size_t

nodiscardnoexcept

Get available send window.

Definition at line 365 of file stream.cpp.

{
    const uint64_t sent = send_offset_ + send_buffer_.size();
    if (sent >= max_send_offset_) {
        return 0;
    }
    return static_cast<size_t>(max_send_offset_ - sent);
}

References max_send_offset_, send_buffer_, and send_offset_.

bytes_consumed()

auto kcenon::network::protocols::quic::stream::bytes_consumed ( ) const -> uint64_t

inlinenodiscardnoexcept

Get bytes consumed from receive buffer.

Definition at line 347 of file stream.h.

{ return recv_offset_; }

References recv_offset_.

can_send()

auto kcenon::network::protocols::quic::stream::can_send ( ) const -> bool

nodiscardnoexcept

Check if stream can send data.

Definition at line 26 of file stream.cpp.

{
    if (is_unidirectional() && !is_local_) {
        // Cannot send on peer-initiated unidirectional stream
        return false;
    }
 
    switch (send_state_) {
        case send_stream_state::ready:
        case send_stream_state::send:
            return true;
        default:
            return false;
    }
}

References is_local_, is_unidirectional(), kcenon::network::protocols::quic::ready, kcenon::network::protocols::quic::send, and send_state_.

Here is the call graph for this function:

fin_sent()

auto kcenon::network::protocols::quic::stream::fin_sent ( ) const -> bool

inlinenodiscardnoexcept

Check if FIN has been sent.

Definition at line 234 of file stream.h.

{ return fin_sent_; }

References fin_sent_.

finish()

auto kcenon::network::protocols::quic::stream::finish ( ) -> VoidResult

nodiscard

Mark stream as finished (send FIN)

Returns

Success or error

Definition at line 76 of file stream.cpp.

{
    if (!can_send()) {
        return error_void(stream_error::stream_state_error,
                         "Stream cannot be finished in current state",
                         "quic::stream");
    }
 
    if (fin_sent_) {
        return error_void(stream_error::stream_state_error,
                         "FIN already sent",
                         "quic::stream");
    }
 
    fin_sent_ = true;
    update_send_state();
    return ok();
}

References kcenon::network::error_void(), kcenon::network::ok(), and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

generate_max_stream_data()

auto kcenon::network::protocols::quic::stream::generate_max_stream_data ( ) -> std::optional<uint64_t>

nodiscard

Generate MAX_STREAM_DATA frame if needed.

Returns

New MAX_STREAM_DATA value or nullopt

Definition at line 391 of file stream.cpp.

{
    if (!should_send_max_stream_data()) {
        return std::nullopt;
    }
 
    // Increase the window
    max_recv_offset_ = recv_offset_ + recv_window_size_;
    return max_recv_offset_;
}

has_data()

auto kcenon::network::protocols::quic::stream::has_data ( ) const -> bool

nodiscardnoexcept

Check if stream has data to read.

Definition at line 189 of file stream.cpp.

{
    return !recv_ready_.empty();
}

References recv_ready_.

id()

auto kcenon::network::protocols::quic::stream::id ( ) const -> uint64_t

inlinenodiscardnoexcept

Get stream identifier.

Definition at line 174 of file stream.h.

{ return id_; }

References id_.

is_bidirectional()

auto kcenon::network::protocols::quic::stream::is_bidirectional ( ) const -> bool

inlinenodiscardnoexcept

Check if stream is bidirectional.

Definition at line 192 of file stream.h.

    {
        return stream_id_type::is_bidirectional(id_);
    }

References id_, and kcenon::network::protocols::quic::stream_id_type::is_bidirectional().

Here is the call graph for this function:

is_fin_received()

auto kcenon::network::protocols::quic::stream::is_fin_received ( ) const -> bool

inlinenodiscardnoexcept

Check if all data has been received.

Definition at line 279 of file stream.h.

{ return recv_fin_; }

References recv_fin_.

is_local()

auto kcenon::network::protocols::quic::stream::is_local ( ) const -> bool

inlinenodiscardnoexcept

Check if stream is locally initiated.

Definition at line 179 of file stream.h.

{ return is_local_; }

References is_local_.

is_unidirectional()

auto kcenon::network::protocols::quic::stream::is_unidirectional ( ) const -> bool

inlinenodiscardnoexcept

Check if stream is unidirectional.

Definition at line 184 of file stream.h.

    {
        return stream_id_type::is_unidirectional(id_);
    }

References id_, and kcenon::network::protocols::quic::stream_id_type::is_unidirectional().

Referenced by can_send().

Here is the call graph for this function:

Here is the caller graph for this function:

max_recv_data()

auto kcenon::network::protocols::quic::stream::max_recv_data ( ) const -> uint64_t

inlinenodiscardnoexcept

Get our MAX_STREAM_DATA.

Definition at line 342 of file stream.h.

{ return max_recv_offset_; }

References max_recv_offset_.

max_send_data()

auto kcenon::network::protocols::quic::stream::max_send_data ( ) const -> uint64_t

inlinenodiscardnoexcept

Get peer's MAX_STREAM_DATA.

Definition at line 326 of file stream.h.

{ return max_send_offset_; }

References max_send_offset_.

next_stream_frame()

auto kcenon::network::protocols::quic::stream::next_stream_frame ( size_t max_size ) -> std::optional<stream_frame>

nodiscard

Get next STREAM frame to send.

Parameters

max_size

Maximum frame size

Returns

Optional STREAM frame or nullopt if no data

Definition at line 111 of file stream.cpp.

{
    if (send_buffer_.empty() && !fin_sent_) {
        return std::nullopt;
    }
 
    // Check if we have pending data or need to send FIN
    if (send_buffer_.empty() && fin_sent_ && !fin_acked_) {
        // Send FIN-only frame
        stream_frame frame;
        frame.stream_id = id_;
        frame.offset = send_offset_;
        frame.fin = true;
        return frame;
    }
 
    if (send_buffer_.empty()) {
        return std::nullopt;
    }
 
    // Calculate how much we can send (considering flow control)
    const auto window_available = available_send_window();
    if (window_available == 0) {
        return std::nullopt;
    }
 
    // Reserve space for frame header (stream_id + offset + length as varints)
    // Maximum varint size is 8 bytes each, plus 1 byte for frame type
    constexpr size_t max_header_size = 1 + 8 + 8 + 8;
    if (max_size <= max_header_size) {
        return std::nullopt;
    }
 
    const size_t max_payload = max_size - max_header_size;
    const size_t to_send = std::min({send_buffer_.size(), window_available, max_payload});
 
    stream_frame frame;
    frame.stream_id = id_;
    frame.offset = send_offset_;
    frame.data.reserve(to_send);
 
    // Copy data from buffer
    for (size_t i = 0; i < to_send; ++i) {
        frame.data.push_back(send_buffer_[i]);
    }
 
    // Remove sent data from buffer
    send_buffer_.erase(send_buffer_.begin(), send_buffer_.begin() + to_send);
    send_offset_ += to_send;
 
    // Set FIN if this is the last data and FIN was requested
    if (fin_sent_ && send_buffer_.empty()) {
        frame.fin = true;
    }
 
    return frame;
}

References kcenon::network::protocols::quic::stream_frame::stream_id.

operator=() [1/2]

auto kcenon::network::protocols::quic::stream::operator= ( const stream & ) -> stream &=delete

delete

operator=() [2/2]

auto kcenon::network::protocols::quic::stream::operator= ( stream && ) -> stream &=default

defaultnoexcept

pending_bytes()

auto kcenon::network::protocols::quic::stream::pending_bytes ( ) const -> size_t

inlinenodiscardnoexcept

Get number of bytes pending to send.

Definition at line 239 of file stream.h.

{ return send_buffer_.size(); }

References send_buffer_.

read()

auto kcenon::network::protocols::quic::stream::read ( std::span< uint8_t > buffer ) -> Result<size_t>

nodiscard

Read data from stream.

Parameters

buffer

Buffer to read into

Returns

Number of bytes read or error

Definition at line 194 of file stream.cpp.

{
    if (is_unidirectional() && is_local_) {
        // Cannot receive on locally-initiated unidirectional stream
        return error<size_t>(stream_error::stream_state_error,
                            "Cannot read from local unidirectional stream",
                            "quic::stream");
    }
 
    if (recv_state_ == recv_stream_state::reset_recvd) {
        return error<size_t>(stream_error::stream_reset,
                            "Stream was reset by peer",
                            "quic::stream");
    }
 
    if (recv_ready_.empty()) {
        if (recv_fin_ && recv_buffer_.empty()) {
            // All data has been read and FIN was received
            recv_state_ = recv_stream_state::data_read;
            return ok(static_cast<size_t>(0));
        }
        return ok(static_cast<size_t>(0));
    }
 
    size_t to_read = std::min(buffer.size(), recv_ready_.size());
    for (size_t i = 0; i < to_read; ++i) {
        buffer[i] = recv_ready_[i];
    }
 
    recv_ready_.erase(recv_ready_.begin(), recv_ready_.begin() + static_cast<std::ptrdiff_t>(to_read));
 
    // Update receive state
    update_recv_state();
 
    return ok(std::move(to_read));
}

References kcenon::network::protocols::quic::data_read, kcenon::network::protocols::quic::error, kcenon::network::ok(), kcenon::network::protocols::quic::reset_recvd, kcenon::network::protocols::quic::stream_error::stream_reset, and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

reassemble_data()

void kcenon::network::protocols::quic::stream::reassemble_data ( )

private

Definition at line 406 of file stream.cpp.

{
    while (!recv_buffer_.empty()) {
        auto it = recv_buffer_.find(recv_offset_);
        if (it == recv_buffer_.end()) {
            break; // Gap in data
        }
 
        recv_ready_.insert(recv_ready_.end(), it->second.begin(), it->second.end());
        recv_offset_ += it->second.size();
        recv_buffer_.erase(it);
    }
}

References recv_buffer_, recv_offset_, and recv_ready_.

receive_data()

auto kcenon::network::protocols::quic::stream::receive_data ( uint64_t offset, std::span< const uint8_t > data, bool fin ) -> VoidResult

nodiscard

Receive STREAM frame data.

Parameters

offset	Data offset in stream
data	Frame data
fin	True if this is the final frame

Returns

Success or error

Definition at line 243 of file stream.cpp.

{
    if (is_unidirectional() && is_local_) {
        return error_void(stream_error::stream_state_error,
                         "Cannot receive on local unidirectional stream",
                         "quic::stream");
    }
 
    if (recv_state_ == recv_stream_state::reset_recvd ||
        recv_state_ == recv_stream_state::reset_read) {
        return error_void(stream_error::stream_state_error,
                         "Stream was reset",
                         "quic::stream");
    }
 
    // Check for final size violations
    if (final_size_.has_value()) {
        if (offset + data.size() > *final_size_) {
            return error_void(stream_error::final_size_error,
                             "Data exceeds final size",
                             "quic::stream");
        }
    }
 
    if (fin) {
        const uint64_t new_final_size = offset + data.size();
        if (final_size_.has_value() && *final_size_ != new_final_size) {
            return error_void(stream_error::final_size_error,
                             "Final size changed",
                             "quic::stream");
        }
        final_size_ = new_final_size;
        recv_fin_ = true;
    }
 
    // Check flow control
    if (offset + data.size() > max_recv_offset_) {
        return error_void(stream_error::flow_control_error,
                         "Received data exceeds flow control limit",
                         "quic::stream");
    }
 
    // Handle data placement
    if (offset < recv_offset_) {
        // Overlapping retransmission
        const size_t overlap = static_cast<size_t>(recv_offset_ - offset);
        if (overlap >= data.size()) {
            // Entirely duplicate, ignore
            update_recv_state();
            return ok();
        }
        // Trim leading overlap
        offset = recv_offset_;
        data = data.subspan(overlap);
    }
 
    if (offset == recv_offset_) {
        // Contiguous data - append directly
        recv_ready_.insert(recv_ready_.end(), data.begin(), data.end());
        recv_offset_ += data.size();
 
        // Try to reassemble any buffered data
        reassemble_data();
    } else {
        // Gap in data - buffer for later
        recv_buffer_[offset] = std::vector<uint8_t>(data.begin(), data.end());
    }
 
    update_recv_state();
    return ok();
}

References kcenon::network::error_void(), kcenon::network::protocols::quic::stream_error::final_size_error, kcenon::network::protocols::quic::stream_error::flow_control_error, kcenon::network::ok(), kcenon::network::protocols::quic::reset_read, kcenon::network::protocols::quic::reset_recvd, and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

receive_reset()

auto kcenon::network::protocols::quic::stream::receive_reset ( uint64_t error_code, uint64_t final_size ) -> VoidResult

nodiscard

Handle received RESET_STREAM frame.

Parameters

error_code	Error code from peer
final_size	Final size of stream

Returns

Success or error

Definition at line 316 of file stream.cpp.

{
    if (is_unidirectional() && is_local_) {
        return error_void(stream_error::stream_state_error,
                         "Cannot receive reset on local unidirectional stream",
                         "quic::stream");
    }
 
    // Check final size consistency
    if (final_size_.has_value() && *final_size_ != final_size) {
        return error_void(stream_error::final_size_error,
                         "Reset final size differs from previously received",
                         "quic::stream");
    }
 
    final_size_ = final_size;
    reset_error_code_ = error_code;
    recv_state_ = recv_stream_state::reset_recvd;
 
    // Clear buffered data
    recv_buffer_.clear();
 
    return ok();
}

References kcenon::network::error_void(), kcenon::network::protocols::quic::stream_error::final_size_error, kcenon::network::ok(), kcenon::network::protocols::quic::reset_recvd, and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

receive_stop_sending()

auto kcenon::network::protocols::quic::stream::receive_stop_sending ( uint64_t error_code ) -> VoidResult

nodiscard

Handle received STOP_SENDING frame.

Parameters

error_code

Error code from peer

Returns

Success or error

Definition at line 341 of file stream.cpp.

{
    if (!can_send()) {
        return error_void(stream_error::stream_state_error,
                         "Cannot handle STOP_SENDING in current state",
                         "quic::stream");
    }
 
    stop_sending_error_code_ = error_code;
    // The sender SHOULD reset the stream in response
    return ok();
}

References kcenon::network::error_void(), kcenon::network::ok(), and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

recv_state()

auto kcenon::network::protocols::quic::stream::recv_state ( ) const -> recv_stream_state

inlinenodiscardnoexcept

Get receive state.

Definition at line 262 of file stream.h.

{ return recv_state_; }

References recv_state_.

reset()

auto kcenon::network::protocols::quic::stream::reset ( uint64_t error_code ) -> VoidResult

nodiscard

Reset the stream with error code.

Parameters

error_code

Application error code

Returns

Success or error

Definition at line 95 of file stream.cpp.

{
    if (send_state_ == send_stream_state::reset_sent ||
        send_state_ == send_stream_state::reset_recvd ||
        send_state_ == send_stream_state::data_recvd) {
        return error_void(stream_error::stream_state_error,
                         "Stream already in terminal state",
                         "quic::stream");
    }
 
    reset_error_code_ = error_code;
    send_state_ = send_stream_state::reset_sent;
    send_buffer_.clear();
    return ok();
}

References kcenon::network::protocols::quic::data_recvd, kcenon::network::error_void(), kcenon::network::ok(), kcenon::network::protocols::quic::reset_recvd, kcenon::network::protocols::quic::reset_sent, and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

reset_error_code()

auto kcenon::network::protocols::quic::stream::reset_error_code ( ) const -> std::optional<uint64_t>

inlinenodiscardnoexcept

Get reset error code (if stream was reset)

Definition at line 367 of file stream.h.

    {
        return reset_error_code_;
    }

References reset_error_code_.

send_state()

auto kcenon::network::protocols::quic::stream::send_state ( ) const -> send_stream_state

inlinenodiscardnoexcept

Get send state.

Definition at line 204 of file stream.h.

{ return send_state_; }

References send_state_.

set_max_recv_data()

void kcenon::network::protocols::quic::stream::set_max_recv_data

(

uint64_t

max

)

Update our MAX_STREAM_DATA (peer's send limit)

Parameters

max	Maximum data peer can send

Definition at line 374 of file stream.cpp.

{
    if (max > max_recv_offset_) {
        max_recv_offset_ = max;
    }
}

References max_recv_offset_.

set_max_send_data()

void kcenon::network::protocols::quic::stream::set_max_send_data

(

uint64_t

max

)

Set peer's MAX_STREAM_DATA (our send limit)

Parameters

max	Maximum data we can send

Definition at line 358 of file stream.cpp.

{
    if (max > max_send_offset_) {
        max_send_offset_ = max;
    }
}

References max_send_offset_.

should_send_max_stream_data()

auto kcenon::network::protocols::quic::stream::should_send_max_stream_data ( ) const -> bool

nodiscardnoexcept

Check if MAX_STREAM_DATA frame should be sent.

Definition at line 381 of file stream.cpp.

{
    // Send update when we've consumed more than threshold of the window
    const uint64_t consumed = recv_offset_;
    const uint64_t threshold = static_cast<uint64_t>(
        recv_window_size_ * window_update_threshold_);
 
    return consumed > (max_recv_offset_ - recv_window_size_ + threshold);
}

References max_recv_offset_, recv_offset_, recv_window_size_, and window_update_threshold_.

stop_sending()

auto kcenon::network::protocols::quic::stream::stop_sending ( uint64_t error_code ) -> VoidResult

nodiscard

Signal that incoming data is no longer wanted.

Parameters

error_code

Application error code

Returns

Success or error

Definition at line 231 of file stream.cpp.

{
    if (is_unidirectional() && is_local_) {
        return error_void(stream_error::stream_state_error,
                         "Cannot stop sending on local unidirectional stream",
                         "quic::stream");
    }
 
    stop_sending_error_code_ = error_code;
    return ok();
}

References kcenon::network::error_void(), kcenon::network::ok(), and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

stop_sending_error_code()

auto kcenon::network::protocols::quic::stream::stop_sending_error_code ( ) const -> std::optional<uint64_t>

inlinenodiscardnoexcept

Get stop sending error code (if STOP_SENDING received)

Definition at line 375 of file stream.h.

    {
        return stop_sending_error_code_;
    }

References stop_sending_error_code_.

update_recv_state()

void kcenon::network::protocols::quic::stream::update_recv_state ( )

private

Definition at line 452 of file stream.cpp.

{
    switch (recv_state_) {
        case recv_stream_state::recv:
            if (recv_fin_) {
                recv_state_ = recv_stream_state::size_known;
            }
            break;
 
        case recv_stream_state::size_known:
            if (final_size_.has_value() && recv_offset_ >= *final_size_) {
                recv_state_ = recv_stream_state::data_recvd;
            }
            break;
 
        case recv_stream_state::data_recvd:
            if (recv_ready_.empty()) {
                recv_state_ = recv_stream_state::data_read;
            }
            break;
 
        case recv_stream_state::reset_recvd:
        case recv_stream_state::data_read:
        case recv_stream_state::reset_read:
            // Terminal states
            break;
    }
}

References kcenon::network::protocols::quic::data_read, kcenon::network::protocols::quic::data_recvd, final_size_, kcenon::network::protocols::quic::recv, recv_fin_, recv_offset_, recv_ready_, recv_state_, kcenon::network::protocols::quic::reset_read, kcenon::network::protocols::quic::reset_recvd, and kcenon::network::protocols::quic::size_known.

update_send_state()

void kcenon::network::protocols::quic::stream::update_send_state ( )

private

Definition at line 420 of file stream.cpp.

{
    switch (send_state_) {
        case send_stream_state::ready:
            if (!send_buffer_.empty()) {
                send_state_ = send_stream_state::send;
            }
            break;
 
        case send_stream_state::send:
            if (fin_sent_ && send_buffer_.empty()) {
                send_state_ = send_stream_state::data_sent;
            }
            break;
 
        case send_stream_state::data_sent:
            if (fin_acked_) {
                send_state_ = send_stream_state::data_recvd;
            }
            break;
 
        case send_stream_state::reset_sent:
            // Wait for acknowledgment
            break;
 
        case send_stream_state::reset_recvd:
        case send_stream_state::data_recvd:
            // Terminal states
            break;
    }
}

References kcenon::network::protocols::quic::data_recvd, kcenon::network::protocols::quic::data_sent, fin_acked_, fin_sent_, kcenon::network::protocols::quic::ready, kcenon::network::protocols::quic::reset_recvd, kcenon::network::protocols::quic::reset_sent, kcenon::network::protocols::quic::send, send_buffer_, and send_state_.

Referenced by acknowledge_data().

Here is the caller graph for this function:

write()

auto kcenon::network::protocols::quic::stream::write ( std::span< const uint8_t > data ) -> Result<size_t>

nodiscard

Write data to stream.

Parameters

data	Data to write

Returns

Number of bytes written or error

Definition at line 42 of file stream.cpp.

{
    if (!can_send()) {
        return error<size_t>(stream_error::stream_state_error,
                            "Stream cannot send data in current state",
                            "quic::stream");
    }
 
    if (fin_sent_) {
        return error<size_t>(stream_error::stream_state_error,
                            "Cannot write after FIN sent",
                            "quic::stream");
    }
 
    // Check flow control
    const auto available = available_send_window();
    if (available == 0) {
        return error<size_t>(stream_error::flow_control_error,
                            "Send window exhausted",
                            "quic::stream");
    }
 
    // Write up to available window
    size_t to_write = std::min(data.size(), available);
    send_buffer_.insert(send_buffer_.end(), data.begin(), data.begin() + static_cast<std::ptrdiff_t>(to_write));
 
    // Update state
    if (send_state_ == send_stream_state::ready && !send_buffer_.empty()) {
        send_state_ = send_stream_state::send;
    }
 
    return ok(std::move(to_write));
}

References kcenon::network::protocols::quic::error, kcenon::network::protocols::quic::stream_error::flow_control_error, kcenon::network::ok(), kcenon::network::protocols::quic::ready, kcenon::network::protocols::quic::send, and kcenon::network::protocols::quic::stream_error::stream_state_error.

Here is the call graph for this function:

Member Data Documentation

acked_offset_

uint64_t kcenon::network::protocols::quic::stream::acked_offset_ {0}

private

Definition at line 388 of file stream.h.

{0};   // Highest contiguously acknowledged

Referenced by acknowledge_data().

fin_acked_

bool kcenon::network::protocols::quic::stream::fin_acked_ {false}

private

Definition at line 390 of file stream.h.

{false};

Referenced by acknowledge_data(), and update_send_state().

fin_sent_

bool kcenon::network::protocols::quic::stream::fin_sent_ {false}

private

Definition at line 389 of file stream.h.

{false};

Referenced by acknowledge_data(), fin_sent(), and update_send_state().

final_size_

std::optional<uint64_t> kcenon::network::protocols::quic::stream::final_size_

private

Definition at line 398 of file stream.h.

Referenced by update_recv_state().

id_

uint64_t kcenon::network::protocols::quic::stream::id_

private

Definition at line 381 of file stream.h.

Referenced by id(), is_bidirectional(), and is_unidirectional().

is_local_

bool kcenon::network::protocols::quic::stream::is_local_

private

Definition at line 382 of file stream.h.

Referenced by can_send(), and is_local().

max_recv_offset_

uint64_t kcenon::network::protocols::quic::stream::max_recv_offset_ {65536}

private

Definition at line 404 of file stream.h.

{65536}; // Our MAX_STREAM_DATA

Referenced by max_recv_data(), set_max_recv_data(), and should_send_max_stream_data().

max_send_offset_

uint64_t kcenon::network::protocols::quic::stream::max_send_offset_ {0}

private

Definition at line 401 of file stream.h.

{0};     // Peer's MAX_STREAM_DATA

Referenced by available_send_window(), max_send_data(), and set_max_send_data().

recv_buffer_

std::map<uint64_t, std::vector<uint8_t> > kcenon::network::protocols::quic::stream::recv_buffer_

private

Definition at line 394 of file stream.h.

Referenced by reassemble_data().

recv_fin_

bool kcenon::network::protocols::quic::stream::recv_fin_ {false}

private

Definition at line 397 of file stream.h.

{false};

Referenced by is_fin_received(), and update_recv_state().

recv_offset_

uint64_t kcenon::network::protocols::quic::stream::recv_offset_ {0}

private

Definition at line 396 of file stream.h.

{0};         // Next expected offset

Referenced by bytes_consumed(), reassemble_data(), should_send_max_stream_data(), and update_recv_state().

recv_ready_

std::deque<uint8_t> kcenon::network::protocols::quic::stream::recv_ready_

private

Definition at line 395 of file stream.h.

Referenced by has_data(), reassemble_data(), and update_recv_state().

recv_state_

recv_stream_state kcenon::network::protocols::quic::stream::recv_state_ {recv_stream_state::recv}

private

Definition at line 393 of file stream.h.

{recv_stream_state::recv};

Referenced by recv_state(), and update_recv_state().

recv_window_size_

uint64_t kcenon::network::protocols::quic::stream::recv_window_size_ {65536}

private

Definition at line 405 of file stream.h.

{65536};

Referenced by should_send_max_stream_data().

reset_error_code_

std::optional<uint64_t> kcenon::network::protocols::quic::stream::reset_error_code_

private

Definition at line 409 of file stream.h.

Referenced by reset_error_code().

send_buffer_

std::deque<uint8_t> kcenon::network::protocols::quic::stream::send_buffer_

private

Definition at line 386 of file stream.h.

Referenced by acknowledge_data(), available_send_window(), pending_bytes(), and update_send_state().

send_offset_

uint64_t kcenon::network::protocols::quic::stream::send_offset_ {0}

private

Definition at line 387 of file stream.h.

{0};    // Next byte to send

Referenced by acknowledge_data(), and available_send_window().

send_state_

send_stream_state kcenon::network::protocols::quic::stream::send_state_ {send_stream_state::ready}

private

Definition at line 385 of file stream.h.

{send_stream_state::ready};

Referenced by can_send(), send_state(), and update_send_state().

stop_sending_error_code_

std::optional<uint64_t> kcenon::network::protocols::quic::stream::stop_sending_error_code_

private

Definition at line 410 of file stream.h.

Referenced by stop_sending_error_code().

window_update_threshold_

double kcenon::network::protocols::quic::stream::window_update_threshold_ {0.5}

staticconstexprprivate

Definition at line 406 of file stream.h.

{0.5};

Referenced by should_send_max_stream_data().

---

The documentation for this class was generated from the following files:

• src/internal/protocols/quic/stream.h
• src/protocols/quic/stream.cpp