Implement unstable WASI support

Cargo.toml

@@ -47,7 +47,7 @@ serde = { version = "1.0.98", default-features = false, features = [
  "alloc",
  "derive",
 ] }
-serde_json = { version = "1.0.8", default-features = false, features = ["alloc"] }
+serde_json = { version = "1.0.60", default-features = false, features = ["alloc"] }
 smallstr = { version = "0.3.0", default-features = false }
 snafu = { version = "0.7.0", default-features = false }
 unicase = "2.6.0"
@@ -155,6 +155,7 @@ wasm-web = [
 ]
 networking = ["std", "splits-io-api"]
 auto-splitting = ["std", "livesplit-auto-splitting", "tokio", "log"]
+unstable-auto-splitting = ["livesplit-auto-splitting?/unstable"]
 
 [lib]
 bench = false

crates/livesplit-auto-splitting/Cargo.toml

@@ -17,3 +17,7 @@ wasmtime = { version = "0.39.1", default-features = false, features = [
  "cranelift",
  "parallel-compilation",
 ] }
+wasmtime-wasi = { version = "0.39.1", optional = true }
+
+[features]
+unstable = ["wasmtime-wasi"]

crates/livesplit-auto-splitting/README.md

@@ -108,3 +108,6 @@ extern "C" {
  pub fn runtime_print_message(text_ptr: *const u8, text_len: usize);
 }
 ```
+
+On top of the runtime's API, there's also unstable `WASI` support via the
+`unstable` feature.

crates/livesplit-auto-splitting/src/lib.rs

@@ -108,6 +108,9 @@
 //! pub fn runtime_print_message(text_ptr: *const u8, text_len: usize);
 //! }
 //! ```
+//!
+//! On top of the runtime's API, there's also unstable `WASI` support via the
+//! `unstable` feature.
 
 #![warn(
  clippy::complexity,

crates/livesplit-auto-splitting/src/runtime.rs

@@ -12,6 +12,8 @@ use sysinfo::{ProcessRefreshKind, RefreshKind, System, SystemExt};
 use wasmtime::{
  Caller, Config, Engine, Extern, Linker, Memory, Module, OptLevel, Store, Trap, TypedFunc,
 };
+#[cfg(feature = "unstable")]
+use wasmtime_wasi::{WasiCtx, WasiCtxBuilder};
 
 /// An error that is returned when the creation of a new runtime fails.
 #[derive(Debug, Snafu)]
@@ -49,6 +51,19 @@ pub enum CreationError {
  /// The WebAssembly module has no exported memory called `memory`, which is
  /// a requirement.
  MissingMemory,
+
+ #[cfg(feature = "unstable")]
+ /// Failed linking the WebAssembly System Interface (WASI).
+ Wasi {
+ /// The underlying error.
+ source: anyhow::Error,
+ },
+ #[cfg(feature = "unstable")]
+ /// Failed running the WebAssembly System Interface (WASI) `_start` function.
+ WasiStart {
+ /// The underlying error.
+ source: wasmtime::Trap,
+ },
 }
 
 /// An error that is returned when executing the WebAssembly module fails.
@@ -72,6 +87,8 @@ pub struct Context<T: Timer> {
  timer: T,
  memory: Option<Memory>,
  process_list: ProcessList,
+ #[cfg(feature = "unstable")]
+ wasi: WasiCtx,
 }
 
 /// A threadsafe handle used to interrupt the execution of the script.
@@ -149,17 +166,31 @@ impl<T: Timer> Runtime<T> {
  timer,
  memory: None,
  process_list: ProcessList::new(),
+ #[cfg(feature = "unstable")]
+ wasi: WasiCtxBuilder::new().build(),
  },
  );
 
  store.set_epoch_deadline(1);
 
  let mut linker = Linker::new(&engine);
  bind_interface(&mut linker)?;
+
+ #[cfg(feature = "unstable")]
+ wasmtime_wasi::add_to_linker(&mut linker, |ctx| &mut ctx.wasi).context(Wasi)?;
+
  let instance = linker
  .instantiate(&mut store, &module)
  .context(ModuleInstantiation)?;
 
