Struct ParsedPacket 

pub struct ParsedPacket { /* private fields */ }

Structured packet view backed by the preserved raw packet bytes.

Implementations

impl ParsedPacket

pub fn raw(&self) -> &RawPacket

Returns the preserved raw packet.

Examples found in repository

examples/service_toolkit.rs (line 29)

fn main() -> Result<(), libaprs_engine::ParseError> {
    let mut engine = Engine::default();
    let mut duplicates = DuplicateWindow::new(128);
    let mut rate = PacketRateBudget::new(100);
    let blocked = SemanticBlocklist::new(&[SemanticFamily::Unsupported, SemanticFamily::Malformed]);

    for packet_bytes in [b"N0CALL>APRS:>service".as_slice()] {
        if rate.try_consume() == RateLimitDecision::Limited {
            continue;
        }
        if duplicates.observe(packet_bytes) == DuplicateDecision::Duplicate {
            continue;
        }

        let packet = parse_packet(packet_bytes)?;
        if blocked.rejects(&packet.aprs_data()) {
            continue;
        }

        let _event = engine.process_event(packet.raw().as_bytes());
    }

    Ok(())
}

examples/encode_packets.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = [b"APRS".as_slice(), b"WIDE1-1".as_slice()];

    let status = encode_status(b"N0CALL", &path, b"encoder example")?;
    assert_eq!(
        parse_packet(&status)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .raw()
            .as_bytes(),
        b"N0CALL>APRS,WIDE1-1:>encoder example"
    );

    let position = encode_uncompressed_position(
        b"N0CALL",
        &path,
        UncompressedPositionEncoding {
            messaging: false,
            latitude: b"4903.50N",
            symbol_table: b'/',
            longitude: b"07201.75W",
            symbol_code: b'-',
            comment: b"encoded",
        },
    )?;
    assert_eq!(
        parse_packet(&position)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .summary()
            .semantic,
        "position"
    );

    let telemetry = encode_telemetry(b"N0CALL", &path, 1, [111, 222, 33, 44, 55], None)?;
    assert_eq!(
        parse_packet(&telemetry)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .summary()
            .semantic,
        "telemetry"
    );

    Ok(())
}

pub fn source(&self) -> &[u8]

Returns the source callsign bytes before the > separator.

Examples found in repository

examples/parse_packet.rs (line 6)

fn main() -> Result<(), libaprs_engine::ParseError> {
    let packet = parse_packet(b"N0CALL>APRS:>hello")?;

    println!("source={}", String::from_utf8_lossy(packet.source()));
    println!(
        "destination={}",
        String::from_utf8_lossy(packet.destination())
    );

    if let AprsData::Status { text } = packet.aprs_data() {
        println!("status={}", String::from_utf8_lossy(text));
    }

    Ok(())
}

pub fn path(&self) -> &[u8]

Returns the destination/path bytes between > and :.

pub fn destination(&self) -> &[u8]

Returns the destination bytes, which are the first path component.

Examples found in repository

examples/parse_packet.rs (line 9)

fn main() -> Result<(), libaprs_engine::ParseError> {
    let packet = parse_packet(b"N0CALL>APRS:>hello")?;

    println!("source={}", String::from_utf8_lossy(packet.source()));
    println!(
        "destination={}",
        String::from_utf8_lossy(packet.destination())
    );

    if let AprsData::Status { text } = packet.aprs_data() {
        println!("status={}", String::from_utf8_lossy(text));
    }

    Ok(())
}

pub fn digipeaters(&self) -> Vec<&[u8]>

Returns digipeater path component byte views after the destination.

pub fn path_components(&self) -> Vec<&[u8]>

Returns all path component byte views, including destination first.

pub fn payload(&self) -> &[u8]

Returns the payload bytes after the : separator.

pub fn data_type_identifier(&self) -> DataTypeIdentifier

Returns the APRS data type identifier from the first payload byte.

pub fn information(&self) -> &[u8]

