Struct riptun::TokioTun

pub struct TokioTun { /* fields omitted */ }

An asynchronous virtual TUN device based on the tokio ecosystem.

Implementations

impl TokioTun

pub fn new(name: &str, num_queues: usize) -> Result<Self>

Create a new multi-queue async Tun device, supporting the tokio ecosystem, using the specified name and number of queues. The name parameter can be augmented with %d to denote a OS determined incrementing ID to assign this device. To get the real device name call TokioTun::name().

pub fn name(&self) -> &str

Return the OS determined name of this device.

pub fn get<I>(&self, index: I) -> Option<&I::Output> where
    I: SliceIndex<[TokioQueue]>, 

Retrieve an immutable reference to the specified queue(s) if the suplied SliceIndex is inbounds.

pub fn get_mut<I>(&mut self, index: I) -> Option<&mut I::Output> where
    I: SliceIndex<[TokioQueue]>, 

Retrieve a mutable reference to the specified queue(s) if the suplied SliceIndex is inbounds.

pub fn close(&mut self) -> Result<()>

Close the device destroying all internal queues. NOTE: If drain is called its on the caller to cleanup the queues.

pub fn drain<R>(&mut self, range: R) -> Drain<'_, TokioQueue> where
    R: RangeBounds<usize>, 

Drain the internal queues, passing ownership of the queue and its lifecycle to the caller. This is useful in certain scenarios where extreme control over threading and I/O operations is desired.

pub fn iter(&self) -> Iter<'_, TokioQueue>

Iterate over immutable instances internal queues.

pub fn iter_mut(&mut self) -> IterMut<'_, TokioQueue>

Iterate over mutable instances of the internal queues.

pub async fn send(&self, datagram: &[u8]) -> Result<usize>

Send a packet asynchronously to an available queue. This method handles collecting all of the TokioQueue::writable() futures. Then leverages [select_all()] to await the first available queue to send the datagram via.

pub async fn send_via(&self, queue: usize, datagram: &[u8]) -> Result<usize>

Send a packet asynchronously via the specified TUN queue, see the TokioQueue::send() documentation for more details.

Errors

General I/O errors are possible, along with a Error::InvalidQueue if the specified queue is out of range for this device.

pub async fn recv(&self, datagram: &mut [u8]) -> Result<usize>

Receive a packet asynchronously from an available queue. This method handles collecting all of the TokioQueue::readable() futures. Then leverages [select_all()] to await the first available queue to send the datagram via.

pub async fn recv_via(&self, queue: usize, datagram: &mut [u8]) -> Result<usize>

Receive a packet asynchronously from the specified TUN queue, see the TokioQueue::recv() documentation for more details.

Errors

General I/O errors are possible, along with a Error::InvalidQueue if the specified queue is out of range for this device.

Trait Implementations

impl Index<usize> for TokioTun

type Output = TokioQueue

The returned type after indexing.

fn index(&self, index: usize) -> &TokioQueue

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for TokioTun

fn index_mut(&mut self, index: usize) -> &mut TokioQueue

Performs the mutable indexing (container[index]) operation.

impl IntoIterator for TokioTun

type Item = TokioQueue

The type of the elements being iterated over.

type IntoIter = IntoIter<TokioQueue>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.