std: move network code into sys

As per rust-lang#117276, this PR moves `sys_common::net` and the `sys::pal::net` into the newly created `sys::net` module. In order to support rust-lang#135141, I've moved all the current network code into a separate `connection` module, future functions like `hostname` can live in separate modules.

I'll probably do a follow-up PR and clean up some of the actual code, this is mostly just a reorganization.

std/src/net/socket_addr.rs

@@ -6,8 +6,7 @@ mod tests;
 pub use core::net::{SocketAddr, SocketAddrV4, SocketAddrV6};
 
 use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use crate::sys::net::netc as c;
-use crate::sys_common::net::LookupHost;
+use crate::sys::net::{LookupHost, netc as c};
 use crate::sys_common::{FromInner, IntoInner};
 use crate::{io, iter, mem, option, slice, vec};
 

std/src/net/tcp.rs

@@ -15,7 +15,8 @@ use crate::io::prelude::*;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::iter::FusedIterator;
 use crate::net::{Shutdown, SocketAddr, ToSocketAddrs};
-use crate::sys_common::{AsInner, FromInner, IntoInner, net as net_imp};
+use crate::sys::net as net_imp;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
 
 /// A TCP stream between a local and a remote socket.

std/src/net/udp.rs

@@ -12,7 +12,8 @@ mod tests;
 use crate::fmt;
 use crate::io::{self, ErrorKind};
 use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
-use crate::sys_common::{AsInner, FromInner, IntoInner, net as net_imp};
+use crate::sys::net as net_imp;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
 
 /// A UDP socket.

std/src/os/fd/net.rs

@@ -1,6 +1,6 @@
 use crate::os::fd::owned::OwnedFd;
 use crate::os::fd::raw::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use crate::sys_common::{self, AsInner, FromInner, IntoInner};
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::{net, sys};
 
 macro_rules! impl_as_raw_fd {
@@ -24,7 +24,7 @@ macro_rules! impl_from_raw_fd {
             unsafe fn from_raw_fd(fd: RawFd) -> net::$t {
                 unsafe {
                     let socket = sys::net::Socket::from_inner(FromInner::from_inner(OwnedFd::from_raw_fd(fd)));
-                    net::$t::from_inner(sys_common::net::$t::from_inner(socket))
+                    net::$t::from_inner(sys::net::$t::from_inner(socket))
                 }
             }
         }

std/src/os/hermit/io/net.rs

@@ -23,7 +23,7 @@ macro_rules! impl_from_raw_fd {
             unsafe fn from_raw_fd(fd: RawFd) -> net::$t {
                 unsafe {
                     let socket = sys::net::Socket::from_inner(FromInner::from_inner(OwnedFd::from_raw_fd(fd)));
-                    net::$t::from_inner(sys_common::net::$t::from_inner(socket))
+                    net::$t::from_inner(sys::net::$t::from_inner(socket))
                 }
             }
         }

std/src/os/solid/io.rs

@@ -48,7 +48,7 @@
 
 use crate::marker::PhantomData;
 use crate::mem::ManuallyDrop;
-use crate::sys_common::{self, AsInner, FromInner, IntoInner};
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::{fmt, net, sys};
 
 /// Raw file descriptors.
@@ -387,7 +387,7 @@ macro_rules! impl_from_raw_fd {
             #[inline]
             unsafe fn from_raw_fd(fd: RawFd) -> net::$t {
                 let socket = unsafe { sys::net::Socket::from_raw_fd(fd) };
-                net::$t::from_inner(sys_common::net::$t::from_inner(socket))
+                net::$t::from_inner(sys::net::$t::from_inner(socket))
             }
         }
     )*};

std/src/os/windows/io/raw.rs

@@ -6,7 +6,7 @@
 use crate::os::windows::io::{AsHandle, AsSocket};
 use crate::os::windows::io::{OwnedHandle, OwnedSocket};
 use crate::os::windows::raw;
-use crate::sys_common::{self, AsInner, FromInner, IntoInner};
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::{fs, io, net, ptr, sys};
 
 /// Raw HANDLEs.
