feature gate windows_unix_domain_sockets

kouhe3 · kouhe3 · commit 913911fb1e26 · 2025-10-04T18:11:57.000+08:00
diff --git a/library/std/src/os/windows/net/addr.rs b/library/std/src/os/windows/net/addr.rs
@@ -1,11 +1,10 @@
-#![stable(feature = "rust1", since = "1.0.0")]
+#![unstable(feature = "windows_unix_domain_sockets", issue = "none")]
 
 use crate::os::raw::{c_char, c_int};
 use crate::path::Path;
 use crate::sys::c::{self, SOCKADDR};
 use crate::sys::cvt;
 use crate::{io, mem};
-#[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;
@@ -47,13 +46,11 @@ fn sun_path_offset(addr: &c::sockaddr_un) -> 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 {
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new<F>(f: F) -> io::Result<SocketAddr>
     where
         F: FnOnce(*mut SOCKADDR, *mut c_int) -> c_int,
@@ -80,7 +77,6 @@ impl SocketAddr {
         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)
 }
diff --git a/library/std/src/os/windows/net/listener.rs b/library/std/src/os/windows/net/listener.rs
@@ -1,3 +1,5 @@
+#![unstable(feature = "windows_unix_domain_sockets", issue = "none")]
+
 use core::mem;
 
 use super::sockaddr_un;
@@ -9,13 +11,10 @@ use crate::path::Path;
 use crate::sys::c::{self, bind, getsockname, 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")]
 
 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()?;
@@ -25,40 +24,34 @@ impl UnixListener {
             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))
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn incoming(&self) -> Incoming<'_> {
         Incoming { listener: self }
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.0.take_error()
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
         self.0.set_nonblocking(nonblocking)
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn local_addr(&self) -> io::Result<SocketAddr> {
         SocketAddr::new(|addr, len| unsafe { getsockname(self.0.as_raw() as _, addr, len) })
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn try_clone(&self) -> io::Result<UnixListener> {
         self.0.duplicate().map(UnixListener)
     }
 }
-#[stable(feature = "rust1", since = "1.0.0")]
+
 pub struct Incoming<'a> {
     listener: &'a UnixListener,
 }
-#[stable(feature = "rust1", since = "1.0.0")]
+
 impl<'a> Iterator for Incoming<'a> {
     type Item = io::Result<UnixStream>;
 
@@ -70,21 +63,19 @@ impl<'a> Iterator for Incoming<'a> {
         (usize::max_value(), None)
     }
 }
