restructure cap-std impls into their own crate

crates/wasi-c2/cap-std-sync/src/dir.rs

@@ -0,0 +1,222 @@
+use crate::file::File;
+use cap_fs_ext::{DirExt, MetadataExt, SystemTimeSpec};
+use std::any::Any;
+use std::convert::TryInto;
+use std::path::{Path, PathBuf};
+use wasi_c2::{
+    dir::{ReaddirCursor, ReaddirEntity, WasiDir},
+    file::{FdFlags, FileCaps, FileType, Filestat, OFlags, WasiFile},
+    Error,
+};
+
+pub struct Dir(cap_std::fs::Dir);
+
+impl Dir {
+    pub fn from_cap_std(dir: cap_std::fs::Dir) -> Self {
+        Dir(dir)
+    }
+}
+
+impl WasiDir for Dir {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn open_file(
+        &self,
+        symlink_follow: bool,
+        path: &str,
+        oflags: OFlags,
+        caps: FileCaps,
+        fdflags: FdFlags,
+    ) -> Result<Box<dyn WasiFile>, Error> {
+        use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt};
+
+        let mut opts = cap_std::fs::OpenOptions::new();
+
+        if oflags.contains(OFlags::CREATE | OFlags::EXCLUSIVE) {
+            opts.create_new(true);
+            opts.write(true);
+        } else if oflags.contains(OFlags::CREATE) {
+            opts.create(true);
+            opts.write(true);
+        }
+        if oflags.contains(OFlags::TRUNCATE) {
+            opts.truncate(true);
+        }
+        if caps.contains(FileCaps::WRITE)
+            || caps.contains(FileCaps::DATASYNC)
+            || caps.contains(FileCaps::ALLOCATE)
+            || caps.contains(FileCaps::FILESTAT_SET_SIZE)
+        {
+            opts.write(true);
+        } else {
+            // If not opened write, open read. This way the OS lets us open the file.
+            // If FileCaps::READ is not set, read calls will be rejected at the
+            // get_cap check.
+            opts.read(true);
+        }
+        if caps.contains(FileCaps::READ) {
+            opts.read(true);
+        }
+        if fdflags.contains(FdFlags::APPEND) {
+            opts.append(true);
+        }
+        // XXX what about rest of fdflags - dsync, sync become oflags.
+        // what do we do with nonblock?
+        // what do we do with rsync?
+
+        if symlink_follow {
+            opts.follow(FollowSymlinks::Yes);
+        } else {
+            opts.follow(FollowSymlinks::No);
+        }
+
+        let f = self.0.open_with(Path::new(path), &opts)?;
+        Ok(Box::new(File::from_cap_std(f)))
+    }
+
+    fn open_dir(&self, symlink_follow: bool, path: &str) -> Result<Box<dyn WasiDir>, Error> {
+        let d = if symlink_follow {
+            self.0.open_dir(Path::new(path))?
+        } else {
+            self.0.open_dir_nofollow(Path::new(path))?
+        };
+        Ok(Box::new(Dir::from_cap_std(d)))
+    }
+
+    fn create_dir(&self, path: &str) -> Result<(), Error> {
+        self.0.create_dir(Path::new(path))?;
+        Ok(())
+    }
+    fn readdir(
+        &self,
+        cursor: ReaddirCursor,
+    ) -> Result<Box<dyn Iterator<Item = Result<(ReaddirEntity, String), Error>>>, Error> {
+        // cap_std's read_dir does not include . and .., we should prepend these.
+        // Why does the Ok contain a tuple? We can't construct a cap_std::fs::DirEntry, and we don't
+        // have enough info to make a ReaddirEntity yet.
+        let dir_meta = self.0.dir_metadata()?;
+        let rd = vec![
+            {
+                let name = ".".to_owned();
+                let namelen = name.as_bytes().len().try_into().expect("1 wont overflow");
+                Ok((FileType::Directory, dir_meta.ino(), namelen, name))
+            },
+            {
+                // XXX if parent dir is mounted it *might* be possible to give its inode, but we
+                // don't know that in this context.
+                let name = "..".to_owned();
+                let namelen = name.as_bytes().len().try_into().expect("2 wont overflow");
+                Ok((FileType::Directory, dir_meta.ino(), namelen, name))
+            },
+        ]
+        .into_iter()
+        .chain(
+            // Now process the `DirEntry`s:
+            self.0.entries()?.map(|entry| {
+                let entry = entry?;
+                let meta = entry.metadata()?;
+                let inode = meta.ino();
+                let filetype = FileType::from(&meta.file_type());
+                let name = entry.file_name().into_string().map_err(|_| Error::Ilseq)?;
+                let namelen = name.as_bytes().len().try_into()?;
+                Ok((filetype, inode, namelen, name))
+            }),
+        )
+        // Enumeration of the iterator makes it possible to define the ReaddirCursor
+        .enumerate()
+        .map(|(ix, r)| match r {
+            Ok((filetype, inode, namelen, name)) => Ok((
+                ReaddirEntity {
+                    next: ReaddirCursor::from(ix as u64 + 1),
+                    filetype,
+                    inode,
+                    namelen,
+                },
+                name,
+            )),
+            Err(e) => Err(e),
+        })
+        .skip(u64::from(cursor) as usize);
+
+        Ok(Box::new(rd))
+    }
+
+    fn symlink(&self, src_path: &str, dest_path: &str) -> Result<(), Error> {
+        self.0.symlink(src_path, dest_path)?;
+        Ok(())
+    }
+    fn remove_dir(&self, path: &str) -> Result<(), Error> {
+        self.0.remove_dir(Path::new(path))?;
+        Ok(())
+    }
+
+    fn unlink_file(&self, path: &str) -> Result<(), Error> {
+        self.0.remove_file(Path::new(path))?;
+        Ok(())
+    }
+    fn read_link(&self, path: &str) -> Result<PathBuf, Error> {
+        let link = self.0.read_link(Path::new(path))?;
+        Ok(link)
+    }
+    fn get_filestat(&self) -> Result<Filestat, Error> {
+        let meta = self.0.dir_metadata()?;
+        Ok(Filestat {
+            device_id: meta.dev(),
+            inode: meta.ino(),
+            filetype: FileType::from(&meta.file_type()),
+            nlink: meta.nlink(),
+            size: meta.len(),
+            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
+            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
+            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
+        })
+    }
+    fn get_path_filestat(&self, path: &str) -> Result<Filestat, Error> {
+        let meta = self.0.metadata(Path::new(path))?;
+        Ok(Filestat {
+            device_id: meta.dev(),
+            inode: meta.ino(),
+            filetype: FileType::from(&meta.file_type()),
+            nlink: meta.nlink(),
+            size: meta.len(),
+            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
+            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
+            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
+        })
+    }
+    fn rename(&self, src_path: &str, dest_dir: &dyn WasiDir, dest_path: &str) -> Result<(), Error> {
+        let dest_dir = dest_dir
+            .as_any()
+            .downcast_ref::<Self>()
+            .ok_or(Error::NotCapable)?;
+        self.0
+            .rename(Path::new(src_path), &dest_dir.0, Path::new(dest_path))?;
+        Ok(())
+    }
+    fn hard_link(
+        &self,
+        src_path: &str,
+        symlink_follow: bool,
+        target_dir: &dyn WasiDir,
+        target_path: &str,
+    ) -> Result<(), Error> {
+        let target_dir = target_dir
+            .as_any()
+            .downcast_ref::<Self>()
+            .ok_or(Error::NotCapable)?;
+        let src_path = Path::new(src_path);
+        let target_path = Path::new(target_path);
+        self.0.hard_link(src_path, &target_dir.0, target_path)?;
+        Ok(())
+    }
+    fn set_times(
+        &self,
+        path: &str,
+        atime: Option<SystemTimeSpec>,
+        mtime: Option<SystemTimeSpec>,
+    ) -> Result<(), Error> {
+        self.0.set_times(Path::new(path), atime, mtime)?;
+        Ok(())
+    }
+}

