Add fallback implementation for GetProcessId

Since that API is only available starting from XP SP1/Server 2003, we'll
have to get a bit creative to emulate the same behavior on older
systems:

We'll have to query whether the process has exited by
`WaitForSingleObject` with a timeout of 0 (= non-blocking). If
`WAIT_TIMEOUT` is returned, the process has not exited, so our saved
process id is still valid (MSDN: "The value is valid from the time the
process is created until the time the process is terminated."). If the
process has exited, the wait will succeed and return `WAIT_OBJECT_0`, in
which case the id is no longer valid, and we return 0, just like
`GetProcessId`.

Author: seritools

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

@@ -401,6 +401,12 @@ compat_fn_with_fallback! {
     pub fn WakeAllConditionVariable(ConditionVariable: PCONDITION_VARIABLE) -> () {
         rtabort!("unavailable")
     }
+
+    // >= XP SP1 / Vista / Server 2003
+    // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getprocessid
+    pub fn GetProcessId(handle: HANDLE) -> DWORD {
+        rtabort!("unavailable")
+    }
 }
 
 compat_fn_optional! {

library/std/src/sys/windows/c/windows_sys.lst

@@ -2517,7 +2517,6 @@ Windows.Win32.System.Threading.GetCurrentProcess
 Windows.Win32.System.Threading.GetCurrentProcessId
 Windows.Win32.System.Threading.GetCurrentThread
 Windows.Win32.System.Threading.GetExitCodeProcess
-Windows.Win32.System.Threading.GetProcessId
 Windows.Win32.System.Threading.HIGH_PRIORITY_CLASS
 Windows.Win32.System.Threading.IDLE_PRIORITY_CLASS
 Windows.Win32.System.Threading.INFINITE

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

@@ -318,10 +318,6 @@ extern "system" {
     pub fn GetProcAddress(hmodule: HMODULE, lpprocname: PCSTR) -> FARPROC;
 }
 #[link(name = "kernel32")]
-extern "system" {
-    pub fn GetProcessId(process: HANDLE) -> u32;
-}
-#[link(name = "kernel32")]
 extern "system" {
     pub fn GetStdHandle(nstdhandle: STD_HANDLE) -> HANDLE;
 }

library/std/src/sys/windows/process.rs

@@ -342,6 +342,7 @@ impl Command {
                 Process {
                     handle: Handle::from_raw_handle(pi.hProcess),
                     main_thread_handle: Handle::from_raw_handle(pi.hThread),
+                    id: pi.dwProcessId,
                 },
                 pipes,
             ))
@@ -591,6 +592,7 @@ impl From<File> for Stdio {
 pub struct Process {
     handle: Handle,
     main_thread_handle: Handle,
+    id: u32,
 }
 
 impl Process {
@@ -600,7 +602,25 @@ impl Process {
     }
 
     pub fn id(&self) -> u32 {
-        unsafe { c::GetProcessId(self.handle.as_raw_handle()) as u32 }
+        if c::GetProcessId::available() {
+            unsafe { c::GetProcessId(self.handle.as_raw_handle()) as u32 }
+        } else {
+            // Query whether the process has exited by waiting with a timeout of 0 (= non-blocking).
+            // If `WAIT_TIMEOUT` is returned, the process has not exited, so our saved process id is
+            // still valid (MSDN: "The value is valid from the time the process is created until the
+            // time the process is terminated."). If the process has exited, the wait will succeed
+            // and return `WAIT_OBJECT_0`, in which case the id is no longer valid, and we return 0,
+            // just like `GetProcessId`.
+            let res = unsafe { c::WaitForSingleObject(self.handle.as_raw_handle(), 0) };
+
+            match res {
+                c::WAIT_TIMEOUT => self.id,
+                c::WAIT_OBJECT_0 | _ => {
+                    // process is exited, there is no valid id associated anymore
+                    0
+                }
+            }
+        }
     }
 
     pub fn main_thread_handle(&self) -> BorrowedHandle<'_> {