Struct PonkAssembler 

pub struct PonkAssembler { /* private fields */ }

Implementations

impl PonkAssembler

pub fn new() -> Self

Creates an assembler with finite limits suitable for untrusted UDP.

pub fn with_max_assemblies(max_assemblies: usize) -> Self

Creates an assembler with the default byte, geometry, and timeout limits and the requested concurrent assembly limit.

A zero assembly limit ignores multipart frames without retaining data.

Examples found in repository

examples/receive_reassemble.rs (line 20)

fn main() -> std::io::Result<()> {
    let group = Ipv4Addr::from(MULTICAST_ADDR);
    let socket = UdpSocket::bind((Ipv4Addr::UNSPECIFIED, DEFAULT_PORT))?;
    socket.join_multicast_v4(&group, &Ipv4Addr::UNSPECIFIED)?;
    println!("listening for PONK on {group}:{DEFAULT_PORT} — Ctrl-C to stop");

    // Cap in-progress assemblies so untrusted senders cannot exhaust memory.
    let mut assembler = PonkAssembler::with_max_assemblies(64);
    let mut buffer = [0u8; RECV_BUFFER_SIZE];

    loop {
        let (len, peer): (usize, SocketAddr) = socket.recv_from(&mut buffer)?;
        match assembler.push_datagram(&buffer[..len], peer) {
            Ok(Some(frame)) => {
                let points: usize = frame.paths.iter().map(|p| p.points.len()).sum();
                println!(
                    "frame from {:?} (id {}): {} path(s), {} point(s)",
                    frame.sender_name,
                    frame.sender_id,
                    frame.paths.len(),
                    points,
                );
            }
            Ok(None) => {}
            Err(error) => eprintln!("malformed datagram from {peer}: {error}"),
        }
    }
}

pub fn with_limits(limits: PonkLimits) -> Self

Creates an assembler with caller-provided resource limits.

pub fn assembly_count(&self) -> usize

pub fn buffered_bytes(&self) -> usize

pub fn prune_stale(&mut self)

Drops incomplete frames that have exceeded assembly_timeout.

pub fn push_datagram( &mut self, datagram: &[u8], peer_addr: SocketAddr, ) -> Result<Option<PonkFrame>, PonkError>

Examples found in repository

examples/receive_reassemble.rs (line 25)

fn main() -> std::io::Result<()> {
    let group = Ipv4Addr::from(MULTICAST_ADDR);
    let socket = UdpSocket::bind((Ipv4Addr::UNSPECIFIED, DEFAULT_PORT))?;
    socket.join_multicast_v4(&group, &Ipv4Addr::UNSPECIFIED)?;
    println!("listening for PONK on {group}:{DEFAULT_PORT} — Ctrl-C to stop");

    // Cap in-progress assemblies so untrusted senders cannot exhaust memory.
    let mut assembler = PonkAssembler::with_max_assemblies(64);
    let mut buffer = [0u8; RECV_BUFFER_SIZE];

    loop {
        let (len, peer): (usize, SocketAddr) = socket.recv_from(&mut buffer)?;
        match assembler.push_datagram(&buffer[..len], peer) {
            Ok(Some(frame)) => {
                let points: usize = frame.paths.iter().map(|p| p.points.len()).sum();
                println!(
                    "frame from {:?} (id {}): {} path(s), {} point(s)",
                    frame.sender_name,
                    frame.sender_id,
                    frame.paths.len(),
                    points,
                );
            }
            Ok(None) => {}
            Err(error) => eprintln!("malformed datagram from {peer}: {error}"),
        }
    }
}

Trait Implementations

impl Default for PonkAssembler

fn default() -> Self

Returns the “default value” for a type.