crates/wasi-c2/cap-std-sync/src/file.rs

@@ -0,0 +1,136 @@
+use cap_fs_ext::MetadataExt;
+use fs_set_times::SetTimes;
+use std::any::Any;
+use std::io;
+use system_interface::fs::{Advice, FileIoExt};
+use system_interface::io::ReadReady;
+use wasi_c2::{
+    file::{FdFlags, FileType, Filestat, WasiFile},
+    Error,
+};
+
+pub struct File(cap_std::fs::File);
+
+impl File {
+    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
+        File(file)
+    }
+}
+
+impl WasiFile for File {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn datasync(&self) -> Result<(), Error> {
+        self.0.sync_data()?;
+        Ok(())
+    }
+    fn sync(&self) -> Result<(), Error> {
+        self.0.sync_all()?;
+        Ok(())
+    }
+    fn get_filetype(&self) -> Result<FileType, Error> {
+        let meta = self.0.metadata()?;
+        Ok(FileType::from(&meta.file_type()))
+    }
+    fn get_fdflags(&self) -> Result<FdFlags, Error> {
+        // XXX get_fdflags is not implemented but lets lie rather than panic:
+        Ok(FdFlags::empty())
+    }
+    fn set_fdflags(&self, _fdflags: FdFlags) -> Result<(), Error> {
+        todo!("set_fdflags is not implemented")
+    }
+    fn get_filestat(&self) -> Result<Filestat, Error> {
+        let meta = self.0.metadata()?;
+        Ok(Filestat {
+            device_id: meta.dev(),
+            inode: meta.ino(),
+            filetype: FileType::from(&meta.file_type()),
+            nlink: meta.nlink(),
+            size: meta.len(),
+            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
+            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
+            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
+        })
+    }
+    fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
+        self.0.set_len(size)?;
+        Ok(())
+    }
+}
+
+impl FileIoExt for File {
+    fn advise(&self, offset: u64, len: u64, advice: Advice) -> io::Result<()> {
+        self.0.advise(offset, len, advice)
+    }
+    fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
+        self.0.allocate(offset, len)
+    }
+    fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+    fn read_exact(&self, buf: &mut [u8]) -> io::Result<()> {
+        self.0.read_exact(buf)
+    }
+    fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
+        self.0.read_at(buf, offset)
+    }
+    fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> io::Result<()> {
+        self.0.read_exact_at(buf, offset)
+    }
+    fn read_vectored(&self, bufs: &mut [io::IoSliceMut]) -> io::Result<usize> {
+        self.0.read_vectored(bufs)
+    }
+    fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        self.0.read_to_end(buf)
+    }
+    fn read_to_string(&self, buf: &mut String) -> io::Result<usize> {
+        self.0.read_to_string(buf)
+    }
+    fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
+    }
+    fn write_all(&self, buf: &[u8]) -> io::Result<()> {
+        self.0.write_all(buf)
+    }
+    fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
+        self.0.write_at(buf, offset)
+    }
+    fn write_all_at(&self, buf: &[u8], offset: u64) -> io::Result<()> {
+        self.0.write_all_at(buf, offset)
+    }
+    fn write_vectored(&self, bufs: &[io::IoSlice]) -> io::Result<usize> {
+        self.0.write_vectored(bufs)
+    }
+    fn write_fmt(&self, fmt: std::fmt::Arguments) -> io::Result<()> {
+        self.0.write_fmt(fmt)
+    }
+    fn flush(&self) -> io::Result<()> {
+        self.0.flush()
+    }
+    fn seek(&self, pos: std::io::SeekFrom) -> io::Result<u64> {
+        self.0.seek(pos)
+    }
+    fn stream_position(&self) -> io::Result<u64> {
+        self.0.stream_position()
+    }
+    fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.peek(buf)
+    }
+}
+
+impl SetTimes for File {
+    fn set_times(
+        &self,
+        atime: Option<fs_set_times::SystemTimeSpec>,
+        mtime: Option<fs_set_times::SystemTimeSpec>,
+    ) -> io::Result<()> {
+        self.0.set_times(atime, mtime)
+    }
+}
+
+impl ReadReady for File {
+    fn num_ready_bytes(&self) -> io::Result<u64> {
+        self.0.num_ready_bytes()
+    }
+}

