Upgrade smoltcp to 0.12.0

Cargo.toml

@@ -36,7 +36,7 @@ rand = { version = "0.8.5", default-features = false }
 rand_hc = "0.3.1"
 raw-cpuid = "11.2.0"
 sha2 = { version = "0.10.8", default-features = false, features = ["force-soft"] }
-smoltcp = { version = "0.11.0", default-features = false, features = ["alloc", "medium-ethernet", "socket-tcp", "socket-udp", "socket-dhcpv4", "proto-ipv4", "proto-dhcpv4"] }
+smoltcp = { version = "0.12.0", default-features = false, features = ["alloc", "medium-ethernet", "socket-tcp", "socket-udp", "socket-dhcpv4", "proto-ipv4", "proto-dhcpv4"] }
 spin = "0.9.8"
 time = { version = "0.2.27", default-features = false }
 geodate = { version = "0.5.0", default-features = false }

src/api/syscall.rs

@@ -4,6 +4,7 @@ use crate::sys::fs::{FileInfo, FileType};
 use crate::sys::syscall::number::*;
 use crate::syscall;
 
+use core::convert::TryInto;
 use core::convert::TryFrom;
 use core::sync::atomic::{fence, Ordering};
 use smoltcp::wire::{IpAddress, Ipv4Address};
@@ -127,7 +128,9 @@ pub fn poll(list: &[(usize, IO)]) -> Option<(usize, IO)> {
 }
 
 pub fn connect(handle: usize, addr: IpAddress, port: u16) -> Result<(), ()> {
-    let buf = addr.as_bytes();
+    let IpAddress::Ipv4(addr) = addr; // Only IPv4 is supported
+    let tmp = addr.octets();
+    let buf = tmp.as_slice();
     let ptr = buf.as_ptr() as usize;
     let len = buf.len();
     let res = unsafe { syscall!(CONNECT, handle, ptr, len, port) } as isize;
@@ -148,16 +151,18 @@ pub fn listen(handle: usize, port: u16) -> Result<(), ()> {
 }
 
 pub fn accept(handle: usize) -> Result<IpAddress, ()> {
-    let addr = IpAddress::v4(0, 0, 0, 0);
-    let buf = addr.as_bytes();
+    let addr = Ipv4Address::new(0, 0, 0, 0);
+    let tmp = addr.octets();
+    let buf = tmp.as_slice();
     let ptr = buf.as_ptr() as usize;
     let len = buf.len();
     let res = unsafe { syscall!(ACCEPT, handle, ptr, len) } as isize;
     if res >= 0 {
-        Ok(IpAddress::from(Ipv4Address::from_bytes(buf)))
-    } else {
-        Err(())
+        if let Ok(buf) = buf.try_into() {
+            return Ok(IpAddress::from(Ipv4Address::from_octets(buf)));
+        }
     }
+    Err(())
 }
 
 pub fn alloc(size: usize, align: usize) -> *mut u8 {

src/lib.rs

@@ -1,10 +1,11 @@
 #![no_std]
 #![cfg_attr(test, no_main)]
-#![feature(vec_pop_if)]
 #![feature(abi_x86_interrupt)]
 #![feature(alloc_error_handler)]
-#![feature(naked_functions)]
 #![feature(custom_test_frameworks)]
+#![feature(ip_from)]
+#![feature(naked_functions)]
+#![feature(vec_pop_if)]
 #![test_runner(crate::test_runner)]
 #![reexport_test_harness_main = "test_main"]
 

src/sys/net/mod.rs

@@ -141,11 +141,11 @@ pub struct RxToken {
 }
 
 impl smoltcp::phy::RxToken for RxToken {
-    fn consume<R, F>(mut self, f: F) -> R
+    fn consume<R, F>(self, f: F) -> R
     where
-        F: FnOnce(&mut [u8]) -> R,
+        F: FnOnce(&[u8]) -> R,
     {
-        f(&mut self.buffer)
+        f(&self.buffer)
     }
 }
 

src/sys/syscall/mod.rs

@@ -6,6 +6,7 @@ use crate::sys;
 use crate::sys::fs::FileInfo;
 
 use core::arch::asm;
+use core::convert::TryInto;
 use smoltcp::wire::IpAddress;
 use smoltcp::wire::Ipv4Address;
 
@@ -104,9 +105,13 @@ pub fn dispatcher(
             let ptr = sys::process::ptr_from_addr(arg2 as u64);
             let len = arg3;
             let buf = unsafe { core::slice::from_raw_parts(ptr, len) };
-            let addr = IpAddress::from(Ipv4Address::from_bytes(buf));
-            let port = arg4 as u16;
-            service::connect(handle, addr, port) as usize
+            if let Ok(buf) = buf.try_into() {
+                let addr = IpAddress::from(Ipv4Address::from_octets(buf));
+                let port = arg4 as u16;
+                service::connect(handle, addr, port) as usize
+            } else {
+                -1 as isize as usize
+            }
         }
         number::LISTEN => {
             let handle = arg1;
@@ -118,8 +123,8 @@ pub fn dispatcher(
             let ptr = sys::process::ptr_from_addr(arg2 as u64);
             let len = arg3;
             let buf = unsafe { core::slice::from_raw_parts_mut(ptr, len) };
-            if let Ok(addr) = service::accept(handle) {
-                buf[0..len].clone_from_slice(addr.as_bytes());
+            if let Ok(IpAddress::Ipv4(addr)) = service::accept(handle) {
+                buf[0..len].clone_from_slice(&addr.octets());
                 0
             } else {
                 -1 as isize as usize

src/usr/host.rs

@@ -168,11 +168,15 @@ pub fn resolve(name: &str) -> Result<IpAddress, ResponseCode> {
                             // the last 4 bytes
                             let n = message.datagram.len();
                             let data = &message.datagram[(n - 4)..];
-                            let ipv4 = Ipv4Address::from_bytes(data);
-                            if ipv4.is_unspecified() {
-                                Err(ResponseCode::NameError) // FIXME
+                            if let Ok(data) = data.try_into() {
+                                let ipv4 = Ipv4Address::from_octets(data);
+                                if ipv4.is_unspecified() {
+                                    Err(ResponseCode::NameError) // FIXME
+                                } else {
+                                    Ok(IpAddress::from(ipv4))
+                                }
                             } else {
-                                Ok(IpAddress::from(ipv4))
+                                Err(ResponseCode::NameError) // FIXME
                             }
                         }
                         code => Err(code),