Struct DeviceFramedWrite 

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

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

A Sink-only abstraction over an AsyncDevice, using an Encoder to

Examples

use bytes::BytesMut;
use futures::SinkExt;
use tun_rs::async_framed::{BytesCodec, DeviceFramedWrite};
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 write-only framed device
    let mut framed_write = DeviceFramedWrite::new(dev, BytesCodec::new());

    // Send a frame (Replace with real IP message)
    let packet = b"[IP Packet: 10.0.0.1 -> 10.0.0.2] Hello, TUN!";
    framed_write.send(BytesMut::from(packet)).await?;

    Ok(())
}

serialize outbound frames into raw packets.

This struct provides a write-only framing interface for the underlying device, allowing decoupled and concurrent handling of outbound data. It is especially useful in async contexts where reads and writes occur in different tasks.

Internally, it manages a send buffer and optional packet aggregator for GSO (Generic Segmentation Offload) support on Linux.

See DeviceFramed for a unified read/write interface.

Implementations

impl<C, T> DeviceFramedWrite<C, T>

where T: Borrow<AsyncDevice>,

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

Construct from a AsyncDevice with a specific codec.

The write 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 write_buffer_size(&self) -> usize

pub fn set_write_buffer_size(&mut self, write_buffer_size: usize)

Sets the size of the write buffer in bytes.

On Linux, if GSO (Generic Segmentation Offload) is enabled, this setting is ignored, and the send buffer size is fixed to a larger value to accommodate large TCP segments.

If the current buffer size is already greater than or equal to the requested size, this call has no effect.

Parameters

• write_buffer_size: Desired size in bytes for the write buffer.

pub fn into_inner(self) -> T

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

Trait Implementations

impl<I, C, T> Sink<I> for DeviceFramedWrite<C, T>

where T: Borrow<AsyncDevice>, C: Encoder<I>,

type Error = <C as Encoder<I>>::Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

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