Revision control
Copy as Markdown
Other Tools
use std::fs::File;
use std::hash::{Hash, Hasher};
use std::io;
use std::os::windows::io::{AsRawHandle, IntoRawHandle, RawHandle};
use std::path::Path;
use winapi_util as winutil;
// For correctness, it is critical that both file handles remain open while
// their attributes are checked for equality. In particular, the file index
// numbers on a Windows stat object are not guaranteed to remain stable over
// time.
//
// See the docs and remarks on MSDN:
//
// It gets worse. It appears that the index numbers are not always
// guaranteed to be unique. Namely, ReFS uses 128 bit numbers for unique
// identifiers. This requires a distinct syscall to get `FILE_ID_INFO`
// documented here:
//
// It seems straight-forward enough to modify this code to use
// `FILE_ID_INFO` when available (minimum Windows Server 2012), but I don't
// have access to such Windows machines.
//
// Two notes.
//
// 1. Java's NIO uses the approach implemented here and appears to ignore
// `FILE_ID_INFO` altogether. So Java's NIO and this code are
// susceptible to bugs when running on a file system where
// `nFileIndex{Low,High}` are not unique.
//
// 2. LLVM has a bug where they fetch the id of a file and continue to use
// it even after the handle has been closed, so that uniqueness is no
// longer guaranteed (when `nFileIndex{Low,High}` are unique).
//
// All said and done, checking whether two files are the same on Windows
// seems quite tricky. Moreover, even if the code is technically incorrect,
// it seems like the chances of actually observing incorrect behavior are
// extremely small. Nevertheless, we mitigate this by checking size too.
//
// In the case where this code is erroneous, two files will be reported
// as equivalent when they are in fact distinct. This will cause the loop
// detection code to report a false positive, which will prevent descending
// into the offending directory. As far as failure modes goes, this isn't
// that bad.
#[derive(Debug)]
pub struct Handle {
kind: HandleKind,
key: Option<Key>,
}
#[derive(Debug)]
enum HandleKind {
/// Used when opening a file or acquiring ownership of a file.
Owned(winutil::Handle),
/// Used for stdio.
Borrowed(winutil::HandleRef),
}
#[derive(Debug, Eq, PartialEq, Hash)]
struct Key {
volume: u64,
index: u64,
}
impl Eq for Handle {}
impl PartialEq for Handle {
fn eq(&self, other: &Handle) -> bool {
// Need this branch to satisfy `Eq` since `Handle`s with
// `key.is_none()` wouldn't otherwise.
if self as *const Handle == other as *const Handle {
return true;
} else if self.key.is_none() || other.key.is_none() {
return false;
}
self.key == other.key
}
}
impl AsRawHandle for crate::Handle {
fn as_raw_handle(&self) -> RawHandle {
match self.0.kind {
HandleKind::Owned(ref h) => h.as_raw_handle(),
HandleKind::Borrowed(ref h) => h.as_raw_handle(),
}
}
}
impl IntoRawHandle for crate::Handle {
fn into_raw_handle(self) -> RawHandle {
match self.0.kind {
HandleKind::Owned(h) => h.into_raw_handle(),
HandleKind::Borrowed(h) => h.as_raw_handle(),
}
}
}
impl Hash for Handle {
fn hash<H: Hasher>(&self, state: &mut H) {
self.key.hash(state);
}
}
impl Handle {
pub fn from_path<P: AsRef<Path>>(p: P) -> io::Result<Handle> {
let h = winutil::Handle::from_path_any(p)?;
let info = winutil::file::information(&h)?;
Ok(Handle::from_info(HandleKind::Owned(h), info))
}
pub fn from_file(file: File) -> io::Result<Handle> {
let h = winutil::Handle::from_file(file);
let info = winutil::file::information(&h)?;
Ok(Handle::from_info(HandleKind::Owned(h), info))
}
fn from_std_handle(h: winutil::HandleRef) -> io::Result<Handle> {
match winutil::file::information(&h) {
Ok(info) => Ok(Handle::from_info(HandleKind::Borrowed(h), info)),
// In a Windows console, if there is no pipe attached to a STD
// handle, then GetFileInformationByHandle will return an error.
// We don't really care. The only thing we care about is that
// this handle is never equivalent to any other handle, which is
// accomplished by setting key to None.
Err(_) => Ok(Handle { kind: HandleKind::Borrowed(h), key: None }),
}
}
fn from_info(
kind: HandleKind,
info: winutil::file::Information,
) -> Handle {
Handle {
kind: kind,
key: Some(Key {
volume: info.volume_serial_number(),
index: info.file_index(),
}),
}
}
pub fn stdin() -> io::Result<Handle> {
Handle::from_std_handle(winutil::HandleRef::stdin())
}
pub fn stdout() -> io::Result<Handle> {
Handle::from_std_handle(winutil::HandleRef::stdout())
}
pub fn stderr() -> io::Result<Handle> {
Handle::from_std_handle(winutil::HandleRef::stderr())
}
pub fn as_file(&self) -> &File {
match self.kind {
HandleKind::Owned(ref h) => h.as_file(),
HandleKind::Borrowed(ref h) => h.as_file(),
}
}
pub fn as_file_mut(&mut self) -> &mut File {
match self.kind {
HandleKind::Owned(ref mut h) => h.as_file_mut(),
HandleKind::Borrowed(ref mut h) => h.as_file_mut(),
}
}
}