-#[stable(feature = "rust1", since = "1.0.0")]
+
 impl AsRawSocket for UnixListener {
     fn as_raw_socket(&self) -> RawSocket {
         self.0.as_raw_socket()
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl FromRawSocket for UnixListener {
     unsafe fn from_raw_socket(sock: RawSocket) -> Self {
         UnixListener(unsafe { Socket::from_raw_socket(sock) })
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl IntoRawSocket for UnixListener {
     fn into_raw_socket(self) -> RawSocket {
         let ret = self.0.as_raw_socket();
@@ -93,7 +84,6 @@ impl IntoRawSocket for UnixListener {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> IntoIterator for &'a UnixListener {
     type Item = io::Result<UnixStream>;
     type IntoIter = Incoming<'a>;
diff --git a/library/std/src/os/windows/net/mod.rs b/library/std/src/os/windows/net/mod.rs
@@ -1,11 +1,8 @@
-#![stable(feature = "rust1", since = "1.0.0")]
+#![unstable(feature = "windows_unix_domain_sockets", issue = "none")]
 
 mod addr;
 mod listener;
 mod stream;
-#[stable(feature = "rust1", since = "1.0.0")]
 pub use addr::*;
-#[stable(feature = "rust1", since = "1.0.0")]
 pub use listener::*;
-#[stable(feature = "rust1", since = "1.0.0")]
 pub use stream::*;
diff --git a/library/std/src/os/windows/net/stream.rs b/library/std/src/os/windows/net/stream.rs
@@ -1,4 +1,4 @@
-#![stable(feature = "rust1", since = "1.0.0")]
+#![unstable(feature = "windows_unix_domain_sockets", issue = "none")]
 
 use core::mem;
 use core::time::Duration;
@@ -14,10 +14,8 @@ use crate::sys::c::{SO_RCVTIMEO, SO_SNDTIMEO, connect, getpeername, getsockname}
 use crate::sys::cvt;
 use crate::sys::net::Socket;
 
-#[stable(feature = "rust1", since = "1.0.0")]
 pub struct UnixStream(pub Socket);
 impl UnixStream {
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> {
         unsafe {
             let inner = Socket::new_unix()?;
@@ -26,64 +24,50 @@ impl UnixStream {
             Ok(UnixStream(inner))
         }
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
-
     pub fn local_addr(&self) -> io::Result<SocketAddr> {
         SocketAddr::new(|addr, len| unsafe { getsockname(self.0.as_raw() as _, addr, len) })
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
         SocketAddr::new(|addr, len| unsafe { getpeername(self.0.as_raw() as _, addr, len) })
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
         self.0.timeout(SO_RCVTIMEO)
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
         self.0.set_nonblocking(nonblocking)
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
         self.0.set_timeout(dur, SO_RCVTIMEO)
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
         self.0.set_timeout(dur, SO_SNDTIMEO)
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
         self.0.shutdown(how)
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.0.take_error()
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn try_clone(&self) -> io::Result<UnixStream> {
         self.0.duplicate().map(UnixStream)
     }
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
         self.0.timeout(SO_SNDTIMEO)
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl io::Read for UnixStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         io::Read::read(&mut &*self, buf)
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> io::Read for &'a UnixStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.0.read(buf)
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl io::Write for UnixStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         io::Write::write(&mut &*self, buf)
@@ -93,7 +77,6 @@ impl io::Write for UnixStream {
         io::Write::flush(&mut &*self)
     }
 }
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> io::Write for &'a UnixStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.0.write_vectored(&[IoSlice::new(buf)])
@@ -104,28 +87,24 @@ impl<'a> io::Write for &'a UnixStream {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl AsSocket for UnixStream {
     fn as_socket(&self) -> BorrowedSocket {
         self.0.as_socket()
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl AsRawSocket for UnixStream {
     fn as_raw_socket(&self) -> RawSocket {
         self.0.as_raw_socket()
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl FromRawSocket for UnixStream {
     unsafe fn from_raw_socket(sock: RawSocket) -> Self {
         unsafe { UnixStream(Socket::from_raw_socket(sock)) }
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
 impl IntoRawSocket for UnixStream {
     fn into_raw_socket(self) -> RawSocket {
         let ret = self.0.as_raw_socket();

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+#![unstable(feature = "windows_unix_domain_sockets", issue = "none")]`
	`2`	`+`
`1`	`3`	`use core::mem;`
`2`	`4`
`3`	`5`	`use super::sockaddr_un;`
`@@ -9,13 +11,10 @@ use crate::path::Path;`
`9`	`11`	`use crate::sys::c::{self, bind, getsockname, listen};`
`10`	`12`	`use crate::sys::cvt;`
`11`	`13`	`use crate::sys::net::Socket;`
`12`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`13`	`14`
`14`	`15`	`pub struct UnixListener(Socket);`
`15`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`16`	`16`
`17`	`17`	`impl UnixListener {`
`18`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`19`	`18`	`pub fn bind<P: AsRef<Path>>(path: &Path) -> io::Result<UnixListener> {`
`20`	`19`	`unsafe {`
`21`	`20`	`let inner = Socket::new_unix()?;`
`@@ -25,40 +24,34 @@ impl UnixListener {`
`25`	`24`	`Ok(UnixListener(inner))`
`26`	`25`	`}`
`27`	`26`	`}`
`28`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`29`	`27`	`pub fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {`
`30`	`28`	`let mut storage: c::sockaddr_un = unsafe { mem::zeroed() };`
`31`	`29`	`let mut len = mem::size_of_val(&storage) as c_int;`
`32`	`30`	`let sock = self.0.accept(&mut storage as mut _ as mut _, &mut len)?;`
`33`	`31`	`let addr = from_sockaddr_un(storage, len)?;`
`34`	`32`	`Ok((UnixStream(sock), addr))`
`35`	`33`	`}`
`36`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`37`	`34`	`pub fn incoming(&self) -> Incoming<'_> {`
`38`	`35`	`Incoming { listener: self }`
`39`	`36`	`}`
`40`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`41`	`37`	`pub fn take_error(&self) -> io::Result<Option<io::Error>> {`
`42`	`38`	`self.0.take_error()`
`43`	`39`	`}`
`44`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`45`	`40`	`pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {`
`46`	`41`	`self.0.set_nonblocking(nonblocking)`
`47`	`42`	`}`
`48`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`49`	`43`	`pub fn local_addr(&self) -> io::Result<SocketAddr> {`
`50`	`44`	`SocketAddr::new(\|addr, len\| unsafe { getsockname(self.0.as_raw() as _, addr, len) })`
`51`	`45`	`}`
`52`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`53`	`46`	`pub fn try_clone(&self) -> io::Result<UnixListener> {`
`54`	`47`	`self.0.duplicate().map(UnixListener)`
`55`	`48`	`}`
`56`	`49`	`}`
`57`		`-#[stable(feature = "rust1", since = "1.0.0")]`
	`50`	`+`
`58`	`51`	`pub struct Incoming<'a> {`
`59`	`52`	`listener: &'a UnixListener,`
`60`	`53`	`}`
`61`		`-#[stable(feature = "rust1", since = "1.0.0")]`
	`54`	`+`
`62`	`55`	`impl<'a> Iterator for Incoming<'a> {`
`63`	`56`	`type Item = io::Result<UnixStream>;`
`64`	`57`
`@@ -70,21 +63,19 @@ impl<'a> Iterator for Incoming<'a> {`
`70`	`63`	`(usize::max_value(), None)`
`71`	`64`	`}`
`72`	`65`	`}`
`73`		`-#[stable(feature = "rust1", since = "1.0.0")]`
	`66`	`+`
`74`	`67`	`impl AsRawSocket for UnixListener {`
`75`	`68`	`fn as_raw_socket(&self) -> RawSocket {`
`76`	`69`	`self.0.as_raw_socket()`
`77`	`70`	`}`
`78`	`71`	`}`
`79`	`72`
`80`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`81`	`73`	`impl FromRawSocket for UnixListener {`
`82`	`74`	`unsafe fn from_raw_socket(sock: RawSocket) -> Self {`
`83`	`75`	`UnixListener(unsafe { Socket::from_raw_socket(sock) })`
`84`	`76`	`}`
`85`	`77`	`}`
`86`	`78`
`87`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`88`	`79`	`impl IntoRawSocket for UnixListener {`
`89`	`80`	`fn into_raw_socket(self) -> RawSocket {`
`90`	`81`	`let ret = self.0.as_raw_socket();`
`@@ -93,7 +84,6 @@ impl IntoRawSocket for UnixListener {`
`93`	`84`	`}`
`94`	`85`	`}`
`95`	`86`
`96`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`97`	`87`	`impl<'a> IntoIterator for &'a UnixListener {`
`98`	`88`	`type Item = io::Result<UnixStream>;`
`99`	`89`	`type IntoIter = Incoming<'a>;`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#![stable(feature = "rust1", since = "1.0.0")]`
	`1`	`+#![unstable(feature = "windows_unix_domain_sockets", issue = "none")]`
`2`	`2`
`3`	`3`	`use core::mem;`
`4`	`4`	`use core::time::Duration;`
`@@ -14,10 +14,8 @@ use crate::sys::c::{SO_RCVTIMEO, SO_SNDTIMEO, connect, getpeername, getsockname}`
`14`	`14`	`use crate::sys::cvt;`
`15`	`15`	`use crate::sys::net::Socket;`
`16`	`16`
`17`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`18`	`17`	`pub struct UnixStream(pub Socket);`
`19`	`18`	`impl UnixStream {`
`20`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`21`	`19`	`pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> {`
`22`	`20`	`unsafe {`
`23`	`21`	`let inner = Socket::new_unix()?;`
`@@ -26,64 +24,50 @@ impl UnixStream {`
`26`	`24`	`Ok(UnixStream(inner))`
`27`	`25`	`}`
`28`	`26`	`}`
`29`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`30`		`-`
`31`	`27`	`pub fn local_addr(&self) -> io::Result<SocketAddr> {`
`32`	`28`	`SocketAddr::new(\|addr, len\| unsafe { getsockname(self.0.as_raw() as _, addr, len) })`
`33`	`29`	`}`
`34`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`35`	`30`	`pub fn peer_addr(&self) -> io::Result<SocketAddr> {`
`36`	`31`	`SocketAddr::new(\|addr, len\| unsafe { getpeername(self.0.as_raw() as _, addr, len) })`
`37`	`32`	`}`
`38`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`39`	`33`	`pub fn read_timeout(&self) -> io::Result<Option<Duration>> {`
`40`	`34`	`self.0.timeout(SO_RCVTIMEO)`
`41`	`35`	`}`
`42`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`43`	`36`	`pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {`
`44`	`37`	`self.0.set_nonblocking(nonblocking)`
`45`	`38`	`}`
`46`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`47`	`39`	`pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {`
`48`	`40`	`self.0.set_timeout(dur, SO_RCVTIMEO)`
`49`	`41`	`}`
`50`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`51`	`42`	`pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {`
`52`	`43`	`self.0.set_timeout(dur, SO_SNDTIMEO)`
`53`	`44`	`}`
`54`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`55`	`45`	`pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {`
`56`	`46`	`self.0.shutdown(how)`
`57`	`47`	`}`
`58`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`59`	`48`	`pub fn take_error(&self) -> io::Result<Option<io::Error>> {`
`60`	`49`	`self.0.take_error()`
`61`	`50`	`}`
`62`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`63`	`51`	`pub fn try_clone(&self) -> io::Result<UnixStream> {`
`64`	`52`	`self.0.duplicate().map(UnixStream)`
`65`	`53`	`}`
`66`		`- #[stable(feature = "rust1", since = "1.0.0")]`
`67`	`54`	`pub fn write_timeout(&self) -> io::Result<Option<Duration>> {`
`68`	`55`	`self.0.timeout(SO_SNDTIMEO)`
`69`	`56`	`}`
`70`	`57`	`}`
`71`	`58`
`72`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`73`	`59`	`impl io::Read for UnixStream {`
`74`	`60`	`fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {`
`75`	`61`	`io::Read::read(&mut &*self, buf)`
`76`	`62`	`}`
`77`	`63`	`}`
`78`	`64`
`79`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`80`	`65`	`impl<'a> io::Read for &'a UnixStream {`
`81`	`66`	`fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {`
`82`	`67`	`self.0.read(buf)`
`83`	`68`	`}`
`84`	`69`	`}`
`85`	`70`
`86`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`87`	`71`	`impl io::Write for UnixStream {`
`88`	`72`	`fn write(&mut self, buf: &[u8]) -> io::Result<usize> {`
`89`	`73`	`io::Write::write(&mut &*self, buf)`
`@@ -93,7 +77,6 @@ impl io::Write for UnixStream {`
`93`	`77`	`io::Write::flush(&mut &*self)`
`94`	`78`	`}`
`95`	`79`	`}`
`96`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`97`	`80`	`impl<'a> io::Write for &'a UnixStream {`
`98`	`81`	`fn write(&mut self, buf: &[u8]) -> io::Result<usize> {`
`99`	`82`	`self.0.write_vectored(&[IoSlice::new(buf)])`
`@@ -104,28 +87,24 @@ impl<'a> io::Write for &'a UnixStream {`
`104`	`87`	`}`
`105`	`88`	`}`
`106`	`89`
`107`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`108`	`90`	`impl AsSocket for UnixStream {`
`109`	`91`	`fn as_socket(&self) -> BorrowedSocket {`
`110`	`92`	`self.0.as_socket()`
`111`	`93`	`}`
`112`	`94`	`}`
`113`	`95`
`114`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`115`	`96`	`impl AsRawSocket for UnixStream {`
`116`	`97`	`fn as_raw_socket(&self) -> RawSocket {`
`117`	`98`	`self.0.as_raw_socket()`
`118`	`99`	`}`
`119`	`100`	`}`
`120`	`101`
`121`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`122`	`102`	`impl FromRawSocket for UnixStream {`
`123`	`103`	`unsafe fn from_raw_socket(sock: RawSocket) -> Self {`
`124`	`104`	`unsafe { UnixStream(Socket::from_raw_socket(sock)) }`
`125`	`105`	`}`
`126`	`106`	`}`
`127`	`107`
`128`		`-#[stable(feature = "rust1", since = "1.0.0")]`
`129`	`108`	`impl IntoRawSocket for UnixStream {`
`130`	`109`	`fn into_raw_socket(self) -> RawSocket {`
`131`	`110`	`let ret = self.0.as_raw_socket();`