Make AsFile fallible

Return `EBADF` in `AsFile` in case a `Handle` cannot be made into
a `std::fs::File`.

Author: Jakub Konka

crates/wasi-common/src/sys/mod.rs

@@ -37,11 +37,11 @@ use stdio::Stdio;
 use sys_impl::get_file_type;
 
 pub(crate) trait AsFile {
-    fn as_file(&self) -> ManuallyDrop<File>;
+    fn as_file(&self) -> io::Result<ManuallyDrop<File>>;
 }
 
 impl AsFile for dyn Handle + 'static {
-    fn as_file(&self) -> ManuallyDrop<File> {
+    fn as_file(&self) -> io::Result<ManuallyDrop<File>> {
         if let Some(file) = self.as_any().downcast_ref::<OsFile>() {
             file.as_file()
         } else if let Some(dir) = self.as_any().downcast_ref::<OsDir>() {
@@ -51,7 +51,8 @@ impl AsFile for dyn Handle + 'static {
         } else if let Some(other) = self.as_any().downcast_ref::<OsOther>() {
             other.as_file()
         } else {
-            panic!("non-OS resource cannot be made into a File")
+            log::error!("tried to make std::fs::File from non-OS handle");
+            Err(io::Error::from_raw_os_error(libc::EBADF))
         }
     }
 }

crates/wasi-common/src/sys/osdir.rs

@@ -40,24 +40,24 @@ impl Handle for OsDir {
     }
     // FdOps
     fn fdstat_get(&self) -> Result<types::Fdflags> {
-        fd::fdstat_get(&self.as_file())
+        fd::fdstat_get(&*self.as_file()?)
     }
     fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
-        if let Some(new_file) = fd::fdstat_set_flags(&self.as_file(), fdflags)? {
+        if let Some(new_file) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
             self.handle.update_from(new_file);
         }
         Ok(())
     }
     fn filestat_get(&self) -> Result<types::Filestat> {
-        fd::filestat_get(&self.as_file())
+        fd::filestat_get(&*self.as_file()?)
     }
     fn filestat_set_times(
         &self,
         atim: types::Timestamp,
         mtim: types::Timestamp,
         fst_flags: types::Fstflags,
     ) -> Result<()> {
-        fd::filestat_set_times(&self.as_file(), atim, mtim, fst_flags)
+        fd::filestat_set_times(&*self.as_file()?, atim, mtim, fst_flags)
     }
     fn readdir<'a>(
         &'a self,

crates/wasi-common/src/sys/osfile.rs

