Trait PcapReaderIterator

Source

pub trait PcapReaderIterator {
    // Required methods
    fn next(&mut self) -> Result<(usize, PcapBlockOwned<'_>), PcapError<&[u8]>>;
    fn consume(&mut self, offset: usize);
    fn consume_noshift(&mut self, offset: usize);
    fn consumed(&self) -> usize;
    fn refill(&mut self) -> Result<(), PcapError<&[u8]>>;
    fn position(&self) -> usize;
    fn grow(&mut self, new_size: usize) -> bool;
    fn data(&self) -> &[u8] ⓘ;
    fn reader_exhausted(&self) -> bool;
}

Expand description

Streaming Iterator over pcap files

Implementors of this trait are usually based on a circular buffer, which means memory usage is constant, and that it can be used to parse huge files or infinite streams. However, this also means some care must be taken so no reference (for ex a pcap block) is kept on the buffer before changing the buffer content.

Each call to next will return the next block, and must be followed by call to consume to avoid reading the same data. consume takes care of shifting data in the buffer if required, but does not refill it.

It is possible to read multiple blocks before consuming data. Call consume_noshift instead of consume. To refill the buffer, first ensures that you do not keep any reference over internal data (blocks or slices), and call refill.

To determine when a refill is needed, either test next() for an incomplete read. You can also use position to implement a heuristic refill (for ex, when position > capacity / 2.

The blocks already read, and underlying data, must be discarded before calling consume or refill. It is the caller’s responsibility to call functions in the correct order.