Rollup merge of #139254 - Ayush1325:uefi-tcp4-connect, r=joboet

std: sys: net: uefi: Implement TCP4 connect
- Implement TCP4 connect using EFI_TCP4_PROTOCOL.
- Tested on QEMU setup with connecting to TCP server on host.

Author: matthiaskrgr

library/std/src/sys/net/connection/uefi/mod.rs

@@ -4,117 +4,120 @@ use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
 usecrate::sys::unsupported;
 usecrate::time::Duration;
 
-pubstructTcpStream(!);
+mod tcp;
+pub(crate)mod tcp4;
+
+pubstructTcpStream(#[expect(dead_code)] tcp::Tcp);
 
 implTcpStream{
-pubfnconnect(_: io::Result<&SocketAddr>) -> io::Result<TcpStream>{
-unsupported()
+pubfnconnect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream>{
+tcp::Tcp::connect(addr?).map(Self)
 }
 
 pubfnconnect_timeout(_:&SocketAddr, _:Duration) -> io::Result<TcpStream>{
 unsupported()
 }
 
 pubfnset_read_timeout(&self, _:Option<Duration>) -> io::Result<()>{
-self.0
+unsupported()
 }
 
 pubfnset_write_timeout(&self, _:Option<Duration>) -> io::Result<()>{
-self.0
+unsupported()
 }
 
 pubfnread_timeout(&self) -> io::Result<Option<Duration>>{
-self.0
+unsupported()
 }
 
 pubfnwrite_timeout(&self) -> io::Result<Option<Duration>>{
-self.0
+unsupported()
 }
 
 pubfnpeek(&self, _:&mut[u8]) -> io::Result<usize>{
-self.0
+unsupported()
 }
 
 pubfnread(&self, _:&mut[u8]) -> io::Result<usize>{
-self.0
+unsupported()
 }
 
 pubfnread_buf(&self,_buf:BorrowedCursor<'_>) -> io::Result<()>{
-self.0
+unsupported()
 }
 
 pubfnread_vectored(&self, _:&mut[IoSliceMut<'_>]) -> io::Result<usize>{
-self.0
+unsupported()
 }
 
 pubfnis_read_vectored(&self) -> bool{
-self.0
+false
 }
 
 pubfnwrite(&self, _:&[u8]) -> io::Result<usize>{
-self.0
+unsupported()
 }
 
 pubfnwrite_vectored(&self, _:&[IoSlice<'_>]) -> io::Result<usize>{
-self.0
+unsupported()
 }
 
 pubfnis_write_vectored(&self) -> bool{
-self.0
+false
 }
 
 pubfnpeer_addr(&self) -> io::Result<SocketAddr>{
-self.0
+unsupported()
 }
 
 pubfnsocket_addr(&self) -> io::Result<SocketAddr>{
-self.0
+unsupported()
 }
 
 pubfnshutdown(&self, _:Shutdown) -> io::Result<()>{
-self.0
+unsupported()
 }
 
 pubfnduplicate(&self) -> io::Result<TcpStream>{
-self.0
+unsupported()
 }
 
 pubfnset_linger(&self, _:Option<Duration>) -> io::Result<()>{
-self.0
+unsupported()
 }
 
 pubfnlinger(&self) -> io::Result<Option<Duration>>{
-self.0
+unsupported()
 }
 
 pubfnset_nodelay(&self, _:bool) -> io::Result<()>{
-self.0
+unsupported()
 }
 
 pubfnnodelay(&self) -> io::Result<bool>{
-self.0
+unsupported()
 }
 
 pubfnset_ttl(&self, _:u32) -> io::Result<()>{
-self.0
+unsupported()
 }
 
 pubfnttl(&self) -> io::Result<u32>{
-self.0
+unsupported()
 }
 
 pubfntake_error(&self) -> io::Result<Option<io::Error>>{
-self.0
+unsupported()
 }
 
 pubfnset_nonblocking(&self, _:bool) -> io::Result<()>{
-self.0
+unsupported()
 }
 }
 
 impl fmt::DebugforTcpStream{
 fnfmt(&self,_f:&mut fmt::Formatter<'_>) -> fmt::Result{
-self.0
+todo!()
 }
 }
 

library/std/src/sys/net/connection/uefi/tcp.rs

@@ -0,0 +1,21 @@
+usesuper::tcp4;
+usecrate::io;
+usecrate::net::SocketAddr;
+
+pub(crate)enumTcp{
+V4(#[expect(dead_code)] tcp4::Tcp4),
+}
+
+implTcp{
+pub(crate)fnconnect(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!(),
+}
+}
+}

library/std/src/sys/net/connection/uefi/tcp4.rs

@@ -0,0 +1,118 @@
+use r_efi::efi::{self,Status};
+use r_efi::protocols::tcp4;
+
+usecrate::io;
+usecrate::net::SocketAddrV4;
+usecrate::ptr::NonNull;
+usecrate::sync::atomic::{AtomicBool,Ordering};
+usecrate::sys::pal::helpers;
+
+constTYPE_OF_SERVICE:u8 = 8;
+constTIME_TO_LIVE:u8 = 255;
+
+pub(crate)structTcp4{
+protocol:NonNull<tcp4::Protocol>,
+flag:AtomicBool,
+#[expect(dead_code)]
+service_binding: helpers::ServiceProtocol,
+}
+
+constDEFAULT_ADDR: efi::Ipv4Address = efi::Ipv4Address{addr:[0u8;4]};
+
+implTcp4{
+pub(crate)fnnew() -> 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)fnconfigure(
+&self,
+active:bool,
+remote_address:Option<&SocketAddrV4>,
+station_address:Option<&SocketAddrV4>,
+) -> io::Result<()>{
+let protocol = self.protocol.as_ptr();
+
+let(remote_address, remote_port) = ifletSome(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));
+
+letmut 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)fnconnect(&self) -> io::Result<()>{
+let evt = unsafe{self.create_evt()}?;
+let completion_token =
+ tcp4::CompletionToken{event: evt.as_ptr(),status:Status::SUCCESS};
+
+let protocol = self.protocol.as_ptr();
+letmut conn_token = tcp4::ConnectionToken{ completion_token };
+
+let r = unsafe{((*protocol).connect)(protocol,&mut conn_token)};
+if r.is_error(){
+returnErr(io::Error::from_raw_os_error(r.as_usize()));
+}
+
+self.wait_for_flag();
+
+if completion_token.status.is_error(){
+Err(io::Error::from_raw_os_error(completion_token.status.as_usize()))
+}else{
+Ok(())
+}
+}
+
+unsafefncreate_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())}),
+)
+}
+
+fnwait_for_flag(&self){
+while !self.flag.load(Ordering::Relaxed){
+let _ = self.poll();
+}
+}
+
+fnpoll(&self) -> io::Result<()>{
+let protocol = self.protocol.as_ptr();
+let r = unsafe{((*protocol).poll)(protocol)};
+
+if r.is_error(){Err(io::Error::from_raw_os_error(r.as_usize()))}else{Ok(())}
+}
+}
+
+extern"efiapi"fntoggle_atomic_flag(_: r_efi::efi::Event,ctx:*mutcrate::ffi::c_void){
+let flag = unsafe{AtomicBool::from_ptr(ctx.cast())};
+ flag.store(true,Ordering::Relaxed);
+}

library/std/src/sys/pal/uefi/helpers.rs

@@ -653,7 +653,6 @@ pub(crate) struct ServiceProtocol {
 }
 
 implServiceProtocol{
-#[expect(dead_code)]
 pub(crate)fnopen(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)fnchild_handle(&self) -> NonNull<crate::ffi::c_void>{
 self.child_handle
 }
@@ -732,6 +730,10 @@ impl OwnedEvent {
 }
 }
 
+pub(crate)fnas_ptr(&self) -> efi::Event{
+self.0.as_ptr()
+}
+
 pub(crate)fninto_raw(self) -> *mutcrate::ffi::c_void{
 let r = self.0.as_ptr();
 crate::mem::forget(self);
@@ -755,3 +757,7 @@ impl Drop for OwnedEvent {
 }
 }
 }
+
+pub(crate)constfnipv4_to_r_efi(addr:crate::net::Ipv4Addr) -> efi::Ipv4Address{
+ efi::Ipv4Address{addr: addr.octets()}
+}