crates/wasi-c2/cap-std-sync/src/lib.rs

@@ -0,0 +1,68 @@
+pub mod dir;
+pub mod file;
+pub mod sched;
+pub mod stdio;
+
+use cap_rand::RngCore;
+use std::cell::RefCell;
+use std::path::Path;
+use std::rc::Rc;
+use wasi_c2::{clocks::WasiClocks, table::Table, Error, WasiCtx, WasiFile};
+
+pub struct WasiCtxBuilder(wasi_c2::WasiCtxBuilder);
+
+impl WasiCtxBuilder {
+    pub fn new() -> Self {
+        WasiCtxBuilder(WasiCtx::builder(
+            random(),
+            clocks(),
+            Box::new(sched::SyncSched),
+            Rc::new(RefCell::new(Table::new())),
+        ))
+    }
+    pub fn arg(self, arg: &str) -> Result<Self, wasi_c2::StringArrayError> {
+        let s = self.0.arg(arg)?;
+        Ok(WasiCtxBuilder(s))
+    }
+    pub fn stdin(self, f: Box<dyn WasiFile>) -> Self {
+        WasiCtxBuilder(self.0.stdin(f))
+    }
+    pub fn stdout(self, f: Box<dyn WasiFile>) -> Self {
+        WasiCtxBuilder(self.0.stdout(f))
+    }
+    pub fn stderr(self, f: Box<dyn WasiFile>) -> Self {
+        WasiCtxBuilder(self.0.stderr(f))
+    }
+    pub fn inherit_stdio(self) -> Self {
+        self.stdin(Box::new(crate::stdio::stdin()))
+            .stdout(Box::new(crate::stdio::stdout()))
+            .stderr(Box::new(crate::stdio::stderr()))
+    }
+    pub fn preopened_dir(
+        self,
+        dir: cap_std::fs::Dir,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, Error> {
+        let dir = Box::new(crate::dir::Dir::from_cap_std(dir));
+        Ok(WasiCtxBuilder(self.0.preopened_dir(dir, path)?))
+    }
+    pub fn build(self) -> Result<WasiCtx, Error> {
+        self.0.build()
+    }
+}
+
+pub fn clocks() -> WasiClocks {
+    let system = Box::new(unsafe { cap_std::time::SystemClock::new() });
+    let monotonic = unsafe { cap_std::time::MonotonicClock::new() };
+    let creation_time = monotonic.now();
+    let monotonic = Box::new(monotonic);
+    WasiClocks {
+        system,
+        monotonic,
+        creation_time,
+    }
+}
+
+pub fn random() -> RefCell<Box<dyn RngCore>> {
+    RefCell::new(Box::new(unsafe { cap_rand::rngs::OsRng::default() }))
+}

crates/wasi-c2/cap-std-sync/src/sched.rs

@@ -0,0 +1,131 @@
+#[cfg(unix)]
+pub use unix::*;
+
+#[cfg(unix)]
+mod unix {
+    use cap_std::time::Duration;
+    use std::convert::TryInto;
+    use std::ops::Deref;
+    use std::os::unix::io::{AsRawFd, RawFd};
+    use wasi_c2::file::WasiFile;
+    use wasi_c2::sched::subscription::{RwEventFlags, Subscription};
+    use wasi_c2::sched::{Poll, WasiSched};
+    use wasi_c2::Error;
+    use yanix::poll::{PollFd, PollFlags};
+
+    pub struct SyncSched;
+
+    impl WasiSched for SyncSched {
+        fn poll_oneoff<'a>(&self, poll: &'a Poll<'a>) -> Result<(), Error> {
+            if poll.is_empty() {
+                return Ok(());
+            }
+            let mut pollfds = Vec::new();
+            let timeout = poll.earliest_clock_deadline();
+            for s in poll.rw_subscriptions() {
+                match s {
+                    Subscription::Read(f) => {
+                        let raw_fd = wasi_file_raw_fd(f.file.deref()).ok_or(Error::Inval)?;
+                        pollfds.push(unsafe { PollFd::new(raw_fd, PollFlags::POLLIN) });
+                    }
+
+                    Subscription::Write(f) => {
+                        let raw_fd = wasi_file_raw_fd(f.file.deref()).ok_or(Error::Inval)?;
+                        pollfds.push(unsafe { PollFd::new(raw_fd, PollFlags::POLLOUT) });
+                    }
+                    Subscription::MonotonicClock { .. } => unreachable!(),
+                }
+            }
+
+            let ready = loop {
+                let poll_timeout = if let Some(t) = timeout {
+                    let duration = t
+                        .deadline
+                        .checked_duration_since(t.clock.now(t.precision))
+                        .unwrap_or(Duration::from_secs(0));
+                    (duration.as_millis() + 1) // XXX try always rounding up?
+                        .try_into()
+                        .map_err(|_| Error::Overflow)?
+                } else {
+                    libc::c_int::max_value()
+                };
+                tracing::debug!(
+                    poll_timeout = tracing::field::debug(poll_timeout),
+                    poll_fds = tracing::field::debug(&pollfds),
+                    "poll"
+                );
+                match yanix::poll::poll(&mut pollfds, poll_timeout) {
+                    Ok(ready) => break ready,
+                    Err(_) => {
+                        let last_err = std::io::Error::last_os_error();
+                        if last_err.raw_os_error().unwrap() == libc::EINTR {
+                            continue;
+                        } else {
+                            return Err(last_err.into());
+                        }
+                    }
+                }
+            };
+            if ready > 0 {
+                for (rwsub, pollfd) in poll.rw_subscriptions().zip(pollfds.into_iter()) {
+                    if let Some(revents) = pollfd.revents() {
+                        let (nbytes, rwsub) = match rwsub {
+                            Subscription::Read(sub) => {
+                                let ready = sub.file.num_ready_bytes()?;
+                                (std::cmp::max(ready, 1), sub)
+                            }
+                            Subscription::Write(sub) => (0, sub),
+                            _ => unreachable!(),
+                        };
+                        if revents.contains(PollFlags::POLLNVAL) {
+                            rwsub.error(Error::Badf);
+                        } else if revents.contains(PollFlags::POLLERR) {
+                            rwsub.error(Error::Io);
+                        } else if revents.contains(PollFlags::POLLHUP) {
+                            rwsub.complete(nbytes, RwEventFlags::HANGUP);
+                        } else {
+                            rwsub.complete(nbytes, RwEventFlags::empty());
+                        };
+                    }
+                }
+            } else {
+                timeout
+                    .expect("timed out")
+                    .result()
+                    .expect("timer deadline is past")
+                    .unwrap()
+            }
+            Ok(())
+        }
+        fn sched_yield(&self) -> Result<(), Error> {
+            std::thread::yield_now();
+            Ok(())
+        }
+    }
+
+    fn wasi_file_raw_fd(f: &dyn WasiFile) -> Option<RawFd> {
+        let a = f.as_any();
+        if a.is::<crate::file::File>() {
+            /* DISABLED UNTIL AsRawFd can be implemented properly
+                Some(a.downcast_ref::<crate::file::File>().unwrap().as_raw_fd())
+            } else if a.is::<crate::stdio::Stdin>() {
+                Some(a.downcast_ref::<crate::stdio::Stdin>().unwrap().as_raw_fd())
+            } else if a.is::<crate::stdio::Stdout>() {
+                Some(
+                    a.downcast_ref::<crate::stdio::Stdout>()
+                        .unwrap()
+                        .as_raw_fd(),
+                )
+            } else if a.is::<crate::stdio::Stderr>() {
+                Some(
+                    a.downcast_ref::<crate::stdio::Stderr>()
+                        .unwrap()
+                        .as_raw_fd(),
+                )
+                */
+            None
+        } else {
+            None
+        }
+    }
+}

