Struct ChannelExtcapControlReader

pub struct ChannelExtcapControlReader {
    pub join_handle: JoinHandle<Result<(), ControlChannelError>>,
    pub read_channel: Receiver<ControlPacket<'static>>,
}

A reader for an Extcap Control using a Channel. This is the easier to use, but higher overhead way to read control packets. When the reader is spawned, a thread is spawned to continuously read messages and writes them into a bounded sync_channel. This allows the user to read the control messages without worrying about threading, by calling try_read_packet every once in a while.

Assuming the extcap capture implementation uses a loop to read or generate the packets, it can repeatedly call try_read_packet to read and handle the control packets until there are no more buffered messages before starting the main capturing logic.

For example:

fn capture(reader: &ChannelExtcapControlReader) -> Result<()> {
    let pcap_header = ...;
    let mut pcap_writer = PcapWriter::with_header(fifo, pcap_header)?;
    loop {
        while let Some(packet) = reader.try_read_packet() {
            // Handle the control packet
        }
        pcap_writer.write_packet(...)?;
    }
    Ok(())
}

Fields

join_handle: JoinHandle<Result<(), ControlChannelError>>

The join handle for the spawned thread. In most cases there is no need to use this, as the control fifo is expected to run for the whole duration of the capture.

read_channel: Receiver<ControlPacket<'static>>

The channel to receive control packets from.

Implementations

impl ChannelExtcapControlReader

pub fn spawn(in_path: PathBuf) -> Self

Create a ChannelExtcapControlReader and spawns the underlying thread it uses to start reading the control packets from the pipe given in in_path.

pub fn try_read_packet(&self) -> Option<ControlPacket<'static>>

Try to read a buffered control packet, or return None if there are no incoming control packets.

pub fn read_packet(&self) -> Result<ControlPacket<'static>, RecvError>

Reads a control packet. If the incoming channel is empty, this will block and wait until an incoming packet comes in. This is typically used when the extcap capture starts to wait for the Initialized packet from the control channel.

If you are only using this method and not using try_read_packet, consider whether you can use ExtcapControlReader directly for lower overhead.