filament-transport · forwarding

#[derive(Debug, Clone)]
pub struct HopInfo {
/// Destination the packet is heading to.

pub destination: DestinationHash,
/// Current hop count.

pub hops: u8,
/// Maximum hops allowed (TTL).

pub max_hops: u8,
/// Packet hash for loop detection.

pub packet_hash: [u8; 32]
}

#[must_use]
pub fn new(destination: DestinationHash, max_hops: u8, packet_hash: [u8; 32]) -> Self;

pub fn increment(&mut self) -> Result<()>;

#[must_use]
pub fn is_expired(&self) -> bool;

#[must_use]
pub fn remaining_hops(&self) -> u8;

#[derive(Debug, Clone)]
pub enum ForwardingDecision {
    /// Deliver locally (this is the destination).
    Deliver,

    /// Forward to next hop.
    Forward {
        /// Next hop destination.
        next_hop: DestinationHash,
        /// Interface to use.
        interface: InterfaceId,
        /// Updated hop info.
        hop_info: HopInfo,
    },

    /// Drop the packet.
    Drop(ForwardingDropReason),
}

#[derive(Debug, Clone)]
pub enum ForwardingDropReason {
    /// TTL expired (hop count reached max).
    TtlExpired,

    /// Loop detected.
    LoopDetected,

    /// No path to destination.
    NoPath,

    /// Interface mode doesn't support transport.
    TransportDisabled,

    /// Invalid hop count.
    InvalidHopCount,
}

pub struct ForwardingEngine {

}

#[must_use]
pub fn new(routing_table: Arc<RoutingTable>, interface_mode: InterfaceMode) -> Self;

pub async fn decide(
        &self,
        destination: DestinationHash,
        mut hop_info: HopInfo,
        is_local: bool,
    ) -> ForwardingDecision;

pub async fn cleanup(&self);

pub fn set_max_hops(&mut self, max_hops: u8);

#[must_use]
pub fn interface_mode(&self) -> InterfaceMode;

pub fn set_interface_mode(&mut self, mode: InterfaceMode);