Struct DeviceFramedRead 

pub struct DeviceFramedRead<C, T = AsyncDevice> { /* private fields */ }

Available on (crate features async_io or async_tokio) and crate feature async_framed only.

A Stream-only abstraction over an AsyncDevice, using a Decoder to

Examples

use futures::StreamExt;
use tun_rs::async_framed::{BytesCodec, DeviceFramedRead};
use tun_rs::DeviceBuilder;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // Create a TUN device with IPv4 configuration
    let dev = DeviceBuilder::new()
        .name("tun0")
        .mtu(1500)
        .ipv4("10.0.0.1", "255.255.255.0", None)
        .build_async()?;

    // Create a read-only framed device
    let mut framed_read = DeviceFramedRead::new(dev, BytesCodec::new());

    // Receive frames
    while let Some(frame) = framed_read.next().await {
        match frame {
            Ok(bytes) => println!("Received: {:?}", bytes),
            Err(e) => eprintln!("Error receiving frame: {}", e),
        }
    }
    Ok(())
}

extract frames from raw packet input.

This struct provides a read-only framing interface for the underlying device, decoupled from writing. It is useful when the reading and writing logic need to be handled independently, such as in split or concurrent tasks.

Internally, it maintains a receipt buffer and optional packet splitter for GRO (Generic Receive Offload) support on Linux.

See DeviceFramed for a unified read/write interface.

Implementations

impl<C, T> DeviceFramedRead<C, T>

where T: Borrow<AsyncDevice>,

pub fn new(dev: T, codec: C) -> DeviceFramedRead<C, T>

Construct from a AsyncDevice with a specific codec.

The read side of the framed device.

Example

use std::net::Ipv4Addr;
use std::sync::Arc;
use tun_rs::{
    async_framed::{BytesCodec, DeviceFramedRead, DeviceFramedWrite},
    DeviceBuilder,
};
let dev = Arc::new(
    DeviceBuilder::new()
        .ipv4(Ipv4Addr::new(10, 0, 0, 21), 24, None)
        .build_async()?,
);
let mut w = DeviceFramedWrite::new(dev.clone(), BytesCodec::new());
let mut r = DeviceFramedRead::new(dev, BytesCodec::new());

Note

An efficient way is to directly use DeviceFramed::split if the device is cloneable

pub fn read_buffer_size(&self) -> usize

pub fn set_read_buffer_size(&mut self, read_buffer_size: usize)

Sets the size of the read buffer in bytes.

Must be at least as large as the MTU to ensure complete packet reception.

pub fn into_inner(self) -> T

Consumes the Framed, returning its underlying I/O stream.

Trait Implementations

impl<C, T> Stream for DeviceFramedRead<C, T>

where T: Borrow<AsyncDevice>, C: Decoder,

type Item = Result<<C as Decoder>::Item, <C as Decoder>::Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<C, T> Unpin for DeviceFramedRead<C, T>