arora-engine 0.1.0

The Arora engine: loads and executes Arora modules (wasm and native hosts).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::borrow::Cow;

use uuid::Uuid;
use wasmtime::{AsContext, AsContextMut, Memory};

pub struct AroraBuffer<'a>(pub Cow<'a, [u8]>);

impl AsRef<[u8]> for AroraBuffer<'_> {
    fn as_ref(&self) -> &[u8] {
        &self.0
    }
}

pub trait ReadWasmMemory {
    fn read_wasm_memory<T, C: AsContext<Data = T>>(
        context: &C,
        memory: Memory,
        offset: u32,
    ) -> Self;
}

#[allow(dead_code)]
pub trait WriteWasmMemory {
    fn write_wasm_memory<T, C: AsContextMut<Data = T>>(
        &self,
        context: &mut C,
        memory: Memory,
        offset: u32,
    );
}

impl ReadWasmMemory for Uuid {
    fn read_wasm_memory<T, C: AsContext<Data = T>>(
        context: &C,
        memory: Memory,
        offset: u32,
    ) -> Self {
        let mut buffer = [0u8; 16];
        memory.read(context, offset as usize, &mut buffer).unwrap();
        Uuid::from_slice(&buffer).unwrap()
    }
}

impl WriteWasmMemory for Uuid {
    fn write_wasm_memory<T, C: AsContextMut<Data = T>>(
        &self,
        context: &mut C,
        memory: Memory,
        offset: u32,
    ) {
        memory
            .write(context, offset as usize, self.as_bytes())
            .unwrap();
    }
}

impl<const N: usize> ReadWasmMemory for [u8; N] {
    fn read_wasm_memory<T, C: AsContext<Data = T>>(
        context: &C,
        memory: Memory,
        offset: u32,
    ) -> Self {
        let mut buffer = [0u8; N];
        memory.read(context, offset as usize, &mut buffer).unwrap();
        buffer
    }
}

impl<const N: usize> WriteWasmMemory for [u8; N] {
    fn write_wasm_memory<T, C: AsContextMut<Data = T>>(
        &self,
        context: &mut C,
        memory: Memory,
        offset: u32,
    ) {
        memory.write(context, offset as usize, self).unwrap();
    }
}

impl ReadWasmMemory for u32 {
    fn read_wasm_memory<T, C: AsContext<Data = T>>(
        context: &C,
        memory: Memory,
        offset: u32,
    ) -> Self {
        let mut buffer = [0u8; 4];
        memory.read(context, offset as usize, &mut buffer).unwrap();
        u32::from_le_bytes(buffer)
    }
}

impl WriteWasmMemory for u32 {
    fn write_wasm_memory<T, C: AsContextMut<Data = T>>(
        &self,
        context: &mut C,
        memory: Memory,
        offset: u32,
    ) {
        self.to_le_bytes()
            .write_wasm_memory(context, memory, offset);
    }
}

impl<'a> ReadWasmMemory for AroraBuffer<'a> {
    fn read_wasm_memory<T, C: AsContext<Data = T>>(
        context: &C,
        memory: Memory,
        offset: u32,
    ) -> Self {
        let size = u32::read_wasm_memory(context, memory, offset);

        let mut buffer = vec![0; size as usize + 4];
        memory.read(context, offset as usize, &mut buffer).unwrap();

        AroraBuffer(Cow::Owned(buffer))
    }
}

impl<'a> WriteWasmMemory for AroraBuffer<'a> {
    fn write_wasm_memory<T, C: AsContextMut<Data = T>>(
        &self,
        context: &mut C,
        memory: Memory,
        offset: u32,
    ) {
        memory
            .write(context, offset as usize, self.as_ref())
            .unwrap();
    }
}