Struct CoreStack 

pub struct CoreStack { /* private fields */ }

Internally i/o free userspace network stack built around smoltcp.

Implementations

impl Netstack

pub fn new(ns_config: Config, now: Instant) -> Netstack

Construct a netstack with the given config and starting instant.

Panics

If ns_config.loopback is set and smoltcp’s iface-max-addr-count (feature flag) is less than 2.

pub fn poll_at(&mut self, now: Instant) -> Option<Instant>

Report the next time the netstack should be polled.

pub fn poll_delay(&mut self, now: Instant) -> Option<Duration>

Report the amount of time until the netstack should next be polled.

pub fn process_cmds(&mut self)

Process all commands available in the command queue.

pub fn wait_for_cmd_blocking( &mut self, timeout: Option<Duration>, ) -> Result<Request, RecvTimeoutError>

Synchronously block for a single command over the channel.

pub fn wait_for_cmd(&self) -> impl Future<Output = Option<Request>> + use<>

Asynchronously wait for a single command over the channel.

pub fn direct_set_ips(&mut self, ips: impl IntoIterator<Item = IpAddr>) -> bool

Set the IP addresses for this interface.

Loopback addresses are automatically appended if indicated by Config::loopback.

The return value reports whether the operation was successful: if not, it was because there wasn’t enough storage configured in smoltcp’s feature flags for the number of submitted interface IPs.

pub fn process_one_cmd(&mut self, _: Request)

Process a single command.

pub fn poll_device_io(&mut self, now: Instant, dev: &mut impl Device) -> bool

Poll the lower device to send and receive packets, and attempt to complete any blocked socket commands.

Returns whether there were any updates to socket state.

pub fn poll_device_ingress_async( &mut self, cx: &mut Context<'_>, now: Instant, dev: Pin<&mut (impl AsyncWakeDevice + Device + Unpin)>, ) -> Poll<bool>

Poll the device for all synchronously-available packets and process them.

The return value indicates whether packets were consumed and if sockets made progress:

• Poll::Pending: no packets were processed because we were waiting for them to arrive from `dev.
• Poll::Ready(false): we received packets but socket state did not make progress
• Poll::Ready(true): we received packets and socket state did make progress

When this function returns, it is guaranteed that all packets currently available to receive from dev have been processed.

Unlike the synchronous poll_device_io, this does not call drain_tcp_closes: the async driver loop (the netstack Future’s poll) owns that, calling it once per poll after both ingress and egress have run (so a socket smoltcp drove to Closed here — which always reports Poll::Ready(true) — is reaped in the same poll cycle). A future caller that drives this method outside that loop must call drain_tcp_closes itself, or autonomously-Closed sockets will linger in pending_tcp_closes until the next drain.

pub fn poll_device_egress_async( &mut self, cx: &mut Context<'_>, now: Instant, dev: Pin<&mut (impl AsyncWakeDevice + Device + Unpin)>, ) -> Poll<bool>

Send all packets the netstack wants to transmit on the network.

Returns:

• Poll::Pending if no packets could be sent because dev wasn’t ready (if AsyncWakeDevice::poll_tx returns Poll::Pending)
• Poll::Ready(false) if dev was ready but no packets needed to be sent
• Poll::Ready(true) if dev was ready and packets were sent

pub fn wait_io_async<'stack, 'dev, D>( &'stack mut self, now: Instant, dev: &'dev mut D, ) -> IoPoller<'stack, 'dev, D>

where D: AsyncWakeDevice + Device + Unpin,

Attempt to send and receive packets on dev.

The future becomes ready when dev sends or receives packets on the network. All synchronously-available network I/O is always performed.

Assumes that alarms are handled separately and that now does not advance over the course of the polled future.

Trait Implementations

impl HasChannel for Netstack

fn borrow_channel(&self) -> impl Borrow<WeakSender<Request>> + Send

Retrieve a Channel borrow.

fn command_channel(&self) -> WeakSender<Request>

Clone a new command channel.

fn request_blocking( &self, handle: Option<SocketHandle>, command: impl Into<Command>, ) -> Result<Response, ChannelClosedError>

Send a request through the channel.

fn request( &self, handle: Option<SocketHandle>, command: impl Into<Command>, ) -> impl Future<Output = Result<Response, Error>> + Send

Asynchronously send a request through the channel.

fn request_nonblocking( &self, handle: Option<SocketHandle>, command: impl Into<Command>, ) -> Result<(), ChannelClosedError>

Send a nonblocking request, discarding any response.