Struct Stack 

pub struct Stack<'d> { /* private fields */ }

A network stack.

Implementations

impl Stack<'_>

pub fn reassembly_timeout(&self) -> Duration

Get the packet reassembly timeout.

This is how long the fragments of an incoming IPv4 or 6LoWPAN packet are kept while waiting for the rest of it. The default is 60 seconds.

pub fn set_reassembly_timeout(&mut self, timeout: Duration)

Set the packet reassembly timeout.

Fragments of an incoming IPv4 or 6LoWPAN packet that is not complete by then are dropped, and the packet buffer they were kept in is freed.

impl<'d> Stack<'d>

pub fn new(random_seed: u64) -> Self

Create a network stack.

random_seed seeds the stack’s PRNG, which picks TCP initial sequence numbers and ephemeral ports. This should be random, or at least different at every boot.

pub fn hostname(&self) -> Option<&str>

The stack’s hostname, or None if not set.

pub fn set_hostname(&mut self, hostname: &str) -> Result<(), HostnameTooLong>

Set the stack’s hostname.

If set, it is sent to the DHCP server in outgoing DHCP messages, as the host name option.

An empty string clears the hostname.

Errors:

• HostnameTooLong if hostname is longer than 63 bytes. The hostname is left unchanged.

pub fn add_iface( &mut self, driver: Box<dyn Driver + 'd>, ) -> Result<IfaceHandle, AddIfaceError>

Add an interface to the stack, returning a handle to it.

The stack owns the boxed device, so this needs the alloc feature. Without alloc, use add_iface_borrowed.

Configure the interface after adding it. At minimum, you will want to add an IP address to it.

let handle = stack.add_iface(driver).unwrap();
stack
    .iface(handle)
    .add_ip_addr(IpCidr::new(Ipv4Addr::new(192, 168, 1, 1).into(), 24))
    .unwrap();

Errors:

• Full if the stack has no room for another interface. Only possible without the alloc feature, where the limit is IFACE_COUNT.
• UnsupportedMedium if the build has no medium-* feature for the device’s medium.
• HardwareAddrMismatch if the hardware address the device reports is not of the kind its medium uses.

pub fn add_iface_borrowed( &mut self, driver: &'d mut dyn Driver, ) -> Result<IfaceHandle, AddIfaceError>

Add an interface to the stack, lending it the device, and returning a handle to it.

The stack holds the device until it is dropped or the interface is removed, so the device must be declared before the stack, or be 'static. Otherwise this is add_iface.

Errors:

• Full if the stack has no room for another interface. Only possible without the alloc feature, where the limit is IFACE_COUNT.
• UnsupportedMedium if the build has no medium-* feature for the device’s medium.
• HardwareAddrMismatch if the hardware address the device reports is not of the kind its medium uses.

pub fn poll_tx_timestamp(&mut self) -> Option<TxTimestamp>

Take the timestamp of an already-transmitted packet, sent with PacketMeta::request_timestamp set.

The timestamps of every interface land in one queue, which Self::poll fills from the drivers. This only reads it, so poll first.

Timestamps arrive an arbitrary time after the packet was sent, possibly out of order, and possibly never: a device may not support transmit timestamping, may have run out of timestamp slots, or the queue may have been full (its capacity is TX_TIMESTAMP_QUEUE_COUNT). Time out waiting for one rather than expecting it.

The queue has one consumer, so the packet ids it reports back must be unique across everything the application sends, on every interface. Don’t reuse an id while a timestamp for the old packet can still arrive. Removing an interface does not drop the timestamps it already queued.

pub fn register_tx_timestamp_waker(&mut self, waker: &Waker)

Register a waker, woken when a TX timestamp is queued.

Register it before checking Self::poll_tx_timestamp. Only one waker is kept: registering another replaces it.

pub fn iface(&mut self, handle: IfaceHandle) -> Iface<'_, 'd>

Borrow an interface from the stack.

Panics

Panics if the handle is stale (the interface was removed).

pub fn remove_iface(&mut self, handle: IfaceHandle)

Remove an interface from the stack.

Panics

Panics if the handle is stale (the interface was already removed).

pub fn neighbor_cache(&self) -> &NeighborCache

Access the neighbor cache.

pub fn neighbor_cache_mut(&mut self) -> &mut NeighborCache

Access the neighbor cache for modification.

pub fn routes(&self) -> &Routes

Access the routing table.

pub fn routes_mut(&mut self) -> &mut Routes

Access the routing table for modification.

pub fn add_udp_socket(&mut self) -> Result<UdpHandle, Full>

Add a UDP socket to the stack, returning a handle to it.

Errors:

• Full if the stack has no room for another UDP socket. Only possible without the alloc feature, where the limit is UDP_SOCKET_COUNT.

pub fn remove_udp_socket(&mut self, handle: UdpHandle)

Remove a UDP socket from the stack.

Panics

Panics if the handle is stale (the socket was already removed).

pub fn udp_socket(&mut self, handle: UdpHandle) -> UdpSocket<'_, 'd>

Borrow a UDP socket from the stack.

Panics

Panics if the handle is stale (the socket was already removed).

pub fn add_raw_socket(&mut self) -> Result<RawHandle, Full>

Add a raw socket to the stack, returning a handle to it.

Errors:

• Full if the stack has no room for another raw socket. Only possible without the alloc feature, where the limit is RAW_SOCKET_COUNT.

pub fn remove_raw_socket(&mut self, handle: RawHandle)

Remove a raw socket from the stack.

Panics

Panics if the handle is stale (the socket was already removed).

pub fn raw_socket(&mut self, handle: RawHandle) -> RawSocket<'_, 'd>

Borrow a raw socket from the stack.

Panics

Panics if the handle is stale (the socket was already removed).

pub fn add_tcp_socket( &mut self, rx_capacity: usize, tx_capacity: usize, ) -> Result<TcpHandle, Full>

Add a TCP socket to the stack, with receive and transmit buffers of the given capacities, returning a handle to it.

The buffers are allocated on the heap, so this needs the alloc feature. Without it, or to use your own buffers, see add_tcp_socket_with_bufs.

Panics

Panics if the receive buffer is larger than 1 GiB.

Errors:

• Full if the stack has no room for another TCP socket. Only possible without the alloc feature, where the limit is TCP_SOCKET_COUNT.

pub fn add_tcp_socket_with_bufs( &mut self, rx_buffer: &'d mut [u8], tx_buffer: &'d mut [u8], ) -> Result<TcpHandle, Full>

Add a TCP socket to the stack, with borrowed receive and transmit buffers, and returning a handle to it.

The stack holds the buffers until it is dropped or the socket is removed, so they must be declared before the stack, or be 'static. Otherwise this is add_tcp_socket.

let handle = stack.add_tcp_socket_with_bufs(rx, tx).unwrap();

Panics

Panics if the receive buffer is larger than 1 GiB.

Errors:

• Full if the stack has no room for another TCP socket. Only possible without the alloc feature, where the limit is TCP_SOCKET_COUNT.

pub fn remove_tcp_socket(&mut self, handle: TcpHandle)

Remove a TCP socket from the stack.

No RST is sent, and any buffered data is lost. To close a connection cleanly, TcpSocket::close it first and poll until it is fully closed.

Panics

Panics if the handle is stale (the socket was already removed).

pub fn tcp_socket(&mut self, handle: TcpHandle) -> TcpSocket<'_, 'd>

Borrow a TCP socket from the stack.

Panics

Panics if the handle is stale (the socket was already removed).

pub fn add_tcp_listener(&mut self) -> Result<TcpListenerHandle, Full>

Add a TCP listener to the stack, returning a handle to it.

Errors:

• Full if the stack has no room for another listener. Only possible without the alloc feature, where the limit is TCP_LISTENER_COUNT.

pub fn remove_tcp_listener(&mut self, handle: TcpListenerHandle)

Remove a TCP listener from the stack.

Panics

Panics if the handle is stale (the listener was already removed).

pub fn tcp_listener(&mut self, handle: TcpListenerHandle) -> TcpListener<'_>

Borrow a TCP listener from the stack.

Panics

Panics if the handle is stale (the listener was already removed).

pub fn ifaces(&mut self) -> IfaceIter<'_, 'd>

Iterate over the interfaces added to the stack.

See IfaceIter for how to use it.

pub fn udp_sockets(&mut self) -> UdpSocketIter<'_, 'd>

Iterate over the UDP sockets added to the stack.

See UdpSocketIter for how to use it.

pub fn raw_sockets(&mut self) -> RawSocketIter<'_, 'd>

Iterate over the raw sockets added to the stack.

See RawSocketIter for how to use it.

pub fn tcp_sockets(&mut self) -> TcpSocketIter<'_, 'd>

Iterate over the TCP sockets added to the stack.

See TcpSocketIter for how to use it.

pub fn tcp_listeners(&mut self) -> TcpListenerIter<'_, 'd>

Iterate over the TCP listeners added to the stack.

See TcpListenerIter for how to use it.

pub fn poll(&mut self, timestamp: Instant) -> Instant

Process all pending ingress packets on all ifaces, advance the stack’s internal timers, and transmit everything the TCP sockets have made due.

timestamp is the current time.

Returns a “poll deadline” instant. It is the earliest expiring timer. You should call poll at that instant to let it advance timers. Special cases:

• If it’s Instant::MIN or in the past, poll should be called again immediately.
• If no timer is pending, Instant::MAX is returned. No need to call poll on a timer, only after a packet is received or an operation is done on the Stack, a socket or an interface.