inline only what we need of cap-std/system-interface traits

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

@@ -1,4 +1,4 @@
-use crate::file::File;
+use crate::file::{filetype_from, File};
 use cap_fs_ext::{DirExt, MetadataExt, SystemTimeSpec};
 use std::any::Any;
 use std::convert::TryInto;
@@ -117,7 +117,7 @@ impl WasiDir for Dir {
                 let entry = entry?;
                 let meta = entry.metadata()?;
                 let inode = meta.ino();
-                let filetype = FileType::from(&meta.file_type());
+                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))
@@ -164,7 +164,7 @@ impl WasiDir for Dir {
         Ok(Filestat {
             device_id: meta.dev(),
             inode: meta.ino(),
-            filetype: FileType::from(&meta.file_type()),
+            filetype: filetype_from(&meta.file_type()),
             nlink: meta.nlink(),
             size: meta.len(),
             atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
@@ -177,7 +177,7 @@ impl WasiDir for Dir {
         Ok(Filestat {
             device_id: meta.dev(),
             inode: meta.ino(),
-            filetype: FileType::from(&meta.file_type()),
+            filetype: filetype_from(&meta.file_type()),
             nlink: meta.nlink(),
             size: meta.len(),
             atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),

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

@@ -1,6 +1,7 @@
 use cap_fs_ext::MetadataExt;
-use fs_set_times::SetTimes;
+use fs_set_times::{SetTimes, SystemTimeSpec};
 use std::any::Any;
+use std::convert::TryInto;
 use std::io;
 use system_interface::fs::{Advice, FileIoExt};
 use system_interface::io::ReadReady;
@@ -31,7 +32,7 @@ impl WasiFile for File {
     }
     fn get_filetype(&self) -> Result<FileType, Error> {
         let meta = self.0.metadata()?;
-        Ok(FileType::from(&meta.file_type()))
+        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:
@@ -45,7 +46,7 @@ impl WasiFile for File {
         Ok(Filestat {
             device_id: meta.dev(),
             inode: meta.ino(),
-            filetype: FileType::from(&meta.file_type()),
+            filetype: filetype_from(&meta.file_type()),
             nlink: meta.nlink(),
             size: meta.len(),
             atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
@@ -57,80 +58,90 @@ impl WasiFile for File {
         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 advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
+        self.0.advise(offset, len, advice)?;
+        Ok(())
     }
-    fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
-        self.0.allocate(offset, len)
+    fn allocate(&self, offset: u64, len: u64) -> Result<(), Error> {
+        self.0.allocate(offset, len)?;
+        Ok(())
     }
-    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)
+        atime: Option<SystemTimeSpec>,
+        mtime: Option<SystemTimeSpec>,
+    ) -> Result<(), Error> {
+        self.0.set_times(atime, mtime)?;
+        Ok(())
+    }
+    fn read_vectored(&self, bufs: &mut [io::IoSliceMut]) -> Result<u64, Error> {
+        let n = self.0.read_vectored(bufs)?;
+        Ok(n.try_into().map_err(|_| Error::Overflow)?)
+    }
+    fn read_vectored_at(&self, bufs: &mut [io::IoSliceMut], offset: u64) -> Result<u64, Error> {
+        let n = self.0.read_vectored_at(bufs, offset)?;
+        Ok(n.try_into().map_err(|_| Error::Overflow)?)
+    }
+    fn write_vectored(&self, bufs: &[io::IoSlice]) -> Result<u64, Error> {
+        let n = self.0.write_vectored(bufs)?;
+        Ok(n.try_into().map_err(|_| Error::Overflow)?)
+    }
+    fn write_vectored_at(&self, bufs: &[io::IoSlice], offset: u64) -> Result<u64, Error> {
+        let n = self.0.write_vectored_at(bufs, offset)?;
+        Ok(n.try_into().map_err(|_| Error::Overflow)?)
+    }
+    fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
+        Ok(self.0.seek(pos)?)
+    }
+    fn stream_position(&self) -> Result<u64, Error> {
+        Ok(self.0.stream_position()?)
+    }
+    fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
+        let n = self.0.peek(buf)?;
+        Ok(n.try_into().map_err(|_| Error::Overflow)?)
+    }
+    fn num_ready_bytes(&self) -> Result<u64, Error> {
+        Ok(self.0.num_ready_bytes()?)
     }
 }
 
-impl ReadReady for File {
-    fn num_ready_bytes(&self) -> io::Result<u64> {
-        self.0.num_ready_bytes()
+pub fn filetype_from(ft: &cap_std::fs::FileType) -> FileType {
+    use cap_fs_ext::FileTypeExt;
+    if ft.is_dir() {
+        FileType::Directory
+    } else if ft.is_symlink() {
+        FileType::SymbolicLink
+    } else if ft.is_socket() {
+        if ft.is_block_device() {
+            FileType::SocketDgram
+        } else {
+            FileType::SocketStream
+        }
+    } else if ft.is_block_device() {
+        FileType::BlockDevice
+    } else if ft.is_char_device() {
+        FileType::CharacterDevice
+    } else if ft.is_file() {
+        FileType::RegularFile
+    } else {
+        FileType::Unknown
+    }
+}
+
+#[cfg(windows)]
+use std::os::windows::io::{AsRawHandle, RawHandle};
+#[cfg(windows)]
+impl AsRawHandle for File {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.0.as_raw_handle()
+    }
+}
+
+#[cfg(unix)]
+use std::os::unix::io::{AsRawFd, RawFd};
+#[cfg(unix)]
+impl AsRawFd for File {
+    fn as_raw_fd(&self) -> RawFd {
+        self.0.as_raw_fd()
     }
 }

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

@@ -106,24 +106,21 @@ mod unix {
     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
+            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(),
+            )
         } else {
             None
         }

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

@@ -1,63 +1,156 @@
-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()
-        }
-    }
-}
+use fs_set_times::SetTimes;
+use std::any::Any;
+use std::convert::TryInto;
+use std::io;
+use system_interface::{
+    fs::{Advice, FileIoExt},
+    io::ReadReady,
+};
+use wasi_c2::{
+    file::{FdFlags, FileType, Filestat, WasiFile},
+    Error,
+};
 
 #[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()
+use std::os::unix::io::{AsRawFd, RawFd};
+#[cfg(windows)]
+use std::os::windows::io::{AsRawHandle, RawHandle};
+
+macro_rules! wasi_file_impl {
+    ($ty:ty, $additional:item) => {
+        impl WasiFile for $ty {
+            fn as_any(&self) -> &dyn Any {
+                self
+            }
+            fn datasync(&self) -> Result<(), Error> {
+                Ok(())
+            }
+            fn sync(&self) -> Result<(), Error> {
+                Ok(())
+            }
+            fn get_filetype(&self) -> Result<FileType, Error> {
+                Ok(FileType::CharacterDevice) // XXX wrong
+            }
+            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> {
+                // XXX
+                Err(Error::Perm)
+            }
+            fn get_filestat(&self) -> Result<Filestat, Error> {
+                // XXX can unsafe-io give a way to get metadata?
+                Ok(Filestat {
+                    device_id: 0,
+                    inode: 0,
+                    filetype: self.get_filetype()?,
+                    nlink: 0,
+                    size: 0,
+                    atim: None,
+                    mtim: None,
+                    ctim: None,
+                })
+            }
+            fn set_filestat_size(&self, _size: u64) -> Result<(), Error> {
+                // XXX is this the right error?
+                Err(Error::Perm)
+            }
+            fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
+                self.0.advise(offset, len, advice)?;
+                Ok(())
+            }
+            fn allocate(&self, offset: u64, len: u64) -> Result<(), Error> {
+                self.0.allocate(offset, len)?;
+                Ok(())
+            }
+            fn read_vectored(&self, bufs: &mut [io::IoSliceMut]) -> Result<u64, Error> {
+                let n = self.0.read_vectored(bufs)?;
+                Ok(n.try_into().map_err(|_| Error::Overflow)?)
+            }
+            fn read_vectored_at(
+                &self,
+                bufs: &mut [io::IoSliceMut],
+                offset: u64,
+            ) -> Result<u64, Error> {
+                let n = self.0.read_vectored_at(bufs, offset)?;
+                Ok(n.try_into().map_err(|_| Error::Overflow)?)
+            }
+            fn write_vectored(&self, bufs: &[io::IoSlice]) -> Result<u64, Error> {
+                let n = self.0.write_vectored(bufs)?;
+                Ok(n.try_into().map_err(|_| Error::Overflow)?)
+            }
+            fn write_vectored_at(&self, bufs: &[io::IoSlice], offset: u64) -> Result<u64, Error> {
+                let n = self.0.write_vectored_at(bufs, offset)?;
+                Ok(n.try_into().map_err(|_| Error::Overflow)?)
+            }
+            fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
+                Ok(self.0.seek(pos)?)
+            }
+            fn stream_position(&self) -> Result<u64, Error> {
+                Ok(self.0.stream_position()?)
+            }
+            fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
+                let n = self.0.peek(buf)?;
+                Ok(n.try_into().map_err(|_| Error::Overflow)?)
+            }
+            fn set_times(
+                &self,
+                atime: Option<fs_set_times::SystemTimeSpec>,
+                mtime: Option<fs_set_times::SystemTimeSpec>,
+            ) -> Result<(), Error> {
+                self.0.set_times(atime, mtime)?;
+                Ok(())
+            }
+            $additional
         }
