Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

17.6 KB
Raw Blame
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 }));
        },
    )
}