Struct PacketHeader 

#[repr(C)]
pub struct PacketHeader {
    pub version: u8,
    pub session_id: SessionId,
    pub stream_id: StreamId,
    pub sequence: SequenceNumber,
    pub flags: PacketFlags,
    pub ack_delay: u16,
    pub epoch: u8,
    pub path_id: u8,
}

Packet header — 45 bytes on the wire (the AEAD AAD).

Serialised by PacketHeader::to_wire as an explicit, fixed big-endian (network byte order) image, version first — declaration order == wire order, no reordering, no reversed arrays:

off  0  version    u8      (= WIRE_VERSION)
off  1  session_id [u8;32]
off 33  stream_id  u16 be
off 35  sequence   u32 be
off 39  flags      u16 be
off 41  ack_delay  u16 be
off 43  epoch      u8
off 44  path_id    u8

The whole 45-byte image is the AEAD AAD, so flipping any byte (version included) fails decryption. The recv path additionally drops a frame whose version != WIRE_VERSION. Frozen by core/tests/wire_vectors/packet_header.bin; grammar in docs/protocol/PROTOCOL.md § 4.2.

Fields

version: u8

On-wire packet-format version. Pinned to WIRE_VERSION; the first wire byte (see PacketHeader::to_wire).

session_id: SessionId

256-bit session identifier, used as encryption salt

stream_id: StreamId

Stream within session (0 = control)

sequence: SequenceNumber

Per-stream sequence number

flags: PacketFlags

Packet flags

ack_delay: u16

Delay between processing packet and sending ACK (in microseconds)

epoch: u8

Rekey generation. Zero at session establishment, incremented in lock- step on each in-band rekey (Phase 1.5).

path_id: u8

Multi-path leg identifier (Phase 4.2). 0 = single-leg default.

Implementations

impl PacketHeader

pub const SIZE: usize = 45

Header size in bytes (serialised wire length).

pub fn new( session_id: SessionId, stream_id: StreamId, sequence: SequenceNumber, flags: PacketFlags, ) -> Self

Create a new packet header (version = WIRE_VERSION, epoch = 0, path_id = 0, ack_delay = 0).

pub fn with_epoch(self, epoch: u8) -> Self

Set the rekey epoch — used by Session::rekey (Phase 1.5).

pub fn with_path_id(self, path_id: u8) -> Self

Set the path id — used by the multi-path scheduler (Phase 4.2).

pub fn to_wire(&self) -> [u8; 45]

Serialise to the fixed 45 on-wire bytes (big-endian, version first). This image is the AEAD AAD.

pub fn from_wire(bytes: &[u8]) -> Result<Self, WireError>

Parse a header from the first Self::SIZE bytes of bytes. Does not validate version — the recv path gates on it separately so the same parser serves both the version check and the codecs.

Trait Implementations

impl Clone for PacketHeader

fn clone(&self) -> PacketHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PacketHeader

impl Debug for PacketHeader

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

Formats the value using the given formatter.

impl Eq for PacketHeader

impl PartialEq for PacketHeader

fn eq(&self, other: &PacketHeader) -> 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 PacketHeader