#![cfg(windows)]
use std::ffi::OsString;
use std::os::windows::ffi::{OsStrExt, OsStringExt};
use std::path::Path;
use std::ptr;
use std::sync::mpsc;
use std::time::Duration;
use windows_sys::Win32::Foundation::{
CloseHandle, ERROR_IO_PENDING, FALSE, HANDLE, INVALID_HANDLE_VALUE, TRUE, WAIT_FAILED,
WAIT_OBJECT_0,
};
use windows_sys::Win32::Storage::FileSystem::{
CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OVERLAPPED, FILE_LIST_DIRECTORY,
FILE_NOTIFY_CHANGE_FILE_NAME, FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE,
OPEN_EXISTING, ReadDirectoryChangesW,
};
use windows_sys::Win32::System::IO::{CancelIoEx, GetOverlappedResult, OVERLAPPED};
use windows_sys::Win32::System::Threading::{CreateEventW, WaitForSingleObject};
use windows_file_watcher::{Change, ChangeKind, DecodedBatch, decode_batch};
fn wide_z(p: &Path) -> Vec<u16> {
p.as_os_str().encode_wide().chain(Some(0)).collect()
}
type WatchResult = Result<Vec<Change>, String>;
struct JoinOnDrop(Option<std::thread::JoinHandle<WatchResult>>);
impl Drop for JoinOnDrop {
fn drop(&mut self) {
if let Some(handle) = self.0.take() {
let _ = handle.join();
}
}
}
#[test]
fn decodes_a_real_read_directory_changes_buffer() {
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("clock")
.as_nanos();
let dir = std::env::temp_dir().join(format!(
"windows-file-watcher-decode-{}-{nonce}",
std::process::id()
));
std::fs::create_dir(&dir).expect("create temp dir");
let (armed_tx, armed_rx) = mpsc::channel::<()>();
let watch_dir = dir.clone();
let mut worker = JoinOnDrop(Some(std::thread::spawn(move || {
watch_once(&watch_dir, &armed_tx)
})));
armed_rx
.recv_timeout(Duration::from_secs(10))
.expect("the worker must arm the read");
std::fs::write(dir.join("created.txt"), b"hi").expect("create file");
let changes = worker
.0
.take()
.expect("worker handle present")
.join()
.expect("the worker thread must not panic")
.expect("the completion must decode to changes, not a desync");
assert!(
changes.iter().any(|change| {
change.kind == ChangeKind::Added && change.name.to_os_string() == "created.txt"
}),
"expected an Added record for created.txt; got {changes:?}"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[link(name = "kernel32")]
unsafe extern "system" {
fn lstrlenW(lpstring: *const u16) -> i32;
}
#[test]
fn decodes_an_unpaired_surrogate_name_from_a_real_buffer() {
let leaf_units: Vec<u16> = vec![
u16::from(b'a'),
0xD800, u16::from(b'b'),
u16::from(b'.'),
u16::from(b't'),
u16::from(b'x'),
u16::from(b't'),
];
let leaf = OsString::from_wide(&leaf_units);
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("clock")
.as_nanos();
let dir = std::env::temp_dir().join(format!(
"windows-file-watcher-decode-surrogate-{}-{nonce}",
std::process::id()
));
std::fs::create_dir(&dir).expect("create temp dir");
let (armed_tx, armed_rx) = mpsc::channel::<()>();
let watch_dir = dir.clone();
let mut worker = JoinOnDrop(Some(std::thread::spawn(move || {
watch_once(&watch_dir, &armed_tx)
})));
armed_rx
.recv_timeout(Duration::from_secs(10))
.expect("the worker must arm the read");
std::fs::write(dir.join(&leaf), b"hi").expect("create the surrogate-named file");
let changes = worker
.0
.take()
.expect("worker handle present")
.join()
.expect("the worker thread must not panic")
.expect("the completion must decode to changes, not a desync");
let change = changes
.iter()
.find(|change| change.kind == ChangeKind::Added)
.unwrap_or_else(|| panic!("expected an Added record; got {changes:?}"));
assert_eq!(change.name.as_wide(), leaf_units.as_slice());
assert_eq!(change.name.to_os_string(), leaf);
assert_eq!(change.name.to_path_buf(), Path::new(&leaf));
let round_trip: Vec<u16> = change.name.to_os_string().encode_wide().collect();
assert_eq!(round_trip, leaf_units);
assert!(!change.name.has_interior_nul());
let counted = unsafe { lstrlenW(change.name.as_wtf16().as_terminated_ptr()) };
assert_eq!(counted as usize, change.name.len());
assert_eq!(change.name.len(), leaf_units.len());
let _ = std::fs::remove_dir_all(&dir);
}
fn watch_once(dir: &Path, armed: &mpsc::Sender<()>) -> WatchResult {
let name = wide_z(dir);
let handle = unsafe {
CreateFileW(
name.as_ptr(),
FILE_LIST_DIRECTORY,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
ptr::null_mut(),
)
};
if handle == INVALID_HANDLE_VALUE {
return Err(format!(
"CreateFileW failed: {}",
std::io::Error::last_os_error()
));
}
read_overlapped(handle, armed)
}
fn read_overlapped(handle: HANDLE, armed: &mpsc::Sender<()>) -> WatchResult {
const TIMEOUT_MS: u32 = 30_000;
let event = unsafe { CreateEventW(ptr::null(), TRUE, FALSE, ptr::null()) };
if event.is_null() {
let err = std::io::Error::last_os_error();
unsafe { CloseHandle(handle) };
return Err(format!("CreateEventW failed: {err}"));
}
let mut buffer = vec![0_u32; 1024];
let mut overlapped: Box<OVERLAPPED> = Box::new(unsafe { std::mem::zeroed() });
overlapped.hEvent = event;
let arm_ok = unsafe {
ReadDirectoryChangesW(
handle,
buffer.as_mut_ptr().cast(),
size_of_val(buffer.as_slice()) as u32,
FALSE, FILE_NOTIFY_CHANGE_FILE_NAME,
ptr::null_mut(),
&mut *overlapped,
None,
)
};
if arm_ok == 0 {
let err = std::io::Error::last_os_error();
if err.raw_os_error() != Some(ERROR_IO_PENDING as i32) {
unsafe { CloseHandle(event) };
unsafe { CloseHandle(handle) };
return Err(format!("ReadDirectoryChangesW failed to arm: {err}"));
}
}
let _ = armed.send(());
let waited = unsafe { WaitForSingleObject(event, TIMEOUT_MS) };
let wait_err = (waited == WAIT_FAILED).then(std::io::Error::last_os_error);
let mut transferred: u32 = 0;
if waited == WAIT_OBJECT_0 {
let ok = unsafe { GetOverlappedResult(handle, &*overlapped, &mut transferred, FALSE) };
let outcome = if ok == 0 {
Err(format!(
"GetOverlappedResult failed: {}",
std::io::Error::last_os_error()
))
} else {
let bytes = unsafe {
std::slice::from_raw_parts(buffer.as_ptr().cast::<u8>(), transferred as usize)
};
decode(bytes)
};
unsafe { CloseHandle(event) };
unsafe { CloseHandle(handle) };
return outcome;
}
let cancelled = unsafe { CancelIoEx(handle, &*overlapped) } != 0;
let cancel_err = if cancelled {
None
} else {
Some(std::io::Error::last_os_error())
};
let retired = unsafe { WaitForSingleObject(event, TIMEOUT_MS) } == WAIT_OBJECT_0;
if retired {
unsafe { GetOverlappedResult(handle, &*overlapped, &mut transferred, FALSE) };
unsafe { CloseHandle(event) };
unsafe { CloseHandle(handle) };
let wait_note = match wait_err {
Some(e) => format!("WaitForSingleObject failed: {e}"),
None => format!("wait result {waited}"),
};
return Err(format!(
"the watch did not report a change within {TIMEOUT_MS} ms \
({wait_note}, cancelled = {cancelled})"
));
}
let cancel_note = match cancel_err {
None => "CancelIoEx succeeded".to_owned(),
Some(e) => format!("CancelIoEx failed: {e}"),
};
std::mem::forget(buffer);
std::mem::forget(overlapped);
Err(format!(
"overlapped read could not be retired within {TIMEOUT_MS} ms ({cancel_note}); \
leaked buffer/overlapped/handle to stay sound"
))
}
fn decode(bytes: &[u8]) -> WatchResult {
match decode_batch(bytes) {
DecodedBatch::Changes(changes) => Ok(changes),
DecodedBatch::Desync(cause) => Err(format!("unexpected desync: {cause:?}")),
}
}