Struct NetworkStack

pub struct NetworkStack<'a, Device, Clock>
where
    Device: Device,
    Clock: Clock,
    u32: From<Clock::T>,
{ /* private fields */ }

Network abstraction layer for smoltcp.

Implementations

impl<'a, Device, Clock> NetworkStack<'a, Device, Clock>

where Device: Device, Clock: Clock, u32: From<Clock::T>,

pub fn new( stack: Interface, device: Device, sockets: SocketSet<'a>, clock: Clock, ) -> Self

Construct a new network stack.

Note

This implementation only supports up to 16 usable sockets.

Any handles provided to this function must not be used after constructing the network stack.

This implementation currently only supports IPv4.

Args

• stack - The ethernet interface to construct the network stack from.
• clock - A clock to use for determining network time.

Returns

A embedded_nal compatible network stack.

pub fn seed_random_port(&mut self, seed: &[u8])

Seed the TCP port randomizer.

Args

• seed - A seed of random data to use for randomizing local TCP port selection.

pub fn poll(&mut self) -> Result<bool, Error>

Poll the network stack for potential updates.

Returns

A boolean indicating if the network stack updated in any way.

pub fn close_sockets(&mut self)

Force-close all sockets.

pub fn handle_link_reset(&mut self)

Handle a disconnection of the physical interface.

pub fn interface(&self) -> &Interface

Access the underlying network interface.

pub fn interface_mut(&mut self) -> &mut Interface

Mutably access the underlying network interface.

Note

Modification of the underlying network interface may unintentionally interfere with operation of this library (e.g. through reset, modification of IP addresses, etc.). Mutable access to the interface should be done with care.

Trait Implementations

impl<Device, Clock> Dns for NetworkStack<'_, Device, Clock>

where Device: Device, Clock: Clock, u32: From<Clock::T>,

type Error = NetworkError

The type returned when we have an error

fn get_host_by_name( &mut self, hostname: &str, _addr_type: AddrType, ) -> Result<IpAddr, Self::Error>

Resolve the first ip address of a host, given its hostname and a desired address record type to look for

fn get_host_by_address( &mut self, _addr: IpAddr, _: &mut [u8], ) -> Result<usize, Error<Self::Error>>

Resolve the hostname of a host, given its ip address.

impl<Device, Clock> TcpClientStack for NetworkStack<'_, Device, Clock>

where Device: Device, Clock: Clock, u32: From<Clock::T>,

type Error = NetworkError

The type returned when we have an error

type TcpSocket = SocketHandle

The type returned when we create a new TCP socket

fn socket(&mut self) -> Result<SocketHandle, NetworkError>

Open a socket for usage as a TCP client.

fn connect( &mut self, socket: &mut SocketHandle, remote: SocketAddr, ) -> Result<(), NetworkError>

Connect to the given remote host and port.

fn send( &mut self, socket: &mut SocketHandle, buffer: &[u8], ) -> Result<usize, NetworkError>

Write to the stream.

fn receive( &mut self, socket: &mut SocketHandle, buffer: &mut [u8], ) -> Result<usize, NetworkError>

Receive data from the stream.

fn close(&mut self, socket: SocketHandle) -> Result<(), NetworkError>

Close an existing TCP socket.

impl<Device, Clock> UdpClientStack for NetworkStack<'_, Device, Clock>

where Device: Device, Clock: Clock, u32: From<Clock::T>,

type Error = NetworkError

The type returned when we have an error

type UdpSocket = UdpSocket

The type returned when we create a new UDP socket

fn socket(&mut self) -> Result<UdpSocket, NetworkError>

Allocate a socket for further use.

fn connect( &mut self, socket: &mut UdpSocket, remote: SocketAddr, ) -> Result<(), NetworkError>

Connect a UDP socket with a peer using a dynamically selected port.

fn send( &mut self, socket: &mut UdpSocket, buffer: &[u8], ) -> Result<(), NetworkError>

Send a datagram to the remote host.

fn receive( &mut self, socket: &mut UdpSocket, buffer: &mut [u8], ) -> Result<(usize, SocketAddr), NetworkError>

Read a datagram the remote host has sent to us.

fn close(&mut self, socket: UdpSocket) -> Result<(), NetworkError>

Close an existing UDP socket.

impl<Device, Clock> UdpFullStack for NetworkStack<'_, Device, Clock>

where Device: Device, Clock: Clock, u32: From<Clock::T>,

fn bind( &mut self, socket: &mut UdpSocket, local_port: u16, ) -> Result<(), NetworkError>

Bind a UDP socket to a specific port.

fn send_to( &mut self, socket: &mut Self::UdpSocket, remote: SocketAddr, buffer: &[u8], ) -> Result<(), NetworkError>

Send a packet to a remote host/port.