Enum EthernetLinkDevice 

pub enum EthernetLinkDevice {}

An implementation of the LinkDevice trait for Ethernet devices.

Trait Implementations

impl<BC: BindingsContext, L: LockBefore<IpState<Ipv4>>> ArpContext<EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

type ConfigCtx<'a> = CoreCtxWithDeviceId<'a, Locked<&'a StackState<BC>, <EthernetIpv4Arp as WrappedLockLevel>::LockLevel>>

The inner configuration context.

type ArpSenderCtx<'a> = CoreCtxWithDeviceId<'a, Locked<&'a StackState<BC>, <EthernetIpv4Arp as WrappedLockLevel>::LockLevel>>

The inner sender context.

fn with_arp_state_mut_and_sender_ctx<O, F: FnOnce(&mut ArpState<EthernetLinkDevice, BC>, &mut Self::ArpSenderCtx<'_>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls the function with a mutable reference to ARP state and the core sender context.

fn get_protocol_addr( &mut self, device_id: &EthernetDeviceId<BC>, ) -> Option<Ipv4Addr>

Get a protocol address of this interface.

fn get_hardware_addr( &mut self, _bindings_ctx: &mut BC, device_id: &EthernetDeviceId<BC>, ) -> UnicastAddr<Mac>

Get the hardware address of this interface.

fn with_arp_state_mut<O, F: FnOnce(&mut ArpState<EthernetLinkDevice, BC>, &mut Self::ConfigCtx<'_>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls the function with a mutable reference to ARP state and the ARP configuration context.

fn with_arp_state<O, F: FnOnce(&ArpState<EthernetLinkDevice, BC>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls the function with an immutable reference to ARP state.

impl<BC: BindingsContext, L: LockBefore<IpDeviceConfiguration<Ipv4>>> ArpIpLayerContext<EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

fn on_arp_packet( &mut self, bindings_ctx: &mut BC, device_id: &EthernetDeviceId<BC>, frame_src: Mac, sender_hwaddr: UnicastAddr<Mac>, sender_addr: Ipv4Addr, target_addr: Ipv4Addr, is_arp_probe: bool, ) -> bool

Dispatches a received ARP Request or Reply to the IP layer.

impl Clone for EthernetLinkDevice

fn clone(&self) -> EthernetLinkDevice

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for EthernetLinkDevice

impl Debug for EthernetLinkDevice

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Device for EthernetLinkDevice

impl<BT> DeviceBufferSpec<BT> for EthernetLinkDevice

where BT: DeviceBufferBindingsTypes,

type TxBuffer = <BT as DeviceBufferBindingsTypes>::TxBuffer

Used to for Tx Buffers.

type TxAllocator = <BT as DeviceBufferBindingsTypes>::TxAllocator

Used to allocate Tx Buffers.

impl<'a, BT, L> DeviceCollectionContext<EthernetLinkDevice, BT> for CoreCtx<'a, BT, L>

where BT: BindingsTypes, L: LockBefore<DeviceLayerState>,

fn insert(&mut self, device: EthernetPrimaryDeviceId<BT>)

Adds device to the device collection.

fn remove( &mut self, device: &EthernetDeviceId<BT>, ) -> Option<EthernetPrimaryDeviceId<BT>>

Removes device from the collection, if it exists.

impl<'a, BT, L> DeviceConfigurationContext<EthernetLinkDevice> for CoreCtx<'a, BT, L>

where L: LockBefore<NudConfig<Ipv4>> + LockBefore<NudConfig<Ipv6>>, BT: BindingsTypes,

fn with_nud_config<I: Ip, O, F: FnOnce(Option<&NudUserConfig>) -> O>( &mut self, device_id: &Self::DeviceId, f: F, ) -> O

Calls the callback with a mutable reference to the NUD user configuration for IP version I.

fn with_nud_config_mut<I: Ip, O, F: FnOnce(Option<&mut NudUserConfig>) -> O>( &mut self, device_id: &Self::DeviceId, f: F, ) -> O

Calls the callback with a mutable reference to the NUD user configuration for IP version I.

impl<BT: BindingsTypes, L> DeviceIdContext<EthernetLinkDevice> for CoreCtx<'_, BT, L>

type DeviceId = BaseDeviceId<EthernetLinkDevice, BT>

The type of device IDs.

type WeakDeviceId = BaseWeakDeviceId<EthernetLinkDevice, BT>

The type of weakly referenced device IDs.

impl DeviceStateSpec for EthernetLinkDevice

const IS_LOOPBACK: bool = false

Marker for loopback devices.

const DEBUG_TYPE: &'static str = "Ethernet"

Marker used to print debug information for device identifiers.

type State<BT: DeviceLayerTypes> = EthernetDeviceState<BT>

The device state.

type External<BT: DeviceLayerTypes> = <BT as DeviceLayerStateTypes>::EthernetDeviceState

The external (bindings) state.

type CreationProperties = EthernetCreationProperties

Properties given to device creation.

type Counters = EthernetDeviceCounters

Device-specific counters.

type TimerId<D: WeakDeviceIdentifier> = EthernetTimerId<D>

The timer identifier required by this device state.

fn new_device_state<CC, BC>( bindings_ctx: &mut BC, self_id: <CC as DeviceIdContext<EthernetLinkDevice>>::WeakDeviceId, _: <EthernetLinkDevice as DeviceStateSpec>::CreationProperties, tx_allocator: <EthernetLinkDevice as DeviceBufferSpec<BC>>::TxAllocator, ) -> <EthernetLinkDevice as DeviceStateSpec>::State<BC>

where CC: CoreTimerContext<<EthernetLinkDevice as DeviceStateSpec>::TimerId<<CC as DeviceIdContext<EthernetLinkDevice>>::WeakDeviceId>, BC> + DeviceIdContext<EthernetLinkDevice>, BC: DeviceLayerTypes + TimerContext, EthernetLinkDevice: DeviceBufferSpec<BC>,

Creates a new device state from the given properties.

fn tx_offload_spec<BT>( state: &<EthernetLinkDevice as DeviceStateSpec>::State<BT>, ) -> Option<ChecksumOffloadSpec>

where BT: DeviceLayerTypes,

Returns the TX checksum offload specification for the device, if it has one.

impl Eq for EthernetLinkDevice

impl Hash for EthernetLinkDevice

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LinkDevice for EthernetLinkDevice

type Address = Mac

The type of address used to address link devices of this type.

impl<BC: BindingsContext, L: LockBefore<FilterState<Ipv6>>> NudContext<Ipv6, EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

type ConfigCtx<'a> = CoreCtxWithDeviceId<'a, Locked<&'a StackState<BC>, <EthernetIpv6Nud as WrappedLockLevel>::LockLevel>>

The inner configuration context.

type SenderCtx<'a> = CoreCtxWithDeviceId<'a, Locked<&'a StackState<BC>, <EthernetIpv6Nud as WrappedLockLevel>::LockLevel>>

The inner send context.

fn with_nud_state_mut_and_sender_ctx<O, F: FnOnce(&mut NudState<Ipv6, EthernetLinkDevice, BC>, &mut Self::SenderCtx<'_>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls the function with a mutable reference to the NUD state and the core sender context.

fn with_nud_state_mut<O, F: FnOnce(&mut NudState<Ipv6, EthernetLinkDevice, BC>, &mut Self::ConfigCtx<'_>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls the function with a mutable reference to the NUD state and NUD configuration for the device.

fn with_nud_state<O, F: FnOnce(&NudState<Ipv6, EthernetLinkDevice, BC>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls the function with an immutable reference to the NUD state.

fn send_neighbor_solicitation( &mut self, bindings_ctx: &mut BC, device_id: &EthernetDeviceId<BC>, lookup_addr: SpecifiedAddr<Ipv6Addr>, remote_link_addr: Option<UnicastAddr<Mac>>, )

Sends a neighbor probe/solicitation message.

impl<BC: BindingsContext, L: LockBefore<IcmpAllSocketsSet<Ipv4>>> NudIcmpContext<Ipv4, EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

fn send_icmp_dest_unreachable( &mut self, bindings_ctx: &mut BC, frame: Buf<Vec<u8>>, device_id: Option<&Self::DeviceId>, original_src_ip: SocketIpAddr<Ipv4Addr>, original_dst_ip: SocketIpAddr<Ipv4Addr>, header_len: usize, proto: Ipv4Proto, fragment_type: Ipv4FragmentType, )

Send an ICMP destination unreachable error to original_src_ip as a result of frame being unable to be sent/forwarded due to link layer address resolution failure.

impl<BC: BindingsContext, L: LockBefore<IcmpAllSocketsSet<Ipv6>>> NudIcmpContext<Ipv6, EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

fn send_icmp_dest_unreachable( &mut self, bindings_ctx: &mut BC, frame: Buf<Vec<u8>>, device_id: Option<&Self::DeviceId>, original_src_ip: SocketIpAddr<Ipv6Addr>, original_dst_ip: SocketIpAddr<Ipv6Addr>, header_len: usize, proto: Ipv6Proto, _metadata: (), )

Send an ICMP destination unreachable error to original_src_ip as a result of frame being unable to be sent/forwarded due to link layer address resolution failure.

impl PartialEq for EthernetLinkDevice

fn eq(&self, other: &EthernetLinkDevice) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for EthernetLinkDevice

impl<BC: BindingsContext, L: LockBefore<EthernetTxDequeue>> TransmitDequeueContext<EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

type TransmitQueueCtx<'a> = Locked<&'a StackState<BC>, <EthernetTxDequeue as WrappedLockLevel>::LockLevel>

The inner context providing dequeuing.

fn with_dequed_packets_and_tx_queue_ctx<O, F: FnOnce(&mut DequeueState<Self::Meta, BC::TxBuffer>, &mut Self::TransmitQueueCtx<'_>) -> O>( &mut self, device_id: &Self::DeviceId, cb: F, ) -> O

Calls the function with the TX deque state and the TX queue context.

impl<BC: BindingsContext, L: LockBefore<EthernetTxQueue>> TransmitQueueCommon<EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

type Meta = <BC as TxMetadataBindingsTypes>::TxMetadata

The metadata associated with every packet in the queue.

type DequeueContext = <BC as DeviceLayerEventDispatcher>::DequeueContext

The context given to send_frame when dequeueing.

fn parse_outgoing_frame<'a, 'b>( buf: &'a [u8], _meta: &'b Self::Meta, ) -> Result<SentFrame<&'a [u8]>, ParseSentFrameError>

Parses an outgoing frame for packet socket delivery.

impl<BC: BindingsContext, L: LockBefore<EthernetTxQueue>> TransmitQueueContext<EthernetLinkDevice, BC> for CoreCtx<'_, BC, L>

fn with_transmit_queue_mut<O, F: FnOnce(&mut TransmitQueueState<Self::Meta, BC::TxBuffer, BC::TxAllocator>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls cb with mutable access to the queue state.

fn with_transmit_queue<O, F: FnOnce(&TransmitQueueState<Self::Meta, BC::TxBuffer, BC::TxAllocator>) -> O>( &mut self, device_id: &EthernetDeviceId<BC>, cb: F, ) -> O

Calls cb with immutable access to the queue state.

fn send_frame( &mut self, bindings_ctx: &mut BC, device_id: &Self::DeviceId, dequeue_context: Option<&mut BC::DequeueContext>, meta: Self::Meta, buf: BC::TxBuffer, ) -> Result<(), DeviceSendFrameError>

Send a frame out the device.