-    }
-    impl AsRawFd for Stdout {
-        fn as_raw_fd(&self) -> RawFd {
-            self.borrow().as_raw_fd()
+        #[cfg(windows)]
+        impl AsRawHandle for $ty {
+            fn as_raw_handle(&self) -> RawHandle {
+                self.0.as_raw_handle()
+            }
         }
-    }
-    impl AsRawFd for Stderr {
-        fn as_raw_fd(&self) -> RawFd {
-            self.borrow().as_raw_fd()
+        #[cfg(unix)]
+        impl AsRawFd for $ty {
+            fn as_raw_fd(&self) -> RawFd {
+                self.0.as_raw_fd()
+            }
         }
-    }
+    };
 }
-*/
+
+pub struct Stdin(std::io::Stdin);
+
+pub fn stdin() -> Stdin {
+    Stdin(std::io::stdin())
+}
+wasi_file_impl!(
+    Stdin,
+    fn num_ready_bytes(&self) -> Result<u64, Error> {
+        Ok(self.0.num_ready_bytes()?)
+    }
+);
+
+pub struct Stdout(std::io::Stdout);
+
+pub fn stdout() -> Stdout {
+    Stdout(std::io::stdout())
+}
+wasi_file_impl!(
+    Stdout,
+    fn num_ready_bytes(&self) -> Result<u64, Error> {
+        Ok(0)
+    }
+);
+
+pub struct Stderr(std::io::Stderr);
+
+pub fn stderr() -> Stderr {
+    Stderr(std::io::stderr())
+}
+wasi_file_impl!(
+    Stderr,
+    fn num_ready_bytes(&self) -> Result<u64, Error> {
+        Ok(0)
+    }
+);