Trait Device

pub trait Device {
    type RxToken<'a>: RxToken
       where Self: 'a;
    type TxToken<'a>: TxToken
       where Self: 'a;

    // Required methods
    fn receive(
        &mut self,
        timestamp: Instant,
    ) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)>;
    fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>>;
    fn capabilities(&self) -> DeviceCapabilities;
}

An interface for sending and receiving raw network frames.

The interface is based on tokens, which are types that allow to receive/transmit a single packet. The receive and transmit functions only construct such tokens, the real sending/receiving operation are performed when the tokens are consumed.

Required Associated Types

type RxToken<'a>: RxToken where Self: 'a

type TxToken<'a>: TxToken where Self: 'a

Required Methods

fn receive( &mut self, timestamp: Instant, ) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)>

Construct a token pair consisting of one receive token and one transmit token.

The additional transmit token makes it possible to generate a reply packet based on the contents of the received packet. For example, this makes it possible to handle arbitrarily large ICMP echo (“ping”) requests, where the all received bytes need to be sent back, without heap allocation.

The timestamp must be a number of milliseconds, monotonically increasing since an arbitrary moment in time, such as system startup.

fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>>

Construct a transmit token.

The timestamp must be a number of milliseconds, monotonically increasing since an arbitrary moment in time, such as system startup.

fn capabilities(&self) -> DeviceCapabilities

Get a description of device capabilities.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Device for Loopback

type RxToken<'a> = RxToken

type TxToken<'a> = TxToken<'a>

impl<D: Device> Device for FaultInjector<D>

type RxToken<'a> = RxToken<'a> where Self: 'a

type TxToken<'a> = TxToken<'a, <D as Device>::TxToken<'a>> where Self: 'a

impl<D: Device> Device for Tracer<D>

type RxToken<'a> = RxToken<<D as Device>::RxToken<'a>> where Self: 'a

type TxToken<'a> = TxToken<<D as Device>::TxToken<'a>> where Self: 'a

impl<D: Device, FTx, FRx> Device for FuzzInjector<D, FTx, FRx>

where FTx: Fuzzer, FRx: Fuzzer,

type RxToken<'a> = RxToken<'a, <D as Device>::RxToken<'a>, FRx> where Self: 'a

type TxToken<'a> = TxToken<'a, <D as Device>::TxToken<'a>, FTx> where Self: 'a

impl<D: Device, S> Device for PcapWriter<D, S>

where S: PcapSink,

type RxToken<'a> = RxToken<'a, <D as Device>::RxToken<'a>, S> where Self: 'a

type TxToken<'a> = TxToken<'a, <D as Device>::TxToken<'a>, S> where Self: 'a