std: sys: net: uefi: Implement TCP4 connect

Ayush1325 · Ayush1325 · commit c00e658a0f5f · 2025-04-02T18:54:55.000+05:30
- Implement TCP4 connect using EFI_TCP4_PROTOCOL.
- Tested on QEMU setup with connecting to TCP server on host.

Signed-off-by: Ayush Singh &lt;ayush@beagleboard.org&gt;
diff --git a/library/std/src/sys/net/connection/uefi/mod.rs b/library/std/src/sys/net/connection/uefi/mod.rs
@@ -4,117 +4,120 @@ use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
 use crate::sys::unsupported;
 use crate::time::Duration;
 
-pub struct TcpStream(!);
+mod tcp;
+pub(crate) mod tcp4;
+
+pub struct TcpStream(#[expect(dead_code)] tcp::Tcp);
 
 impl TcpStream {
-    pub fn connect(_: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
-        unsupported()
+    pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
+        tcp::Tcp::connect(addr?).map(Self)
     }
 
     pub fn connect_timeout(_: &SocketAddr, _: Duration) -> io::Result<TcpStream> {
         unsupported()
     }
 
     pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
-        self.0
+        unsupported()
     }
 
     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
-        self.0
+        unsupported()
     }
 
     pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {
-        self.0
+        unsupported()
     }
 
     pub fn read(&self, _: &mut [u8]) -> io::Result<usize> {
-        self.0
+        unsupported()
     }
 
     pub fn read_buf(&self, _buf: BorrowedCursor<'_>) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn read_vectored(&self, _: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.0
+        unsupported()
     }
 
     pub fn is_read_vectored(&self) -> bool {
-        self.0
+        false
     }
 
     pub fn write(&self, _: &[u8]) -> io::Result<usize> {
-        self.0
+        unsupported()
     }
 
     pub fn write_vectored(&self, _: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.0
+        unsupported()
     }
 
     pub fn is_write_vectored(&self) -> bool {
-        self.0
+        false
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        self.0
+        unsupported()
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        self.0
+        unsupported()
     }
 
     pub fn shutdown(&self, _: Shutdown) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn duplicate(&self) -> io::Result<TcpStream> {
-        self.0
+        unsupported()
     }
 
     pub fn set_linger(&self, _: Option<Duration>) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn linger(&self) -> io::Result<Option<Duration>> {
-        self.0
+        unsupported()
     }
 
     pub fn set_nodelay(&self, _: bool) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        self.0
+        unsupported()
     }
 
     pub fn set_ttl(&self, _: u32) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        self.0
+        unsupported()
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        self.0
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 }
 
 impl fmt::Debug for TcpStream {
     fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
+        todo!()
     }
 }
 