Returns payload bytes after the data type identifier.

pub fn aprs_data(&self) -> AprsData<'_>

Returns a semantic view of the APRS information field.

Examples found in repository

examples/parse_packet.rs (line 12)

fn main() -> Result<(), libaprs_engine::ParseError> {
    let packet = parse_packet(b"N0CALL>APRS:>hello")?;

    println!("source={}", String::from_utf8_lossy(packet.source()));
    println!(
        "destination={}",
        String::from_utf8_lossy(packet.destination())
    );

    if let AprsData::Status { text } = packet.aprs_data() {
        println!("status={}", String::from_utf8_lossy(text));
    }

    Ok(())
}

examples/service_toolkit.rs (line 25)

fn main() -> Result<(), libaprs_engine::ParseError> {
    let mut engine = Engine::default();
    let mut duplicates = DuplicateWindow::new(128);
    let mut rate = PacketRateBudget::new(100);
    let blocked = SemanticBlocklist::new(&[SemanticFamily::Unsupported, SemanticFamily::Malformed]);

    for packet_bytes in [b"N0CALL>APRS:>service".as_slice()] {
        if rate.try_consume() == RateLimitDecision::Limited {
            continue;
        }
        if duplicates.observe(packet_bytes) == DuplicateDecision::Duplicate {
            continue;
        }

        let packet = parse_packet(packet_bytes)?;
        if blocked.rejects(&packet.aprs_data()) {
            continue;
        }

        let _event = engine.process_event(packet.raw().as_bytes());
    }

    Ok(())
}

pub fn summary(&self) -> PacketSummary<'_>

Returns a structured diagnostic summary for observability.

Examples found in repository

examples/process_file.rs (line 19)

fn main() -> std::io::Result<()> {
    let Some(path) = std::env::args().nth(1) else {
        eprintln!("usage: process_file <packets.aprs>");
        std::process::exit(2);
    };

    let input = read_all_with_limit(File::open(path)?, DEFAULT_TRANSPORT_READ_LIMIT)?;
    let mut engine = Engine::new(Policy::strict());

    for packet_bytes in LineTransport::new(&input).packets() {
        match engine.process(packet_bytes) {
            EngineResult::Accepted { packet } => {
                let summary = packet.summary();
                println!(
                    "accepted source={} destination={} semantic={}",
                    String::from_utf8_lossy(summary.source),
                    String::from_utf8_lossy(summary.destination),
                    summary.semantic
                );
            }
            EngineResult::Rejected { reason, .. } => eprintln!("rejected: {}", reason.code()),
            EngineResult::ParseError(error) => eprintln!("malformed: {}", error.code()),
        }
    }

    Ok(())
}

examples/encode_packets.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = [b"APRS".as_slice(), b"WIDE1-1".as_slice()];

    let status = encode_status(b"N0CALL", &path, b"encoder example")?;
    assert_eq!(
        parse_packet(&status)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .raw()
            .as_bytes(),
        b"N0CALL>APRS,WIDE1-1:>encoder example"
    );

    let position = encode_uncompressed_position(
        b"N0CALL",
        &path,
        UncompressedPositionEncoding {
            messaging: false,
            latitude: b"4903.50N",
            symbol_table: b'/',
            longitude: b"07201.75W",
            symbol_code: b'-',
            comment: b"encoded",
        },
    )?;
    assert_eq!(
        parse_packet(&position)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .summary()
            .semantic,
        "position"
    );

    let telemetry = encode_telemetry(b"N0CALL", &path, 1, [111, 222, 33, 44, 55], None)?;
    assert_eq!(
        parse_packet(&telemetry)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .summary()
            .semantic,
        "telemetry"
    );

    Ok(())
}

examples/service_ingest.rs (line 17)

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 ParsedPacket

fn clone(&self) -> ParsedPacket

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParsedPacket

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

Formats the value using the given formatter.

impl Eq for ParsedPacket

impl PartialEq for ParsedPacket

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParsedPacket