Change Socket::set_no_inherit signature

To match Socket::set_cloexec. Also add a test for it and
Type::no_inherit.

Author: Thomasdezeeuw

src/sys/windows.rs

@@ -22,14 +22,11 @@ use winapi::ctypes::{c_char, c_long, c_ulong};
 use winapi::shared::in6addr::*;
 use winapi::shared::inaddr::*;
 use winapi::shared::minwindef::DWORD;
-#[cfg(feature = "all")]
 use winapi::shared::ntdef::HANDLE;
 use winapi::shared::ws2def::{self, *};
 use winapi::shared::ws2ipdef::*;
-#[cfg(feature = "all")]
 use winapi::um::handleapi::SetHandleInformation;
 use winapi::um::processthreadsapi::GetCurrentProcessId;
-#[cfg(feature = "all")]
 use winapi::um::winbase;
 use winapi::um::winbase::INFINITE;
 use winapi::um::winsock2::{self as sock, u_long, SD_BOTH, SD_RECEIVE, SD_SEND};
@@ -91,7 +88,7 @@ impl_debug!(
 impl Type {
     /// Our custom flag to set `WSA_FLAG_NO_HANDLE_INHERIT` on socket creation.
     /// Trying to mimic `Type::cloexec` on windows.
-    const NO_INHERIT: c_int = 1 << (size_of::<c_int>());
+    const NO_INHERIT: c_int = 1 << ((size_of::<c_int>() * 8) - 1); // Last bit.
 
     /// Set `WSA_FLAG_NO_HANDLE_INHERIT` on the socket.
     #[cfg(feature = "all")]
@@ -300,12 +297,16 @@ fn ioctlsocket(socket: SysSocket, cmd: c_long, payload: &mut u_long) -> io::Resu
 /// Windows only API.
 impl crate::Socket {
     /// Sets `HANDLE_FLAG_INHERIT` to zero using `SetHandleInformation`.
-    #[cfg(feature = "all")]
-    pub fn set_no_inherit(&self) -> io::Result<()> {
+    pub fn set_no_inherit(&self, no_inherit: bool) -> io::Result<()> {
         // NOTE: can't use `syscall!` because it expects the function in the
         // `sock::` path.
-        let res =
-            unsafe { SetHandleInformation(self.inner as HANDLE, winbase::HANDLE_FLAG_INHERIT, 0) };
+        let res = unsafe {
+            SetHandleInformation(
+                self.inner as HANDLE,
+                winbase::HANDLE_FLAG_INHERIT,
+                !no_inherit as _,
+            )
+        };
         if res == 0 {
             // Zero means error.
             Err(io::Error::last_os_error())

tests/socket.rs

@@ -1,5 +1,16 @@
+#[cfg(windows)]
+use std::io;
 #[cfg(unix)]
 use std::os::unix::io::AsRawFd;
+#[cfg(windows)]
+use std::os::windows::io::AsRawSocket;
+
+#[cfg(windows)]
+use winapi::shared::minwindef::DWORD;
+#[cfg(windows)]
+use winapi::um::handleapi::GetHandleInformation;
+#[cfg(windows)]
+use winapi::um::winbase::HANDLE_FLAG_INHERIT;
 
 use socket2::{Domain, Socket, Type};
 
@@ -28,7 +39,7 @@ fn set_nonblocking() {
 ))]
 #[test]
 fn type_nonblocking() {
-    let ty = Type::Stream.nonblocking();
+    let ty = Type::STREAM.nonblocking();
     let socket = Socket::new(Domain::IPV4, ty, None).unwrap();
     assert_nonblocking(&socket, true);
 }
@@ -76,17 +87,58 @@ fn set_cloexec() {
 ))]
 #[test]
 fn type_cloexec() {
-    let ty = Type::Stream.cloexec();
+    let ty = Type::STREAM.cloexec();
     let socket = Socket::new(Domain::IPV4, ty, None).unwrap();
     assert_close_on_exec(&socket, true);
 }
 
 /// Assert that `CLOEXEC` is set on `socket`.
 #[cfg(unix)]
+#[track_caller]
 pub fn assert_close_on_exec<S>(socket: &S, want: bool)
 where
     S: AsRawFd,
 {
     let flags = unsafe { libc::fcntl(socket.as_raw_fd(), libc::F_GETFD) };
     assert_eq!(flags & libc::FD_CLOEXEC != 0, want, "CLOEXEC option");
 }
+
+#[cfg(windows)]
+#[test]
+fn set_no_inherit() {
+    let socket = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
+    assert_flag_inherit(&socket, false);
+
+    socket.set_no_inherit(true).unwrap();
+    assert_flag_inherit(&socket, true);
+
+    socket.set_no_inherit(false).unwrap();
+    assert_flag_inherit(&socket, false);
+}
+
+#[cfg(all(feature = "all", windows))]
+#[test]
+fn type_no_inherit() {
+    let ty = Type::STREAM.no_inherit();
+    let socket = Socket::new(Domain::IPV4, ty, None).unwrap();
+    assert_flag_inherit(&socket, true);
+}
+
+/// Assert that `FLAG_INHERIT` is set on `socket`.
+#[cfg(windows)]
+#[track_caller]
+pub fn assert_flag_inherit<S>(socket: &S, want: bool)
+where
+    S: AsRawSocket,
+{
+    let mut flags: DWORD = 0;
+    if unsafe { GetHandleInformation(socket.as_raw_socket() as _, &mut flags) } == 0 {
+        let err = io::Error::last_os_error();
+        panic!("unexpected error: {}", err);
+    }
+    assert_eq!(
+        flags & HANDLE_FLAG_INHERIT != 0,
+        want,
+        "FLAG_INHERIT option"
+    );
+}