Add WASI support to runtime-c-api

lib/runtime-c-api/src/import.rs

@@ -51,6 +51,110 @@ pub unsafe extern "C" fn wasmer_import_object_new() -> *mut wasmer_import_object
     Box::into_raw(import_object) as *mut wasmer_import_object_t
 }
 
+#[cfg(feature = "wasi")]
+mod wasi {
+    use super::*;
+    use std::path::PathBuf;
+
+    /// Opens a directory that's visible to the WASI module as `alias` but
+    /// is backed by the host file at `host_file_path`
+    #[repr(C)]
+    pub struct wasmer_wasi_map_dir_entry_t {
+        /// What the WASI module will see in its virtual root
+        pub alias: wasmer_byte_array,
+        /// The backing file that the WASI module will interact with via the alias
+        pub host_file_path: wasmer_byte_array,
+    }
+
+    impl wasmer_wasi_map_dir_entry_t {
+        /// Converts the data into owned, Rust types
+        pub unsafe fn as_tuple(&self) -> Result<(String, PathBuf), std::str::Utf8Error> {
+            let alias = self.alias.as_str()?.to_owned();
+            let host_path = std::path::PathBuf::from(self.host_file_path.as_str()?);
+
+            Ok((alias, host_path))
+        }
+    }
+
+    /// Creates a WASI import object
+    #[no_mangle]
+    pub unsafe extern "C" fn wasmer_wasi_generate_import_object(
+        args: *const wasmer_byte_array,
+        args_len: c_uint,
+        envs: *const wasmer_byte_array,
+        envs_len: c_uint,
+        preopened_files: *const wasmer_byte_array,
+        preopened_files_len: c_uint,
+        mapped_dirs: *const wasmer_wasi_map_dir_entry_t,
+        mapped_dirs_len: c_uint,
+    ) -> *mut wasmer_import_object_t {
+        let arg_list = std::slice::from_raw_parts(args, args_len as usize);
+        let env_list = std::slice::from_raw_parts(envs, envs_len as usize);
+        let preopened_file_list =
+            std::slice::from_raw_parts(preopened_files, preopened_files_len as usize);
+        let mapped_dir_list = std::slice::from_raw_parts(mapped_dirs, mapped_dirs_len as usize);
+
+        wasmer_wasi_generate_import_object_inner(
+            arg_list,
+            env_list,
+            preopened_file_list,
+            mapped_dir_list,
+        )
+        .unwrap_or(std::ptr::null_mut())
+    }
+
+    /// Inner function that wraps error handling
+    fn wasmer_wasi_generate_import_object_inner(
+        arg_list: &[wasmer_byte_array],
+        env_list: &[wasmer_byte_array],
+        preopened_file_list: &[wasmer_byte_array],
+        mapped_dir_list: &[wasmer_wasi_map_dir_entry_t],
+    ) -> Result<*mut wasmer_import_object_t, std::str::Utf8Error> {
+        let arg_vec = arg_list.iter().map(|arg| unsafe { arg.as_vec() }).collect();
+        let env_vec = env_list
+            .iter()
+            .map(|env_var| unsafe { env_var.as_vec() })
+            .collect();
+        let po_file_vec = preopened_file_list
+            .iter()
+            .map(|po_file| Ok(unsafe { po_file.as_str()? }.to_owned()))
+            .collect::<Result<Vec<_>, _>>()?;
+        let mapped_dir_vec = mapped_dir_list
+            .iter()
+            .map(|entry| unsafe { entry.as_tuple() })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let import_object = Box::new(wasmer_wasi::generate_import_object(
+            arg_vec,
+            env_vec,
+            po_file_vec,
+            mapped_dir_vec,
+        ));
+        Ok(Box::into_raw(import_object) as *mut wasmer_import_object_t)
+    }
+
+    /// Convenience function that creates a WASI import object with no arguments,
+    /// environment variables, preopened files, or mapped directories.
+    ///
+    /// This function is the same as calling [`wasmer_wasi_generate_import_object`] with all
+    /// empty values.
+    #[no_mangle]
+    pub unsafe extern "C" fn wasmer_wasi_generate_default_import_object(
+    ) -> *mut wasmer_import_object_t {
+        let import_object = Box::new(wasmer_wasi::generate_import_object(
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+        ));
+
+        Box::into_raw(import_object) as *mut wasmer_import_object_t
+    }
+}
+
+#[cfg(feature = "wasi")]
+pub use self::wasi::*;
+
 /// Extends an existing import object with new imports
 #[allow(clippy::cast_ptr_alignment)]
 #[no_mangle]

lib/runtime-c-api/src/lib.rs

@@ -129,3 +129,23 @@ pub struct wasmer_byte_array {
     pub bytes: *const u8,
     pub bytes_len: u32,
 }
+
+impl wasmer_byte_array {
+    /// Get the data as a slice
+    pub unsafe fn as_slice<'a>(&self) -> &'a [u8] {
+        std::slice::from_raw_parts(self.bytes, self.bytes_len as usize)
+    }
+
+    /// Copy the data into an owned Vec
+    pub unsafe fn as_vec(&self) -> Vec<u8> {
+        let mut out = Vec::with_capacity(self.bytes_len as usize);
+        out.extend_from_slice(self.as_slice());
+
+        out
+    }
+
+    /// Read the data as a &str, returns an error if the string is not valid UTF8
+    pub unsafe fn as_str<'a>(&self) -> Result<&'a str, std::str::Utf8Error> {
+        std::str::from_utf8(self.as_slice())
+    }
+}