Lines
41.27 %
Functions
20.59 %
Branches
100 %
use std::sync::{Arc, Mutex};
use std::time::{SystemTime, UNIX_EPOCH};
use wasmtime::{Caller, Linker, Memory};
pub struct HostState {
pub input_offset: u32,
pub output_offset: u32,
pub strings_offset: u32,
pub output_strings_offset: Arc<Mutex<u32>>,
pub memory: Option<Memory>,
}
impl HostState {
#[must_use]
pub fn new(input_offset: u32, output_offset: u32, strings_offset: u32) -> Self {
Self {
input_offset,
output_offset,
strings_offset,
output_strings_offset: Arc::new(Mutex::new(0)),
memory: None,
pub fn define_host_functions(linker: &mut Linker<HostState>) -> wasmtime::Result<()> {
linker.func_wrap(
"env",
"get_input_offset",
|caller: Caller<HostState>| -> u32 { caller.data().input_offset },
)?;
"get_output_offset",
|caller: Caller<HostState>| -> u32 { caller.data().output_offset },
"get_strings_offset",
|caller: Caller<HostState>| -> u32 { caller.data().strings_offset },
"write_bytes",
|mut caller: Caller<HostState>, dst: u32, src: u32, len: u32| -> u32 {
let memory = match caller.data().memory {
Some(mem) => mem,
None => return 0,
};
let data = memory.data_mut(&mut caller);
let src_start = src as usize;
let src_end = src_start + len as usize;
let dst_start = dst as usize;
if src_end > data.len() || dst_start + len as usize > data.len() {
return 0;
let bytes: Vec<u8> = data[src_start..src_end].to_vec();
data[dst_start..dst_start + len as usize].copy_from_slice(&bytes);
len
},
"write_string",
|mut caller: Caller<HostState>, ptr: u32, len: u32| -> u32 {
let output_offset = caller.data().output_offset;
let output_strings = caller.data().output_strings_offset.clone();
let src_start = ptr as usize;
if src_end > data.len() {
let mut strings_offset = match output_strings.lock() {
Ok(guard) => guard,
Err(_) => return 0,
let current_offset = *strings_offset;
let dst = output_offset as usize + current_offset as usize;
if dst + len as usize > data.len() {
data[dst..dst + len as usize].copy_from_slice(&bytes);
*strings_offset += len;
current_offset
"log",
|caller: Caller<HostState>, level: u32, msg_ptr: u32, msg_len: u32| {
None => return,
let data = memory.data(&caller);
let start = msg_ptr as usize;
let end = start + msg_len as usize;
if end > data.len() {
return;
let msg = match std::str::from_utf8(&data[start..end]) {
Ok(s) => s,
Err(_) => return,
match level {
0 => log::debug!("[script] {msg}"),
1 => log::info!("[script] {msg}"),
2 => log::warn!("[script] {msg}"),
_ => log::error!("[script] {msg}"),
linker.func_wrap("env", "get_timestamp", || -> i64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
})?;
"generate_uuid",
|mut caller: Caller<HostState>, out_ptr: u32| {
let uuid_bytes = uuid::Uuid::new_v4().into_bytes();
let start = out_ptr as usize;
if start + 16 > data.len() {
data[start..start + 16].copy_from_slice(&uuid_bytes);
Ok(())
#[cfg(test)]
mod tests {
use super::*;
use crate::format::BASE_OFFSET;
#[test]
fn test_host_state_creation() {
let state = HostState::new(BASE_OFFSET, BASE_OFFSET + 1024, BASE_OFFSET + 512);
assert_eq!(state.input_offset, BASE_OFFSET);
assert_eq!(state.output_offset, BASE_OFFSET + 1024);
assert_eq!(state.strings_offset, BASE_OFFSET + 512);