Struct ProxyFrame 

pub struct ProxyFrame {
    pub conn_id: u64,
    pub rip: [u8; 16],
    pub rport: u16,
    pub payload: Vec<u8>,
    pub uuid: [u8; 16],
    pub timestamp: u64,
    pub checksum: u32,
    pub flags: FrameFlags,
}

Proxy frame - the fundamental unit of all data transmission

Each frame represents either:

• A data packet (payload contains actual traffic)
• A control message (DoH query, keepalive, etc.)

Fields

conn_id: u64

Connection ID - unique per logical connection

rip: [u8; 16]

Remote IP address (16 bytes for IPv6, IPv4 mapped to ::ffff:x.x.x.x)

rport: u16

Remote port

payload: Vec<u8>

Payload data

uuid: [u8; 16]

Frame UUID - unique per frame (replay protection)

timestamp: u64

Timestamp in milliseconds since Unix epoch

checksum: u32

CRC32 checksum of payload

flags: FrameFlags

Frame flags

Implementations

impl ProxyFrame

pub fn new_data( conn_id: u64, rip: [u8; 16], rport: u16, payload: Vec<u8>, ) -> Self

Create a new data frame

pub fn new_control(payload: Vec<u8>) -> Self

Create a control frame (e.g., DoH query)

pub fn new_close(conn_id: u64) -> Self

Create a connection close frame

pub fn verify_checksum(&self) -> bool

Verify the checksum

pub fn ipv4_to_mapped(ipv4: [u8; 4]) -> [u8; 16]

Convert IPv4 address to mapped IPv6 format

pub fn mapped_to_ipv4(mapped: &[u8; 16]) -> Option<[u8; 4]>

Extract IPv4 from mapped IPv6 format (if applicable)

Trait Implementations

impl Archive for ProxyFrame

where u64: Archive, [u8; 16]: Archive, u16: Archive, Vec<u8>: Archive, u32: Archive, FrameFlags: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedProxyFrame

The archived representation of this type.

type Resolver = ProxyFrameResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ProxyFrame

fn clone(&self) -> ProxyFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProxyFrame

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<ProxyFrame, __D> for Archived<ProxyFrame>

where u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>, [u8; 16]: Archive, <[u8; 16] as Archive>::Archived: Deserialize<[u8; 16], __D>, u16: Archive, <u16 as Archive>::Archived: Deserialize<u16, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, FrameFlags: Archive, <FrameFlags as Archive>::Archived: Deserialize<FrameFlags, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ProxyFrame, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl PartialEq<ArchivedProxyFrame> for ProxyFrame

where u64: Archive, [u8; 16]: Archive, u16: Archive, Vec<u8>: Archive, u32: Archive, FrameFlags: Archive, <u64 as Archive>::Archived: PartialEq<u64>, <[u8; 16] as Archive>::Archived: PartialEq<[u8; 16]>, <u16 as Archive>::Archived: PartialEq<u16>, <Vec<u8> as Archive>::Archived: PartialEq<Vec<u8>>, <u32 as Archive>::Archived: PartialEq<u32>, <FrameFlags as Archive>::Archived: PartialEq<FrameFlags>,

fn eq(&self, other: &ArchivedProxyFrame) -> 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 PartialEq<ProxyFrame> for ArchivedProxyFrame

where u64: Archive, [u8; 16]: Archive, u16: Archive, Vec<u8>: Archive, u32: Archive, FrameFlags: Archive, <u64 as Archive>::Archived: PartialEq<u64>, <[u8; 16] as Archive>::Archived: PartialEq<[u8; 16]>, <u16 as Archive>::Archived: PartialEq<u16>, <Vec<u8> as Archive>::Archived: PartialEq<Vec<u8>>, <u32 as Archive>::Archived: PartialEq<u32>, <FrameFlags as Archive>::Archived: PartialEq<FrameFlags>,

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

fn eq(&self, other: &ProxyFrame) -> 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<__S: Fallible + ?Sized> Serialize<__S> for ProxyFrame

where u64: Serialize<__S>, [u8; 16]: Serialize<__S>, u16: Serialize<__S>, Vec<u8>: Serialize<__S>, u32: Serialize<__S>, FrameFlags: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for ProxyFrame