Struct ethox::nic::external::External

pub struct External<T> { /* fields omitted */ }

An interface with buffers managed externally.

This implementation can be used in a number of ways. Firstly, it is good to mock a real interface in tests, allowing full control over the behaviour between operations. Secondly, it can be used as a temporary software buffer for virtualization purposes.

Methods

impl<T> External<T>

pub fn set_one_past_receive(&mut self, at: usize)

Set the index of the last to-receive buffer.

pub fn reset_send(&mut self)

Reset sending, resending into the first buffer.

pub fn reset_receive(&mut self)

Reset receiving, receiving the first buffer again.

impl<T, P> External<T> where
    T: Deref<Target = [P]>, 

pub fn new_send(buffer: T) -> Self

A new external nic, only sending packets.

pub fn new_recv(buffer: T) -> Self

A new external nic, only receiving packets.

pub fn to_recv(&self) -> usize

Remaining number of buffers to receive.

pub fn to_send(&self) -> usize

Remaining number of buffers to send.

pub fn receive_all(&mut self)

Change the buffer state such that all packets are pending to be received.

pub fn send_all(&mut self)

Change the buffer state such that all packets are pending to be sent.

pub fn get(&self, idx: usize) -> Option<&P>

Get a reference to the buffer as the specified index.

pub fn get_mut(&mut self, idx: usize) -> Option<&mut P> where
    T: DerefMut, 

Get a mutable reference to the buffer as the specified index.

pub fn set_current_time(&mut self, instant: Instant)

Update the timestamp on all future received packets.

Trait Implementations

impl<T, P> Device for External<T> where
    T: Deref<Target = [P]> + DerefMut,
    P: Payload, 

type Handle = Handle

The control handle type also providing packet meta information.

type Payload = P

The payload buffer type of this device.

fn personality(&self) -> Personality

A description of the device.

fn tx(
    &mut self,
    max: usize,
    sender: impl Send<Self::Handle, Self::Payload>
) -> Result<usize>

Transmit some packets utilizing the sender.

fn rx(
    &mut self,
    max: usize,
    receptor: impl Recv<Self::Handle, Self::Payload>
) -> Result<usize>

Receive packet utilizing the receptor.