@@ -57,7 +57,7 @@ impl Handle for OsFile {
         fd::advise(self, advice, offset, len)
     }
     fn allocate(&self, offset: types::Filesize, len: types::Filesize) -> Result<()> {
-        let fd = self.as_file();
+        let fd = self.as_file()?;
         let metadata = fd.metadata()?;
         let current_size = metadata.len();
         let wanted_size = offset.checked_add(len).ok_or(Errno::TooBig)?;
@@ -71,23 +71,23 @@ impl Handle for OsFile {
         Ok(())
     }
     fn datasync(&self) -> Result<()> {
-        self.as_file().sync_data()?;
+        self.as_file()?.sync_data()?;
         Ok(())
     }
     fn fdstat_get(&self) -> Result<types::Fdflags> {
-        fd::fdstat_get(&self.as_file())
+        fd::fdstat_get(&*self.as_file()?)
     }
     fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
-        if let Some(new_handle) = fd::fdstat_set_flags(&self.as_file(), fdflags)? {
+        if let Some(new_handle) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
             self.handle.update_from(new_handle);
         }
         Ok(())
     }
     fn filestat_get(&self) -> Result<types::Filestat> {
-        fd::filestat_get(&self.as_file())
+        fd::filestat_get(&*self.as_file()?)
     }
     fn filestat_set_size(&self, size: types::Filesize) -> Result<()> {
-        self.as_file().set_len(size)?;
+        self.as_file()?.set_len(size)?;
         Ok(())
     }
     fn filestat_set_times(
@@ -96,38 +96,38 @@ impl Handle for OsFile {
         mtim: types::Timestamp,
         fst_flags: types::Fstflags,
     ) -> Result<()> {
-        fd::filestat_set_times(&self.as_file(), atim, mtim, fst_flags)
+        fd::filestat_set_times(&*self.as_file()?, atim, mtim, fst_flags)
     }
     fn preadv(&self, buf: &mut [io::IoSliceMut], offset: u64) -> Result<usize> {
-        let mut fd: &File = &self.as_file();
+        let mut fd: &File = &*self.as_file()?;
         let cur_pos = fd.seek(SeekFrom::Current(0))?;
         fd.seek(SeekFrom::Start(offset))?;
         let nread = self.read_vectored(buf)?;
         fd.seek(SeekFrom::Start(cur_pos))?;
         Ok(nread)
     }
     fn pwritev(&self, buf: &[io::IoSlice], offset: u64) -> Result<usize> {
-        let mut fd: &File = &self.as_file();
+        let mut fd: &File = &*self.as_file()?;
         let cur_pos = fd.seek(SeekFrom::Current(0))?;
         fd.seek(SeekFrom::Start(offset))?;
         let nwritten = self.write_vectored(&buf)?;
         fd.seek(SeekFrom::Start(cur_pos))?;
         Ok(nwritten)
     }
     fn read_vectored(&self, iovs: &mut [io::IoSliceMut]) -> Result<usize> {
-        let nread = self.as_file().read_vectored(iovs)?;
+        let nread = self.as_file()?.read_vectored(iovs)?;
         Ok(nread)
     }
     fn seek(&self, offset: SeekFrom) -> Result<u64> {
-        let pos = self.as_file().seek(offset)?;
+        let pos = self.as_file()?.seek(offset)?;
         Ok(pos)
     }
     fn sync(&self) -> Result<()> {
-        self.as_file().sync_all()?;
+        self.as_file()?.sync_all()?;
         Ok(())
     }
     fn write_vectored(&self, iovs: &[io::IoSlice]) -> Result<usize> {
-        let nwritten = self.as_file().write_vectored(&iovs)?;
+        let nwritten = self.as_file()?.write_vectored(&iovs)?;
         Ok(nwritten)
     }
 }

crates/wasi-common/src/sys/osother.rs

@@ -66,20 +66,20 @@ impl Handle for OsOther {
     }
     // FdOps
     fn fdstat_get(&self) -> Result<types::Fdflags> {
-        fd::fdstat_get(&self.as_file())
+        fd::fdstat_get(&*self.as_file()?)
     }
     fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
