Crate ts_netstack_smoltcp_socket 

ts_netstack_smoltcp_socket (netsock)

Ergonomic sockets API layer built around ts_netstack_smoltcp_core.

The idea is to take the command Channel and use it to expose an API that looks something like std::net or tokio::net, i.e. with UdpSocket, TcpStream, TcpListener, etc. This is implemented here by internalizing the Channel into each socket type so that they can all send commands on their own behalf.

Socket creation is implemented by CreateSocket as a set of extension methods on T where T: HasChannel.

Example

Compare the example in ts_netstack_smoltcp_core:

use core::net::SocketAddr;
use bytes::Bytes;
use netcore::smoltcp::time::Instant;
use netcore::smoltcp::phy::Medium;
use netcore::{Response, udp, HasChannel};
use netsock::CreateSocket;

extern crate ts_netstack_smoltcp_core as netcore;
extern crate ts_netstack_smoltcp_socket as netsock;

fn main() {
    // Construct a new netstack:
    let mut stack = netcore::Netstack::new(netcore::Config::default(), Instant::ZERO);

    // Grab a channel through which we can send commands:
    let channel = stack.command_channel();

    // Process the upcoming bind and send commands in the background (request() blocks
    // for a response, hence the thread)
    let thread = std::thread::spawn(move || {
        for i in 0..2 {
            let cmd = stack.wait_for_cmd_blocking(None).unwrap();
            stack.process_one_cmd(cmd);
        }

        stack
    });

    // Send a command to bind a UDP socket:
    let sock = channel.udp_bind_blocking(([127, 0, 0, 1], 1000).into()).unwrap();
    println!("bound udp socket: {sock:?}");

    sock.send_to_blocking(([1, 2, 3, 4], 80).into(), b"hello");
    println!("sent udp packet");

    // Wait for the thread started above to finish processing the two UDP port commands:
    let mut stack = thread.join().unwrap();

    // Pump the netstack to produce the IP packet that needs to be sent out on the network:
    let (end1, end2) = netcore::Pipe::unbounded();
    stack.poll_device_io(Instant::ZERO, &mut netcore::PipeDev {
        pipe: end1,
        medium: Medium::Ip,
        mtu: 1500,
    });

    // Receive the packet from the pipe device:
    let packet = end2.rx.recv().unwrap();
    println!("packet: {packet:?}");

    // Sanity-check that the packet we got back is shaped correctly:
    assert_eq!(
        packet.len(), 
        netcore::smoltcp::wire::IPV4_HEADER_LEN + netcore::smoltcp::wire::UDP_HEADER_LEN + b"hello".len(),
    );
    assert_eq!(packet[0] >> 4, 4); // ipv4 packet
    assert!(packet.ends_with(b"hello"));
}

Re-exports

pub extern crate ts_netstack_smoltcp_core as netcore;

Re-exports

pub use ping::PingError;

Modules

ping

Overlay ICMPv4 echo (ping) over a netstack Channel.

Structs

RawSocket

A raw IP socket.

TcpListener

A TCP listener waiting to accept connections.

TcpStream

A TCP stream.

UdpSocket

A UDP socket.

Enums

IpProtocol

IP datagram encapsulated protocol.

Traits

CreateSocket

API for creating sockets over a HasChannel.