Struct RoutingHeader 

#[repr(C)]
pub struct RoutingHeader {
    pub dest_id: u64,
    pub src_id: u32,
    pub ttl: u8,
    pub hop_count: u8,
    pub flags: RouteFlags,
    pub _reserved: u8,
}

Routing header for multi-hop Net packets.

Layout (18 bytes):

┌───────────────────────────────────────────────────────────────────┐
│ magic (2) │ ttl │ hops │ flags │ rsvd │ src_id (4) │ dest_id (8) │
└───────────────────────────────────────────────────────────────────┘

magic is always ROUTING_MAGIC (ASCII "RT" on the wire — 0x5452 as a little-endian u16), distinct from the direct- packet magic 0x4E45. The receive-loop discriminator reads bytes 0-1 alone and dispatches unambiguously — the previous 16-byte layout put dest_id at bytes 0-7, and any recipient whose node_id had low-16-bits equal to the direct-packet magic (~1 in 65 536) silently mis-classified its own incoming routed packets as Net packets.

Fields

dest_id: u64

Final destination node ID (64-bit)

src_id: u32

Source node ID (truncated to 32-bit for space)

ttl: u8

Time-to-live (decremented at each hop)

hop_count: u8

Hop count so far

flags: RouteFlags

Route flags

_reserved: u8

Reserved for future use

Implementations

impl RoutingHeader

pub fn new(dest_id: u64, src_id: u32, ttl: u8) -> Self

Create a new routing header

pub fn control(dest_id: u64, src_id: u32, ttl: u8) -> Self

Create a control packet header

pub fn priority(dest_id: u64, src_id: u32, ttl: u8) -> Self

Create a priority packet header

pub fn to_bytes(&self) -> [u8; 18]

Serialize to bytes.

The magic tag rides at bytes 0-1 so the receive-loop discriminator reads it directly — see ROUTING_MAGIC.

pub fn from_bytes(buf: &[u8]) -> Option<Self>

Deserialize from bytes. Returns None on short input, wrong magic, or malformed numeric fields.

pub fn write_to(&self, buf: &mut BytesMut)

Write to a buffer

pub fn write_at(&self, dst: &mut [u8])

Overwrite an existing 18-byte slice with this header, in place.

Distinct from Self::write_to which appends to the tail of a BytesMut: this targets the head of an existing buffer (an inbound packet’s routing-header prefix) so the forwarder can flip TTL / increment hop_count without allocating a fresh packet. Used by Router::route_packet’s Bytes::try_into_mut fast path — perf #18.

Panics

Panics if dst.len() < ROUTING_HEADER_SIZE. The caller is expected to have already validated the slice length via the same check that decoded the header.

pub fn read_from(buf: &mut Bytes) -> Option<Self>

Read from a buffer. Returns None on short input or wrong magic; fields are consumed only on successful parse.

pub fn is_expired(&self) -> bool

Check if TTL is expired

pub fn forward(&mut self) -> bool

Decrement TTL and increment hop count (for forwarding)

hop_count is u8, so on a 256+-hop path the saturating_add pins it at 255 and the hop_count + 2 indirect-route metric used downstream undercounts the true distance. Routing correctness is preserved — ttl (separate, larger) still bounds loops — but best-route selection may pick a path with bogus metrics. Log once at saturation so an operator can notice and reconfigure path lengths or upgrade hop_count to u16. (Changing the wire format is a breaking change held off until consumers migrate.)

Trait Implementations

impl Clone for RoutingHeader

fn clone(&self) -> RoutingHeader

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RoutingHeader

impl Debug for RoutingHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for RoutingHeader

impl PartialEq for RoutingHeader

fn eq(&self, other: &RoutingHeader) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RoutingHeader