#![cfg(hookfs_backend)]
use crate::router::Engine;
use core::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::cell::Cell;
use std::panic::AssertUnwindSafe;
use std::sync::{Arc, RwLock};
#[cfg(windows)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(usize)]
pub(crate) enum Sym {
CreateFileW,
CreateFileA,
CreateFile2,
ReadFile,
ReadFileEx,
WriteFile,
WriteFileEx,
SetFilePointer,
SetFilePointerEx,
GetFileSize,
GetFileSizeEx,
GetFileType,
GetFileInformationByHandle,
GetFileInformationByHandleEx,
FlushFileBuffers,
SetEndOfFile,
CloseHandle,
FindFirstFileExW,
FindFirstFileW,
FindNextFileW,
FindClose,
GetFileAttributesW,
GetFileAttributesExW,
GetFullPathNameW,
GetFullPathNameA,
GetCurrentDirectoryW,
DeleteFileW,
MoveFileExW,
GetDiskFreeSpaceA,
GetDriveTypeW,
CreateDirectoryW,
LoadLibraryExW,
LoadLibraryA,
}
#[cfg(windows)]
impl Sym {
pub(crate) const fn name(self) -> &'static str {
match self {
Self::CreateFileW => "CreateFileW",
Self::CreateFileA => "CreateFileA",
Self::CreateFile2 => "CreateFile2",
Self::ReadFile => "ReadFile",
Self::ReadFileEx => "ReadFileEx",
Self::WriteFile => "WriteFile",
Self::WriteFileEx => "WriteFileEx",
Self::SetFilePointer => "SetFilePointer",
Self::SetFilePointerEx => "SetFilePointerEx",
Self::GetFileSize => "GetFileSize",
Self::GetFileSizeEx => "GetFileSizeEx",
Self::GetFileType => "GetFileType",
Self::GetFileInformationByHandle => "GetFileInformationByHandle",
Self::GetFileInformationByHandleEx => "GetFileInformationByHandleEx",
Self::FlushFileBuffers => "FlushFileBuffers",
Self::SetEndOfFile => "SetEndOfFile",
Self::CloseHandle => "CloseHandle",
Self::FindFirstFileExW => "FindFirstFileExW",
Self::FindFirstFileW => "FindFirstFileW",
Self::FindNextFileW => "FindNextFileW",
Self::FindClose => "FindClose",
Self::GetFileAttributesW => "GetFileAttributesW",
Self::GetFileAttributesExW => "GetFileAttributesExW",
Self::GetFullPathNameW => "GetFullPathNameW",
Self::GetFullPathNameA => "GetFullPathNameA",
Self::GetCurrentDirectoryW => "GetCurrentDirectoryW",
Self::DeleteFileW => "DeleteFileW",
Self::MoveFileExW => "MoveFileExW",
Self::GetDiskFreeSpaceA => "GetDiskFreeSpaceA",
Self::GetDriveTypeW => "GetDriveTypeW",
Self::CreateDirectoryW => "CreateDirectoryW",
Self::LoadLibraryExW => "LoadLibraryExW",
Self::LoadLibraryA => "LoadLibraryA",
}
}
pub(crate) fn from_name(name: &str) -> Option<Self> {
ALL.iter().copied().find(|s| s.name() == name)
}
}
#[cfg(windows)]
pub(crate) const ALL: [Sym; Sym::COUNT] = [
Sym::CreateFileW,
Sym::CreateFileA,
Sym::CreateFile2,
Sym::ReadFile,
Sym::ReadFileEx,
Sym::WriteFile,
Sym::WriteFileEx,
Sym::SetFilePointer,
Sym::SetFilePointerEx,
Sym::GetFileSize,
Sym::GetFileSizeEx,
Sym::GetFileType,
Sym::GetFileInformationByHandle,
Sym::GetFileInformationByHandleEx,
Sym::FlushFileBuffers,
Sym::SetEndOfFile,
Sym::CloseHandle,
Sym::FindFirstFileExW,
Sym::FindFirstFileW,
Sym::FindNextFileW,
Sym::FindClose,
Sym::GetFileAttributesW,
Sym::GetFileAttributesExW,
Sym::GetFullPathNameW,
Sym::GetFullPathNameA,
Sym::GetCurrentDirectoryW,
Sym::DeleteFileW,
Sym::MoveFileExW,
Sym::GetDiskFreeSpaceA,
Sym::GetDriveTypeW,
Sym::CreateDirectoryW,
Sym::LoadLibraryExW,
Sym::LoadLibraryA,
];
#[cfg(windows)]
impl Sym {
pub(crate) const COUNT: usize = 33;
}
#[cfg(target_os = "linux")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(usize)]
pub(crate) enum Sym {
Fopen,
Fopen64,
Open,
Open64,
Openat,
Read,
Readv,
Pread,
Lseek,
Lseek64,
Close,
Write,
Writev,
Pwrite,
Ftruncate,
Ftruncate64,
Truncate,
Fsync,
Mkdir,
Remove,
Rename,
Unlink,
Link,
Symlink,
Sendfile,
Fchmod,
Fchmodat,
Utimensat,
Xstat,
Fxstat,
Lxstat,
Xstat64,
Fxstat64,
Lxstat64,
Stat,
Fstat,
Lstat,
Fstatat,
Statx,
Statvfs,
Fstatvfs,
Opendir,
Fdopendir,
Readdir,
Readdir64,
Closedir,
Realpath,
Access,
Faccessat,
Getcwd,
Chdir,
Readlink,
Dlopen,
Dlclose,
}
#[cfg(target_os = "linux")]
impl Sym {
pub(crate) const fn name(self) -> &'static str {
match self {
Self::Fopen => "fopen",
Self::Fopen64 => "fopen64",
Self::Open => "open",
Self::Open64 => "open64",
Self::Openat => "openat",
Self::Read => "read",
Self::Readv => "readv",
Self::Pread => "pread",
Self::Lseek => "lseek",
Self::Lseek64 => "lseek64",
Self::Close => "close",
Self::Write => "write",
Self::Writev => "writev",
Self::Pwrite => "pwrite",
Self::Ftruncate => "ftruncate",
Self::Ftruncate64 => "ftruncate64",
Self::Truncate => "truncate",
Self::Fsync => "fsync",
Self::Mkdir => "mkdir",
Self::Remove => "remove",
Self::Rename => "rename",
Self::Unlink => "unlink",
Self::Link => "link",
Self::Symlink => "symlink",
Self::Sendfile => "sendfile",
Self::Fchmod => "fchmod",
Self::Fchmodat => "fchmodat",
Self::Utimensat => "utimensat",
Self::Xstat => "__xstat",
Self::Fxstat => "__fxstat",
Self::Lxstat => "__lxstat",
Self::Xstat64 => "__xstat64",
Self::Fxstat64 => "__fxstat64",
Self::Lxstat64 => "__lxstat64",
Self::Stat => "stat",
Self::Fstat => "fstat",
Self::Lstat => "lstat",
Self::Fstatat => "fstatat",
Self::Statx => "statx",
Self::Statvfs => "statvfs",
Self::Fstatvfs => "fstatvfs",
Self::Opendir => "opendir",
Self::Fdopendir => "fdopendir",
Self::Readdir => "readdir",
Self::Readdir64 => "readdir64",
Self::Closedir => "closedir",
Self::Realpath => "realpath",
Self::Access => "access",
Self::Faccessat => "faccessat",
Self::Getcwd => "getcwd",
Self::Chdir => "chdir",
Self::Readlink => "readlink",
Self::Dlopen => "dlopen",
Self::Dlclose => "dlclose",
}
}
pub(crate) fn from_name(name: &str) -> Option<Self> {
ALL.iter().copied().find(|s| s.name() == name)
}
pub(crate) const COUNT: usize = 54;
}
#[cfg(target_os = "linux")]
pub(crate) const ALL: [Sym; Sym::COUNT] = [
Sym::Fopen,
Sym::Fopen64,
Sym::Open,
Sym::Open64,
Sym::Openat,
Sym::Read,
Sym::Readv,
Sym::Pread,
Sym::Lseek,
Sym::Lseek64,
Sym::Close,
Sym::Write,
Sym::Writev,
Sym::Pwrite,
Sym::Ftruncate,
Sym::Ftruncate64,
Sym::Truncate,
Sym::Fsync,
Sym::Mkdir,
Sym::Remove,
Sym::Rename,
Sym::Unlink,
Sym::Link,
Sym::Symlink,
Sym::Sendfile,
Sym::Fchmod,
Sym::Fchmodat,
Sym::Utimensat,
Sym::Xstat,
Sym::Fxstat,
Sym::Lxstat,
Sym::Xstat64,
Sym::Fxstat64,
Sym::Lxstat64,
Sym::Stat,
Sym::Fstat,
Sym::Lstat,
Sym::Fstatat,
Sym::Statx,
Sym::Statvfs,
Sym::Fstatvfs,
Sym::Opendir,
Sym::Fdopendir,
Sym::Readdir,
Sym::Readdir64,
Sym::Closedir,
Sym::Realpath,
Sym::Access,
Sym::Faccessat,
Sym::Getcwd,
Sym::Chdir,
Sym::Readlink,
Sym::Dlopen,
Sym::Dlclose,
];
#[cfg(any(target_os = "macos", target_os = "ios"))]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(usize)]
pub(crate) enum Sym {
Fopen,
Open,
Openat,
Read,
Readv,
Pread,
Lseek,
Close,
Write,
Writev,
Pwrite,
Ftruncate,
Truncate,
Fsync,
Mkdir,
Remove,
Rename,
Unlink,
Link,
Symlink,
Fchmod,
Fchmodat,
Utimensat,
Stat,
Fstat,
Lstat,
Fstatat,
Statvfs,
Fstatvfs,
Opendir,
Fdopendir,
Readdir,
Closedir,
Getdirentries64,
Realpath,
Access,
Faccessat,
Getcwd,
Chdir,
Readlink,
Dlopen,
Dlclose,
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
impl Sym {
pub(crate) const fn name(self) -> &'static str {
match self {
Self::Fopen => "fopen",
Self::Open => "open",
Self::Openat => "openat",
Self::Read => "read",
Self::Readv => "readv",
Self::Pread => "pread",
Self::Lseek => "lseek",
Self::Close => "close",
Self::Write => "write",
Self::Writev => "writev",
Self::Pwrite => "pwrite",
Self::Ftruncate => "ftruncate",
Self::Truncate => "truncate",
Self::Fsync => "fsync",
Self::Mkdir => "mkdir",
Self::Remove => "remove",
Self::Rename => "rename",
Self::Unlink => "unlink",
Self::Link => "link",
Self::Symlink => "symlink",
Self::Fchmod => "fchmod",
Self::Fchmodat => "fchmodat",
Self::Utimensat => "utimensat",
Self::Stat => "stat",
Self::Fstat => "fstat",
Self::Lstat => "lstat",
Self::Fstatat => "fstatat",
Self::Statvfs => "statvfs",
Self::Fstatvfs => "fstatvfs",
Self::Opendir => "opendir",
Self::Fdopendir => "fdopendir",
Self::Readdir => "readdir",
Self::Closedir => "closedir",
Self::Getdirentries64 => "__getdirentries64",
Self::Realpath => "realpath",
Self::Access => "access",
Self::Faccessat => "faccessat",
Self::Getcwd => "getcwd",
Self::Chdir => "chdir",
Self::Readlink => "readlink",
Self::Dlopen => "dlopen",
Self::Dlclose => "dlclose",
}
}
pub(crate) fn from_name(name: &str) -> Option<Self> {
ALL.iter().copied().find(|s| s.name() == name)
}
pub(crate) const COUNT: usize = 42;
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
pub(crate) const ALL: [Sym; Sym::COUNT] = [
Sym::Fopen,
Sym::Open,
Sym::Openat,
Sym::Read,
Sym::Readv,
Sym::Pread,
Sym::Lseek,
Sym::Close,
Sym::Write,
Sym::Writev,
Sym::Pwrite,
Sym::Ftruncate,
Sym::Truncate,
Sym::Fsync,
Sym::Mkdir,
Sym::Remove,
Sym::Rename,
Sym::Unlink,
Sym::Link,
Sym::Symlink,
Sym::Fchmod,
Sym::Fchmodat,
Sym::Utimensat,
Sym::Stat,
Sym::Fstat,
Sym::Lstat,
Sym::Fstatat,
Sym::Statvfs,
Sym::Fstatvfs,
Sym::Opendir,
Sym::Fdopendir,
Sym::Readdir,
Sym::Closedir,
Sym::Getdirentries64,
Sym::Realpath,
Sym::Access,
Sym::Faccessat,
Sym::Getcwd,
Sym::Chdir,
Sym::Readlink,
Sym::Dlopen,
Sym::Dlclose,
];
static ORIGINALS: [AtomicUsize; Sym::COUNT] = [const { AtomicUsize::new(0) }; Sym::COUNT];
pub(crate) fn set_original(name: &str, ptr: usize) {
if let Some(cell) = Sym::from_name(name).and_then(|sym| ORIGINALS.get(sym as usize)) {
cell.store(ptr, Ordering::Release);
}
}
pub(crate) fn original(sym: Sym) -> usize {
ORIGINALS
.get(sym as usize)
.map_or(0, |cell| cell.load(Ordering::Acquire))
}
static ACTIVE: RwLock<Option<Active>> = RwLock::new(None);
static NEXT_INSTALL_ID: AtomicU64 = AtomicU64::new(1);
struct Active {
engine: Arc<Engine>,
id: u64,
}
pub(crate) fn try_activate(engine: Arc<Engine>) -> Option<u64> {
let mut slot = ACTIVE
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if slot.is_some() {
return None;
}
let id = NEXT_INSTALL_ID.fetch_add(1, Ordering::Relaxed);
*slot = Some(Active { engine, id });
Some(id)
}
pub(crate) fn deactivate(id: u64) {
let mut slot = ACTIVE
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if slot.as_ref().is_some_and(|active| active.id == id) {
*slot = None;
}
}
pub(crate) fn current_engine() -> Option<Arc<Engine>> {
ACTIVE
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.as_ref()
.map(|a| a.engine.clone())
}
#[cfg(test)]
pub(crate) static GLOBAL_STATE_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
static RESCAN: RwLock<Option<Arc<dyn Fn() + Send + Sync>>> = RwLock::new(None);
pub(crate) fn set_rescan(cb: Arc<dyn Fn() + Send + Sync>) {
*RESCAN
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner) = Some(cb);
}
pub(crate) fn clear_rescan() {
*RESCAN
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner) = None;
}
pub(crate) fn trigger_rescan() {
let cb = RESCAN
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clone();
if let Some(cb) = cb {
cb();
}
}
thread_local! {
static IN_HOOK: Cell<bool> = const { Cell::new(false) };
}
pub(crate) struct HookScope;
impl HookScope {
pub(crate) fn enter() -> Option<Self> {
IN_HOOK.with(|flag| {
if flag.get() {
None
} else {
flag.set(true);
Some(Self)
}
})
}
}
impl Drop for HookScope {
fn drop(&mut self) {
IN_HOOK.with(|flag| flag.set(false));
}
}
pub(crate) fn guard_abi<R>(fallback: R, on_panic: u32, f: impl FnOnce() -> R) -> R {
if let Ok(value) = std::panic::catch_unwind(AssertUnwindSafe(f)) {
value
} else {
#[cfg(windows)]
unsafe {
windows_sys::Win32::Foundation::SetLastError(on_panic);
}
#[cfg(target_os = "linux")]
unsafe {
*libc::__errno_location() = i32::try_from(on_panic).unwrap_or(libc::EIO);
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
unsafe {
*libc::__error() = i32::try_from(on_panic).unwrap_or(libc::EIO);
}
fallback
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::namespace::Namespace;
use crate::providers::MemoryFs;
fn test_engine() -> Arc<Engine> {
let ns = Namespace::from_root(crate::namespace::reserved_root());
Arc::new(Engine::new(MemoryFs::new(), ns, false))
}
#[test]
fn single_active_installation_is_enforced() {
let _serial = GLOBAL_STATE_TEST_LOCK
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
assert!(current_engine().is_none());
let id1 = try_activate(test_engine()).expect("first activation should succeed");
assert!(current_engine().is_some());
assert!(try_activate(test_engine()).is_none());
assert!(current_engine().is_some());
deactivate(id1.wrapping_add(1_000));
assert!(current_engine().is_some());
deactivate(id1);
assert!(current_engine().is_none());
let id2 = try_activate(test_engine()).expect("activation should succeed after teardown");
assert_ne!(id1, id2, "each installation gets a fresh token");
deactivate(id2);
assert!(current_engine().is_none());
}
}