Update dependencies

Author: veluca93

pixie-shared/src/lib.rs

@@ -4,13 +4,11 @@ extern crate alloc;
 
 use alloc::{collections::BTreeMap, string::String, vec::Vec};
 use blake3::OUT_LEN;
+use core::net::Ipv4Addr;
 use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "std")]
-use std::{
-    collections::HashMap,
-    net::{Ipv4Addr, SocketAddrV4},
-};
+use std::{collections::HashMap, net::SocketAddrV4};
 
 pub mod bijection;
 pub use bijection::Bijection;
@@ -82,11 +80,9 @@ pub const PACKET_LEN: usize = 1436;
 pub const HEADER_LEN: usize = 34;
 pub const BODY_LEN: usize = PACKET_LEN - HEADER_LEN;
 
-pub type Ip = [u8; 4];
-
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct Address {
-    pub ip: Ip,
+    pub ip: Ipv4Addr,
     pub port: u16,
 }
 

pixie-uefi/Cargo.lock

@@ -19,8 +19,8 @@ managed = { version = "0.8.0", default-features = false, features = ["alloc"] }
 postcard = { version = "1.0.8", default-features = false, features = ["alloc"] }
 rand = { version = "0.8.5", default-features = false }
 rand_xoshiro = { version = "0.6.0", default-features = false }
-smoltcp = { version = "0.11.0", default-features = false, features = ["alloc", "proto-ipv4", "medium-ethernet", "socket-udp", "socket-tcp", "socket-dhcpv4", "async"] }
-uefi = { version = "0.32.0", features = ["alloc", "global_allocator", "panic_handler"] }
+smoltcp = { version = "0.12.0", default-features = false, features = ["alloc", "proto-ipv4", "medium-ethernet", "socket-udp", "socket-tcp", "socket-dhcpv4", "async", "socket-tcp-cubic"] }
+uefi = { version = "0.33.0", features = ["alloc", "global_allocator", "panic_handler"] }
 
 [dependencies.pixie-shared]
 path = "../pixie-shared"

pixie-uefi/Cargo.toml

@@ -5,6 +5,7 @@
 #![deny(unused_must_use)]
 
 use alloc::boxed::Box;
+use core::net::Ipv4Addr;
 use futures::future::{self, Either};
 use pixie_shared::{Action, Address, TcpRequest, UdpRequest, ACTION_PORT};
 use uefi::prelude::*;
@@ -37,7 +38,7 @@ async fn server_discover(os: UefiOS) -> Result<Address> {
 
         let msg = postcard::to_allocvec(&UdpRequest::Discover).unwrap();
         loop {
-            socket.send([255; 4], ACTION_PORT, &msg).await?;
+            socket.send(Ipv4Addr::BROADCAST, ACTION_PORT, &msg).await?;
             os.sleep_us(1_000_000).await;
         }
     };

pixie-uefi/src/main.rs

@@ -4,7 +4,7 @@ use alloc::{
 };
 use uefi::{
     proto::device_path::DevicePath,
-    table::runtime::{VariableAttributes, VariableVendor},
+    runtime::{VariableAttributes, VariableVendor},
     CString16,
 };
 

pixie-uefi/src/os/boot_options.rs

@@ -7,9 +7,8 @@ use gpt_disk_io::{
     BlockIo,
 };
 use uefi::{
-    boot::ScopedProtocol,
+    boot::{OpenProtocolParams, ScopedProtocol},
     proto::media::{block::BlockIO, disk::DiskIo},
-    table::boot::OpenProtocolParams,
     Handle,
 };
 
@@ -30,7 +29,7 @@ fn open_disk(
                 controller: None,
                 handle,
             },
-            uefi::table::boot::OpenProtocolAttributes::GetProtocol,
+            uefi::boot::OpenProtocolAttributes::GetProtocol,
         )
     };
     Ok((os.open_handle(handle)?, bio?))

pixie-uefi/src/os/disk.rs

@@ -3,6 +3,7 @@ use core::{
     ffi::c_void,
     fmt::{self, Display, Write},
     future::{poll_fn, Future, PollFn},
+    net::Ipv4Addr,
     ptr::NonNull,
     task::{Context, Poll},
 };
