feat(kernel): bump crabnet and crabnet_tcp

* Bump `crabnet` and `crabnet_tcp`
* No longer ignore the TCP options and pass them to `on_packet` on the
  respective TCP socket.

Signed-off-by: Anhad Singh <[email protected]>

Author: Andy-Python-Programmer

src/Cargo.lock

@@ -50,6 +50,8 @@ vte = { git = "https://github.com/alacritty/vte", features = ["ansi"] }
 byte_endian = { git = "https://github.com/aero-os/byte_endian" }
 crabnet = { git = "https://github.com/aero-os/crabnet" }
 crabnet_tcp = { git = "https://github.com/aero-os/crabnet", default-features = false }
+# crabnet = { path = "../../../orgs/aero/crabnet" }
+# crabnet_tcp = { path = "../../../orgs/aero/crabnet/crabnet_tcp", default-features = false }
 
 # X86_64 specific dependencies:
 [target.'cfg(target_arch = "x86_64")'.dependencies]

src/aero_kernel/Cargo.toml

@@ -18,6 +18,7 @@
 use alloc::boxed::Box;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
+use crabnet::transport::TcpOptions;
 use spin::RwLock;
 
 pub mod arp;
@@ -132,12 +133,11 @@ fn packet_processor_thread() {
 
                     Ipv4Type::Tcp => {
                         let tcp = parser.next::<Tcp>();
-                        let options_size = tcp.options_size() as usize;
-                        let size = ip.payload_len() as usize - core::mem::size_of::<Tcp>();
+                        let size = ip.payload_len() as usize - tcp.header_size() as usize;
+                        let options = parser.next::<TcpOptions>();
+                        let payload = &parser.payload()[..size];
 
-                        // TODO(andypython): do not ignore TCP options.
-                        let payload = &parser.payload()[options_size..size];
-                        tcp::on_packet(tcp, payload)
+                        tcp::on_packet(tcp, options, payload)
                     }
                 }
             }
@@ -217,6 +217,26 @@ pub mod shim {
         }
     }
 
+    impl<T: Protocol, U: Protocol, S: Protocol> PacketSend
+        for Stacked<Stacked<Stacked<Stacked<Eth, Ipv4>, T>, U>, S>
+    {
+        fn send(mut self) {
+            let device = net::default_device();
+
+            let eth = &mut self.upper.upper.upper.upper;
+            let ip = &self.upper.upper.upper.lower;
+
+            eth.src_mac = device.mac();
+
+            if let Some(addr) = arp::get(ip.dest_ip()) {
+                eth.dest_mac = addr;
+                device.send(self.into_boxed_bytes_in(DmaAllocator));
+            } else {
+                arp::request_ip(ip.dest_ip(), self.into_boxed_bytes_in(DmaAllocator));
+            }
+        }
+    }
+
     impl PacketSend for Arp {
         fn send(self) {
             let device = net::default_device();

src/aero_kernel/src/net/mod.rs

@@ -18,18 +18,18 @@
 use alloc::collections::BTreeMap;
 use alloc::sync::Arc;
 
-use crabnet::transport::Tcp;
+use crabnet::transport::{Tcp, TcpOptions};
 use spin::RwLock;
 
 use crate::socket::tcp::TcpSocket;
 
 static HANDLERS: RwLock<BTreeMap<u16, Arc<TcpSocket>>> = RwLock::new(BTreeMap::new());
 
-pub fn on_packet(tcp: &Tcp, payload: &[u8]) {
+pub fn on_packet(tcp: &Tcp, options: TcpOptions, payload: &[u8]) {
     let handlers = HANDLERS.read();
 
     if let Some(handler) = handlers.get(&tcp.dest_port()) {
-        handler.on_packet(tcp, payload);
+        handler.on_packet(tcp, options, payload);
     } else {
         log::warn!("tcp: no handler registered for port {}", tcp.dest_port());
     }

src/aero_kernel/src/net/tcp.rs

@@ -3,11 +3,12 @@ use aero_syscall::{InAddr, OpenFlags, SocketAddrInet, AF_INET};
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 
+use crabnet::network::Ipv4Addr;
 use spin::Once;
 
 use crabnet::data_link::{Eth, EthType, MacAddr};
-use crabnet::transport::Tcp;
-use crabnet_tcp::{Address, Error as TcpError, State};
+use crabnet::transport::{Tcp, TcpOptions};
+use crabnet_tcp::{Address, Error as TcpError, Packet as TcpPacket, State};
 
 use crate::fs::file_table::FileHandle;
 use crate::fs::inode::{FileType, INodeInterface, Metadata, PollFlags, PollTable};
@@ -23,19 +24,14 @@ use crate::utils::sync::{Mutex, WaitQueue};
 struct DeviceShim(Arc<NetworkDevice>);
 
 impl crabnet_tcp::NetworkDevice for DeviceShim {
-    fn send(
-        &self,
-        ipv4: crabnet::network::Ipv4,
-        tcp: Tcp,
-        payload: &[u8],
-        _handle: crabnet_tcp::RetransmitHandle,
-    ) {
-        // TODO(andypython): Handle TCP retransmission here.
+    fn ip(&self) -> Ipv4Addr {
+        self.0.ip()
+    }
 
+    fn send(&self, packet: TcpPacket, _handle: crabnet_tcp::RetransmitHandle) {
+        // TODO(andypython): Handle TCP retransmission here.
         let eth = Eth::new(MacAddr::NULL, self.0.mac(), EthType::Ip);
-        let ipv4 = ipv4.set_src_ip(self.0.ip());
-
-        (eth / ipv4 / tcp / payload).send();
+        (eth / packet.ip / packet.tcp / packet.options / packet.payload).send();
     }
 
     fn remove_retransmit(&self, _seq_number: u32) {
@@ -62,9 +58,15 @@ impl TcpSocket {
         })
     }
 
-    pub fn on_packet(&self, tcp: &Tcp, payload: &[u8]) {
+    pub fn on_packet(&self, tcp: &Tcp, options: TcpOptions, payload: &[u8]) {
         if let Some(socket) = self.tcp.lock_irq().as_mut() {
-            socket.on_packet(tcp, payload);
+            // Ignore any invalid TCP options.
+            let options = options
+                .iter()
+                .filter_map(|option| option.ok())
+                .collect::<Vec<_>>();
+
+            socket.on_packet(tcp, &options, payload);
             self.wq.notify_all();
         }
     }