It's wiggle time! (#1202)

* Use wiggle in place of wig in wasi-common

This is a rather massive commit that introduces `wiggle` into the
picture. We still use `wig`'s macro in `old` snapshot and to generate
`wasmtime-wasi` glue, but everything else is now autogenerated by `wiggle`.
In summary, thanks to `wiggle`, we no longer need to worry about
serialising and deserialising to and from the guest memory, and
all guest (WASI) types are now proper idiomatic Rust types.

While we're here, in preparation for the ephemeral snapshot, I went
ahead and reorganised the internal structure of the crate. Instead of
modules like `hostcalls_impl` or `hostcalls_impl::fs`, the structure
now resembles that in ephemeral with modules like `path`, `fd`, etc.
Now, I'm not requiring we leave it like this, but I reckon it looks
cleaner this way after all.

* Fix wig to use new first-class access to caller's mem

* Ignore warning in proc_exit for the moment

* Group unsafes together in args and environ calls

* Simplify pwrite; more unsafe blocks

* Simplify fd_read

* Bundle up unsafes in fd_readdir

* Simplify fd_write

* Add comment to path_readlink re zero-len buffers

* Simplify unsafes in random_get

* Hide GuestPtr<str> to &str in path::get

* Rewrite pread and pwrite using SeekFrom and read/write_vectored

I've left the implementation of VirtualFs pretty much untouched
as I don't feel that comfortable in changing the API too much.
Having said that, I reckon `pread` and `pwrite` could be refactored
out, and `preadv` and `pwritev` could be entirely rewritten using
`seek` and `read_vectored` and `write_vectored`.

* Add comment about VirtFs unsafety

* Fix all mentions of FdEntry to Entry

* Fix warnings on Win

* Add aux struct EntryTable responsible for Fds and Entries

This commit adds aux struct `EntryTable` which is private to `WasiCtx`
and is basically responsible for `Fd` alloc/dealloc as well as storing
matching `Entry`s. This struct is entirely private to `WasiCtx` and
as such as should remain transparent to `WasiCtx` users.

* Remove redundant check for empty buffer in path_readlink

* Preserve and rewind file cursor in pread/pwrite

* Use GuestPtr<[u8]>::copy_from_slice wherever copying bytes directly

* Use GuestPtr<[u8]>::copy_from_slice in fd_readdir

* Clean up unsafes around WasiCtx accessors

* Fix bugs in args_get and environ_get

* Fix conflicts after rebase

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

@@ -0,0 +1,138 @@
+use crate::entry::{Descriptor, OsHandleRef};
+use crate::wasi::{types, RightsExt};
+use std::fs::File;
+use std::io;
+use std::mem::ManuallyDrop;
+use std::ops::{Deref, DerefMut};
+use std::os::windows::prelude::{AsRawHandle, FromRawHandle, RawHandle};
+
+#[derive(Debug)]
+pub(crate) struct OsHandle(File);
+
+impl From<File> for OsHandle {
+    fn from(file: File) -> Self {
+        Self(file)
+    }
+}
+
+impl AsRawHandle for OsHandle {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.0.as_raw_handle()
+    }
+}
+
+impl Deref for OsHandle {
+    type Target = File;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for OsHandle {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl AsRawHandle for Descriptor {
+    fn as_raw_handle(&self) -> RawHandle {
+        match self {
+            Self::OsHandle(file) => file.as_raw_handle(),
+            Self::VirtualFile(_file) => {
+                unimplemented!("virtual as_raw_handle");
+            }
+            Self::Stdin => io::stdin().as_raw_handle(),
+            Self::Stdout => io::stdout().as_raw_handle(),
+            Self::Stderr => io::stderr().as_raw_handle(),
+        }
+    }
+}
+
+pub(crate) fn descriptor_as_oshandle<'lifetime>(
+    desc: &'lifetime Descriptor,
+) -> OsHandleRef<'lifetime> {
+    OsHandleRef::new(ManuallyDrop::new(OsHandle::from(unsafe {
+        File::from_raw_handle(desc.as_raw_handle())
+    })))
+}
+
+/// Returns the set of all possible rights that are both relevant for the file
+/// type and consistent with the open mode.
+///
+/// This function is unsafe because it operates on a raw file descriptor.
+pub(crate) unsafe fn determine_type_and_access_rights<Handle: AsRawHandle>(
+    handle: &Handle,
+) -> io::Result<(types::Filetype, types::Rights, types::Rights)> {
+    use winx::file::{query_access_information, AccessMode};
+
+    let (file_type, mut rights_base, rights_inheriting) = determine_type_rights(handle)?;
+
+    match file_type {
+        types::Filetype::Directory | types::Filetype::RegularFile => {
+            let mode = query_access_information(handle.as_raw_handle())?;
+            if mode.contains(AccessMode::FILE_GENERIC_READ) {
+                rights_base |= types::Rights::FD_READ;
+            }
+            if mode.contains(AccessMode::FILE_GENERIC_WRITE) {
+                rights_base |= types::Rights::FD_WRITE;
+            }
+        }
+        _ => {
+            // TODO: is there a way around this? On windows, it seems
+            // we cannot check access rights for anything but dirs and regular files
+        }
+    }
+
+    Ok((file_type, rights_base, rights_inheriting))
+}
+
+/// Returns the set of all possible rights that are relevant for file type.
+///
+/// This function is unsafe because it operates on a raw file descriptor.
+pub(crate) unsafe fn determine_type_rights<Handle: AsRawHandle>(
+    handle: &Handle,
+) -> io::Result<(types::Filetype, types::Rights, types::Rights)> {
+    let (file_type, rights_base, rights_inheriting) = {
+        let file_type = winx::file::get_file_type(handle.as_raw_handle())?;
+        if file_type.is_char() {
+            // character file: LPT device or console
+            // TODO: rule out LPT device
+            (
+                types::Filetype::CharacterDevice,
+                types::Rights::tty_base(),
+                types::Rights::tty_base(),
+            )
+        } else if file_type.is_disk() {
+            // disk file: file, dir or disk device
+            let file = std::mem::ManuallyDrop::new(File::from_raw_handle(handle.as_raw_handle()));
+            let meta = file.metadata()?;
+            if meta.is_dir() {
+                (
+                    types::Filetype::Directory,
+                    types::Rights::directory_base(),
+                    types::Rights::directory_inheriting(),
+                )
+            } else if meta.is_file() {
+                (
+                    types::Filetype::RegularFile,
+                    types::Rights::regular_file_base(),
+                    types::Rights::regular_file_inheriting(),
+                )
+            } else {
+                return Err(io::Error::from_raw_os_error(libc::EINVAL));
+            }
+        } else if file_type.is_pipe() {
+            // pipe object: socket, named pipe or anonymous pipe
+            // TODO: what about pipes, etc?
+            (
+                types::Filetype::SocketStream,
+                types::Rights::socket_base(),
+                types::Rights::socket_inheriting(),
+            )
+        } else {
+            return Err(io::Error::from_raw_os_error(libc::EINVAL));
+        }
+    };
+    Ok((file_type, rights_base, rights_inheriting))
+}