Usb Hardware Fixes For High Speed & Networking

crates/kernel/examples/net.rs

@@ -4,87 +4,143 @@
 extern crate alloc;
 extern crate kernel;
 
-use kernel::networking::repr::Ipv4Address;
+#[allow(unused_imports)]
+use kernel::{
+    device::usb::device::net::get_dhcpd_mut,
+    event::{task, thread},
+    networking::{
+        iface::icmp,
+        repr::{HttpMethod, HttpPacket, IcmpPacket, Ipv4Address},
+        socket::RawSocket,
+        Result,
+    },
+    ringbuffer,
+};
+
 #[allow(unused_imports)]
 use kernel::networking::socket::{
-    bind, connect, recv_from, send_to, SocketAddr, TcpSocket, UdpSocket,
+    accept, bind, close, connect, listen, recv_from, send_to, SocketAddr, TcpSocket, UdpSocket,
 };
 use kernel::*;
 
+use alloc::string::String;
+
 #[no_mangle]
 extern "Rust" fn kernel_main(_device_tree: device_tree::DeviceTree) {
-    let count = 32;
-    // WARN: this is unfortunately necessary to give dhcp time to resolve our ip address because
-    // we don't have blocking currently
-    for _i in 0..count {
-        sync::spin_sleep(100_000);
-    }
-
-    // [udp send test]
+    println!("| starting kernel_main");
+    task::spawn_async(async move {
+        main().await;
+    });
+    crate::event::thread::stop();
+}
+
+async fn main() {
+    println!("starting dhcpd");
+
+    let dhcpd = get_dhcpd_mut();
+    let _ = dhcpd.start().await;
+
+    println!("out of dhcpd");
+
+    // // [udp send test]
+    // println!("udp send test");
     // let s = UdpSocket::new();
     // let saddr = SocketAddr {
-    //     addr: Ipv4Address::new([11, 187, 10, 102]),
+    //     addr: Ipv4Address::new([10, 0, 2, 2]),
     //     port: 1337,
     // };
     // for _i in 0..5 {
-    //     let _ = send_to(s, "hello everynyan".as_bytes().to_vec(), saddr);
+    //     let _ = send_to(s, "hello everynyan\n".as_bytes().to_vec(), saddr).await;
+    // }
+    // println!("end udp send test");
+
+    // for _i in 0..5 {
+    //     sync::spin_sleep(500_000);
     // }
 
     // [udp listening test]
-    // To use this, send packets from your machine and uncomment this test
-    //
+    // println!("udp listening test");
     // let s = UdpSocket::new();
     //
-    // bind(s, 2222);
+    // bind(s, 53);
     //
-    // loop {
-    //     sync::spin_sleep(500_000);
-    //     let recv = recv_from(s);
+    // for i in 0..5 {
+    //     println!("listening for packets");
+    //     let recv = recv_from(s).await;
     //     if let Ok((payload, senderaddr)) = recv {
     //         println!("got message: {:x?}", payload);
     //     }
     // }
+    //
+    // println!("end udp listening test");
 
     // [tcp send test]
-    let saddr = SocketAddr {
-        addr: Ipv4Address::new([11, 187, 10, 102]),
-        port: 1337,
-    };
-
-    let s = TcpSocket::new();
-    match connect(s, saddr) {
-        Ok(_) => (),
-        Err(_) => println!("couldn't connect"),
-    };
-
-    // WARN: same as above, but for tcp handshake
-    for _i in 0..count {
-        sync::spin_sleep(100_000);
-    }
-
-    for _i in 0..5 {
-        let _ = send_to(s, "hello everynyan".as_bytes().to_vec(), saddr);
-    }
+    // println!("tcp send test");
+    // let saddr = SocketAddr {
+    //     addr: Ipv4Address::new([10, 0, 2, 2]),
+    //     port: 1337,
+    // };
+    //
+    // let s = TcpSocket::new();
+    // match connect(s, saddr).await {
+    //     Ok(_) => (),
+    //     Err(_) => println!("couldn't connect"),
+    // };
+    //
+    // for _i in 0..100 {
+    //     let _ = send_to(s, "hello everynyan\n".as_bytes().to_vec(), saddr).await;
+    // }
+    //
+    // close(s).await;
+    // println!("tcp send test end");
 
     // [tcp recv test]
-    // To use this, send packets from your machine and uncomment this test
-
     // let s = TcpSocket::new();
     //
-    // bind(s, 2222);
-    // listen(s); // has a timeout, we will wait for 5 seconds
+    // bind(s, 22);
+
+    // listen(s, 1).await;
     //
-    // let client = accept(s);
-    // // WARN: same as above, but for tcp handshake
-    // for _i in 0..count {
-    //     sync::spin_sleep(100_000);
-    // }
+    // let clientfd = accept(s).await;
     //
-    // loop {
-    //     sync::spin_sleep(500_000);
-    //     let recv = recv_from(s);
+    // let mut tot = 0;
+    // while let recv = recv_from(*clientfd.as_ref().unwrap()).await {
     //     if let Ok((payload, senderaddr)) = recv {
     //         println!("got message: {:x?}", payload);
+    //         tot += payload.len()
+    //     } else {
+    //         println!("\t[!] got a fin, ended");
+    //         break;
     //     }
     // }
+    //
+    // println!("got {} bytes", tot);
+
+    // [http request test]
+    println!("http send test");
+    // let host = "http.badssl.com";
+    // let host = "http-textarea.badssl.com";
+    // let host = "httpforever.com";
+    let host = "neverssl.com";
+    let saddr = SocketAddr::resolve(host, 80).await;
+
+    let s = TcpSocket::new();
+    match connect(s, saddr).await {
+        Ok(_) => (),
+        Err(_) => println!("couldn't connect"),
+    };
+
+    let path = "/";
+    let http_req = HttpPacket::new(HttpMethod::Get, host, path);
+    let _ = send_to(s, http_req.serialize(), saddr).await;
+
+    let (resp, _) = recv_from(s).await.unwrap();
+
+    let _ = close(s).await;
+
+    println!("response:\n{:?}", resp);
+    println!("response:\n{:?}", String::from_utf8(resp));
+    println!("http send test end");
+
+    shutdown();
 }