@@ -15,7 +16,7 @@ use alloc::{
     vec::Vec,
 };
 use uefi::{
-    boot::ScopedProtocol,
+    boot::{EventType, ScopedProtocol, TimerTrigger, Tpl},
     proto::{
         console::text::{Color, Input, Key, Output},
         device_path::{
@@ -25,10 +26,7 @@ use uefi::{
         },
         Protocol,
     },
-    table::{
-        boot::{EventType, TimerTrigger, Tpl},
-        runtime::{VariableAttributes, VariableVendor},
-    },
+    runtime::{VariableAttributes, VariableVendor},
     CStr16, Event, Handle, Status,
 };
 
@@ -435,7 +433,7 @@ impl UefiOS {
         Disk::new(*self)
     }
 
-    pub async fn connect(&self, ip: [u8; 4], port: u16) -> Result<TcpStream> {
+    pub async fn connect(&self, ip: Ipv4Addr, port: u16) -> Result<TcpStream> {
         TcpStream::new(*self, ip, port).await
     }
 
@@ -570,7 +568,7 @@ impl UefiOS {
     }
 
     pub fn reset(&self) -> ! {
-        uefi::runtime::reset(uefi::table::runtime::ResetType::WARM, Status::SUCCESS, None)
+        uefi::runtime::reset(uefi::runtime::ResetType::WARM, Status::SUCCESS, None)
     }
 }
 

pixie-uefi/src/os/mod.rs

@@ -1,16 +1,15 @@
-use core::{future::poll_fn, task::Poll};
+use core::{future::poll_fn, net::IpAddr, task::Poll};
 
 use alloc::boxed::Box;
 use futures::future::select;
 
 use smoltcp::{
-    iface::{Config, Interface, SocketHandle, SocketSet},
+    iface::{Config, Interface, PollResult, SocketHandle, SocketSet},
     phy::{Device, DeviceCapabilities, Medium, RxToken, TxToken},
     socket::{
         dhcpv4::{Event, Socket as Dhcpv4Socket},
         tcp::{Socket as TcpSocket, State},
-        udp,
-        udp::Socket as UdpSocket,
+        udp::{self, Socket as UdpSocket},
     },
     storage::RingBuffer,
     time::{Duration, Instant},
@@ -102,7 +101,7 @@ impl TxToken for SnpTxToken<'_> {
 impl RxToken for SnpRxToken<'_> {
     fn consume<R, F>(self, f: F) -> R
     where
-        F: FnOnce(&mut [u8]) -> R,
+        F: FnOnce(&[u8]) -> R,
     {
         f(self.packet)
     }
@@ -224,7 +223,7 @@ impl NetworkInterface {
         let status = self
             .interface
             .poll(now, &mut self.device, &mut self.socket_set);
-        if !status {
+        if status == PollResult::None {
             return false;
         }
 
@@ -265,20 +264,21 @@ pub struct TcpStream {
 // create that many, but still it would be nice to fix eventually.
 // Also, trying to use a closed connection may result in panics.
 impl TcpStream {
-    pub async fn new(os: UefiOS, ip: [u8; 4], port: u16) -> Result<TcpStream> {
+    pub async fn new(os: UefiOS, ip: Ipv4Address, port: u16) -> Result<TcpStream> {
         os.wait_for_ip().await;
         const TCP_BUF_SIZE: usize = 1 << 22;
         let mut tcp_socket = TcpSocket::new(
             RingBuffer::new(vec![0; TCP_BUF_SIZE]),
             RingBuffer::new(vec![0; TCP_BUF_SIZE]),
         );
+        tcp_socket.set_congestion_control(smoltcp::socket::tcp::CongestionControl::Cubic);
         tcp_socket.set_timeout(Some(Duration::from_secs(5)));
         tcp_socket.set_keep_alive(Some(Duration::from_secs(1)));
         let sport = os.net().get_ephemeral_port();
         tcp_socket.connect(
             os.net().interface.context(),
             IpEndpoint {
-                addr: IpAddress::Ipv4(Ipv4Address(ip)),
+                addr: IpAddress::Ipv4(ip),
                 port,
             },
             sport,
@@ -467,9 +467,9 @@ impl UdpHandle {
         Ok(ret)
     }
 
-    pub async fn send(&self, ip: [u8; 4], port: u16, data: &[u8]) -> Result<()> {
+    pub async fn send(&self, ip: Ipv4Address, port: u16, data: &[u8]) -> Result<()> {
         let endpoint = IpEndpoint {
-            addr: IpAddress::Ipv4(Ipv4Address(ip)),
+            addr: ip.into(),
             port,
         };
 
@@ -499,7 +499,9 @@ impl UdpHandle {
             } else {
                 // Cannot fail if can_recv() returned true.
                 let recvd = socket.recv_slice(buf2).unwrap();
-                let ip = (recvd.1).endpoint.addr.as_bytes().try_into().unwrap();
+                let IpAddr::V4(ip) = (recvd.1).endpoint.addr.into() else {
+                    unreachable!();
+                };
                 let port = (recvd.1).endpoint.port;
                 Poll::Ready((recvd.0, Address { ip, port }))
             }