835 lines
28 KiB
Rust
835 lines
28 KiB
Rust
#![allow(non_camel_case_types)]
|
|
#![allow(unused_unsafe)]
|
|
use super::fdentry::{determine_type_rights, FdEntry};
|
|
use super::fs_helpers::*;
|
|
use super::host_impl;
|
|
|
|
use crate::ctx::WasiCtx;
|
|
use crate::{host, wasm32};
|
|
|
|
use nix::libc::{self, c_long, c_void, off_t};
|
|
use std::ffi::OsStr;
|
|
use std::os::unix::prelude::{FromRawFd, OsStrExt};
|
|
|
|
pub(crate) fn fd_close(fd_entry: FdEntry) -> Result<(), host::__wasi_errno_t> {
|
|
nix::unistd::close(fd_entry.fd_object.rawfd)
|
|
.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn fd_datasync(fd_entry: &FdEntry) -> Result<(), host::__wasi_errno_t> {
|
|
let res;
|
|
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
res = nix::unistd::fdatasync(fd_entry.fd_object.rawfd);
|
|
}
|
|
|
|
#[cfg(not(target_os = "linux"))]
|
|
{
|
|
res = nix::unistd::fsync(fd_entry.fd_object.rawfd);
|
|
}
|
|
|
|
res.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn fd_pread(
|
|
fd_entry: &FdEntry,
|
|
buf: &mut [u8],
|
|
offset: host::__wasi_filesize_t,
|
|
) -> Result<usize, host::__wasi_errno_t> {
|
|
nix::sys::uio::pread(fd_entry.fd_object.rawfd, buf, offset as off_t)
|
|
.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn fd_pwrite(
|
|
fd_entry: &FdEntry,
|
|
buf: &[u8],
|
|
offset: host::__wasi_filesize_t,
|
|
) -> Result<usize, host::__wasi_errno_t> {
|
|
nix::sys::uio::pwrite(fd_entry.fd_object.rawfd, buf, offset as off_t)
|
|
.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn fd_read(
|
|
fd_entry: &FdEntry,
|
|
iovs: &mut [host::__wasi_iovec_t],
|
|
) -> Result<usize, host::__wasi_errno_t> {
|
|
use nix::sys::uio::{readv, IoVec};
|
|
|
|
let mut iovs: Vec<IoVec<&mut [u8]>> = iovs
|
|
.iter_mut()
|
|
.map(|iov| unsafe { host_impl::iovec_to_nix_mut(iov) })
|
|
.collect();
|
|
|
|
readv(fd_entry.fd_object.rawfd, &mut iovs)
|
|
.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn fd_renumber(
|
|
wasi_ctx: &mut WasiCtx,
|
|
from: host::__wasi_fd_t,
|
|
to: host::__wasi_fd_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
let fe_from = match wasi_ctx.fds.get(&from) {
|
|
Some(fe_from) => fe_from,
|
|
None => return Err(host::__WASI_EBADF),
|
|
};
|
|
let fe_to = match wasi_ctx.fds.get(&to) {
|
|
Some(fe_to) => fe_to,
|
|
None => return Err(host::__WASI_EBADF),
|
|
};
|
|
if let Err(e) = nix::unistd::dup2(fe_from.fd_object.rawfd, fe_to.fd_object.rawfd) {
|
|
return Err(host_impl::errno_from_nix(e.as_errno().unwrap()));
|
|
}
|
|
|
|
let fe_from_rawfd = fe_from.fd_object.rawfd;
|
|
wasi_ctx.fds.remove(&(fe_from_rawfd as host::__wasi_fd_t));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn fd_seek(
|
|
fd_entry: &FdEntry,
|
|
offset: host::__wasi_filedelta_t,
|
|
whence: host::__wasi_whence_t,
|
|
) -> Result<u64, host::__wasi_errno_t> {
|
|
use nix::unistd::{lseek, Whence};
|
|
let nwhence = match whence {
|
|
host::__WASI_WHENCE_CUR => Whence::SeekCur,
|
|
host::__WASI_WHENCE_END => Whence::SeekEnd,
|
|
host::__WASI_WHENCE_SET => Whence::SeekSet,
|
|
_ => return Err(host::__WASI_EINVAL),
|
|
};
|
|
|
|
match lseek(fd_entry.fd_object.rawfd, offset, nwhence) {
|
|
Ok(offset) => Ok(offset as u64),
|
|
Err(e) => Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_tell(fd_entry: &FdEntry) -> Result<u64, host::__wasi_errno_t> {
|
|
use nix::unistd::{lseek, Whence};
|
|
match lseek(fd_entry.fd_object.rawfd, 0, Whence::SeekCur) {
|
|
Ok(newoffset) => Ok(newoffset as u64),
|
|
Err(e) => Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_fdstat_get(
|
|
fd_entry: &FdEntry,
|
|
) -> Result<host::__wasi_fdflags_t, host::__wasi_errno_t> {
|
|
use nix::fcntl::{fcntl, OFlag, F_GETFL};
|
|
match fcntl(fd_entry.fd_object.rawfd, F_GETFL).map(OFlag::from_bits_truncate) {
|
|
Ok(flags) => Ok(host_impl::fdflags_from_nix(flags)),
|
|
Err(e) => Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_fdstat_set_flags(
|
|
fd_entry: &FdEntry,
|
|
fdflags: host::__wasi_fdflags_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
let nix_flags = host_impl::nix_from_fdflags(fdflags);
|
|
match nix::fcntl::fcntl(fd_entry.fd_object.rawfd, nix::fcntl::F_SETFL(nix_flags)) {
|
|
Ok(_) => Ok(()),
|
|
Err(e) => Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_sync(fd_entry: &FdEntry) -> Result<(), host::__wasi_errno_t> {
|
|
nix::unistd::fsync(fd_entry.fd_object.rawfd)
|
|
.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn fd_write(
|
|
fd_entry: &FdEntry,
|
|
iovs: &[host::__wasi_iovec_t],
|
|
) -> Result<usize, host::__wasi_errno_t> {
|
|
use nix::sys::uio::{writev, IoVec};
|
|
let iovs: Vec<IoVec<&[u8]>> = iovs
|
|
.iter()
|
|
.map(|iov| unsafe { host_impl::iovec_to_nix(iov) })
|
|
.collect();
|
|
writev(fd_entry.fd_object.rawfd, &iovs)
|
|
.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn fd_advise(
|
|
fd_entry: &FdEntry,
|
|
advice: host::__wasi_advice_t,
|
|
offset: host::__wasi_filesize_t,
|
|
len: host::__wasi_filesize_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
let host_advice = match advice {
|
|
host::__WASI_ADVICE_DONTNEED => libc::POSIX_FADV_DONTNEED,
|
|
host::__WASI_ADVICE_SEQUENTIAL => libc::POSIX_FADV_SEQUENTIAL,
|
|
host::__WASI_ADVICE_WILLNEED => libc::POSIX_FADV_DONTNEED,
|
|
host::__WASI_ADVICE_NOREUSE => libc::POSIX_FADV_NOREUSE,
|
|
host::__WASI_ADVICE_RANDOM => libc::POSIX_FADV_RANDOM,
|
|
host::__WASI_ADVICE_NORMAL => libc::POSIX_FADV_NORMAL,
|
|
_ => return Err(host::__WASI_EINVAL),
|
|
};
|
|
let res = unsafe {
|
|
libc::posix_fadvise(
|
|
fd_entry.fd_object.rawfd,
|
|
offset as off_t,
|
|
len as off_t,
|
|
host_advice,
|
|
)
|
|
};
|
|
if res != 0 {
|
|
return Err(host_impl::errno_from_nix(nix::errno::Errno::last()));
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_os = "linux"))]
|
|
{
|
|
let _ = (fd_entry, offset, len);
|
|
match advice {
|
|
host::__WASI_ADVICE_DONTNEED
|
|
| host::__WASI_ADVICE_SEQUENTIAL
|
|
| host::__WASI_ADVICE_WILLNEED
|
|
| host::__WASI_ADVICE_NOREUSE
|
|
| host::__WASI_ADVICE_RANDOM
|
|
| host::__WASI_ADVICE_NORMAL => {}
|
|
_ => return Err(host::__WASI_EINVAL),
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn fd_allocate(
|
|
fd_entry: &FdEntry,
|
|
offset: host::__wasi_filesize_t,
|
|
len: host::__wasi_filesize_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
let res = unsafe {
|
|
libc::posix_fallocate(fd_entry.fd_object.rawfd, offset as off_t, len as off_t)
|
|
};
|
|
if res != 0 {
|
|
return Err(host_impl::errno_from_nix(nix::errno::Errno::last()));
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_os = "linux"))]
|
|
{
|
|
use nix::sys::stat::fstat;
|
|
use nix::unistd::ftruncate;
|
|
|
|
match fstat(fd_entry.fd_object.rawfd) {
|
|
Err(e) => return Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
Ok(st) => {
|
|
let current_size = st.st_size as u64;
|
|
let wanted_size = match offset.checked_add(len) {
|
|
Some(wanted_size) => wanted_size,
|
|
None => return Err(host::__WASI_E2BIG),
|
|
};
|
|
if wanted_size > i64::max_value() as u64 {
|
|
return Err(host::__WASI_E2BIG);
|
|
}
|
|
if wanted_size > current_size {
|
|
if let Err(e) = ftruncate(fd_entry.fd_object.rawfd, wanted_size as off_t) {
|
|
return Err(host_impl::errno_from_nix(e.as_errno().unwrap()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn path_create_directory(
|
|
ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
path: &OsStr,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::libc::mkdirat;
|
|
|
|
let (dir, path) = match path_get(
|
|
ctx,
|
|
dirfd,
|
|
0,
|
|
path,
|
|
host::__WASI_RIGHT_PATH_OPEN | host::__WASI_RIGHT_PATH_CREATE_DIRECTORY,
|
|
0,
|
|
false,
|
|
) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let path_cstr = match std::ffi::CString::new(path.as_os_str().as_bytes()) {
|
|
Ok(path_cstr) => path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
// nix doesn't expose mkdirat() yet
|
|
match unsafe { mkdirat(dir, path_cstr.as_ptr(), 0o777) } {
|
|
0 => Ok(()),
|
|
_ => Err(host_impl::errno_from_nix(nix::errno::Errno::last())),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn path_link(
|
|
ctx: &WasiCtx,
|
|
old_dirfd: host::__wasi_fd_t,
|
|
new_dirfd: host::__wasi_fd_t,
|
|
old_path: &OsStr,
|
|
new_path: &OsStr,
|
|
source_rights: host::__wasi_rights_t,
|
|
target_rights: host::__wasi_rights_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::libc::linkat;
|
|
let (old_dir, old_path) = match path_get(ctx, old_dirfd, 0, old_path, source_rights, 0, false) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let (new_dir, new_path) = match path_get(ctx, new_dirfd, 0, new_path, target_rights, 0, false) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let old_path_cstr = match std::ffi::CString::new(old_path.as_bytes()) {
|
|
Ok(old_path_cstr) => old_path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
let new_path_cstr = match std::ffi::CString::new(new_path.as_bytes()) {
|
|
Ok(new_path_cstr) => new_path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
|
|
// Not setting AT_SYMLINK_FOLLOW fails on most filesystems
|
|
let atflags = libc::AT_SYMLINK_FOLLOW;
|
|
let res = unsafe {
|
|
linkat(
|
|
old_dir,
|
|
old_path_cstr.as_ptr(),
|
|
new_dir,
|
|
new_path_cstr.as_ptr(),
|
|
atflags,
|
|
)
|
|
};
|
|
if res != 0 {
|
|
Err(host_impl::errno_from_nix(nix::errno::Errno::last()))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub(crate) fn path_open(
|
|
ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
dirflags: host::__wasi_lookupflags_t,
|
|
path: &OsStr,
|
|
oflags: host::__wasi_oflags_t,
|
|
read: bool,
|
|
write: bool,
|
|
mut needed_base: host::__wasi_rights_t,
|
|
mut needed_inheriting: host::__wasi_rights_t,
|
|
fs_flags: host::__wasi_fdflags_t,
|
|
) -> Result<FdEntry, host::__wasi_errno_t> {
|
|
use nix::errno::Errno;
|
|
use nix::fcntl::{openat, AtFlags, OFlag};
|
|
use nix::sys::stat::{fstatat, Mode, SFlag};
|
|
|
|
let mut nix_all_oflags = if read && write {
|
|
OFlag::O_RDWR
|
|
} else if write {
|
|
OFlag::O_WRONLY
|
|
} else {
|
|
OFlag::O_RDONLY
|
|
};
|
|
|
|
// on non-Capsicum systems, we always want nofollow
|
|
nix_all_oflags.insert(OFlag::O_NOFOLLOW);
|
|
|
|
// convert open flags
|
|
let nix_oflags = host_impl::nix_from_oflags(oflags);
|
|
nix_all_oflags.insert(nix_oflags);
|
|
if nix_all_oflags.contains(OFlag::O_CREAT) {
|
|
needed_base |= host::__WASI_RIGHT_PATH_CREATE_FILE;
|
|
}
|
|
if nix_all_oflags.contains(OFlag::O_TRUNC) {
|
|
needed_base |= host::__WASI_RIGHT_PATH_FILESTAT_SET_SIZE;
|
|
}
|
|
|
|
// convert file descriptor flags
|
|
nix_all_oflags.insert(host_impl::nix_from_fdflags(fs_flags));
|
|
if nix_all_oflags.contains(OFlag::O_DSYNC) {
|
|
needed_inheriting |= host::__WASI_RIGHT_FD_DATASYNC;
|
|
}
|
|
if nix_all_oflags.intersects(host_impl::O_RSYNC | OFlag::O_SYNC) {
|
|
needed_inheriting |= host::__WASI_RIGHT_FD_SYNC;
|
|
}
|
|
|
|
let (dir, path) = match path_get(
|
|
ctx,
|
|
dirfd,
|
|
dirflags,
|
|
path,
|
|
needed_base,
|
|
needed_inheriting,
|
|
nix_oflags.contains(OFlag::O_CREAT),
|
|
) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
|
|
// Call openat. Use mode 0o666 so that we follow whatever the user's
|
|
// umask is, but don't set the executable flag, because it isn't yet
|
|
// meaningful for WASI programs to create executable files.
|
|
let new_fd = match openat(
|
|
dir,
|
|
path.as_os_str(),
|
|
nix_all_oflags,
|
|
Mode::from_bits_truncate(0o666),
|
|
) {
|
|
Ok(fd) => fd,
|
|
Err(e) => {
|
|
match e.as_errno() {
|
|
// Linux returns ENXIO instead of EOPNOTSUPP when opening a socket
|
|
Some(Errno::ENXIO) => {
|
|
if let Ok(stat) = fstatat(dir, path.as_os_str(), AtFlags::AT_SYMLINK_NOFOLLOW) {
|
|
if SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::S_IFSOCK) {
|
|
return Err(host::__WASI_ENOTSUP);
|
|
} else {
|
|
return Err(host::__WASI_ENXIO);
|
|
}
|
|
} else {
|
|
return Err(host::__WASI_ENXIO);
|
|
}
|
|
}
|
|
// Linux returns ENOTDIR instead of ELOOP when using O_NOFOLLOW|O_DIRECTORY
|
|
// on a symlink.
|
|
Some(Errno::ENOTDIR)
|
|
if !(nix_all_oflags & (OFlag::O_NOFOLLOW | OFlag::O_DIRECTORY)).is_empty() =>
|
|
{
|
|
if let Ok(stat) = fstatat(dir, path.as_os_str(), AtFlags::AT_SYMLINK_NOFOLLOW) {
|
|
if SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::S_IFLNK) {
|
|
return Err(host::__WASI_ELOOP);
|
|
}
|
|
}
|
|
return Err(host::__WASI_ENOTDIR);
|
|
}
|
|
// FreeBSD returns EMLINK instead of ELOOP when using O_NOFOLLOW on
|
|
// a symlink.
|
|
Some(Errno::EMLINK) if !(nix_all_oflags & OFlag::O_NOFOLLOW).is_empty() => {
|
|
return Err(host::__WASI_ELOOP);
|
|
}
|
|
Some(e) => return Err(host_impl::errno_from_nix(e)),
|
|
None => return Err(host::__WASI_ENOSYS),
|
|
}
|
|
}
|
|
};
|
|
|
|
// Determine the type of the new file descriptor and which rights contradict with this type
|
|
match unsafe { determine_type_rights(new_fd) } {
|
|
Err(e) => {
|
|
// if `close` fails, note it but do not override the underlying errno
|
|
nix::unistd::close(new_fd).unwrap_or_else(|e| {
|
|
dbg!(e);
|
|
});
|
|
Err(e)
|
|
}
|
|
Ok((_ty, max_base, max_inheriting)) => {
|
|
let mut fe = unsafe { FdEntry::from_raw_fd(new_fd) };
|
|
fe.rights_base &= max_base;
|
|
fe.rights_inheriting &= max_inheriting;
|
|
Ok(fe)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_readdir(
|
|
fd_entry: &FdEntry,
|
|
host_buf: &mut [u8],
|
|
cookie: host::__wasi_dircookie_t,
|
|
) -> Result<usize, host::__wasi_errno_t> {
|
|
use libc::{dirent, fdopendir, memcpy, readdir_r, seekdir};
|
|
|
|
let host_buf_ptr = host_buf.as_mut_ptr();
|
|
let host_buf_len = host_buf.len();
|
|
let dir = unsafe { fdopendir(fd_entry.fd_object.rawfd) };
|
|
if dir.is_null() {
|
|
return Err(host_impl::errno_from_nix(nix::errno::Errno::last()));
|
|
}
|
|
if cookie != wasm32::__WASI_DIRCOOKIE_START {
|
|
unsafe { seekdir(dir, cookie as c_long) };
|
|
}
|
|
let mut entry_buf = unsafe { std::mem::uninitialized::<dirent>() };
|
|
let mut left = host_buf_len;
|
|
let mut host_buf_offset: usize = 0;
|
|
while left > 0 {
|
|
let mut host_entry: *mut dirent = std::ptr::null_mut();
|
|
let res = unsafe { readdir_r(dir, &mut entry_buf, &mut host_entry) };
|
|
if res == -1 {
|
|
return Err(host_impl::errno_from_nix(nix::errno::Errno::last()));
|
|
}
|
|
if host_entry.is_null() {
|
|
break;
|
|
}
|
|
let entry: wasm32::__wasi_dirent_t =
|
|
match host_impl::dirent_from_host(&unsafe { *host_entry }) {
|
|
Ok(entry) => entry,
|
|
Err(e) => return Err(e),
|
|
};
|
|
let name_len = entry.d_namlen as usize;
|
|
let required_space = std::mem::size_of_val(&entry) + name_len;
|
|
if required_space > left {
|
|
break;
|
|
}
|
|
unsafe {
|
|
let ptr = host_buf_ptr.offset(host_buf_offset as isize) as *mut c_void
|
|
as *mut wasm32::__wasi_dirent_t;
|
|
*ptr = entry;
|
|
}
|
|
host_buf_offset += std::mem::size_of_val(&entry);
|
|
let name_ptr = unsafe { *host_entry }.d_name.as_ptr();
|
|
unsafe {
|
|
memcpy(
|
|
host_buf_ptr.offset(host_buf_offset as isize) as *mut _,
|
|
name_ptr as *const _,
|
|
name_len,
|
|
)
|
|
};
|
|
host_buf_offset += name_len;
|
|
left -= required_space;
|
|
}
|
|
Ok(host_buf_len - left)
|
|
}
|
|
|
|
pub(crate) fn path_readlink(
|
|
wasi_ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
path: &OsStr,
|
|
rights: host::__wasi_rights_t,
|
|
buf: &mut [u8],
|
|
) -> Result<usize, host::__wasi_errno_t> {
|
|
use nix::fcntl::readlinkat;
|
|
|
|
let (dir, path) = match path_get(wasi_ctx, dirfd, 0, path, rights, 0, false) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
|
|
let target_path = match readlinkat(dir, path.as_os_str(), buf) {
|
|
Err(e) => return Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
Ok(target_path) => target_path,
|
|
};
|
|
Ok(target_path.len())
|
|
}
|
|
|
|
pub(crate) fn path_rename(
|
|
wasi_ctx: &WasiCtx,
|
|
old_dirfd: host::__wasi_fd_t,
|
|
old_path: &OsStr,
|
|
old_rights: host::__wasi_rights_t,
|
|
new_dirfd: host::__wasi_fd_t,
|
|
new_path: &OsStr,
|
|
new_rights: host::__wasi_rights_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::libc::renameat;
|
|
|
|
let (old_dir, old_path) = match path_get(wasi_ctx, old_dirfd, 0, old_path, old_rights, 0, false)
|
|
{
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let (new_dir, new_path) = match path_get(wasi_ctx, new_dirfd, 0, new_path, new_rights, 0, false)
|
|
{
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let old_path_cstr = match std::ffi::CString::new(old_path.as_bytes()) {
|
|
Ok(old_path_cstr) => old_path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
let new_path_cstr = match std::ffi::CString::new(new_path.as_bytes()) {
|
|
Ok(new_path_cstr) => new_path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
let res = unsafe {
|
|
renameat(
|
|
old_dir,
|
|
old_path_cstr.as_ptr(),
|
|
new_dir,
|
|
new_path_cstr.as_ptr(),
|
|
)
|
|
};
|
|
if res != 0 {
|
|
Err(host_impl::errno_from_nix(nix::errno::Errno::last()))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_filestat_get(
|
|
fd_entry: &FdEntry,
|
|
) -> Result<host::__wasi_filestat_t, host::__wasi_errno_t> {
|
|
use nix::sys::stat::fstat;
|
|
|
|
match fstat(fd_entry.fd_object.rawfd) {
|
|
Err(e) => Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
Ok(filestat) => Ok(host_impl::filestat_from_nix(filestat)),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_filestat_set_times(
|
|
fd_entry: &FdEntry,
|
|
st_atim: host::__wasi_timestamp_t,
|
|
mut st_mtim: host::__wasi_timestamp_t,
|
|
fst_flags: host::__wasi_fstflags_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::sys::time::{TimeSpec, TimeValLike};
|
|
|
|
if fst_flags & host::__WASI_FILESTAT_SET_MTIM_NOW != 0 {
|
|
let clock_id = libc::CLOCK_REALTIME;
|
|
let mut timespec = unsafe { std::mem::uninitialized::<libc::timespec>() };
|
|
let res = unsafe { libc::clock_gettime(clock_id, &mut timespec as *mut libc::timespec) };
|
|
if res != 0 {
|
|
return Err(host_impl::errno_from_nix(nix::errno::Errno::last()));
|
|
}
|
|
let time_ns = match (timespec.tv_sec as host::__wasi_timestamp_t)
|
|
.checked_mul(1_000_000_000)
|
|
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as host::__wasi_timestamp_t))
|
|
{
|
|
Some(time_ns) => time_ns,
|
|
None => return Err(host::__WASI_EOVERFLOW),
|
|
};
|
|
st_mtim = time_ns;
|
|
}
|
|
let ts_atime = match fst_flags {
|
|
f if f & host::__WASI_FILESTAT_SET_ATIM_NOW != 0 => libc::timespec {
|
|
tv_sec: 0,
|
|
tv_nsec: utime_now(),
|
|
},
|
|
f if f & host::__WASI_FILESTAT_SET_ATIM != 0 => {
|
|
*TimeSpec::nanoseconds(st_atim as i64).as_ref()
|
|
}
|
|
_ => libc::timespec {
|
|
tv_sec: 0,
|
|
tv_nsec: utime_omit(),
|
|
},
|
|
};
|
|
let ts_mtime = *TimeSpec::nanoseconds(st_mtim as i64).as_ref();
|
|
let times = [ts_atime, ts_mtime];
|
|
let res = unsafe { libc::futimens(fd_entry.fd_object.rawfd, times.as_ptr()) };
|
|
if res != 0 {
|
|
Err(host_impl::errno_from_nix(nix::errno::Errno::last()))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fd_filestat_set_size(
|
|
fd_entry: &FdEntry,
|
|
st_size: host::__wasi_filesize_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::unistd::ftruncate;
|
|
|
|
ftruncate(fd_entry.fd_object.rawfd, st_size as off_t)
|
|
.map_err(|e| host_impl::errno_from_nix(e.as_errno().unwrap()))
|
|
}
|
|
|
|
pub(crate) fn path_filestat_get(
|
|
wasi_ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
dirflags: host::__wasi_lookupflags_t,
|
|
path: &OsStr,
|
|
) -> Result<host::__wasi_filestat_t, host::__wasi_errno_t> {
|
|
use nix::fcntl::AtFlags;
|
|
use nix::sys::stat::fstatat;
|
|
|
|
let (dir, path) = match path_get(
|
|
wasi_ctx,
|
|
dirfd,
|
|
dirflags,
|
|
path,
|
|
host::__WASI_RIGHT_PATH_FILESTAT_GET,
|
|
0,
|
|
false,
|
|
) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let atflags = match dirflags {
|
|
0 => AtFlags::empty(),
|
|
_ => AtFlags::AT_SYMLINK_NOFOLLOW,
|
|
};
|
|
|
|
match fstatat(dir, path.as_os_str(), atflags) {
|
|
Err(e) => Err(host_impl::errno_from_nix(e.as_errno().unwrap())),
|
|
Ok(filestat) => Ok(host_impl::filestat_from_nix(filestat)),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn path_filestat_set_times(
|
|
wasi_ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
dirflags: host::__wasi_lookupflags_t,
|
|
path: &OsStr,
|
|
rights: host::__wasi_rights_t,
|
|
st_atim: host::__wasi_timestamp_t,
|
|
mut st_mtim: host::__wasi_timestamp_t,
|
|
fst_flags: host::__wasi_fstflags_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::sys::time::{TimeSpec, TimeValLike};
|
|
|
|
let (dir, path) = match path_get(wasi_ctx, dirfd, dirflags, path, rights, 0, false) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let atflags = match dirflags {
|
|
wasm32::__WASI_LOOKUP_SYMLINK_FOLLOW => 0,
|
|
_ => libc::AT_SYMLINK_NOFOLLOW,
|
|
};
|
|
if fst_flags & host::__WASI_FILESTAT_SET_MTIM_NOW != 0 {
|
|
let clock_id = libc::CLOCK_REALTIME;
|
|
let mut timespec = unsafe { std::mem::uninitialized::<libc::timespec>() };
|
|
let res = unsafe { libc::clock_gettime(clock_id, &mut timespec as *mut libc::timespec) };
|
|
if res != 0 {
|
|
return Err(host_impl::errno_from_nix(nix::errno::Errno::last()));
|
|
}
|
|
let time_ns = match (timespec.tv_sec as host::__wasi_timestamp_t)
|
|
.checked_mul(1_000_000_000)
|
|
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as host::__wasi_timestamp_t))
|
|
{
|
|
Some(time_ns) => time_ns,
|
|
None => return Err(host::__WASI_EOVERFLOW),
|
|
};
|
|
st_mtim = time_ns;
|
|
}
|
|
let ts_atime = match fst_flags {
|
|
f if f & host::__WASI_FILESTAT_SET_ATIM_NOW != 0 => libc::timespec {
|
|
tv_sec: 0,
|
|
tv_nsec: utime_now(),
|
|
},
|
|
f if f & host::__WASI_FILESTAT_SET_ATIM != 0 => {
|
|
*TimeSpec::nanoseconds(st_atim as i64).as_ref()
|
|
}
|
|
_ => libc::timespec {
|
|
tv_sec: 0,
|
|
tv_nsec: utime_omit(),
|
|
},
|
|
};
|
|
let ts_mtime = *TimeSpec::nanoseconds(st_mtim as i64).as_ref();
|
|
let times = [ts_atime, ts_mtime];
|
|
let path_cstr = match std::ffi::CString::new(path.as_os_str().as_bytes()) {
|
|
Ok(path_cstr) => path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
let res = unsafe { libc::utimensat(dir, path_cstr.as_ptr(), times.as_ptr(), atflags) };
|
|
if res != 0 {
|
|
Err(host_impl::errno_from_nix(nix::errno::Errno::last()))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub(crate) fn path_symlink(
|
|
wasi_ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
rights: host::__wasi_rights_t,
|
|
old_path: &OsStr,
|
|
new_path: &OsStr,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::libc::symlinkat;
|
|
|
|
let (dir, new_path) = match path_get(wasi_ctx, dirfd, 0, new_path, rights, 0, false) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let old_path_cstr = match std::ffi::CString::new(old_path.as_bytes()) {
|
|
Ok(old_path_cstr) => old_path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
let new_path_cstr = match std::ffi::CString::new(new_path.as_bytes()) {
|
|
Ok(new_path_cstr) => new_path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
let res = unsafe { symlinkat(old_path_cstr.as_ptr(), dir, new_path_cstr.as_ptr()) };
|
|
if res != 0 {
|
|
Err(host_impl::errno_from_nix(nix::errno::Errno::last()))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub(crate) fn path_unlink_file(
|
|
wasi_ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
path: &OsStr,
|
|
rights: host::__wasi_rights_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::errno;
|
|
use nix::libc::unlinkat;
|
|
|
|
let (dir, path) = match path_get(wasi_ctx, dirfd, 0, path, rights, 0, false) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let path_cstr = match std::ffi::CString::new(path.as_os_str().as_bytes()) {
|
|
Ok(path_cstr) => path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
// nix doesn't expose unlinkat() yet
|
|
match unsafe { unlinkat(dir, path_cstr.as_ptr(), 0) } {
|
|
0 => Ok(()),
|
|
_ => {
|
|
let mut e = errno::Errno::last();
|
|
|
|
#[cfg(not(linux))]
|
|
{
|
|
// Non-Linux implementations may return EPERM when attempting to remove a
|
|
// directory without REMOVEDIR. While that's what POSIX specifies, it's
|
|
// less useful. Adjust this to EISDIR. It doesn't matter that this is not
|
|
// atomic with the unlinkat, because if the file is removed and a directory
|
|
// is created before fstatat sees it, we're racing with that change anyway
|
|
// and unlinkat could have legitimately seen the directory if the race had
|
|
// turned out differently.
|
|
use nix::fcntl::AtFlags;
|
|
use nix::sys::stat::{fstatat, SFlag};
|
|
|
|
if e == errno::Errno::EPERM {
|
|
if let Ok(stat) = fstatat(dir, path.as_os_str(), AtFlags::AT_SYMLINK_NOFOLLOW) {
|
|
if SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::S_IFDIR) {
|
|
e = errno::Errno::EISDIR;
|
|
}
|
|
} else {
|
|
e = errno::Errno::last();
|
|
}
|
|
}
|
|
}
|
|
|
|
Err(host_impl::errno_from_nix(e))
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn path_remove_directory(
|
|
wasi_ctx: &WasiCtx,
|
|
dirfd: host::__wasi_fd_t,
|
|
path: &OsStr,
|
|
rights: host::__wasi_rights_t,
|
|
) -> Result<(), host::__wasi_errno_t> {
|
|
use nix::errno;
|
|
use nix::libc::{unlinkat, AT_REMOVEDIR};
|
|
|
|
let (dir, path) = match path_get(wasi_ctx, dirfd, 0, path, rights, 0, false) {
|
|
Ok((dir, path)) => (dir, path),
|
|
Err(e) => return Err(e),
|
|
};
|
|
let path_cstr = match std::ffi::CString::new(path.as_os_str().as_bytes()) {
|
|
Ok(path_cstr) => path_cstr,
|
|
Err(_) => return Err(host::__WASI_EINVAL),
|
|
};
|
|
// nix doesn't expose unlinkat() yet
|
|
match unsafe { unlinkat(dir, path_cstr.as_ptr(), AT_REMOVEDIR) } {
|
|
0 => Ok(()),
|
|
_ => Err(host_impl::errno_from_nix(errno::Errno::last())),
|
|
}
|
|
}
|