@@ -262,7 +262,7 @@ impl FromRawSocket for net::TcpStream {
     unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpStream {
         unsafe {
             let sock = sys::net::Socket::from_inner(OwnedSocket::from_raw_socket(sock));
-            net::TcpStream::from_inner(sys_common::net::TcpStream::from_inner(sock))
+            net::TcpStream::from_inner(sys::net::TcpStream::from_inner(sock))
         }
     }
 }
@@ -272,7 +272,7 @@ impl FromRawSocket for net::TcpListener {
     unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpListener {
         unsafe {
             let sock = sys::net::Socket::from_inner(OwnedSocket::from_raw_socket(sock));
-            net::TcpListener::from_inner(sys_common::net::TcpListener::from_inner(sock))
+            net::TcpListener::from_inner(sys::net::TcpListener::from_inner(sock))
         }
     }
 }
@@ -282,7 +282,7 @@ impl FromRawSocket for net::UdpSocket {
     unsafe fn from_raw_socket(sock: RawSocket) -> net::UdpSocket {
         unsafe {
             let sock = sys::net::Socket::from_inner(OwnedSocket::from_raw_socket(sock));
-            net::UdpSocket::from_inner(sys_common::net::UdpSocket::from_inner(sock))
+            net::UdpSocket::from_inner(sys::net::UdpSocket::from_inner(sock))
         }
     }
 }

std/src/sys/mod.rs

@@ -12,6 +12,7 @@ pub mod anonymous_pipe;
 pub mod backtrace;
 pub mod cmath;
 pub mod exit_guard;
+pub mod net;
 pub mod os_str;
 pub mod path;
 pub mod random;

std/src/sys/pal/sgx/net.rs → std/src/sys/net/connection/sgx.rs

@@ -1,7 +1,7 @@
-use super::abi::usercalls;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs};
 use crate::sync::Arc;
+use crate::sys::abi::usercalls;
 use crate::sys::fd::FileDesc;
 use crate::sys::{AsInner, FromInner, IntoInner, TryIntoInner, sgx_ineffective, unsupported};
 use crate::time::Duration;

std/src/sys_common/net.rs → std/src/sys/net/connection/socket.rs

@@ -5,11 +5,31 @@ use crate::ffi::{c_int, c_void};
 use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut};
 use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
 use crate::sys::common::small_c_string::run_with_cstr;
-use crate::sys::net::{Socket, cvt, cvt_gai, cvt_r, init, netc as c, wrlen_t};
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
 use crate::{cmp, fmt, mem, ptr};
 
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "hermit")] {
+        mod hermit;
+        pub use hermit::*;
+    } else if #[cfg(target_os = "solid_asp3")] {
+        mod solid;
+        pub use solid::*;
+    } else if #[cfg(target_family = "unix")] {
+        mod unix;
+        pub use unix::*;
+    } else if #[cfg(all(target_os = "wasi", target_env = "p2"))] {
+        mod wasip2;
+        pub use wasip2::*;
+    } else if #[cfg(target_os = "windows")] {
+        mod windows;
+        pub use windows::*;
+    }
+}
+
+use netc as c;
+
 cfg_if::cfg_if! {
     if #[cfg(any(
         target_os = "dragonfly",
@@ -24,11 +44,11 @@ cfg_if::cfg_if! {
         target_os = "nuttx",
         target_vendor = "apple",
     ))] {
-        use crate::sys::net::netc::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
-        use crate::sys::net::netc::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
+        use c::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
+        use c::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
     } else {
-        use crate::sys::net::netc::IPV6_ADD_MEMBERSHIP;
-        use crate::sys::net::netc::IPV6_DROP_MEMBERSHIP;
+        use c::IPV6_ADD_MEMBERSHIP;
+        use c::IPV6_DROP_MEMBERSHIP;
     }
 }
 

std/src/sys/pal/hermit/net.rs → std/src/sys/net/connection/socket/hermit.rs

@@ -2,21 +2,20 @@
 
 use core::ffi::c_int;
 
-use super::fd::FileDesc;
+pub(crate) use hermit_abi as netc;
+
 use crate::io::{self, BorrowedBuf, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Shutdown, SocketAddr};
 use crate::os::hermit::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, RawFd};