diff --git a/library/std/src/sys/net/connection/uefi/tcp.rs b/library/std/src/sys/net/connection/uefi/tcp.rs
@@ -0,0 +1,21 @@
+use super::tcp4;
+use crate::io;
+use crate::net::SocketAddr;
+
+pub(crate) enum Tcp {
+    V4(#[expect(dead_code)] tcp4::Tcp4),
+}
+
+impl Tcp {
+    pub(crate) fn connect(addr: &SocketAddr) -> io::Result<Self> {
+        match addr {
+            SocketAddr::V4(x) => {
+                let temp = tcp4::Tcp4::new()?;
+                temp.configure(true, Some(x), None)?;
+                temp.connect()?;
+                Ok(Tcp::V4(temp))
+            }
+            SocketAddr::V6(_) => todo!(),
+        }
+    }
+}
diff --git a/library/std/src/sys/net/connection/uefi/tcp4.rs b/library/std/src/sys/net/connection/uefi/tcp4.rs
@@ -0,0 +1,118 @@
+use r_efi::efi::{self, Status};
+use r_efi::protocols::tcp4;
+
+use crate::io;
+use crate::net::SocketAddrV4;
+use crate::ptr::NonNull;
+use crate::sync::atomic::{AtomicBool, Ordering};
+use crate::sys::pal::helpers;
+
+const TYPE_OF_SERVICE: u8 = 8;
+const TIME_TO_LIVE: u8 = 255;
+
+pub(crate) struct Tcp4 {
+    protocol: NonNull<tcp4::Protocol>,
+    flag: AtomicBool,
+    #[expect(dead_code)]
+    service_binding: helpers::ServiceProtocol,
+}
+
+const DEFAULT_ADDR: efi::Ipv4Address = efi::Ipv4Address { addr: [0u8; 4] };
+
+impl Tcp4 {
+    pub(crate) fn new() -> io::Result<Self> {
+        let service_binding = helpers::ServiceProtocol::open(tcp4::SERVICE_BINDING_PROTOCOL_GUID)?;
+        let protocol = helpers::open_protocol(service_binding.child_handle(), tcp4::PROTOCOL_GUID)?;
+
+        Ok(Self { service_binding, protocol, flag: AtomicBool::new(false) })
+    }
+
+    pub(crate) fn configure(
+        &self,
+        active: bool,
+        remote_address: Option<&SocketAddrV4>,
+        station_address: Option<&SocketAddrV4>,
+    ) -> io::Result<()> {
+        let protocol = self.protocol.as_ptr();
+
+        let (remote_address, remote_port) = if let Some(x) = remote_address {
+            (helpers::ipv4_to_r_efi(*x.ip()), x.port())
+        } else {
+            (DEFAULT_ADDR, 0)
+        };
+
+        // FIXME: Remove when passive connections with proper subnet handling are added
+        assert!(station_address.is_none());
+        let use_default_address = efi::Boolean::TRUE;
+        let (station_address, station_port) = (DEFAULT_ADDR, 0);
+        let subnet_mask = helpers::ipv4_to_r_efi(crate::net::Ipv4Addr::new(0, 0, 0, 0));
+
+        let mut config_data = tcp4::ConfigData {
+            type_of_service: TYPE_OF_SERVICE,
+            time_to_live: TIME_TO_LIVE,
+            access_point: tcp4::AccessPoint {
+                use_default_address,
+                remote_address,
+                remote_port,
+                active_flag: active.into(),
+                station_address,
+                station_port,
+                subnet_mask,
+            },
+            control_option: crate::ptr::null_mut(),
+        };
+
+        let r = unsafe { ((*protocol).configure)(protocol, &mut config_data) };
+        if r.is_error() { Err(crate::io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
+    }
+
+    pub(crate) fn connect(&self) -> io::Result<()> {
+        let evt = self.create_evt()?;
+        let completion_token =
+            tcp4::CompletionToken { event: evt.as_ptr(), status: Status::SUCCESS };
+
+        let protocol = self.protocol.as_ptr();
+        let mut conn_token = tcp4::ConnectionToken { completion_token };
+
+        let r = unsafe { ((*protocol).connect)(protocol, &mut conn_token) };
+        if r.is_error() {
+            return Err(io::Error::from_raw_os_error(r.as_usize()));
+        }
+
+        self.wait_for_flag().unwrap();
+
+        if completion_token.status.is_error() {
+            Err(io::Error::from_raw_os_error(completion_token.status.as_usize()))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn create_evt(&self) -> io::Result<helpers::OwnedEvent> {
+        self.flag.store(false, Ordering::Relaxed);
+        helpers::OwnedEvent::new(
+            efi::EVT_NOTIFY_SIGNAL,
+            efi::TPL_CALLBACK,
+            Some(toggle_atomic_flag),
+            Some(unsafe { NonNull::new_unchecked(self.flag.as_ptr().cast()) }),
+        )
+    }
+
+    fn wait_for_flag(&self) -> io::Result<()> {
+        while !self.flag.load(Ordering::Relaxed) {
+            let protocol = self.protocol.as_ptr();
+            let r = unsafe { ((*protocol).poll)(protocol) };
+
+            if r.is_error() {
+                return Err(io::Error::from_raw_os_error(r.as_usize()));
+            }
+        }
+
+        Ok(())
+    }
+}
+
+extern "efiapi" fn toggle_atomic_flag(_: r_efi::efi::Event, ctx: *mut crate::ffi::c_void) {
+    let flag = unsafe { AtomicBool::from_ptr(ctx.cast()) };
+    flag.store(true, Ordering::Relaxed);
+}
diff --git a/library/std/src/sys/pal/uefi/helpers.rs b/library/std/src/sys/pal/uefi/helpers.rs
@@ -653,7 +653,6 @@ pub(crate) struct ServiceProtocol {
 }
 
 impl ServiceProtocol {
-    #[expect(dead_code)]
     pub(crate) fn open(service_guid: r_efi::efi::Guid) -> io::Result<Self> {
         let handles = locate_handles(service_guid)?;
 
@@ -670,7 +669,6 @@ impl ServiceProtocol {
         Err(io::const_error!(io::ErrorKind::NotFound, "no service binding protocol found"))
     }
 
-    #[expect(dead_code)]
     pub(crate) fn child_handle(&self) -> NonNull<crate::ffi::c_void> {
         self.child_handle
     }
@@ -732,6 +730,10 @@ impl OwnedEvent {
         }
     }
 
+    pub(crate) fn as_ptr(&self) -> efi::Event {
+        self.0.as_ptr()
+    }
+
     pub(crate) fn into_raw(self) -> *mut crate::ffi::c_void {
         let r = self.0.as_ptr();
         crate::mem::forget(self);
@@ -755,3 +757,7 @@ impl Drop for OwnedEvent {
         }
     }
 }
+
+pub(crate) const fn ipv4_to_r_efi(addr: crate::net::Ipv4Addr) -> efi::Ipv4Address {
+    efi::Ipv4Address { addr: addr.octets() }
+}

Original file line number	Diff line number	Diff line change
`@@ -4,117 +4,120 @@ use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};`
`4`	`4`	`use crate::sys::unsupported;`
`5`	`5`	`use crate::time::Duration;`
`6`	`6`
`7`		`-pub struct TcpStream(!);`
	`7`	`+mod tcp;`
	`8`	`+pub(crate) mod tcp4;`
	`9`	`+`
	`10`	`+pub struct TcpStream(#[expect(dead_code)] tcp::Tcp);`
`8`	`11`
`9`	`12`	`impl TcpStream {`
`10`		`- pub fn connect(_: io::Result<&SocketAddr>) -> io::Result<TcpStream> {`
`11`		`- unsupported()`
	`13`	`+ pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {`
	`14`	`+ tcp::Tcp::connect(addr?).map(Self)`
`12`	`15`	`}`
`13`	`16`
`14`	`17`	`pub fn connect_timeout(_: &SocketAddr, _: Duration) -> io::Result<TcpStream> {`
`15`	`18`	`unsupported()`
`16`	`19`	`}`
`17`	`20`
`18`	`21`	`pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {`
`19`		`- self.0`
	`22`	`+ unsupported()`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {`
`23`		`- self.0`
	`26`	`+ unsupported()`
`24`	`27`	`}`
`25`	`28`
`26`	`29`	`pub fn read_timeout(&self) -> io::Result<Option<Duration>> {`
`27`		`- self.0`
	`30`	`+ unsupported()`
`28`	`31`	`}`
`29`	`32`
`30`	`33`	`pub fn write_timeout(&self) -> io::Result<Option<Duration>> {`
`31`		`- self.0`
	`34`	`+ unsupported()`
`32`	`35`	`}`
`33`	`36`
`34`	`37`	`pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {`
`35`		`- self.0`
	`38`	`+ unsupported()`
`36`	`39`	`}`
`37`	`40`
`38`	`41`	`pub fn read(&self, _: &mut [u8]) -> io::Result<usize> {`
`39`		`- self.0`
	`42`	`+ unsupported()`
`40`	`43`	`}`
`41`	`44`
`42`	`45`	`pub fn read_buf(&self, _buf: BorrowedCursor<'_>) -> io::Result<()> {`
`43`		`- self.0`
	`46`	`+ unsupported()`
`44`	`47`	`}`
`45`	`48`
`46`	`49`	`pub fn read_vectored(&self, _: &mut [IoSliceMut<'_>]) -> io::Result<usize> {`
`47`		`- self.0`
	`50`	`+ unsupported()`
`48`	`51`	`}`
`49`	`52`
`50`	`53`	`pub fn is_read_vectored(&self) -> bool {`
`51`		`- self.0`
	`54`	`+ false`
`52`	`55`	`}`
`53`	`56`
`54`	`57`	`pub fn write(&self, _: &[u8]) -> io::Result<usize> {`
`55`		`- self.0`
	`58`	`+ unsupported()`
`56`	`59`	`}`
`57`	`60`
`58`	`61`	`pub fn write_vectored(&self, _: &[IoSlice<'_>]) -> io::Result<usize> {`
`59`		`- self.0`
	`62`	`+ unsupported()`
`60`	`63`	`}`
`61`	`64`
`62`	`65`	`pub fn is_write_vectored(&self) -> bool {`
`63`		`- self.0`
	`66`	`+ false`
`64`	`67`	`}`
`65`	`68`
`66`	`69`	`pub fn peer_addr(&self) -> io::Result<SocketAddr> {`
`67`		`- self.0`
	`70`	`+ unsupported()`
`68`	`71`	`}`
`69`	`72`
`70`	`73`	`pub fn socket_addr(&self) -> io::Result<SocketAddr> {`
`71`		`- self.0`
	`74`	`+ unsupported()`
`72`	`75`	`}`
`73`	`76`
`74`	`77`	`pub fn shutdown(&self, _: Shutdown) -> io::Result<()> {`
`75`		`- self.0`
	`78`	`+ unsupported()`
`76`	`79`	`}`
`77`	`80`
`78`	`81`	`pub fn duplicate(&self) -> io::Result<TcpStream> {`
`79`		`- self.0`
	`82`	`+ unsupported()`
`80`	`83`	`}`
`81`	`84`
`82`	`85`	`pub fn set_linger(&self, _: Option<Duration>) -> io::Result<()> {`
`83`		`- self.0`
	`86`	`+ unsupported()`
`84`	`87`	`}`
`85`	`88`
`86`	`89`	`pub fn linger(&self) -> io::Result<Option<Duration>> {`
`87`		`- self.0`
	`90`	`+ unsupported()`
`88`	`91`	`}`
`89`	`92`
`90`	`93`	`pub fn set_nodelay(&self, _: bool) -> io::Result<()> {`
`91`		`- self.0`
	`94`	`+ unsupported()`
`92`	`95`	`}`
`93`	`96`
`94`	`97`	`pub fn nodelay(&self) -> io::Result<bool> {`
`95`		`- self.0`
	`98`	`+ unsupported()`
`96`	`99`	`}`
`97`	`100`
`98`	`101`	`pub fn set_ttl(&self, _: u32) -> io::Result<()> {`
`99`		`- self.0`
	`102`	`+ unsupported()`
`100`	`103`	`}`
`101`	`104`
`102`	`105`	`pub fn ttl(&self) -> io::Result<u32> {`
`103`		`- self.0`
	`106`	`+ unsupported()`
`104`	`107`	`}`
`105`	`108`
`106`	`109`	`pub fn take_error(&self) -> io::Result<Option<io::Error>> {`
`107`		`- self.0`
	`110`	`+ unsupported()`
`108`	`111`	`}`
`109`	`112`
`110`	`113`	`pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {`
`111`		`- self.0`
	`114`	`+ unsupported()`
`112`	`115`	`}`
`113`	`116`	`}`
`114`	`117`
`115`	`118`	`impl fmt::Debug for TcpStream {`
`116`	`119`	`fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`117`		`- self.0`
	`120`	`+ todo!()`
`118`	`121`	`}`
`119`	`122`	`}`
`120`	`123`
Original file line number	Diff line number	Diff line change
`@@ -653,7 +653,6 @@ pub(crate) struct ServiceProtocol {`
`653`	`653`	`}`
`654`	`654`
`655`	`655`	`impl ServiceProtocol {`
`656`		`- #[expect(dead_code)]`
`657`	`656`	`pub(crate) fn open(service_guid: r_efi::efi::Guid) -> io::Result<Self> {`
`658`	`657`	`let handles = locate_handles(service_guid)?;`
`659`	`658`
`@@ -670,7 +669,6 @@ impl ServiceProtocol {`
`670`	`669`	`Err(io::const_error!(io::ErrorKind::NotFound, "no service binding protocol found"))`
`671`	`670`	`}`
`672`	`671`
`673`		`- #[expect(dead_code)]`
`674`	`672`	`pub(crate) fn child_handle(&self) -> NonNull<crate::ffi::c_void> {`
`675`	`673`	`self.child_handle`
`676`	`674`	`}`
`@@ -732,6 +730,10 @@ impl OwnedEvent {`
`732`	`730`	`}`
`733`	`731`	`}`
`734`	`732`
	`733`	`+ pub(crate) fn as_ptr(&self) -> efi::Event {`
	`734`	`+ self.0.as_ptr()`
	`735`	`+ }`
	`736`	`+`
`735`	`737`	`pub(crate) fn into_raw(self) -> *mut crate::ffi::c_void {`
`736`	`738`	`let r = self.0.as_ptr();`
`737`	`739`	`crate::mem::forget(self);`
`@@ -755,3 +757,7 @@ impl Drop for OwnedEvent {`
`755`	`757`	`}`
`756`	`758`	`}`
`757`	`759`	`}`
	`760`	`+`
	`761`	`+pub(crate) const fn ipv4_to_r_efi(addr: crate::net::Ipv4Addr) -> efi::Ipv4Address {`
	`762`	`+ efi::Ipv4Address { addr: addr.octets() }`
	`763`	`+}`