use std::ffi::OsString;
use std::path::PathBuf;
use wtf_string::{Wtf16Str, Wtf16String};
use crate::retry::WatchMode;
use windows_sys::Win32::Storage::FileSystem::{
FILE_ACTION_ADDED, FILE_ACTION_MODIFIED, FILE_ACTION_REMOVED, FILE_ACTION_RENAMED_NEW_NAME,
FILE_ACTION_RENAMED_OLD_NAME,
};
const HEADER_LEN: usize = 12;
const UNIT_LEN: usize = 2;
const RECORD_ALIGNMENT: usize = 4;
const FINAL_RECORD_OFFSET: usize = 0;
mod field {
pub const NEXT_ENTRY_OFFSET: usize = 0;
pub const ACTION: usize = 4;
pub const FILE_NAME_LENGTH: usize = 8;
}
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct RelativeName {
name: Wtf16String,
}
impl std::ops::Deref for RelativeName {
type Target = Wtf16Str;
fn deref(&self) -> &Wtf16Str {
&self.name
}
}
impl RelativeName {
pub(crate) fn from_units(units: Vec<u16>) -> Self {
Self {
name: Wtf16String::from_units(&units),
}
}
#[must_use]
pub fn as_wide(&self) -> &[u16] {
self.name.as_units()
}
#[must_use]
pub fn as_wtf16(&self) -> &Wtf16String {
&self.name
}
#[must_use]
pub fn to_os_string(&self) -> OsString {
self.name.to_os_string()
}
#[must_use]
pub fn to_path_buf(&self) -> PathBuf {
PathBuf::from(self.to_os_string())
}
}
#[cfg(feature = "test-util")]
impl RelativeName {
#[must_use]
pub fn for_test(name: impl AsRef<str>) -> Self {
Self {
name: Wtf16String::from(name.as_ref()),
}
}
#[must_use]
pub fn for_test_os(name: &std::ffi::OsStr) -> Self {
Self {
name: Wtf16String::from_os_str(name),
}
}
#[must_use]
pub fn for_test_units(units: &[u16]) -> Self {
Self {
name: Wtf16String::from_units(units),
}
}
}
impl std::fmt::Debug for RelativeName {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Debug::fmt(&self.name, f)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
struct RawChange {
action: u32,
name: RelativeName,
}
#[must_use]
fn records(buffer: &[u8]) -> Records<'_> {
Records {
buffer,
pos: Some(0),
malformed: false,
}
}
struct Records<'a> {
buffer: &'a [u8],
pos: Option<usize>,
malformed: bool,
}
impl Iterator for Records<'_> {
type Item = RawChange;
fn next(&mut self) -> Option<RawChange> {
let pos = self.pos?;
let Some(rec) = self.buffer.get(pos..) else {
self.pos = None;
self.malformed = true;
return None;
};
if rec.len() < HEADER_LEN {
self.pos = None;
self.malformed = true;
return None;
}
let next_offset = read_u32(rec, field::NEXT_ENTRY_OFFSET) as usize;
let action = read_u32(rec, field::ACTION);
let name_len_bytes = read_u32(rec, field::FILE_NAME_LENGTH) as usize;
let record_span = if next_offset == FINAL_RECORD_OFFSET {
rec.len()
} else {
next_offset.min(rec.len())
};
let name_end = match HEADER_LEN.checked_add(name_len_bytes) {
Some(end) if end <= record_span && name_len_bytes.is_multiple_of(UNIT_LEN) => end,
_ => {
self.pos = None;
self.malformed = true;
return None;
}
};
if next_offset == FINAL_RECORD_OFFSET {
let padded_end = match name_end.checked_add(RECORD_ALIGNMENT - 1) {
Some(sum) => sum & !(RECORD_ALIGNMENT - 1),
None => {
self.pos = None;
self.malformed = true;
return None;
}
};
if rec.len() != name_end && rec.len() != padded_end {
self.pos = None;
self.malformed = true;
return None;
}
}
let name = decode_utf16(&rec[HEADER_LEN..name_end]);
self.pos = if next_offset == FINAL_RECORD_OFFSET {
None
} else if next_offset.is_multiple_of(RECORD_ALIGNMENT) && next_offset >= name_end {
match pos.checked_add(next_offset) {
Some(next) => Some(next),
None => {
self.malformed = true;
None
}
}
} else {
self.malformed = true;
None
};
Some(RawChange { action, name })
}
}
fn read_u32(rec: &[u8], offset: usize) -> u32 {
u32::from_le_bytes([
rec[offset],
rec[offset + 1],
rec[offset + 2],
rec[offset + 3],
])
}
fn decode_utf16(bytes: &[u8]) -> RelativeName {
let units: Vec<u16> = bytes
.as_chunks::<UNIT_LEN>()
.0
.iter()
.map(|pair| u16::from_le_bytes(*pair))
.collect();
RelativeName::from_units(units)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ChangeKind {
Added,
Removed,
Modified,
RenamedOldName,
RenamedNewName,
Unknown(u32),
}
impl ChangeKind {
fn from_action(action: u32) -> ChangeKind {
match action {
FILE_ACTION_ADDED => ChangeKind::Added,
FILE_ACTION_REMOVED => ChangeKind::Removed,
FILE_ACTION_MODIFIED => ChangeKind::Modified,
FILE_ACTION_RENAMED_OLD_NAME => ChangeKind::RenamedOldName,
FILE_ACTION_RENAMED_NEW_NAME => ChangeKind::RenamedNewName,
other => ChangeKind::Unknown(other),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Change {
pub kind: ChangeKind,
pub name: RelativeName,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum DesyncCause {
Overflow,
QueueFull,
Coarse,
Reestablished,
Stopped,
}
impl DesyncCause {
#[must_use]
pub fn is_terminal(self) -> bool {
match self {
DesyncCause::Stopped => true,
DesyncCause::Overflow
| DesyncCause::QueueFull
| DesyncCause::Coarse
| DesyncCause::Reestablished => false,
}
}
#[must_use]
pub fn is_reachable_in(self, mode: WatchMode) -> bool {
match self {
DesyncCause::Overflow => matches!(mode, WatchMode::Detailed),
DesyncCause::Coarse => matches!(mode, WatchMode::Coarse),
DesyncCause::QueueFull | DesyncCause::Reestablished | DesyncCause::Stopped => true,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum DecodedBatch {
Changes(Vec<Change>),
Desync(DesyncCause),
}
#[must_use]
pub fn decode_batch(buffer: &[u8]) -> DecodedBatch {
if buffer.is_empty() {
return DecodedBatch::Desync(DesyncCause::Overflow);
}
let mut iter = records(buffer);
let changes: Vec<Change> = iter
.by_ref()
.map(|raw| Change {
kind: ChangeKind::from_action(raw.action),
name: raw.name,
})
.collect();
if iter.malformed {
return DecodedBatch::Desync(DesyncCause::Overflow);
}
DecodedBatch::Changes(changes)
}
#[cfg(test)]
mod tests;