+use crate::sys::fd::FileDesc;
+use crate::sys::net::{getsockopt, setsockopt, sockaddr_to_addr};
 use crate::sys::time::Instant;
-use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
+pub use crate::sys::{cvt, cvt_r};
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
 use crate::{cmp, mem};
 
-#[allow(unused_extern_crates)]
-pub extern crate hermit_abi as netc;
-
-pub use crate::sys::{cvt, cvt_r};
-
+#[expect(non_camel_case_types)]
 pub type wrlen_t = usize;
 
 pub fn cvt_gai(err: i32) -> io::Result<()> {

std/src/sys/pal/solid/net.rs → std/src/sys/net/connection/socket/solid.rs

@@ -1,24 +1,23 @@
 use libc::{c_int, c_void, size_t};
 
 use self::netc::{MSG_PEEK, sockaddr, socklen_t};
-use super::abi;
 use crate::ffi::CStr;
 use crate::io::{self, BorrowedBuf, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut};
 use crate::net::{Shutdown, SocketAddr};
 use crate::os::solid::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd};
-use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
+use crate::sys::abi;
+use crate::sys::net::{getsockopt, setsockopt, sockaddr_to_addr};
 use crate::sys_common::{FromInner, IntoInner};
 use crate::time::Duration;
 use crate::{cmp, mem, ptr, str};
 
 pub mod netc {
-    pub use super::super::abi::sockets::*;
+    pub use crate::sys::abi::sockets::*;
 }
 
+#[expect(non_camel_case_types)]
 pub type wrlen_t = size_t;
 
-const READ_LIMIT: usize = libc::ssize_t::MAX as usize;
-
 const fn max_iov() -> usize {
     // Judging by the source code, it's unlimited, but specify a lower
     // value just in case.
@@ -78,7 +77,7 @@ fn last_error() -> io::Error {
     io::Error::from_raw_os_error(unsafe { netc::SOLID_NET_GetLastError() })
 }
 
-pub(super) fn error_name(er: abi::ER) -> Option<&'static str> {
+pub fn error_name(er: abi::ER) -> Option<&'static str> {
     unsafe { CStr::from_ptr(netc::strerror(er)) }.to_str().ok()
 }
 
@@ -87,7 +86,7 @@ pub fn is_interrupted(er: abi::ER) -> bool {
     er == netc::SOLID_NET_ERR_BASE - libc::EINTR
 }
 