-        if let Some(handle) = fd::fdstat_set_flags(&self.as_file(), fdflags)? {
+        if let Some(handle) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
             self.handle.update_from(handle);
         }
         Ok(())
     }
     fn read_vectored(&self, iovs: &mut [io::IoSliceMut]) -> Result<usize> {
-        let nread = self.as_file().read_vectored(iovs)?;
+        let nread = self.as_file()?.read_vectored(iovs)?;
         Ok(nread)
     }
     fn write_vectored(&self, iovs: &[io::IoSlice]) -> Result<usize> {
-        let mut fd: &File = &self.as_file();
+        let mut fd: &File = &*self.as_file()?;
         let nwritten = if self.is_tty() {
             SandboxedTTYWriter::new(&mut fd).write_vectored(&iovs)?
         } else {

crates/wasi-common/src/sys/stdio.rs

@@ -50,10 +50,10 @@ impl Handle for Stdio {
     }
     // FdOps
     fn fdstat_get(&self) -> Result<types::Fdflags> {
-        fd::fdstat_get(&self.as_file())
+        fd::fdstat_get(&*self.as_file()?)
     }
     fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
-        if let Some(_) = fd::fdstat_set_flags(&self.as_file(), fdflags)? {
+        if let Some(_) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
             // OK, this means we should somehow update the underlying os handle,
             // and we can't do that with `std::io::std{in, out, err}`, so we'll
             // panic for now.

crates/wasi-common/src/sys/unix/mod.rs

@@ -40,9 +40,9 @@ use yanix::file::{AtFlag, OFlag};
 pub(crate) use sys_impl::*;
 
 impl<T: AsRawFd> AsFile for T {
-    fn as_file(&self) -> ManuallyDrop<File> {
+    fn as_file(&self) -> io::Result<ManuallyDrop<File>> {
         let file = unsafe { File::from_raw_fd(self.as_raw_fd()) };
-        ManuallyDrop::new(file)
+        Ok(ManuallyDrop::new(file))
     }
 }
 

crates/wasi-common/src/sys/unix/oshandle.rs

@@ -11,7 +11,7 @@ pub(crate) struct OsHandle(Cell<RawFd>);
 impl OsHandle {
     /// Tries clone `self`.
     pub(crate) fn try_clone(&self) -> io::Result<Self> {
-        let fd = self.as_file().try_clone()?;
+        let fd = self.as_file()?.try_clone()?;
         Ok(Self(Cell::new(fd.into_raw_fd())))
     }
     /// Consumes `other` taking the ownership of the underlying

crates/wasi-common/src/sys/unix/poll.rs

@@ -1,6 +1,5 @@
 use crate::entry::EntryHandle;
 use crate::poll::{ClockEventData, FdEventData};
-use crate::sys::osfile::OsFile;
 use crate::sys::AsFile;
 use crate::wasi::{types, Errno, Result};
 use std::io;
@@ -17,7 +16,7 @@ pub(crate) fn oneoff(
         return Ok(());
     }
 
-    let mut poll_fds: Vec<_> = fd_events
+    let poll_fds: Result<Vec<_>> = fd_events
         .iter()
         .map(|event| {
             let mut flags = PollFlags::empty();
@@ -29,9 +28,11 @@ pub(crate) fn oneoff(
                 // events we filtered before. If we get something else here, the code has a serious bug.
                 _ => unreachable!(),
             };
-            unsafe { PollFd::new(event.handle.as_file().as_raw_fd(), flags) }
+            let file = event.handle.as_file()?;
+            unsafe { Ok(PollFd::new(file.as_raw_fd(), flags)) }
         })
         .collect();
+    let mut poll_fds = poll_fds?;
 
     let poll_timeout = timeout.map_or(-1, |timeout| {
         let delay = timeout.delay / 1_000_000; // poll syscall requires delay to expressed in milliseconds
@@ -77,15 +78,16 @@ fn handle_fd_event(
     events: &mut Vec<types::Event>,
 ) -> Result<()> {
     fn query_nbytes(handle: EntryHandle) -> Result<u64> {
-        if let Some(file) = handle.as_any().downcast_ref::<OsFile>() {
+        let file = handle.as_file()?;
+        if handle.get_file_type() == types::Filetype::RegularFile {
             // fionread may overflow for large files, so use another way for regular files.
             use yanix::file::tell;
-            let meta = file.as_file().metadata()?;
+            let meta = file.metadata()?;
             let len = meta.len();
             let host_offset = unsafe { tell(file.as_raw_fd())? };
             return Ok(len - host_offset);
         }
-        Ok(unsafe { fionread(handle.as_file().as_raw_fd())?.into() })
+        Ok(unsafe { fionread(file.as_raw_fd())?.into() })
     }
 
     for (fd_event, poll_fd) in ready_events {

crates/wasi-common/src/sys/windows/fd.rs

@@ -128,7 +128,7 @@ pub(crate) fn readdir(
     use winx::file::get_file_path;
 
     let cookie = cookie.try_into()?;
-    let path = get_file_path(&dirfd.as_file())?;
+    let path = get_file_path(&*dirfd.as_file()?)?;
     // std::fs::ReadDir doesn't return . and .., so we need to emulate it
     let path = Path::new(&path);
     // The directory /.. is the same as / on Unix (at least on ext4), so emulate this behavior too

crates/wasi-common/src/sys/windows/mod.rs

@@ -21,9 +21,9 @@ use winapi::shared::winerror;
 use winx::file::{CreationDisposition, Flags};
 
 impl<T: AsRawHandle> AsFile for T {
-    fn as_file(&self) -> ManuallyDrop<File> {
+    fn as_file(&self) -> io::Result<ManuallyDrop<File>> {
         let file = unsafe { File::from_raw_handle(self.as_raw_handle()) };
-        ManuallyDrop::new(file)
+        Ok(ManuallyDrop::new(file))
     }
 }
 
@@ -35,7 +35,7 @@ pub(crate) fn get_file_type(file: &File) -> io::Result<types::Filetype> {
         types::Filetype::CharacterDevice
     } else if file_type.is_disk() {
         // disk file: file, dir or disk device
-        let file = file.as_file();
+        let file = file.as_file()?;
         let meta = file.metadata()?;
         if meta.is_dir() {
             types::Filetype::Directory