Crate tcp

A TCP implementation with a somewhat-BSD-like socket API. It is written as a “sans-I/O” library meaning it doesn’t do any networking I/O itself, it just accepts bytes and provides bytes. A dependencies object must be be provided to support setting timers and getting the current time. The TCP state object should probably be used with a reference-counting wrapper so that a reference to the state object can be stored in the timer callbacks.

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
struct TcpDependencies {
    // a reference to the tcp state
    state: Weak<RefCell<tcp::TcpState<Self>>>,
}

impl tcp::Dependencies for TcpDependencies {
    type Instant = std::time::Instant;
    type Duration = std::time::Duration;

    fn register_timer(
        &self,
        time: Self::Instant,
        f: impl FnOnce(&mut tcp::TcpState<Self>, tcp::TimerRegisteredBy) + Send + Sync + 'static,
    ) {
        let tcp_state = self.state.upgrade().unwrap();

        // TODO: To register timers, you would likely want to involve an async
        // runtime. A simple example would create a new task for each timer. The
        // task would sleep for some duration and then run the callback.
    }

    fn current_time(&self) -> Self::Instant {
        std::time::Instant::now()
    }

    fn fork(&self) -> Self {
        // TODO: the implementation here would depend on the implementation
        // of `register_timer`
        todo!();
    }
}

// create the TCP state object
let tcp_state = Rc::new_cyclic(|weak| {
    let dependencies = TcpDependencies {
        state: weak.clone(),
    };
    RefCell::new(tcp::TcpState::new(dependencies, tcp::TcpConfig::default()))
});

let mut tcp_state = tcp_state.borrow_mut();

// connect to port 80
let dst_addr = "127.0.0.1:80".parse().unwrap();
tcp_state.connect(dst_addr, || {
    // here we would ask the network interface for an unused port (implicit bind),
    // or where we would use the port assigned to a raw IP socket
    let bind_addr = "127.0.0.1:2532".parse().unwrap();
    Ok::<_, ()>((bind_addr, ()))
}).unwrap();

// get the SYN packet from the connect
let (header, _payload) = tcp_state.pop_packet().unwrap();
assert!(header.flags.contains(tcp::TcpFlags::SYN));
assert_eq!(header.dst(), dst_addr);

Modules

• util

Structs

• AcceptedTcpState
  An accept()ed TCP state. This is used to ensure that the caller uses finalize to update the state’s Dependencies since the state is no longer owned by the listening socket.
• Ipv4Header
• Payload
  A packet payload containing a list of byte chunks.
• PollState
• TcpConfig
• TcpFlags
• TcpHeader
• TcpState

Enums

• AcceptError
• CloseError
• ConnectError
• ListenError
• PopPacketError
• PushPacketError
• RecvError
• SendError
• Shutdown
• ShutdownError
• TcpError
• TimerRegisteredBy
  Specifies whether the callback is meant to run on the parent state or a child state.

Traits

• Dependencies
  A collection of methods that allow the TCP state to interact with the external system.