-pub(super) fn decode_error_kind(er: abi::ER) -> ErrorKind {
+pub fn decode_error_kind(er: abi::ER) -> ErrorKind {
     let errno = netc::SOLID_NET_ERR_BASE - er;
     match errno as libc::c_int {
         libc::ECONNREFUSED => ErrorKind::ConnectionRefused,
@@ -268,17 +267,6 @@ impl Socket {
         self.recv_from_with_flags(buf, MSG_PEEK)
     }
 
-    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::write(
-                self.as_raw_fd(),
-                buf.as_ptr() as *const c_void,
-                cmp::min(buf.len(), READ_LIMIT),
-            )
-        })?;
-        Ok(ret as usize)
-    }
-
     pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
         let ret = cvt(unsafe {
             netc::writev(

std/src/sys/pal/unix/net.rs → std/src/sys/net/connection/socket/unix.rs

@@ -5,8 +5,8 @@ use crate::io::{self, BorrowedBuf, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Shutdown, SocketAddr};
 use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use crate::sys::fd::FileDesc;
-use crate::sys::pal::unix::IsMinusOne;
-use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
+use crate::sys::net::{getsockopt, setsockopt, sockaddr_to_addr};
+use crate::sys::pal::IsMinusOne;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::{Duration, Instant};
 use crate::{cmp, mem};
@@ -19,11 +19,11 @@ cfg_if::cfg_if! {
     }
 }
 
-pub use crate::sys::{cvt, cvt_r};
+pub(crate) use libc as netc;
 
-#[allow(unused_extern_crates)]
-pub extern crate libc as netc;
+pub use crate::sys::{cvt, cvt_r};
 
+#[expect(non_camel_case_types)]
 pub type wrlen_t = size_t;
 
 pub struct Socket(FileDesc);

std/src/sys/pal/wasip2/net.rs → std/src/sys/net/connection/socket/wasip2.rs

@@ -6,8 +6,8 @@ use crate::ffi::CStr;
 use crate::io::{self, BorrowedBuf, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Shutdown, SocketAddr};
 use crate::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
+use crate::sys::net::{getsockopt, setsockopt, sockaddr_to_addr};
 use crate::sys::unsupported;
-use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::{Duration, Instant};
 use crate::{cmp, mem, str};

std/src/sys/pal/windows/net.rs → std/src/sys/net/connection/socket/windows.rs

@@ -9,7 +9,7 @@ use crate::os::windows::io::{
 };
 use crate::sync::OnceLock;
 use crate::sys::c;
-use crate::sys_common::{AsInner, FromInner, IntoInner, net};
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
 use crate::{cmp, mem, ptr, sys};
 
@@ -110,6 +110,7 @@ pub mod netc {
     }
 }
 
+#[expect(missing_debug_implementations)]
 pub struct Socket(OwnedSocket);
 
 static WSA_CLEANUP: OnceLock<unsafe extern "system" fn() -> i32> = OnceLock::new();
@@ -400,12 +401,12 @@ impl Socket {
                 let error = unsafe { c::WSAGetLastError() };
 
                 if error == c::WSAESHUTDOWN {
-                    Ok((0, net::sockaddr_to_addr(&storage, addrlen as usize)?))
+                    Ok((0, super::sockaddr_to_addr(&storage, addrlen as usize)?))
                 } else {
                     Err(io::Error::from_raw_os_error(error))
                 }
             }
-            _ => Ok((result as usize, net::sockaddr_to_addr(&storage, addrlen as usize)?)),
+            _ => Ok((result as usize, super::sockaddr_to_addr(&storage, addrlen as usize)?)),
         }
     }
 
@@ -450,11 +451,11 @@ impl Socket {
             }
             None => 0,
         };
-        net::setsockopt(self, c::SOL_SOCKET, kind, timeout)
+        super::setsockopt(self, c::SOL_SOCKET, kind, timeout)
     }
 
     pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
-        let raw: u32 = net::getsockopt(self, c::SOL_SOCKET, kind)?;
+        let raw: u32 = super::getsockopt(self, c::SOL_SOCKET, kind)?;
         if raw == 0 {
             Ok(None)
         } else {
@@ -487,26 +488,26 @@ impl Socket {
             l_linger: linger.unwrap_or_default().as_secs() as c_ushort,
         };
 
-        net::setsockopt(self, c::SOL_SOCKET, c::SO_LINGER, linger)
+        super::setsockopt(self, c::SOL_SOCKET, c::SO_LINGER, linger)
     }
 
     pub fn linger(&self) -> io::Result<Option<Duration>> {
-        let val: c::LINGER = net::getsockopt(self, c::SOL_SOCKET, c::SO_LINGER)?;
+        let val: c::LINGER = super::getsockopt(self, c::SOL_SOCKET, c::SO_LINGER)?;
 
         Ok((val.l_onoff != 0).then(|| Duration::from_secs(val.l_linger as u64)))
     }
 
     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
-        net::setsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY, nodelay as c::BOOL)
+        super::setsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY, nodelay as c::BOOL)
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        let raw: c::BOOL = net::getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY)?;
+        let raw: c::BOOL = super::getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY)?;
         Ok(raw != 0)
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let raw: c_int = net::getsockopt(self, c::SOL_SOCKET, c::SO_ERROR)?;
+        let raw: c_int = super::getsockopt(self, c::SOL_SOCKET, c::SO_ERROR)?;
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 

std/src/sys/pal/wasi/net.rs → std/src/sys/net/connection/wasip1.rs

@@ -1,12 +1,11 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-use super::err2io;
-use super::fd::WasiFd;
 use crate::fmt;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
 use crate::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
-use crate::sys::unsupported;
+use crate::sys::fd::WasiFd;
+use crate::sys::{err2io, unsupported};
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;