crates/kernel/scripts/attach-serial.sh

@@ -1,4 +1,4 @@
-SERIAL_DEV=/dev/serial/by-id/usb-FTDI_FT232R_USB_UART_B0044ASI-if00-port0
+SERIAL_DEV=/dev/tty.usbserial-B0044ASI
 LOGFILE=log/$(date -Is).log
 echo "Logging to $LOGFILE"
 tio "$SERIAL_DEV" -b 115200 -d 8 -s 1 -p none -f none -m INLCRNL -L --log-file="$LOGFILE"

crates/kernel/scripts/run-usb.sh

@@ -1,9 +1,10 @@
 #!/usr/bin/env bash
-
 set -ex
-QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-usb -device usb-kbd -device usb-mouse -device usb-net,netdev=net0 -netdev user,id=net0,hostfwd=tcp::2222-:22 -object filter-dump,id=f1,netdev=net0,file=net0.pcap" "$(dirname "$0")/run.sh"
+QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-device usb-net,netdev=net0 -netdev user,id=net0,hostfwd=tcp::2222-:22 -object filter-dump,id=f1,netdev=net0,file=net0.pcap" "$(dirname "$0")/run.sh"
 # QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-usb -device usb-kbd -device usb-mouse -device usb-net,netdev=net0 -netdev tap,id=net0,ifname=tap0,script=no,downscript=no -object filter-dump,id=f1,netdev=net0,file=net0.pcap" "$(dirname "$0")/run.sh"
 
 # QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-usb -device usb-kbd -device usb-mouse -device usb-net,netdev=net0 -netdev bridge,id=net0,br=br0 -object filter-dump,id=f1,netdev=net0,file=net0.pcap" "$(dirname "$0")/run.sh"
 # QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-device usb-hub,id=hub1 -device usb-kbd -device usb-mouse" "$(dirname "$0")/run.sh"
 # QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-usb -device usb-kbd -device usb-mouse,pcap=usb-mouse.pcap -device usb-net,netdev=net0 -netdev user,id=net0,hostfwd=tcp::2222-:22 -object filter-dump,id=f1,netdev=net0,file=net0.pcap" "$(dirname "$0")/run.sh"
+# # QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-usb -device usb-kbd -device usb-mouse -device usb-net,netdev=net0 -netdev tap,id=net0,ifname=tap0,script=no,downscript=no -object filter-dump,id=f1,netdev=net0,file=net0.pcap" "$(dirname "$0")/run.sh"
+# QEMU_DISPLAY=${QEMU_DISPLAY-"default"} QEMU_DEVICES="-device usb-net,netdev=net0 -netdev tap,id=net0,ifname=tap0,script=no,downscript=no -object filter-dump,id=f1,netdev=net0,file=net0.pcap" "$(dirname "$0")/run.sh"

crates/kernel/scripts/run.sh

@@ -57,4 +57,4 @@ qemu-system-aarch64 \
 # -device usb-net,netdev=net0 \
 # -netdev user,id=net0,hostfwd=tcp::2222-:22 \
 # -object filter-dump,id=f1,netdev=net0,file=net0.pcap \
-# -trace enable=net* \
+# -trace enable=net*\

crates/kernel/scripts/test_socket.py

@@ -0,0 +1,22 @@
+import socket
+
+# TCP configuration
+host = '127.0.0.1'  # Localhost IP
+port = 2222         # Port to send the packet to
+
+# Message to send
+message = b'cowscowscows'
+
+# Create a TCP socket
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+# Connect to the server
+sock.connect((host, port))
+
+# Send the message to the server
+sock.sendall(message)
+
+# Close the socket
+sock.close()
+
+print(f"Message sent to {host}:{port}")

crates/kernel/src/device/bcm2835_aux.rs

@@ -223,7 +223,7 @@ impl MiniUart {
         //         console.render();
         //     }
         //     drop(console);
-        //     crate::sync::spin_sleep(3000);
+        crate::sync::spin_sleep(3000);
         // }
     }
 }

crates/kernel/src/device/mailbox.rs

@@ -226,7 +226,7 @@ define_property!(0x00038009 => struct PropSetTurbo {
 #[derive(Debug)]
 pub struct MailboxError;
 
-struct HexDisplay<'a, T>(&'a [T]);
+pub struct HexDisplay<'a, T>(pub &'a [T]);
 
 impl<T: core::fmt::LowerHex> core::fmt::LowerHex for HexDisplay<'_, T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

crates/kernel/src/device/system_timer.rs

@@ -357,14 +357,14 @@ pub struct ArmGenericTimer {
 }
 
 #[inline(always)]
-unsafe fn read_cntpct() -> u64 {
+pub unsafe fn read_cntpct() -> u64 {
     let cnt: u64;
     unsafe { asm!("mrs {}, cntpct_el0", out(reg) cnt, options(nomem, nostack, preserves_flags)) };
     cnt
 }
 
 #[inline(always)]
-unsafe fn read_cntfrq() -> u64 {
+pub unsafe fn read_cntfrq() -> u64 {
     let cnt: u64;
     unsafe { asm!("mrs {}, cntfrq_el0", out(reg) cnt, options(nomem, nostack, preserves_flags)) };
     cnt

crates/kernel/src/device/uart.rs

@@ -141,7 +141,9 @@ impl UARTInner {
         //         console.render();
         //     }
         //     drop(console);
-        //     spin_sleep(3000);
+        use crate::sync::spin_sleep;
+
+        spin_sleep(3000);
         // }
     }
 }

crates/kernel/src/device/usb.rs

@@ -9,7 +9,6 @@ pub mod usbd;
 pub use device::hid::keyboard;
 pub use device::hid::mouse;
 
-use device::net::NetSendPacket;
 use device::net::RegisterNetReceiveCallback;
 
 use alloc::boxed::Box;
@@ -37,9 +36,3 @@ pub fn usb_check_for_change(_bus: &mut UsbBus) {
 pub fn usb_register_net_callback(callback: fn(*mut u8, u32)) {
     RegisterNetReceiveCallback(callback);
 }
-
-pub unsafe fn usb_send_packet(buffer: *mut u8, buffer_length: u32) {
-    unsafe {
-        NetSendPacket(buffer, buffer_length);
-    }
-}

crates/kernel/src/device/usb/device.rs

@@ -1,3 +1,4 @@
+pub mod ax88179;
 pub mod hid;
 pub mod hub;
 pub mod net;