+ #[cfg(feature = "unstable")]
+ // TODO: _start is kind of correct, but not in the long term. They are
+ // intending for us to use a different function for libraries. Look into
+ // reactors.
+ if let Ok(func) = instance.get_typed_func(&mut store, "_start") {
+ func.call(&mut store, ()).context(WasiStart)?;
+ }
+
  let update = instance
  .get_typed_func(&mut store, "update")
  .context(MissingUpdateFunction)?;

crates/livesplit-auto-splitting/tests/sandboxing.rs

@@ -0,0 +1,182 @@
+#![cfg(feature = "unstable")]
+
+use livesplit_auto_splitting::{Runtime, Timer, TimerState};
+use log::Log;
+use std::{
+ cell::RefCell,
+ ffi::OsStr,
+ fmt::Write,
+ fs,
+ path::PathBuf,
+ process::{Command, Stdio},
+ thread,
+ time::Duration,
+};
+
+thread_local! {
+ static BUF: RefCell<Option<String>> = RefCell::new(None);
+}
+struct Logger;
+static LOGGER: Logger = Logger;
+
+impl Log for Logger {
+ fn enabled(&self, _: &log::Metadata) -> bool {
+ true
+ }
+ fn log(&self, record: &log::Record) {
+ if record.target() != "Auto Splitter" {
+ return;
+ }
+ BUF.with(|b| {
+ if let Some(b) = &mut *b.borrow_mut() {
+ let _ = writeln!(b, "{}", record.args());
+ }
+ });
+ }
+ fn flush(&self) {}
+}
+
+struct DummyTimer;
+
+impl Timer for DummyTimer {
+ fn state(&self) -> TimerState {
+ TimerState::NotRunning
+ }
+ fn start(&mut self) {}
+ fn split(&mut self) {}
+ fn reset(&mut self) {}
+ fn set_game_time(&mut self, time: time::Duration) {}
+ fn pause_game_time(&mut self) {}
+ fn resume_game_time(&mut self) {}
+ fn set_variable(&mut self, key: &str, value: &str) {}
+}
+
+fn compile(crate_name: &str) -> anyhow::Result<Runtime<DummyTimer>> {
+ let mut path = PathBuf::from("tests");
+ path.push("test-cases");
+ path.push(crate_name);
+
+ let output = Command::new("cargo")
+ .current_dir(&path)
+ .arg("build")
+ .arg("--target")
+ .arg("wasm32-wasi")
+ .stdin(Stdio::null())
+ .stdout(Stdio::null())
+ .output()
+ .unwrap();
+
+ if !output.status.success() {
+ let output = String::from_utf8_lossy(&output.stderr);
+ panic!("{}", output);
+ }
+
+ path.push("target");
+ path.push("wasm32-wasi");
+ path.push("debug");
+ let wasm_path = fs::read_dir(path)
+ .unwrap()
+ .find_map(|e| {
+ let path = e.unwrap().path();
+ if path.extension() == Some(OsStr::new("wasm")) {
+ Some(path)
+ } else {
+ None
+ }
+ })
+ .unwrap();
+
+ Ok(Runtime::new(&wasm_path, DummyTimer)?)
+}
+
+fn run(crate_name: &str) -> anyhow::Result<()> {
+ let mut runtime = compile(crate_name)?;
+ runtime.step()?;
+ Ok(())
+}
+
+#[test]
+fn empty() {
+ run("empty").unwrap();
+}
+
+#[test]
+fn proc_exit() {
+ assert!(run("proc-exit").is_err());
+}
+
+#[test]
+fn create_file() {
+ run("create-file").unwrap();
+}
+
+#[test]
+fn stdout() {
+ let _ = log::set_logger(&LOGGER);
+ log::set_max_level(log::LevelFilter::Trace);
+ BUF.with(|b| *b.borrow_mut() = Some(String::new()));
+ run("stdout").unwrap();
+ let output = BUF.with(|b| b.borrow_mut().take());
+ // FIXME: For now we don't actually hook up stdout or stderr.
+ assert_eq!(output.unwrap(), "");
+}
+
+#[test]
+fn segfault() {
+ assert!(run("segfault").is_err());
+}
+
+#[test]
+fn env() {
+ run("env").unwrap();
+ assert!(std::env::var("AUTOSPLITTER_HOST_SHOULDNT_SEE_THIS").is_err());
+}
+
+#[test]
+fn threads() {
+ // There's no threads in WASI / WASM yet, so this is expected to trap.
+ assert!(run("threads").is_err());
+}
+
+#[test]
+fn sleep() {
+ // FIXME: Sleeping can basically deadlock the code. We should have a limit on
+ // how long it can sleep.
+ run("sleep").unwrap();
+}
+
+#[test]
+fn time() {
+ run("time").unwrap();
+}
+
+#[test]
+fn random() {
+ run("random").unwrap();
+}
+
+// #[test]
+// fn poll() {
+// // FIXME: This is basically what happens at the lower levels of sleeping. You
+// // can block on file descriptors and have a timeout with this. Both of which
+// // could deadlock the script.
+// run("poll").unwrap();
+// }
+
+#[test]
+fn infinite_loop() {
+ let mut runtime = compile("infinite-loop").unwrap();
+
+ let interrupt = runtime.interrupt_handle();
+
+ thread::spawn(move || {
+ thread::sleep(Duration::from_secs(5));
+ interrupt.interrupt();
+ });
+
+ assert!(runtime.step().is_err());
+}
+
+// FIXME: Test Network
+
+// FIXME: Test heavy amounts of allocations

