| use crate::FileMetadata; |
| use rustix::fs::AtFlags; |
| use rustix::fs::Mode; |
| use rustix::fs::OFlags; |
| use rustix::fs::Stat; |
| #[cfg(target_os = "linux")] |
| use rustix::fs::Statx; |
| #[cfg(target_os = "linux")] |
| use rustix::fs::StatxFlags; |
| use rustix::fs::fstat; |
| use rustix::fs::mkdirat; |
| use rustix::fs::open; |
| use rustix::fs::openat; |
| use rustix::fs::statat; |
| #[cfg(target_os = "linux")] |
| use rustix::fs::statx; |
| use rustix::fs::unlinkat; |
| use std::ffi::OsString; |
| use std::io; |
| use std::io::Write; |
| use std::os::fd::OwnedFd; |
| use std::path::Component; |
| use std::path::Path; |
| use std::path::PathBuf; |
|
|
| #[cfg(any(target_os = "linux", target_os = "android"))] |
| fn directory_access_flags() -> OFlags { |
| OFlags::PATH |
| } |
|
|
| #[cfg(target_vendor = "apple")] |
| fn directory_access_flags() -> OFlags { |
| OFlags::from_bits_retain(libc::O_SEARCH as u32) |
| } |
|
|
| #[cfg(not(any(target_os = "linux", target_os = "android", target_vendor = "apple")))] |
| fn directory_access_flags() -> OFlags { |
| OFlags::RDONLY |
| } |
|
|
| fn components(path: &Path) -> io::Result<Vec<OsString>> { |
| if !path.is_absolute() { |
| return Err(io::Error::new( |
| io::ErrorKind::InvalidInput, |
| "no-follow filesystem operations require an absolute path", |
| )); |
| } |
| path.components() |
| .filter_map(|component| match component { |
| Component::RootDir => None, |
| Component::Normal(component) => Some(Ok(component.to_os_string())), |
| Component::CurDir | Component::ParentDir | Component::Prefix(_) => { |
| Some(Err(io::Error::new( |
| io::ErrorKind::InvalidInput, |
| "no-follow filesystem operations require a normalized path", |
| ))) |
| } |
| }) |
| .collect() |
| } |
|
|
| fn root() -> io::Result<OwnedFd> { |
| open( |
| "/", |
| directory_access_flags() | OFlags::DIRECTORY | OFlags::CLOEXEC, |
| Mode::empty(), |
| ) |
| .map_err(io::Error::from) |
| } |
|
|
| fn open_directory(parent: &OwnedFd, name: &OsString) -> io::Result<OwnedFd> { |
| openat( |
| parent, |
| name, |
| directory_access_flags() | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC, |
| Mode::empty(), |
| ) |
| .map_err(io::Error::from) |
| } |
|
|
| fn parent(path: &Path) -> io::Result<(OwnedFd, OsString)> { |
| let mut components = components(path)?; |
| let leaf = components |
| .pop() |
| .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "path must name an entry"))?; |
| let mut directory = root()?; |
| for component in components { |
| directory = open_directory(&directory, &component)?; |
| } |
| Ok((directory, leaf)) |
| } |
|
|
| fn open_entry_sync(path: &Path) -> io::Result<std::fs::File> { |
| let (parent, leaf) = parent(path)?; |
| let file = openat( |
| &parent, |
| leaf, |
| OFlags::RDONLY | OFlags::NOFOLLOW | OFlags::NONBLOCK | OFlags::CLOEXEC, |
| Mode::empty(), |
| ) |
| .map_err(io::Error::from)?; |
| Ok(std::fs::File::from(file)) |
| } |
|
|
| fn open_file_sync(path: &Path) -> io::Result<std::fs::File> { |
| let file = open_entry_sync(path)?; |
| if !file.metadata()?.is_file() { |
| return Err(io::Error::new( |
| io::ErrorKind::InvalidInput, |
| "path is not a regular file", |
| )); |
| } |
| Ok(file) |
| } |
|
|
| pub(super) async fn open_file(path: PathBuf) -> io::Result<tokio::fs::File> { |
| tokio::task::spawn_blocking(move || open_file_sync(&path).map(tokio::fs::File::from_std)) |
| .await |
| .map_err(|error| io::Error::other(format!("filesystem task failed: {error}")))? |
| } |
|
|
| pub(super) async fn write_file(path: PathBuf, contents: Vec<u8>) -> io::Result<()> { |
| tokio::task::spawn_blocking(move || { |
| let (parent, leaf) = parent(&path)?; |
| |
| |
| let file = openat( |
| &parent, |
| leaf, |
| OFlags::WRONLY | OFlags::CREATE | OFlags::NOFOLLOW | OFlags::NONBLOCK | OFlags::CLOEXEC, |
| Mode::from_raw_mode(0o666), |
| ) |
| .map_err(io::Error::from)?; |
| let mut file = std::fs::File::from(file); |
| if !file.metadata()?.is_file() { |
| return Err(io::Error::new( |
| io::ErrorKind::InvalidInput, |
| "path is not a regular file", |
| )); |
| } |
| file.set_len(0)?; |
| file.write_all(&contents) |
| }) |
| .await |
| .map_err(|error| io::Error::other(format!("filesystem task failed: {error}")))? |
| } |
|
|
| fn metadata_sync(path: &Path) -> io::Result<FileMetadata> { |
| let components = components(path)?; |
|
|
| #[cfg(target_os = "linux")] |
| { |
| let (parent, leaf, flags) = if components.is_empty() { |
| (root()?, OsString::new(), AtFlags::EMPTY_PATH) |
| } else { |
| let (parent, leaf) = parent(path)?; |
| (parent, leaf, AtFlags::SYMLINK_NOFOLLOW) |
| }; |
| let metadata = statx( |
| &parent, |
| &leaf, |
| flags, |
| StatxFlags::BASIC_STATS | StatxFlags::BTIME, |
| ); |
| match metadata { |
| Ok(metadata) => file_metadata_linux(metadata), |
| Err(error) if error == rustix::io::Errno::NOSYS || error == rustix::io::Errno::PERM => { |
| let metadata = if components.is_empty() { |
| fstat(&parent) |
| } else { |
| statat(&parent, &leaf, AtFlags::SYMLINK_NOFOLLOW) |
| } |
| .map_err(io::Error::from)?; |
| file_metadata(metadata, 0) |
| } |
| Err(error) => Err(io::Error::from(error)), |
| } |
| } |
|
|
| #[cfg(not(target_os = "linux"))] |
| if components.is_empty() { |
| let root = root()?; |
| let metadata = fstat(&root).map_err(io::Error::from)?; |
| let created_at_ms = created_at_ms(&metadata); |
| file_metadata(metadata, created_at_ms) |
| } else { |
| let (parent, leaf) = parent(path)?; |
| let metadata = |
| statat(&parent, &leaf, AtFlags::SYMLINK_NOFOLLOW).map_err(io::Error::from)?; |
| let created_at_ms = created_at_ms(&metadata); |
| file_metadata(metadata, created_at_ms) |
| } |
| } |
|
|
| #[cfg(target_os = "linux")] |
| fn file_metadata_linux(metadata: Statx) -> io::Result<FileMetadata> { |
| let kind = u32::from(metadata.stx_mode) & libc::S_IFMT; |
| if kind == libc::S_IFLNK { |
| return Err(io::Error::new( |
| io::ErrorKind::InvalidInput, |
| "path contains a symbolic link", |
| )); |
| } |
| let created_at_ms = if metadata.stx_mask & StatxFlags::BTIME.bits() == 0 { |
| 0 |
| } else { |
| unix_time_ms(metadata.stx_btime.tv_sec, metadata.stx_btime.tv_nsec) |
| }; |
| Ok(FileMetadata { |
| is_directory: kind == libc::S_IFDIR, |
| is_file: kind == libc::S_IFREG, |
| is_symlink: false, |
| size: metadata.stx_size, |
| created_at_ms, |
| modified_at_ms: unix_time_ms(metadata.stx_mtime.tv_sec, metadata.stx_mtime.tv_nsec), |
| }) |
| } |
|
|
| fn file_metadata(metadata: Stat, created_at_ms: i64) -> io::Result<FileMetadata> { |
| let kind = metadata.st_mode & libc::S_IFMT; |
| if kind == libc::S_IFLNK { |
| return Err(io::Error::new( |
| io::ErrorKind::InvalidInput, |
| "path contains a symbolic link", |
| )); |
| } |
| Ok(FileMetadata { |
| is_directory: kind == libc::S_IFDIR, |
| is_file: kind == libc::S_IFREG, |
| is_symlink: false, |
| size: u64::try_from(metadata.st_size).unwrap_or(0), |
| created_at_ms, |
| modified_at_ms: unix_time_ms(metadata.st_mtime, metadata.st_mtime_nsec), |
| }) |
| } |
|
|
| #[cfg(target_vendor = "apple")] |
| fn created_at_ms(metadata: &Stat) -> i64 { |
| unix_time_ms(metadata.st_birthtime, metadata.st_birthtime_nsec) |
| } |
|
|
| #[cfg(not(any(target_vendor = "apple", target_os = "linux")))] |
| fn created_at_ms(_metadata: &Stat) -> i64 { |
| 0 |
| } |
|
|
| fn unix_time_ms(seconds: i64, nanoseconds: impl TryInto<i64>) -> i64 { |
| let nanoseconds = nanoseconds.try_into().unwrap_or_default(); |
| seconds |
| .saturating_mul(1_000) |
| .saturating_add(nanoseconds / 1_000_000) |
| } |
|
|
| pub(super) async fn metadata(path: PathBuf) -> io::Result<FileMetadata> { |
| tokio::task::spawn_blocking(move || metadata_sync(&path)) |
| .await |
| .map_err(|error| io::Error::other(format!("filesystem task failed: {error}")))? |
| } |
|
|
| pub(super) async fn create_directory(path: PathBuf, recursive: bool) -> io::Result<()> { |
| tokio::task::spawn_blocking(move || { |
| let components = components(&path)?; |
| if components.is_empty() && !recursive { |
| return Err(io::Error::new( |
| io::ErrorKind::AlreadyExists, |
| "directory already exists", |
| )); |
| } |
| let mut directory = root()?; |
| for (index, component) in components.iter().enumerate() { |
| let is_leaf = index + 1 == components.len(); |
| if !recursive && is_leaf { |
| mkdirat(&directory, component, Mode::from_raw_mode(0o777)) |
| .map_err(io::Error::from)?; |
| return Ok(()); |
| } |
| match open_directory(&directory, component) { |
| Ok(next) => directory = next, |
| Err(error) if recursive && error.kind() == io::ErrorKind::NotFound => { |
| match mkdirat(&directory, component, Mode::from_raw_mode(0o777)) { |
| Ok(()) | Err(rustix::io::Errno::EXIST) => {} |
| Err(error) => return Err(io::Error::from(error)), |
| } |
| directory = open_directory(&directory, component)?; |
| } |
| Err(error) => return Err(error), |
| } |
| } |
| Ok(()) |
| }) |
| .await |
| .map_err(|error| io::Error::other(format!("filesystem task failed: {error}")))? |
| } |
|
|
| pub(super) async fn remove(path: PathBuf, recursive: bool, force: bool) -> io::Result<()> { |
| tokio::task::spawn_blocking(move || { |
| if recursive { |
| return Err(io::Error::new( |
| io::ErrorKind::Unsupported, |
| "recursive no-follow removal is unsupported", |
| )); |
| } |
| let (parent, leaf) = match parent(&path) { |
| Ok(value) => value, |
| Err(error) if force && error.kind() == io::ErrorKind::NotFound => return Ok(()), |
| Err(error) => return Err(error), |
| }; |
| let metadata = match statat(&parent, &leaf, AtFlags::SYMLINK_NOFOLLOW) { |
| Ok(metadata) => metadata, |
| Err(error) if force && error == rustix::io::Errno::NOENT => return Ok(()), |
| Err(error) => return Err(io::Error::from(error)), |
| }; |
| let kind = metadata.st_mode & libc::S_IFMT; |
| if kind == libc::S_IFLNK { |
| return Err(io::Error::new( |
| io::ErrorKind::InvalidInput, |
| "path contains a symbolic link", |
| )); |
| } |
| let flags = if kind == libc::S_IFDIR { |
| AtFlags::REMOVEDIR |
| } else { |
| AtFlags::empty() |
| }; |
| unlinkat(&parent, leaf, flags).map_err(io::Error::from) |
| }) |
| .await |
| .map_err(|error| io::Error::other(format!("filesystem task failed: {error}")))? |
| } |
|
|
