libstd: win: Remove calls to SetHandleInformation

The WSA_FLAG_NO_HANDLE_INHERIT is available starting from Windows 7
(sp1) which only matches rustc's target platform for Windows, but not
the runtime target platforms.

This function isn't available when targeting UWP.
Instead:
- Create all sockets with the WSA_FLAG_NO_HANDLE_INHERIT flag
  The socket created by accept() need not to explicitely disable handle
  inheritance, since the documentation states «The newly created socket
  is the socket that will handle the actual connection; it has the same
  properties as socket s, including the asynchronous events registered
  with the WSAAsyncSelect or WSAEventSelect functions.»
- Pass a boolean flag to allow the 'their' end of pipes to be
  inheritable directly upon creating it, instead of a later call to
  SetHandleInformation

Author: chouquette

src/libstd/sys/windows/c.rs

@@ -132,6 +132,8 @@ impl Clone for WIN32_FIND_DATAW {
 }
 
 pub const WSA_FLAG_OVERLAPPED: DWORD = 0x01;
+#[cfg(target_os = "uwp")]
+pub const WSA_FLAG_NO_HANDLE_INHERIT: DWORD = 0x80;
 
 pub const WSADESCRIPTION_LEN: usize = 256;
 pub const WSASYS_STATUS_LEN: usize = 128;
@@ -168,6 +170,7 @@ pub const STD_INPUT_HANDLE: DWORD = -10i32 as DWORD;
 pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as DWORD;
 pub const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
 
+#[cfg(not(target_os = "uwp"))]
 pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
 
 pub const PROGRESS_CONTINUE: DWORD = 0;
@@ -1083,6 +1086,7 @@ extern "system" {
     pub fn GetUserProfileDirectoryW(hToken: HANDLE,
                                     lpProfileDir: LPWSTR,
                                     lpcchSize: *mut DWORD) -> BOOL;
+    #[cfg(not(target_os = "uwp"))]
     pub fn SetHandleInformation(hObject: HANDLE,
                                 dwMask: DWORD,
                                 dwFlags: DWORD) -> BOOL;

src/libstd/sys/windows/net.rs

@@ -96,12 +96,16 @@ impl Socket {
             SocketAddr::V6(..) => c::AF_INET6,
         };
         let socket = unsafe {
-            match c::WSASocketW(fam, ty, 0, ptr::null_mut(), 0,
-                                c::WSA_FLAG_OVERLAPPED) {
+            #[cfg(not(target_os = "uwp"))]
+            let socket_flags = c::WSA_FLAG_OVERLAPPED;
+            #[cfg(target_os = "uwp")]
+            let socket_flags = c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT;
+            match c::WSASocketW(fam, ty, 0, ptr::null_mut(), 0, socket_flags) {
                 c::INVALID_SOCKET => Err(last_error()),
                 n => Ok(Socket(n)),
             }
         }?;
+        #[cfg(not(target_os = "uwp"))]
         socket.set_no_inherit()?;
         Ok(socket)
     }
@@ -168,6 +172,7 @@ impl Socket {
                 n => Ok(Socket(n)),
             }
         }?;
+        #[cfg(not(target_os = "uwp"))]
         socket.set_no_inherit()?;
         Ok(socket)
     }
@@ -178,15 +183,21 @@ impl Socket {
             cvt(c::WSADuplicateSocketW(self.0,
                                             c::GetCurrentProcessId(),
                                             &mut info))?;
+            #[cfg(not(target_os = "uwp"))]
+            let socket_flags = c::WSA_FLAG_OVERLAPPED;
+            #[cfg(target_os = "uwp")]
+            let socket_flags = c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT;
+
             match c::WSASocketW(info.iAddressFamily,
                                 info.iSocketType,
                                 info.iProtocol,
                                 &mut info, 0,
-                                c::WSA_FLAG_OVERLAPPED) {
+                                socket_flags) {
                 c::INVALID_SOCKET => Err(last_error()),
                 n => Ok(Socket(n)),
             }
         }?;
+        #[cfg(not(target_os = "uwp"))]
         socket.set_no_inherit()?;
         Ok(socket)
     }
@@ -312,6 +323,7 @@ impl Socket {
         }
     }
 
+    #[cfg(not(target_os = "uwp"))]
     fn set_no_inherit(&self) -> io::Result<()> {
         sys::cvt(unsafe {
             c::SetHandleInformation(self.0 as c::HANDLE,

src/libstd/sys/windows/pipe.rs

@@ -45,7 +45,7 @@ pub struct Pipes {
 /// mode. This means that technically speaking it should only ever be used
 /// with `OVERLAPPED` instances, but also works out ok if it's only ever used
 /// once at a time (which we do indeed guarantee).
-pub fn anon_pipe(ours_readable: bool) -> io::Result<Pipes> {
+pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Result<Pipes> {
     // Note that we specifically do *not* use `CreatePipe` here because
     // unfortunately the anonymous pipes returned do not support overlapped
     // operations. Instead, we create a "hopefully unique" name and create a
@@ -137,6 +137,13 @@ pub fn anon_pipe(ours_readable: bool) -> io::Result<Pipes> {
         opts.write(ours_readable);
         opts.read(!ours_readable);
         opts.share_mode(0);
+        let size = mem::size_of::<c::SECURITY_ATTRIBUTES>();
+        let mut sa = c::SECURITY_ATTRIBUTES {
+            nLength: size as c::DWORD,
+            lpSecurityDescriptor: ptr::null_mut(),
+            bInheritHandle: their_handle_inheritable as i32,
+        };
+        opts.security_attributes(&mut sa);
         let theirs = File::open(Path::new(&name), &opts)?;
         let theirs = AnonPipe { inner: theirs.into_handle() };
 

src/libstd/sys/windows/process.rs

@@ -267,13 +267,8 @@ impl Stdio {
 
             Stdio::MakePipe => {
                 let ours_readable = stdio_id != c::STD_INPUT_HANDLE;
-                let pipes = pipe::anon_pipe(ours_readable)?;
+                let pipes = pipe::anon_pipe(ours_readable, true)?;
                 *pipe = Some(pipes.ours);
-                cvt(unsafe {
-                    c::SetHandleInformation(pipes.theirs.handle().raw(),
-                                            c::HANDLE_FLAG_INHERIT,
-                                            c::HANDLE_FLAG_INHERIT)
-                })?;
                 Ok(pipes.theirs.into_handle())
             }