crates/livesplit-auto-splitting/tests/test-cases/create-file/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "create-file"
+version = "0.1.0"
+authors = ["Christopher Serr <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+
+[dependencies]

crates/livesplit-auto-splitting/tests/test-cases/create-file/src/main.rs

@@ -0,0 +1,10 @@
+#[no_mangle]
+pub extern "C" fn update() {
+ assert!(std::fs::write(
+ "shouldnt_exist.txt",
+ "This file should never exist. File a bug if you see this.",
+ )
+ .is_err());
+}
+
+fn main() {}

crates/livesplit-auto-splitting/tests/test-cases/empty/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "empty"
+version = "0.1.0"
+authors = ["Christopher Serr <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+
+[dependencies]

crates/livesplit-auto-splitting/tests/test-cases/empty/src/main.rs

@@ -0,0 +1,4 @@
+#[no_mangle]
+pub extern "C" fn update() {}
+
+fn main() {}

crates/livesplit-auto-splitting/tests/test-cases/env/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "env"
+version = "0.1.0"
+authors = ["Christopher Serr <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+
+[dependencies]

crates/livesplit-auto-splitting/tests/test-cases/env/src/main.rs

@@ -0,0 +1,19 @@
+use std::{env, path::Path};
+
+#[no_mangle]
+pub extern "C" fn update() {
+ assert!(env::args().next().is_none());
+ assert!(env::current_exe().is_err());
+ assert_eq!(env::current_dir().unwrap(), Path::new("/"));
+ assert!(env::vars().next().is_none());
+
+ env::set_var("AUTOSPLITTER_HOST_SHOULDNT_SEE_THIS", "YES");
+
+ // but auto splitter should
+ assert_eq!(
+ env::var("AUTOSPLITTER_HOST_SHOULDNT_SEE_THIS").unwrap(),
+ "YES",
+ );
+}
+
+fn main() {}

crates/livesplit-auto-splitting/tests/test-cases/infinite-loop/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "infinite-loop"
+version = "0.1.0"
+authors = ["Christopher Serr <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+
+[dependencies]

crates/livesplit-auto-splitting/tests/test-cases/infinite-loop/src/main.rs

@@ -0,0 +1,8 @@
+#[no_mangle]
+pub extern "C" fn update() {
+ loop {
+ std::thread::yield_now();
+ }
+}
+
+fn main() {}

crates/livesplit-auto-splitting/tests/test-cases/proc-exit/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "proc-exit"
+version = "0.1.0"
+authors = ["Christopher Serr <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+
+[dependencies]