539 lines
19 KiB
Rust
539 lines
19 KiB
Rust
use crate::handle::{Handle, HandleRights};
|
|
use crate::sys::osdir::OsDir;
|
|
use crate::sys::{fd, AsFile};
|
|
use crate::wasi::{types, Errno, Result};
|
|
use std::convert::TryFrom;
|
|
use std::ffi::{OsStr, OsString};
|
|
use std::fs::{self, Metadata, OpenOptions};
|
|
use std::os::windows::ffi::{OsStrExt, OsStringExt};
|
|
use std::os::windows::fs::OpenOptionsExt;
|
|
use std::path::{Path, PathBuf};
|
|
use winapi::shared::winerror;
|
|
use winx::file::AccessMode;
|
|
|
|
fn strip_trailing_slashes_and_concatenate(dirfd: &OsDir, path: &str) -> Result<Option<PathBuf>> {
|
|
if path.ends_with('/') {
|
|
let suffix = path.trim_end_matches('/');
|
|
concatenate(dirfd, Path::new(suffix)).map(Some)
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
fn strip_extended_prefix<P: AsRef<OsStr>>(path: P) -> OsString {
|
|
let path: Vec<u16> = path.as_ref().encode_wide().collect();
|
|
if &[92, 92, 63, 92] == &path[0..4] {
|
|
OsString::from_wide(&path[4..])
|
|
} else {
|
|
OsString::from_wide(&path)
|
|
}
|
|
}
|
|
|
|
fn concatenate<P: AsRef<Path>>(file: &OsDir, path: P) -> Result<PathBuf> {
|
|
use winx::file::get_file_path;
|
|
|
|
// WASI is not able to deal with absolute paths
|
|
// so error out if absolute
|
|
if path.as_ref().is_absolute() {
|
|
return Err(Errno::Notcapable);
|
|
}
|
|
|
|
let dir_path = get_file_path(&*file.as_file()?)?;
|
|
// concatenate paths
|
|
let mut out_path = PathBuf::from(dir_path);
|
|
out_path.push(path.as_ref());
|
|
// strip extended prefix; otherwise we will error out on any relative
|
|
// components with `out_path`
|
|
let out_path = PathBuf::from(strip_extended_prefix(out_path));
|
|
|
|
tracing::debug!(out_path = tracing::field::debug(&out_path));
|
|
|
|
Ok(out_path)
|
|
}
|
|
|
|
fn file_access_mode_from_fdflags(fdflags: types::Fdflags, read: bool, write: bool) -> AccessMode {
|
|
let mut access_mode = AccessMode::READ_CONTROL;
|
|
|
|
// We always need `FILE_WRITE_ATTRIBUTES` so that we can set attributes such as filetimes, etc.
|
|
access_mode.insert(AccessMode::FILE_WRITE_ATTRIBUTES);
|
|
|
|
// Note that `GENERIC_READ` and `GENERIC_WRITE` cannot be used to properly support append-only mode
|
|
// The file-specific flags `FILE_GENERIC_READ` and `FILE_GENERIC_WRITE` are used here instead
|
|
// These flags have the same semantic meaning for file objects, but allow removal of specific permissions (see below)
|
|
if read {
|
|
access_mode.insert(AccessMode::FILE_GENERIC_READ);
|
|
}
|
|
|
|
if write {
|
|
access_mode.insert(AccessMode::FILE_GENERIC_WRITE);
|
|
}
|
|
|
|
// For append, grant the handle FILE_APPEND_DATA access but *not* FILE_WRITE_DATA.
|
|
// This makes the handle "append only".
|
|
// Changes to the file pointer will be ignored (like POSIX's O_APPEND behavior).
|
|
if fdflags.contains(&types::Fdflags::APPEND) {
|
|
access_mode.insert(AccessMode::FILE_APPEND_DATA);
|
|
access_mode.remove(AccessMode::FILE_WRITE_DATA);
|
|
}
|
|
|
|
access_mode
|
|
}
|
|
|
|
/// Creates owned WASI path from OS string.
|
|
///
|
|
/// NB WASI spec requires OS string to be valid UTF-8. Otherwise,
|
|
/// `__WASI_ERRNO_ILSEQ` error is returned.
|
|
pub(crate) fn from_host<S: AsRef<OsStr>>(s: S) -> Result<String> {
|
|
let vec: Vec<u16> = s.as_ref().encode_wide().collect();
|
|
let s = String::from_utf16(&vec)?;
|
|
Ok(s)
|
|
}
|
|
|
|
pub(crate) fn open_rights(
|
|
input_rights: &HandleRights,
|
|
oflags: types::Oflags,
|
|
fdflags: types::Fdflags,
|
|
) -> HandleRights {
|
|
// which rights are needed on the dirfd?
|
|
let mut needed_base = types::Rights::PATH_OPEN;
|
|
let mut needed_inheriting = input_rights.base | input_rights.inheriting;
|
|
|
|
// convert open flags
|
|
if oflags.contains(&types::Oflags::CREAT) {
|
|
needed_base |= types::Rights::PATH_CREATE_FILE;
|
|
} else if oflags.contains(&types::Oflags::TRUNC) {
|
|
needed_base |= types::Rights::PATH_FILESTAT_SET_SIZE;
|
|
}
|
|
|
|
// convert file descriptor flags
|
|
if fdflags.contains(&types::Fdflags::DSYNC)
|
|
|| fdflags.contains(&types::Fdflags::RSYNC)
|
|
|| fdflags.contains(&types::Fdflags::SYNC)
|
|
{
|
|
needed_inheriting |= types::Rights::FD_DATASYNC;
|
|
needed_inheriting |= types::Rights::FD_SYNC;
|
|
}
|
|
|
|
HandleRights::new(needed_base, needed_inheriting)
|
|
}
|
|
|
|
pub(crate) fn readlinkat(dirfd: &OsDir, s_path: &str) -> Result<String> {
|
|
use winx::file::get_file_path;
|
|
|
|
let path = concatenate(dirfd, Path::new(s_path))?;
|
|
let err = match path.read_link() {
|
|
Ok(target_path) => {
|
|
// since on Windows we are effectively emulating 'at' syscalls
|
|
// we need to strip the prefix from the absolute path
|
|
// as otherwise we will error out since WASI is not capable
|
|
// of dealing with absolute paths
|
|
let dir_path = get_file_path(&*dirfd.as_file()?)?;
|
|
let dir_path = PathBuf::from(strip_extended_prefix(dir_path));
|
|
let target_path = target_path
|
|
.strip_prefix(dir_path)
|
|
.map_err(|_| Errno::Notcapable)?;
|
|
let target_path = target_path.to_str().ok_or(Errno::Ilseq)?;
|
|
return Ok(target_path.to_owned());
|
|
}
|
|
Err(e) => e,
|
|
};
|
|
if let Some(code) = err.raw_os_error() {
|
|
tracing::debug!("readlinkat error={:?}", code);
|
|
if code as u32 == winerror::ERROR_INVALID_NAME {
|
|
if s_path.ends_with('/') {
|
|
// strip "/" and check if exists
|
|
let path = concatenate(dirfd, Path::new(s_path.trim_end_matches('/')))?;
|
|
if path.exists() && !path.is_dir() {
|
|
return Err(Errno::Notdir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Err(err.into())
|
|
}
|
|
|
|
pub(crate) fn create_directory(file: &OsDir, path: &str) -> Result<()> {
|
|
let path = concatenate(file, path)?;
|
|
std::fs::create_dir(&path)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn link(
|
|
old_dirfd: &OsDir,
|
|
old_path: &str,
|
|
new_dirfd: &OsDir,
|
|
new_path: &str,
|
|
follow_symlinks: bool,
|
|
) -> Result<()> {
|
|
use std::fs;
|
|
let mut old_path = concatenate(old_dirfd, old_path)?;
|
|
let new_path = concatenate(new_dirfd, new_path)?;
|
|
if follow_symlinks {
|
|
// in particular, this will return an error if the target path doesn't exist
|
|
tracing::debug!(
|
|
old_path = tracing::field::display(old_path.display()),
|
|
"Following symlinks"
|
|
);
|
|
old_path = fs::canonicalize(&old_path).map_err(|e| match e.raw_os_error() {
|
|
// fs::canonicalize under Windows will return:
|
|
// * ERROR_FILE_NOT_FOUND, if it encounters a dangling symlink
|
|
// * ERROR_CANT_RESOLVE_FILENAME, if it encounters a symlink loop
|
|
Some(code) if code as u32 == winerror::ERROR_CANT_RESOLVE_FILENAME => Errno::Loop,
|
|
_ => e.into(),
|
|
})?;
|
|
}
|
|
let err = match fs::hard_link(&old_path, &new_path) {
|
|
Ok(()) => return Ok(()),
|
|
Err(e) => e,
|
|
};
|
|
if let Some(code) = err.raw_os_error() {
|
|
tracing::debug!("path_link at fs::hard_link error code={:?}", code);
|
|
if code as u32 == winerror::ERROR_ACCESS_DENIED {
|
|
// If an attempt is made to create a hard link to a directory, POSIX-compliant
|
|
// implementations of link return `EPERM`, but `ERROR_ACCESS_DENIED` is converted
|
|
// to `EACCES`. We detect and correct this case here.
|
|
if fs::metadata(&old_path).map(|m| m.is_dir()).unwrap_or(false) {
|
|
return Err(Errno::Perm);
|
|
}
|
|
}
|
|
}
|
|
Err(err.into())
|
|
}
|
|
|
|
pub(crate) fn open(
|
|
dirfd: &OsDir,
|
|
path: &str,
|
|
read: bool,
|
|
write: bool,
|
|
oflags: types::Oflags,
|
|
fdflags: types::Fdflags,
|
|
) -> Result<Box<dyn Handle>> {
|
|
use winx::file::{AccessMode, CreationDisposition, Flags};
|
|
|
|
let is_trunc = oflags.contains(&types::Oflags::TRUNC);
|
|
|
|
if is_trunc {
|
|
// Windows does not support append mode when opening for truncation
|
|
// This is because truncation requires `GENERIC_WRITE` access, which will override the removal
|
|
// of the `FILE_WRITE_DATA` permission.
|
|
if fdflags.contains(&types::Fdflags::APPEND) {
|
|
return Err(Errno::Notsup);
|
|
}
|
|
}
|
|
|
|
// convert open flags
|
|
// note: the calls to `write(true)` are to bypass an internal OpenOption check
|
|
// the write flag will ultimately be ignored when `access_mode` is calculated below.
|
|
let mut opts = OpenOptions::new();
|
|
match oflags.into() {
|
|
CreationDisposition::CREATE_ALWAYS => {
|
|
opts.create(true).truncate(true).write(true);
|
|
}
|
|
CreationDisposition::CREATE_NEW => {
|
|
opts.create_new(true).write(true);
|
|
}
|
|
CreationDisposition::TRUNCATE_EXISTING => {
|
|
opts.truncate(true).write(true);
|
|
}
|
|
_ => {}
|
|
}
|
|
let path = concatenate(dirfd, path)?;
|
|
match path.symlink_metadata().map(|metadata| metadata.file_type()) {
|
|
Ok(file_type) => {
|
|
// check if we are trying to open a symlink
|
|
if file_type.is_symlink() {
|
|
return Err(Errno::Loop);
|
|
}
|
|
// check if we are trying to open a file as a dir
|
|
if file_type.is_file() && oflags.contains(&types::Oflags::DIRECTORY) {
|
|
return Err(Errno::Notdir);
|
|
}
|
|
}
|
|
Err(err) => match err.raw_os_error() {
|
|
Some(code) => {
|
|
tracing::debug!("path_open at symlink_metadata error code={:?}", code);
|
|
match code as u32 {
|
|
winerror::ERROR_FILE_NOT_FOUND => {
|
|
// file not found, let it proceed to actually
|
|
// trying to open it
|
|
}
|
|
winerror::ERROR_INVALID_NAME => {
|
|
// TODO rethink this. For now, migrate how we handled
|
|
// it in `path::openat` on Windows.
|
|
return Err(Errno::Notdir);
|
|
}
|
|
_ => return Err(err.into()),
|
|
};
|
|
}
|
|
None => {
|
|
tracing::debug!("Inconvertible OS error: {}", err);
|
|
return Err(Errno::Io);
|
|
}
|
|
},
|
|
}
|
|
|
|
let mut access_mode = file_access_mode_from_fdflags(fdflags, read, write);
|
|
|
|
// Truncation requires the special `GENERIC_WRITE` bit set (this is why it doesn't work with append-only mode)
|
|
if is_trunc {
|
|
access_mode |= AccessMode::GENERIC_WRITE;
|
|
}
|
|
|
|
let flags: Flags = fdflags.into();
|
|
let file = opts
|
|
.access_mode(access_mode.bits())
|
|
.custom_flags(flags.bits())
|
|
.open(&path)?;
|
|
let handle = <Box<dyn Handle>>::try_from(file)?;
|
|
Ok(handle)
|
|
}
|
|
|
|
pub(crate) fn readlink(dirfd: &OsDir, path: &str, buf: &mut [u8]) -> Result<usize> {
|
|
use winx::file::get_file_path;
|
|
|
|
let path = concatenate(dirfd, path)?;
|
|
let target_path = path.read_link()?;
|
|
|
|
// since on Windows we are effectively emulating 'at' syscalls
|
|
// we need to strip the prefix from the absolute path
|
|
// as otherwise we will error out since WASI is not capable
|
|
// of dealing with absolute paths
|
|
let dir_path = get_file_path(&*dirfd.as_file()?)?;
|
|
let dir_path = PathBuf::from(strip_extended_prefix(dir_path));
|
|
let target_path = target_path
|
|
.strip_prefix(dir_path)
|
|
.map_err(|_| Errno::Notcapable)
|
|
.and_then(|path| path.to_str().map(String::from).ok_or(Errno::Ilseq))?;
|
|
|
|
if buf.len() > 0 {
|
|
let mut chars = target_path.chars();
|
|
let mut nread = 0usize;
|
|
|
|
for i in 0..buf.len() {
|
|
match chars.next() {
|
|
Some(ch) => {
|
|
buf[i] = ch as u8;
|
|
nread += 1;
|
|
}
|
|
None => break,
|
|
}
|
|
}
|
|
|
|
Ok(nread)
|
|
} else {
|
|
Ok(0)
|
|
}
|
|
}
|
|
|
|
pub(crate) fn rename(
|
|
old_dirfd: &OsDir,
|
|
old_path_: &str,
|
|
new_dirfd: &OsDir,
|
|
new_path_: &str,
|
|
) -> Result<()> {
|
|
use std::fs;
|
|
|
|
let old_path = concatenate(old_dirfd, old_path_)?;
|
|
let new_path = concatenate(new_dirfd, new_path_)?;
|
|
|
|
// First sanity check: check we're not trying to rename dir to file or vice versa.
|
|
// NB on Windows, the former is actually permitted [std::fs::rename].
|
|
//
|
|
// [std::fs::rename]: https://doc.rust-lang.org/std/fs/fn.rename.html
|
|
if old_path.is_dir() && new_path.is_file() {
|
|
return Err(Errno::Notdir);
|
|
}
|
|
// Second sanity check: check we're not trying to rename a file into a path
|
|
// ending in a trailing slash.
|
|
if old_path.is_file() && new_path_.ends_with('/') {
|
|
return Err(Errno::Notdir);
|
|
}
|
|
|
|
// TODO handle symlinks
|
|
let err = match fs::rename(&old_path, &new_path) {
|
|
Ok(()) => return Ok(()),
|
|
Err(e) => e,
|
|
};
|
|
match err.raw_os_error() {
|
|
Some(code) => {
|
|
tracing::debug!("path_rename at rename error code={:?}", code);
|
|
match code as u32 {
|
|
winerror::ERROR_ACCESS_DENIED => {
|
|
// So most likely dealing with new_path == dir.
|
|
// Eliminate case old_path == file first.
|
|
if old_path.is_file() {
|
|
return Err(Errno::Isdir);
|
|
} else {
|
|
// Ok, let's try removing an empty dir at new_path if it exists
|
|
// and is a nonempty dir.
|
|
fs::remove_dir(&new_path)?;
|
|
fs::rename(old_path, new_path)?;
|
|
return Ok(());
|
|
}
|
|
}
|
|
winerror::ERROR_INVALID_NAME => {
|
|
// If source contains trailing slashes, check if we are dealing with
|
|
// a file instead of a dir, and if so, throw ENOTDIR.
|
|
if let Some(path) =
|
|
strip_trailing_slashes_and_concatenate(old_dirfd, old_path_)?
|
|
{
|
|
if path.is_file() {
|
|
return Err(Errno::Notdir);
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
Err(err.into())
|
|
}
|
|
None => {
|
|
tracing::debug!("Inconvertible OS error: {}", err);
|
|
Err(Errno::Io)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn symlink(old_path: &str, new_dirfd: &OsDir, new_path_: &str) -> Result<()> {
|
|
use std::os::windows::fs::{symlink_dir, symlink_file};
|
|
|
|
let old_path = concatenate(new_dirfd, Path::new(old_path))?;
|
|
let new_path = concatenate(new_dirfd, new_path_)?;
|
|
|
|
// Windows distinguishes between file and directory symlinks.
|
|
// If the source doesn't exist or is an exotic file type, we fall back
|
|
// to regular file symlinks.
|
|
let use_dir_symlink = fs::metadata(&new_path)
|
|
.as_ref()
|
|
.map(Metadata::is_dir)
|
|
.unwrap_or(false);
|
|
|
|
let res = if use_dir_symlink {
|
|
symlink_dir(&old_path, &new_path)
|
|
} else {
|
|
symlink_file(&old_path, &new_path)
|
|
};
|
|
|
|
let err = match res {
|
|
Ok(()) => return Ok(()),
|
|
Err(e) => e,
|
|
};
|
|
match err.raw_os_error() {
|
|
Some(code) => {
|
|
tracing::debug!("path_symlink at symlink_file error code={:?}", code);
|
|
match code as u32 {
|
|
// If the target contains a trailing slash, the Windows API returns
|
|
// ERROR_INVALID_NAME (which corresponds to ENOENT) instead of
|
|
// ERROR_ALREADY_EXISTS (which corresponds to EEXIST)
|
|
//
|
|
// This concerns only trailing slashes (not backslashes) and
|
|
// only symbolic links (not hard links).
|
|
//
|
|
// Since POSIX will return EEXIST in such case, we simulate this behavior
|
|
winerror::ERROR_INVALID_NAME => {
|
|
if let Some(path) =
|
|
strip_trailing_slashes_and_concatenate(new_dirfd, new_path_)?
|
|
{
|
|
if path.exists() {
|
|
return Err(Errno::Exist);
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
Err(err.into())
|
|
}
|
|
None => {
|
|
tracing::debug!("Inconvertible OS error: {}", err);
|
|
Err(Errno::Io)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn unlink_file(dirfd: &OsDir, path: &str) -> Result<()> {
|
|
use std::fs;
|
|
|
|
let path = concatenate(dirfd, path)?;
|
|
let file_type = path
|
|
.symlink_metadata()
|
|
.map(|metadata| metadata.file_type())?;
|
|
|
|
// check if we're unlinking a symlink
|
|
// NB this will get cleaned up a lot when [std::os::windows::fs::FileTypeExt]
|
|
// stabilises
|
|
//
|
|
// [std::os::windows::fs::FileTypeExt]: https://doc.rust-lang.org/std/os/windows/fs/trait.FileTypeExt.html
|
|
if file_type.is_symlink() {
|
|
let err = match fs::remove_file(&path) {
|
|
Ok(()) => return Ok(()),
|
|
Err(e) => e,
|
|
};
|
|
match err.raw_os_error() {
|
|
Some(code) => {
|
|
tracing::debug!("path_unlink_file at symlink_file error code={:?}", code);
|
|
if code as u32 == winerror::ERROR_ACCESS_DENIED {
|
|
// try unlinking a dir symlink instead
|
|
return fs::remove_dir(path).map_err(Into::into);
|
|
}
|
|
|
|
Err(err.into())
|
|
}
|
|
None => {
|
|
tracing::debug!("Inconvertible OS error: {}", err);
|
|
Err(Errno::Io)
|
|
}
|
|
}
|
|
} else if file_type.is_dir() {
|
|
Err(Errno::Isdir)
|
|
} else if file_type.is_file() {
|
|
fs::remove_file(path).map_err(Into::into)
|
|
} else {
|
|
Err(Errno::Inval)
|
|
}
|
|
}
|
|
|
|
pub(crate) fn remove_directory(dirfd: &OsDir, path: &str) -> Result<()> {
|
|
let path = concatenate(dirfd, path)?;
|
|
std::fs::remove_dir(&path).map_err(Into::into)
|
|
}
|
|
|
|
pub(crate) fn filestat_get_at(dirfd: &OsDir, path: &str, follow: bool) -> Result<types::Filestat> {
|
|
use winx::file::Flags;
|
|
let path = concatenate(dirfd, path)?;
|
|
let mut opts = OpenOptions::new();
|
|
|
|
if !follow {
|
|
// By specifying FILE_FLAG_OPEN_REPARSE_POINT, we force Windows to *not* dereference symlinks.
|
|
opts.custom_flags(Flags::FILE_FLAG_OPEN_REPARSE_POINT.bits());
|
|
}
|
|
|
|
let file = opts.read(true).open(path)?;
|
|
let stat = fd::filestat_get(&file)?;
|
|
Ok(stat)
|
|
}
|
|
|
|
pub(crate) fn filestat_set_times_at(
|
|
dirfd: &OsDir,
|
|
path: &str,
|
|
atim: types::Timestamp,
|
|
mtim: types::Timestamp,
|
|
fst_flags: types::Fstflags,
|
|
follow: bool,
|
|
) -> Result<()> {
|
|
use winx::file::{AccessMode, Flags};
|
|
let path = concatenate(dirfd, path)?;
|
|
let mut opts = OpenOptions::new();
|
|
|
|
if !follow {
|
|
// By specifying FILE_FLAG_OPEN_REPARSE_POINT, we force Windows to *not* dereference symlinks.
|
|
opts.custom_flags(Flags::FILE_FLAG_OPEN_REPARSE_POINT.bits());
|
|
}
|
|
|
|
let file = opts
|
|
.access_mode(AccessMode::FILE_WRITE_ATTRIBUTES.bits())
|
|
.open(path)?;
|
|
fd::filestat_set_times(&file, atim, mtim, fst_flags)?;
|
|
Ok(())
|
|
}
|