windows unix stream: bind accept

Author: kouhe3

library/std/src/os/windows/mod.rs

@@ -32,6 +32,7 @@ pub mod io;
 pub mod process;
 pub mod raw;
 pub mod thread;
+pub mod net;
 
 /// A prelude for conveniently writing platform-specific code.
 ///

library/std/src/os/windows/net/addr.rs

@@ -0,0 +1,73 @@
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::os::raw::{c_char, c_int};
+use crate::{io, mem};
+use crate::sys::c;
+use crate::path::Path;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub fn sockaddr_un(path: &Path)->io::Result<(c::sockaddr_un,c_int)>{
+    let mut addr: c::sockaddr_un = unsafe { mem::zeroed()};
+    addr.sun_family = c::AF_UNIX;
+    // Winsock2 expects 'sun_path' to be a Win32 UTF-8 file system path
+    let bytes = path.to_str().map(|s| s.as_bytes()).ok_or(io::Error::new(
+        io::ErrorKind::InvalidInput,
+        "path contains invalid characters",
+    ))?;
+
+    if bytes.contains(&0) {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "paths may not contain interior null bytes",
+        ));
+    }
+
+    if bytes.len() >= addr.sun_path.len() {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "path must be shorter than SUN_LEN",
+        ));
+    }
+    for (dst, src) in addr.sun_path.iter_mut().zip(bytes.iter()) {
+        *dst = *src as c_char;
+    }
+    // null byte for pathname addresses is already there because we zeroed the
+    // struct
+
+    let mut len = sun_path_offset(&addr) + bytes.len();
+    match bytes.first() {
+        Some(&0) | None => {}
+        Some(_) => len += 1,
+    }
+    Ok((addr,len as _))
+}
+fn sun_path_offset(addr: &c::sockaddr_un) -> usize {
+    // Work with an actual instance of the type since using a null pointer is UB
+    let base = addr as *const _ as usize;
+    let path = &addr.sun_path as *const _ as usize;
+    path - base
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct SocketAddr {
+    addr: c::sockaddr_un,
+    len: c_int,
+}
+impl SocketAddr {
+    fn from_parts(addr: c::sockaddr_un, mut len: c_int) -> io::Result<SocketAddr> {
+        if len == 0 {
+            // When there is a datagram from unnamed unix socket
+            // linux returns zero bytes of address
+            len = sun_path_offset(&addr) as c_int; // i.e. zero-length address
+        } else if addr.sun_family != c::AF_UNIX {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "file descriptor did not correspond to a Unix socket",
+            ));
+        }
+
+        Ok(SocketAddr { addr, len })
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+pub fn from_sockaddr_un(addr: c::sockaddr_un, len: c_int) -> io::Result<SocketAddr> {
+    SocketAddr::from_parts(addr, len)
+}

library/std/src/os/windows/net/listener.rs

@@ -0,0 +1,36 @@
+use core::mem;
+
+use super::sockaddr_un;
+use crate::io;
+use crate::os::raw::c_int;
+use crate::os::windows::net::{SocketAddr, from_sockaddr_un};
+use crate::path::Path;
+use crate::sys::c::{self, bind, listen};
+use crate::sys::cvt;
+use crate::sys::net::Socket;
+#[stable(feature = "rust1", since = "1.0.0")]
+
+pub struct UnixListener(Socket);
+#[stable(feature = "rust1", since = "1.0.0")]
+
+pub struct UnixStream(Socket);
+impl UnixListener {
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn bind<P: AsRef<Path>>(path: &Path) -> io::Result<UnixListener> {
+        unsafe {
+            let inner = Socket::new_unix()?;
+            let (addr, len) = sockaddr_un(path)?;
+            cvt(bind(inner.as_raw(), &addr as *const _ as *const _, len))?;
+            cvt(listen(inner.as_raw(), 128))?;
+            Ok(UnixListener(inner))
+        }
+    }
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {
+        let mut storage: c::sockaddr_un = unsafe { mem::zeroed() };
+        let mut len = mem::size_of_val(&storage) as c_int;
+        let sock = self.0.accept(&mut storage as *mut _ as *mut _, &mut len)?;
+        let addr = from_sockaddr_un(storage, len)?;
+        Ok((UnixStream(sock), addr))
+    }
+}

library/std/src/os/windows/net/mod.rs

@@ -0,0 +1,8 @@
+#![stable(feature = "rust1", since = "1.0.0")]
+
+mod listener;
+mod addr;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use addr::*;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use listener::*;

library/std/src/sys/net/connection/socket/windows.rs

@@ -9,6 +9,7 @@ use crate::os::windows::io::{
     AsRawSocket, AsSocket, BorrowedSocket, FromRawSocket, IntoRawSocket, OwnedSocket, RawSocket,
 };
 use crate::sys::c;
+use crate::sys::c::{AF_UNIX, INVALID_SOCKET, SOCK_STREAM, WSA_FLAG_OVERLAPPED, WSASocketW};
 use crate::sys::pal::winsock::last_error;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
@@ -28,7 +29,7 @@ pub(super) mod netc {
     use crate::sys::c::{self, ADDRESS_FAMILY, ADDRINFOA, SOCKADDR, SOCKET};
     // re-exports from Windows API bindings.
     pub use crate::sys::c::{
-        ADDRESS_FAMILY as sa_family_t, ADDRINFOA as addrinfo, IP_ADD_MEMBERSHIP,
+        ADDRESS_FAMILY as sa_family_t, ADDRINFOA as addrinfo, AF_UNIX, IP_ADD_MEMBERSHIP,
         IP_DROP_MEMBERSHIP, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_TTL, IPPROTO_IP, IPPROTO_IPV6,
         IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_MULTICAST_LOOP, IPV6_V6ONLY, SO_BROADCAST,
         SO_RCVTIMEO, SO_SNDTIMEO, SOCK_DGRAM, SOCK_STREAM, SOCKADDR as sockaddr,
@@ -117,6 +118,16 @@ pub use crate::sys::pal::winsock::{cleanup, cvt, cvt_gai, cvt_r, startup as init
 pub struct Socket(OwnedSocket);
 
 impl Socket {
+    pub fn new_unix() -> io::Result<Socket> {
+        let socket = unsafe {
+            match WSASocketW(AF_UNIX as i32, SOCK_STREAM, 0, ptr::null_mut(), 0, WSA_FLAG_OVERLAPPED) {
+                INVALID_SOCKET => Err(last_error()),
+                n => Ok(Socket::from_raw(n)),
+            }
+        }?;
+        socket.0.set_no_inherit();
+        Ok(socket)
+    }
     pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
         let family = match *addr {
             SocketAddr::V4(..) => netc::AF_INET,

library/std/src/sys/pal/windows/c.rs

@@ -11,8 +11,16 @@ use core::ptr;
 mod windows_sys;
 pub use windows_sys::*;
 
-pub type WCHAR = u16;
+use crate::os::raw::c_char;
 
+pub type WCHAR = u16;
+pub const AF_UNIX: u16 = 1;
+#[derive(Clone,Copy)]
+#[repr(C)]
+pub struct sockaddr_un {
+    pub sun_family: ADDRESS_FAMILY,
+    pub sun_path: [c_char; 108],
+}
 pub const INVALID_HANDLE_VALUE: HANDLE = ::core::ptr::without_provenance_mut(-1i32 as _);
 
 // https://learn.microsoft.com/en-us/cpp/c-runtime-library/exit-success-exit-failure?view=msvc-170