#![allow(unsafe_code)]
use std::io;
use std::os::windows::io::RawHandle;
use windows_sys::Win32::Foundation::{
CloseHandle, HANDLE, HANDLE_FLAG_INHERIT, SetHandleInformation,
};
use windows_sys::Win32::System::Console::{
GetStdHandle, STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
};
use windows_sys::Win32::System::JobObjects::{
AssignProcessToJobObject, CreateJobObjectW, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
JobObjectExtendedLimitInformation, SetInformationJobObject, TerminateJobObject,
};
pub fn seal_std_handles() {
for id in [STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE] {
let handle = unsafe { GetStdHandle(id) };
if handle.is_null() || handle == windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE {
continue;
}
unsafe {
let _ = SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0);
}
}
}
#[derive(Debug)]
pub(crate) struct Job(HANDLE);
unsafe impl Send for Job {}
unsafe impl Sync for Job {}
impl Job {
pub(crate) fn create() -> io::Result<Self> {
let handle = unsafe { CreateJobObjectW(core::ptr::null(), core::ptr::null()) };
if handle.is_null() {
return Err(io::Error::last_os_error());
}
let job = Self(handle);
let info: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = unsafe { core::mem::zeroed() };
let ok = unsafe {
SetInformationJobObject(
job.0,
JobObjectExtendedLimitInformation,
core::ptr::from_ref(&info).cast(),
u32::try_from(core::mem::size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>())
.expect("the size of a fixed Win32 struct fits in u32"),
)
};
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(job)
}
pub(crate) fn assign(&self, process: RawHandle) -> io::Result<()> {
let ok = unsafe { AssignProcessToJobObject(self.0, process as HANDLE) };
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
pub(crate) fn terminate(&self, exit_code: u32) -> io::Result<()> {
let ok = unsafe { TerminateJobObject(self.0, exit_code) };
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
}
impl Drop for Job {
fn drop(&mut self) {
unsafe {
let _ = CloseHandle(self.0);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_empty_job_is_created_and_terminated_without_error() {
let job = Job::create().expect("a job object must be creatable");
job.terminate(1)
.expect("terminating a job with no members must succeed");
}
#[tokio::test]
async fn a_child_assigned_to_a_job_is_killed_by_terminate() {
let job = Job::create().unwrap();
let mut child = tokio::process::Command::new("cmd")
.args(["/C", "ping", "-n", "600", "127.0.0.1"])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null())
.spawn()
.expect("cmd must be spawnable on Windows");
let handle = child
.raw_handle()
.expect("a just-spawned child has a raw handle");
job.assign(handle).expect("assignment must succeed");
job.terminate(9).unwrap();
let status = tokio::time::timeout(std::time::Duration::from_secs(10), child.wait())
.await
.expect("a terminated job member must not outlive its job")
.unwrap();
assert!(
!status.success(),
"a job-terminated child must not report success"
);
}
}