crates/wasi-c2/cap-std-sync/src/stdio.rs

@@ -0,0 +1,63 @@
+use wasi_c2::pipe::{ReadPipe, WritePipe};
+
+pub type Stdin = ReadPipe<std::io::Stdin>;
+
+pub fn stdin() -> Stdin {
+    ReadPipe::new(std::io::stdin())
+}
+
+pub type Stdout = WritePipe<std::io::Stdout>;
+
+pub fn stdout() -> Stdout {
+    WritePipe::new(std::io::stdout())
+}
+
+pub type Stderr = WritePipe<std::io::Stderr>;
+
+pub fn stderr() -> Stderr {
+    WritePipe::new(std::io::stderr())
+}
+
+/*
+#[cfg(windows)]
+mod windows {
+    use super::*;
+    use std::os::windows::io::{AsRawHandle, RawHandle};
+    impl AsRawHandle for Stdin {
+        fn as_raw_handle(&self) -> RawHandle {
+            self.borrow().as_raw_handle()
+        }
+    }
+    impl AsRawHandle for Stdout {
+        fn as_raw_handle(&self) -> RawHandle {
+            self.borrow().as_raw_handle()
+        }
+    }
+    impl AsRawHandle for Stderr {
+        fn as_raw_handle(&self) -> RawHandle {
+            self.borrow().as_raw_handle()
+        }
+    }
+}
+
+#[cfg(unix)]
+mod unix {
+    use super::*;
+    use std::os::unix::io::{AsRawFd, RawFd};
+    impl AsRawFd for Stdin {
+        fn as_raw_fd(&self) -> RawFd {
+            self.borrow().as_raw_fd()
+        }
+    }
+    impl AsRawFd for Stdout {
+        fn as_raw_fd(&self) -> RawFd {
+            self.borrow().as_raw_fd()
+        }
+    }
+    impl AsRawFd for Stderr {
+        fn as_raw_fd(&self) -> RawFd {
+            self.borrow().as_raw_fd()
+        }
+    }
+}
+*/