Struct MalformedPacketEvent 

pub struct MalformedPacketEvent {
    pub raw: Vec<u8>,
    pub raw_truncated: bool,
    pub error: ParseError,
    pub diagnostic: ErrorDiagnostic,
}

Codec-malformed packet observability event.

Fields

raw: Vec<u8>

Original input bytes copied for application-owned evidence.

This is exact when raw_truncated is false and capped at EVENT_RAW_BYTE_LIMIT otherwise.

raw_truncated: bool

Whether raw was capped before copying.

error: ParseError

Codec failure.

diagnostic: ErrorDiagnostic

Stable parse diagnostic metadata.

Implementations

impl MalformedPacketEvent

pub const fn kind(&self) -> EngineEventKind

Returns the stable event kind.

Examples found in repository

examples/service_ingest.rs (line 31)

fn main() -> Result<(), std::io::Error> {
    let input = b"N0CALL>APRS:>service online\nN1CALL>APRS:~opaque\nbad packet\n";
    let mut engine = Engine::new(Policy::strict());

    let packets = LineTransport::new(input).packets_with_limit(MAX_PACKET_LEN)?;

    for packet in packets {
        match engine.process_event(packet) {
            EngineEvent::Accepted(event) => {
                println!(
                    "event={} semantic={}",
                    event.kind().code(),
                    event.packet.summary().semantic
                );
            }
            EngineEvent::Rejected(event) => {
                println!(
                    "event={} code={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.diagnostic.remediation
                );
            }
            EngineEvent::Malformed(event) => {
                println!(
                    "event={} code={} raw_len={} raw_truncated={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.raw.len(),
                    event.raw_truncated,
                    event.diagnostic.remediation
                );
            }
        }
    }

    let counters = engine.counters();
    println!(
        "summary accepted={} rejected={} malformed={}",
        counters.accepted, counters.rejected, counters.malformed
    );

    Ok(())
}

Trait Implementations

impl Clone for MalformedPacketEvent

fn clone(&self) -> MalformedPacketEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MalformedPacketEvent

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

Formats the value using the given formatter.

impl PartialEq for MalformedPacketEvent

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

impl StructuralPartialEq for MalformedPacketEvent