A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
use crate::{
WasmtimeStoreContextMut, handle_result, wasm_name_t, wasmtime_component_resource_type_t,
wasmtime_error_t,
};
use std::mem;
use std::mem::{ManuallyDrop, MaybeUninit};
use std::ptr;
use std::slice;
use wasmtime::component::{ResourceAny, ResourceDynamic, Val};
use wasmtime::{Error, Result, format_err};
crate::declare_vecs! {
(
name: wasmtime_component_vallist_t,
ty: wasmtime_component_val_t,
new: wasmtime_component_vallist_new,
empty: wasmtime_component_vallist_new_empty,
uninit: wasmtime_component_vallist_new_uninit,
copy: wasmtime_component_vallist_copy,
delete: wasmtime_component_vallist_delete,
)
(
name: wasmtime_component_valrecord_t,
ty: wasmtime_component_valrecord_entry_t,
new: wasmtime_component_valrecord_new,
empty: wasmtime_component_valrecord_new_empty,
uninit: wasmtime_component_valrecord_new_uninit,
copy: wasmtime_component_valrecord_copy,
delete: wasmtime_component_valrecord_delete,
)
(
name: wasmtime_component_valtuple_t,
ty: wasmtime_component_val_t,
new: wasmtime_component_valtuple_new,
empty: wasmtime_component_valtuple_new_empty,
uninit: wasmtime_component_valtuple_new_uninit,
copy: wasmtime_component_valtuple_copy,
delete: wasmtime_component_valtuple_delete,
)
(
name: wasmtime_component_valflags_t,
ty: wasm_name_t,
new: wasmtime_component_valflags_new,
empty: wasmtime_component_valflags_new_empty,
uninit: wasmtime_component_valflags_new_uninit,
copy: wasmtime_component_valflags_copy,
delete: wasmtime_component_valflags_delete,
)
(
name: wasmtime_component_valmap_t,
ty: wasmtime_component_valmap_entry_t,
new: wasmtime_component_valmap_new,
empty: wasmtime_component_valmap_new_empty,
uninit: wasmtime_component_valmap_new_uninit,
copy: wasmtime_component_valmap_copy,
delete: wasmtime_component_valmap_delete,
)
}
impl TryFrom<&wasmtime_component_vallist_t> for Vec<Val> {
type Error = Error;
fn try_from(value: &wasmtime_component_vallist_t) -> Result<Self> {
value.as_slice().iter().map(Val::try_from).collect()
}
}
impl From<&[Val]> for wasmtime_component_vallist_t {
fn from(value: &[Val]) -> Self {
value
.iter()
.map(wasmtime_component_val_t::from)
.collect::<Vec<_>>()
.into()
}
}
impl TryFrom<&wasmtime_component_valmap_t> for Vec<(Val, Val)> {
type Error = Error;
fn try_from(value: &wasmtime_component_valmap_t) -> Result<Self> {
value
.as_slice()
.iter()
.map(|entry| Ok((Val::try_from(&entry.key)?, Val::try_from(&entry.value)?)))
.collect()
}
}
impl From<&[(Val, Val)]> for wasmtime_component_valmap_t {
fn from(value: &[(Val, Val)]) -> Self {
value
.iter()
.map(|(k, v)| wasmtime_component_valmap_entry_t {
key: wasmtime_component_val_t::from(k),
value: wasmtime_component_val_t::from(v),
})
.collect::<Vec<_>>()
.into()
}
}
#[derive(Clone)]
#[repr(C)]
pub struct wasmtime_component_valrecord_entry_t {
name: wasm_name_t,
val: wasmtime_component_val_t,
}
#[derive(Clone, Default)]
#[repr(C)]
pub struct wasmtime_component_valmap_entry_t {
key: wasmtime_component_val_t,
value: wasmtime_component_val_t,
}
impl Default for wasmtime_component_valrecord_entry_t {
fn default() -> Self {
Self {
name: wasm_name_t::from_name(String::new()),
val: Default::default(),
}
}
}
impl TryFrom<&wasmtime_component_valrecord_entry_t> for (String, Val) {
type Error = Error;
fn try_from(value: &wasmtime_component_valrecord_entry_t) -> Result<Self> {
Ok((name_to_string(&value.name)?, Val::try_from(&value.val)?))
}
}
impl From<&(String, Val)> for wasmtime_component_valrecord_entry_t {
fn from((name, val): &(String, Val)) -> Self {
Self {
name: wasm_name_t::from_name(name.clone()),
val: wasmtime_component_val_t::from(val),
}
}
}
impl TryFrom<&wasmtime_component_valrecord_t> for Vec<(String, Val)> {
type Error = Error;
fn try_from(value: &wasmtime_component_valrecord_t) -> Result<Self> {
value.as_slice().iter().map(TryInto::try_into).collect()
}
}
impl From<&[(String, Val)]> for wasmtime_component_valrecord_t {
fn from(value: &[(String, Val)]) -> Self {
value
.iter()
.map(wasmtime_component_valrecord_entry_t::from)
.collect::<Vec<_>>()
.into()
}
}
impl TryFrom<&wasmtime_component_valtuple_t> for Vec<Val> {
type Error = Error;
fn try_from(value: &wasmtime_component_valtuple_t) -> Result<Self> {
value.as_slice().iter().map(Val::try_from).collect()
}
}
impl From<&[Val]> for wasmtime_component_valtuple_t {
fn from(value: &[Val]) -> Self {
value
.iter()
.map(wasmtime_component_val_t::from)
.collect::<Vec<_>>()
.into()
}
}
impl TryFrom<&wasmtime_component_valflags_t> for Vec<String> {
type Error = Error;
fn try_from(value: &wasmtime_component_valflags_t) -> Result<Self> {
value.as_slice().iter().map(name_to_string).collect()
}
}
impl From<&[String]> for wasmtime_component_valflags_t {
fn from(value: &[String]) -> Self {
value
.iter()
.map(|x| wasm_name_t::from_name(x.clone()))
.collect::<Vec<_>>()
.into()
}
}
#[repr(C)]
#[derive(Clone)]
pub struct wasmtime_component_valvariant_t {
discriminant: wasm_name_t,
val: Option<Box<wasmtime_component_val_t>>,
}
impl From<(&String, &Option<Box<Val>>)> for wasmtime_component_valvariant_t {
fn from((discriminant, value): (&String, &Option<Box<Val>>)) -> Self {
Self {
discriminant: wasm_name_t::from_name(discriminant.clone()),
val: value
.as_ref()
.map(|x| Box::new(wasmtime_component_val_t::from(x.as_ref()))),
}
}
}
impl TryFrom<&wasmtime_component_valvariant_t> for (String, Option<Box<Val>>) {
type Error = Error;
fn try_from(value: &wasmtime_component_valvariant_t) -> Result<Self> {
Ok((
name_to_string(&value.discriminant)?,
option_box_try_from(&value.val)?,
))
}
}
#[repr(C)]
#[derive(Clone)]
pub struct wasmtime_component_valresult_t {
is_ok: bool,
val: Option<Box<wasmtime_component_val_t>>,
}
impl TryFrom<&wasmtime_component_valresult_t>
for core::result::Result<Option<Box<Val>>, Option<Box<Val>>>
{
type Error = Error;
fn try_from(value: &wasmtime_component_valresult_t) -> Result<Self> {
let val = option_box_try_from(&value.val)?;
Ok(match value.is_ok {
true => Ok(val),
false => Err(val),
})
}
}
impl From<&core::result::Result<Option<Box<Val>>, Option<Box<Val>>>>
for wasmtime_component_valresult_t
{
fn from(value: &core::result::Result<Option<Box<Val>>, Option<Box<Val>>>) -> Self {
let (Ok(x) | Err(x)) = value;
Self {
is_ok: value.is_ok(),
val: x
.as_ref()
.map(|x| Box::new(wasmtime_component_val_t::from(x.as_ref()))),
}
}
}
#[repr(C, u8)]
#[derive(Clone)]
pub enum wasmtime_component_val_t {
Bool(bool),
S8(i8),
U8(u8),
S16(i16),
U16(u16),
S32(i32),
U32(u32),
S64(i64),
U64(u64),
F32(f32),
F64(f64),
Char(u32),
String(wasm_name_t),
List(wasmtime_component_vallist_t),
Record(wasmtime_component_valrecord_t),
Tuple(wasmtime_component_valtuple_t),
Variant(wasmtime_component_valvariant_t),
Enum(wasm_name_t),
Option(Option<Box<Self>>),
Result(wasmtime_component_valresult_t),
Flags(wasmtime_component_valflags_t),
Resource(Box<wasmtime_component_resource_any_t>),
Map(wasmtime_component_valmap_t),
FixedLengthList(wasmtime_component_vallist_t),
}
// Safety: the C API async contract (documented in async.h) guarantees that
// values are not concurrently accessed while a future is alive.
unsafe impl Send for wasmtime_component_val_t {}
impl Default for wasmtime_component_val_t {
fn default() -> Self {
Self::Bool(false)
}
}
fn name_to_string(name: &wasm_name_t) -> Result<String> {
Ok(String::from_utf8(name.clone().take())?)
}
fn option_box_try_from(val: &Option<Box<wasmtime_component_val_t>>) -> Result<Option<Box<Val>>> {
val.as_ref()
.map(|x| Val::try_from(x.as_ref()).map(Box::new))
.transpose()
}
impl TryFrom<&wasmtime_component_val_t> for Val {
type Error = Error;
fn try_from(value: &wasmtime_component_val_t) -> Result<Self> {
Ok(match value {
wasmtime_component_val_t::Bool(x) => Val::Bool(*x),
wasmtime_component_val_t::S8(x) => Val::S8(*x),
wasmtime_component_val_t::U8(x) => Val::U8(*x),
wasmtime_component_val_t::S16(x) => Val::S16(*x),
wasmtime_component_val_t::U16(x) => Val::U16(*x),
wasmtime_component_val_t::S32(x) => Val::S32(*x),
wasmtime_component_val_t::U32(x) => Val::U32(*x),
wasmtime_component_val_t::S64(x) => Val::S64(*x),
wasmtime_component_val_t::U64(x) => Val::U64(*x),
wasmtime_component_val_t::F32(x) => Val::Float32(*x),
wasmtime_component_val_t::F64(x) => Val::Float64(*x),
wasmtime_component_val_t::Char(x) => Val::Char(
char::from_u32(*x).ok_or_else(|| format_err!("invalid char value: {x:#x}"))?,
),
wasmtime_component_val_t::String(x) => Val::String(name_to_string(x)?),
wasmtime_component_val_t::List(x) => Val::List(x.try_into()?),
wasmtime_component_val_t::Record(x) => Val::Record(x.try_into()?),
wasmtime_component_val_t::Tuple(x) => Val::Tuple(x.try_into()?),
wasmtime_component_val_t::Variant(x) => {
let (a, b) = x.try_into()?;
Val::Variant(a, b)
}
wasmtime_component_val_t::Enum(x) => Val::Enum(name_to_string(x)?),
wasmtime_component_val_t::Option(x) => Val::Option(option_box_try_from(x)?),
wasmtime_component_val_t::Result(x) => Val::Result(x.try_into()?),
wasmtime_component_val_t::Flags(x) => Val::Flags(x.try_into()?),
wasmtime_component_val_t::Map(x) => Val::Map(x.try_into()?),
wasmtime_component_val_t::Resource(x) => Val::Resource(x.resource),
wasmtime_component_val_t::FixedLengthList(x) => Val::FixedLengthList(x.try_into()?),
})
}
}
impl From<&Val> for wasmtime_component_val_t {
fn from(value: &Val) -> Self {
match value {
Val::Bool(x) => wasmtime_component_val_t::Bool(*x),
Val::S8(x) => wasmtime_component_val_t::S8(*x),
Val::U8(x) => wasmtime_component_val_t::U8(*x),
Val::S16(x) => wasmtime_component_val_t::S16(*x),
Val::U16(x) => wasmtime_component_val_t::U16(*x),
Val::S32(x) => wasmtime_component_val_t::S32(*x),
Val::U32(x) => wasmtime_component_val_t::U32(*x),
Val::S64(x) => wasmtime_component_val_t::S64(*x),
Val::U64(x) => wasmtime_component_val_t::U64(*x),
Val::Float32(x) => wasmtime_component_val_t::F32(*x),
Val::Float64(x) => wasmtime_component_val_t::F64(*x),
Val::Char(x) => wasmtime_component_val_t::Char(*x as _),
Val::String(x) => wasmtime_component_val_t::String(wasm_name_t::from_name(x.clone())),
Val::List(x) => wasmtime_component_val_t::List(x.as_slice().into()),
Val::Record(x) => wasmtime_component_val_t::Record(x.as_slice().into()),
Val::Tuple(x) => wasmtime_component_val_t::Tuple(x.as_slice().into()),
Val::Variant(discriminant, val) => {
wasmtime_component_val_t::Variant((discriminant, val).into())
}
Val::Enum(x) => wasmtime_component_val_t::Enum(wasm_name_t::from_name(x.clone())),
Val::Option(x) => wasmtime_component_val_t::Option(
x.as_ref()
.map(|x| Box::new(wasmtime_component_val_t::from(x.as_ref()))),
),
Val::Result(x) => wasmtime_component_val_t::Result(x.into()),
Val::Flags(x) => wasmtime_component_val_t::Flags(x.as_slice().into()),
Val::Map(x) => wasmtime_component_val_t::Map(x.as_slice().into()),
Val::Resource(resource_any) => {
wasmtime_component_val_t::Resource(Box::new(wasmtime_component_resource_any_t {
resource: *resource_any,
}))
}
Val::Future(_) => todo!(),
Val::Stream(_) => todo!(),
Val::ErrorContext(_) => todo!(),
Val::FixedLengthList(ty) => wasmtime_component_val_t::FixedLengthList(
wasmtime_component_vallist_t::from(ty.as_ref()),
),
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_val_new(
src: &mut wasmtime_component_val_t,
) -> Box<wasmtime_component_val_t> {
Box::new(mem::replace(src, wasmtime_component_val_t::default()))
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_val_free(_dst: Option<Box<wasmtime_component_val_t>>) {}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_val_clone(
src: &wasmtime_component_val_t,
dst: &mut MaybeUninit<wasmtime_component_val_t>,
) {
dst.write(src.clone());
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_component_val_delete(
value: &mut ManuallyDrop<wasmtime_component_val_t>,
) {
unsafe {
ManuallyDrop::drop(value);
}
}
#[repr(C)]
#[derive(Clone)]
pub struct wasmtime_component_resource_any_t {
resource: ResourceAny,
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_any_type(
resource: &wasmtime_component_resource_any_t,
) -> Box<wasmtime_component_resource_type_t> {
Box::new(wasmtime_component_resource_type_t {
ty: resource.resource.ty(),
})
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_any_clone(
resource: &wasmtime_component_resource_any_t,
) -> Box<wasmtime_component_resource_any_t> {
Box::new(wasmtime_component_resource_any_t {
resource: resource.resource,
})
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_any_owned(
resource: &wasmtime_component_resource_any_t,
) -> bool {
resource.resource.owned()
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_any_drop(
store: WasmtimeStoreContextMut<'_>,
resource: &wasmtime_component_resource_any_t,
) -> Option<Box<wasmtime_error_t>> {
handle_result(resource.resource.resource_drop(store), |()| ())
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_any_delete(
_resource: Option<Box<wasmtime_component_resource_any_t>>,
) {
}
#[repr(C)]
pub struct wasmtime_component_resource_host_t {
resource: ResourceDynamic,
}
impl wasmtime_component_resource_host_t {
// "poor man's clone"
fn resource(&self) -> ResourceDynamic {
let rep = self.resource.rep();
let ty = self.resource.ty();
if self.resource.owned() {
ResourceDynamic::new_own(rep, ty)
} else {
ResourceDynamic::new_borrow(rep, ty)
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_host_new(
owned: bool,
rep: u32,
ty: u32,
) -> Box<wasmtime_component_resource_host_t> {
Box::new(wasmtime_component_resource_host_t {
resource: if owned {
ResourceDynamic::new_own(rep, ty)
} else {
ResourceDynamic::new_borrow(rep, ty)
},
})
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_host_clone(
resource: &wasmtime_component_resource_host_t,
) -> Box<wasmtime_component_resource_host_t> {
Box::new(wasmtime_component_resource_host_t {
resource: resource.resource(),
})
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_host_rep(
resource: &wasmtime_component_resource_host_t,
) -> u32 {
resource.resource.rep()
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_host_type(
resource: &wasmtime_component_resource_host_t,
) -> u32 {
resource.resource.ty()
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_host_owned(
resource: &wasmtime_component_resource_host_t,
) -> bool {
resource.resource.owned()
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_host_delete(
_resource: Option<Box<wasmtime_component_resource_host_t>>,
) {
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_any_to_host(
store: WasmtimeStoreContextMut<'_>,
resource: &wasmtime_component_resource_any_t,
ret: &mut MaybeUninit<Box<wasmtime_component_resource_host_t>>,
) -> Option<Box<wasmtime_error_t>> {
handle_result(
resource.resource.try_into_resource_dynamic(store),
|resource| {
ret.write(Box::new(wasmtime_component_resource_host_t { resource }));
},
)
}
#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_resource_host_to_any(
store: WasmtimeStoreContextMut<'_>,
resource: &wasmtime_component_resource_host_t,
ret: &mut MaybeUninit<Box<wasmtime_component_resource_any_t>>,
) -> Option<Box<wasmtime_error_t>> {
handle_result(
resource.resource().try_into_resource_any(store),
|resource| {
ret.write(Box::new(wasmtime_component_resource_any_t { resource }));
},
)
}