#![allow(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
clippy::cast_possible_wrap
)]
use super::{
CookieState, PANIC_ERRNO, cookie_close_state, cookie_read_into, cookie_seek_to,
cookie_write_from, orig_fn, set_errno,
};
use crate::dispatch::{HookScope, Sym, current_engine, guard_abi};
use crate::router::Engine;
use core::ffi::{c_char, c_int, c_void};
use libc::{FILE, off_t, size_t, ssize_t};
use std::path::Path;
type Fpos = off_t;
type FunopenRead = unsafe extern "C" fn(*mut c_void, *mut c_char, c_int) -> c_int;
type FunopenWrite = unsafe extern "C" fn(*mut c_void, *const c_char, c_int) -> c_int;
type FunopenSeek = unsafe extern "C" fn(*mut c_void, Fpos, c_int) -> Fpos;
type FunopenClose = unsafe extern "C" fn(*mut c_void) -> c_int;
unsafe extern "C" {
fn funopen(
cookie: *const c_void,
readfn: Option<FunopenRead>,
writefn: Option<FunopenWrite>,
seekfn: Option<FunopenSeek>,
closefn: Option<FunopenClose>,
) -> *mut FILE;
}
extern "C" fn funopen_read(cookie: *mut c_void, buf: *mut c_char, nbytes: c_int) -> c_int {
guard_abi(-1, PANIC_ERRNO, || {
let len = usize::try_from(nbytes).unwrap_or(0);
let read = cookie_read_into(cookie, buf.cast::<u8>(), len);
c_int::try_from(read).unwrap_or(c_int::MAX)
})
}
extern "C" fn funopen_write(cookie: *mut c_void, buf: *const c_char, nbytes: c_int) -> c_int {
guard_abi(-1, PANIC_ERRNO, || {
let len = usize::try_from(nbytes).unwrap_or(0);
let written = cookie_write_from(cookie, buf.cast::<u8>(), len);
c_int::try_from(written).unwrap_or(c_int::MAX)
})
}
extern "C" fn funopen_seek(cookie: *mut c_void, offset: Fpos, whence: c_int) -> Fpos {
guard_abi(-1, PANIC_ERRNO, || {
cookie_seek_to(cookie, offset, whence).unwrap_or(-1)
})
}
extern "C" fn funopen_close(cookie: *mut c_void) -> c_int {
guard_abi(-1, PANIC_ERRNO, || {
cookie_close_state(cookie);
0
})
}
pub(super) fn fopen_virtual(engine: &Engine, path: &Path, mode: *const c_char) -> *mut FILE {
let Some(cookie) = super::prepare_cookie(engine, path, mode) else {
return core::ptr::null_mut();
};
let writable = unsafe { (*cookie).writable };
let file = unsafe {
funopen(
cookie.cast::<c_void>(),
Some(funopen_read),
writable.then_some(funopen_write as FunopenWrite),
Some(funopen_seek),
Some(funopen_close),
)
};
if file.is_null() {
drop(unsafe { Box::from_raw(cookie.cast::<CookieState>()) });
set_errno(libc::EIO);
}
file
}
pub(super) extern "C" fn shim_getdirentries64(
fd: c_int,
buf: *mut c_void,
bufsize: size_t,
basep: *mut off_t,
) -> ssize_t {
guard_abi(-1, PANIC_ERRNO, || {
let pass = || {
let orig: PfnGetdirentries64 = orig_fn(Sym::Getdirentries64);
unsafe { orig(fd, buf, bufsize, basep) }
};
let Some(_scope) = HookScope::enter() else {
return pass();
};
let Some(engine) = current_engine() else {
return pass();
};
if engine.registry().get_file(fd as usize).is_some() {
set_errno(libc::ENOTDIR); -1
} else {
pass()
}
})
}
type PfnGetdirentries64 = unsafe extern "C" fn(c_int, *mut c_void, size_t, *mut off_t) -> ssize_t;
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::undocumented_unsafe_blocks)]
mod layout_tests {
use super::super::{fill_dirent, fill_stat};
use crate::vfs::{VfsDirEntry, VfsMetadata};
use std::path::Path;
#[test]
fn fill_stat_reports_a_read_only_regular_file() {
let meta = VfsMetadata::file(12_345);
let mut st: libc::stat = unsafe { core::mem::zeroed() };
unsafe { fill_stat(&raw mut st, Path::new("/__hookfs__/x/clip.braw"), &meta) };
assert_eq!(st.st_size, 12_345);
assert_eq!(st.st_mode & libc::S_IFMT, libc::S_IFREG);
assert_eq!(st.st_mode & 0o777, 0o444);
assert_eq!(st.st_nlink, 1);
assert_ne!(st.st_ino, 0, "a stable non-zero inode identity");
assert_eq!(st.st_blksize, 512);
}
#[test]
fn fill_stat_for_a_directory_sets_ifdir() {
let meta = VfsMetadata::dir();
let mut st: libc::stat = unsafe { core::mem::zeroed() };
unsafe { fill_stat(&raw mut st, Path::new("/d"), &meta) };
assert_eq!(st.st_mode & libc::S_IFMT, libc::S_IFDIR);
}
#[test]
fn fill_stat_handles_large_sizes() {
let meta = VfsMetadata::file(1 << 40); let mut st: libc::stat = unsafe { core::mem::zeroed() };
unsafe { fill_stat(&raw mut st, Path::new("/big"), &meta) };
assert_eq!(st.st_size, 1 << 40);
}
#[test]
fn dirent_name_is_nul_terminated_and_truncated() {
let entry = VfsDirEntry {
name: std::ffi::OsString::from("sample.braw"),
metadata: VfsMetadata::file(1),
};
let mut d: libc::dirent = unsafe { core::mem::zeroed() };
let ptr = fill_dirent(&entry, &mut d, 0);
assert_eq!(ptr, &raw mut d);
assert_eq!(d.d_type, libc::DT_REG);
assert_eq!(usize::from(d.d_namlen), "sample.braw".len());
let name = unsafe { core::ffi::CStr::from_ptr(d.d_name.as_ptr()) };
assert_eq!(name.to_str().unwrap(), "sample.braw");
}
}