Add Windows support for Unix Domain Sockets

src/lib.rs

@@ -50,6 +50,8 @@ mod macros;
 mod interest;
 mod poll;
 mod sys;
+#[cfg(all(windows, feature = "net"))]
+pub use sys::uds;
 mod token;
 #[cfg(not(target_os = "wasi"))]
 mod waker;

src/net/mod.rs

@@ -33,7 +33,9 @@ mod udp;
 #[cfg(not(target_os = "wasi"))]
 pub use self::udp::UdpSocket;
 
-#[cfg(unix)]
+#[cfg(any(unix,windows))]
 mod uds;
+#[cfg(any(unix,windows))]
+pub use self::uds::{UnixListener, UnixStream};
 #[cfg(unix)]
-pub use self::uds::{UnixDatagram, UnixListener, UnixStream};
+pub use self::uds::UnixDatagram;

src/net/uds/datagram.rs

@@ -1,6 +1,6 @@
+#![cfg(unix)]
 use std::net::Shutdown;
-use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
-use std::os::unix::net::{self, SocketAddr};
+use std::os::{fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd},unix::net::{self, SocketAddr}};
 use std::path::Path;
 use std::{fmt, io};
 

src/net/uds/listener.rs

@@ -1,5 +1,12 @@
-use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
-use std::os::unix::net::{self, SocketAddr};
+#[cfg(windows)]
+use crate::sys::uds::{net, SocketAddr};
+#[cfg(windows)]
+use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
+#[cfg(unix)]
+use std::os::{
+    fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd},
+    unix::net::{self, SocketAddr},
+};
 use std::path::Path;
 use std::{fmt, io};
 
@@ -53,6 +60,10 @@ impl UnixListener {
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.inner.take_error()
     }
+    /// Sets the non-blocking mode for this socket
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.inner.set_nonblocking(nonblocking)
+    }
 }
 
 impl event::Source for UnixListener {
@@ -84,19 +95,19 @@ impl fmt::Debug for UnixListener {
         self.inner.fmt(f)
     }
 }
-
+#[cfg(unix)]
 impl IntoRawFd for UnixListener {
     fn into_raw_fd(self) -> RawFd {
         self.inner.into_inner().into_raw_fd()
     }
 }
-
+#[cfg(unix)]
 impl AsRawFd for UnixListener {
     fn as_raw_fd(&self) -> RawFd {
         self.inner.as_raw_fd()
     }
 }
-
+#[cfg(unix)]
 impl FromRawFd for UnixListener {
     /// Converts a `RawFd` to a `UnixListener`.
     ///
@@ -109,6 +120,7 @@ impl FromRawFd for UnixListener {
     }
 }
 
+#[cfg(unix)]
 impl From<UnixListener> for net::UnixListener {
     fn from(listener: UnixListener) -> Self {
         // Safety: This is safe since we are extracting the raw fd from a well-constructed
@@ -117,21 +129,39 @@ impl From<UnixListener> for net::UnixListener {
         unsafe { net::UnixListener::from_raw_fd(listener.into_raw_fd()) }
     }
 }
-
+#[cfg(unix)]
 impl From<UnixListener> for OwnedFd {
     fn from(unix_listener: UnixListener) -> Self {
         unix_listener.inner.into_inner().into()
     }
 }
-
+#[cfg(unix)]
 impl AsFd for UnixListener {
     fn as_fd(&self) -> BorrowedFd<'_> {
         self.inner.as_fd()
     }
 }
-
+#[cfg(unix)]
 impl From<OwnedFd> for UnixListener {
     fn from(fd: OwnedFd) -> Self {
         UnixListener::from_std(From::from(fd))
     }
 }
+#[cfg(windows)]
+impl AsRawSocket for UnixListener {
+    fn as_raw_socket(&self) -> RawSocket {
+        self.inner.as_raw_socket()
+    }
+}
+#[cfg(windows)]
+impl FromRawSocket for UnixListener {
+    unsafe fn from_raw_socket(sock: RawSocket) -> Self {
+        UnixListener::from_std(FromRawSocket::from_raw_socket(sock))
+    }
+}
+#[cfg(windows)]
+impl IntoRawSocket for UnixListener {
+    fn into_raw_socket(self) -> RawSocket {
+        self.inner.into_inner().into_raw_socket()
+    }
+}

src/net/uds/mod.rs

@@ -1,8 +1,11 @@
 mod datagram;
+#[cfg(unix)]
 pub use self::datagram::UnixDatagram;
 
 mod listener;
+#[cfg(any(unix,windows))]
 pub use self::listener::UnixListener;
 
 mod stream;
+#[cfg(any(unix,windows))]
 pub use self::stream::UnixStream;

src/net/uds/stream.rs

@@ -1,8 +1,16 @@
+#[cfg(windows)]
+use crate::sys::uds::{net, SocketAddr};
 use std::fmt;
 use std::io::{self, IoSlice, IoSliceMut, Read, Write};
 use std::net::Shutdown;
-use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
-use std::os::unix::net::{self, SocketAddr};
+#[cfg(windows)]
+use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
+#[cfg(unix)]
+use std::os::{
+    fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd},
+    unix::net::{self, SocketAddr},
+};
+
 use std::path::Path;
 
 use crate::io_source::IoSource;
@@ -52,6 +60,7 @@ impl UnixStream {
     /// Creates an unnamed pair of connected sockets.
     ///
     /// Returns two `UnixStream`s which are connected to each other.
+    #[cfg(unix)]
     pub fn pair() -> io::Result<(UnixStream, UnixStream)> {
         sys::uds::stream::pair().map(|(stream1, stream2)| {
             (UnixStream::from_std(stream1), UnixStream::from_std(stream2))
@@ -149,6 +158,10 @@ impl UnixStream {
     {
         self.inner.do_io(|_| f())
     }
+    /// Sets the non-blocking mode for this socket
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.inner.set_nonblocking(nonblocking)
+    }
 }
 
 impl Read for UnixStream {
@@ -228,18 +241,20 @@ impl fmt::Debug for UnixStream {
         self.inner.fmt(f)
     }
 }
-
+#[cfg(unix)]
 impl IntoRawFd for UnixStream {
     fn into_raw_fd(self) -> RawFd {
         self.inner.into_inner().into_raw_fd()
     }
 }
+#[cfg(unix)]
 
 impl AsRawFd for UnixStream {
     fn as_raw_fd(&self) -> RawFd {
         self.inner.as_raw_fd()
     }
 }
+#[cfg(unix)]
 
 impl FromRawFd for UnixStream {
     /// Converts a `RawFd` to a `UnixStream`.
@@ -252,6 +267,7 @@ impl FromRawFd for UnixStream {
         UnixStream::from_std(FromRawFd::from_raw_fd(fd))
     }
 }
+#[cfg(unix)]
 
 impl From<UnixStream> for net::UnixStream {
     fn from(stream: UnixStream) -> Self {
@@ -261,21 +277,42 @@ impl From<UnixStream> for net::UnixStream {
         unsafe { net::UnixStream::from_raw_fd(stream.into_raw_fd()) }
     }
 }
+#[cfg(unix)]
 
 impl From<UnixStream> for OwnedFd {
     fn from(unix_stream: UnixStream) -> Self {
         unix_stream.inner.into_inner().into()
     }
 }
+#[cfg(unix)]
 
 impl AsFd for UnixStream {
     fn as_fd(&self) -> BorrowedFd<'_> {
         self.inner.as_fd()
     }
 }
+#[cfg(unix)]
 
 impl From<OwnedFd> for UnixStream {
     fn from(fd: OwnedFd) -> Self {
         UnixStream::from_std(From::from(fd))
     }
 }
+#[cfg(windows)]
+impl AsRawSocket for UnixStream {
+    fn as_raw_socket(&self) -> RawSocket {
+        self.inner.as_raw_socket()
+    }
+}
+#[cfg(windows)]
+impl FromRawSocket for UnixStream {
+    unsafe fn from_raw_socket(sock: RawSocket) -> Self {
+        UnixStream::from_std(FromRawSocket::from_raw_socket(sock))
+    }
+}
+#[cfg(windows)]
+impl IntoRawSocket for UnixStream {
+    fn into_raw_socket(self) -> RawSocket {
+        self.inner.into_inner().into_raw_socket()
+    }
+}

src/sys/windows/event.rs

@@ -4,7 +4,7 @@ use super::afd;
 use super::iocp::CompletionStatus;
 use crate::Token;
 
-#[derive(Clone)]
+#[derive(Clone,Debug)]
 pub struct Event {
     pub flags: u32,
     pub data: u64,

src/sys/windows/mod.rs

@@ -41,6 +41,8 @@ cfg_net! {
 
 cfg_os_ext! {
     pub(crate) mod named_pipe;
+    /// UDS on Windows
+    pub mod uds;
 }
 
 mod waker;

src/sys/windows/net.rs

@@ -3,6 +3,7 @@ use std::mem;
 use std::net::SocketAddr;
 use std::sync::Once;
 
+use windows_sys::Win32::Networking::WinSock::SOCKADDR_UN;
 use windows_sys::Win32::Networking::WinSock::{
     closesocket, ioctlsocket, socket, AF_INET, AF_INET6, FIONBIO, IN6_ADDR, IN6_ADDR_0,
     INVALID_SOCKET, IN_ADDR, IN_ADDR_0, SOCKADDR, SOCKADDR_IN, SOCKADDR_IN6, SOCKADDR_IN6_0,
@@ -55,6 +56,7 @@ pub(crate) fn new_socket(domain: u32, socket_type: i32) -> io::Result<SOCKET> {
 pub(crate) union SocketAddrCRepr {
     v4: SOCKADDR_IN,
     v6: SOCKADDR_IN6,
+    unix: SOCKADDR_UN
 }
 
 impl SocketAddrCRepr {