Add --dir and --mapdir support to native executable

lib/c-api/build.rs

@@ -357,6 +357,8 @@ fn exclude_items_from_wasm_c_api(builder: Builder) -> Builder {
     builder
         .exclude_item("wasi_config_arg")
         .exclude_item("wasi_config_env")
+        .exclude_item("wasi_config_mapdir")
+        .exclude_item("wasi_config_preopen_dir")
         .exclude_item("wasi_config_inherit_stderr")
         .exclude_item("wasi_config_inherit_stdin")
         .exclude_item("wasi_config_inherit_stdout")

lib/c-api/src/wasm_c_api/wasi/mod.rs

@@ -75,6 +75,63 @@ pub unsafe extern "C" fn wasi_config_arg(config: &mut wasi_config_t, arg: *const
     config.state_builder.arg(arg_bytes);
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn wasi_config_preopen_dir(
+    config: &mut wasi_config_t,
+    dir: *const c_char,
+) -> bool {
+    let dir_cstr = CStr::from_ptr(dir);
+    let dir_bytes = dir_cstr.to_bytes();
+    let dir_str = match std::str::from_utf8(dir_bytes) {
+        Ok(dir_str) => dir_str,
+        Err(e) => {
+            update_last_error(e);
+            return false;
+        }
+    };
+
+    if let Err(e) = config.state_builder.preopen_dir(dir_str) {
+        update_last_error(e);
+        return false;
+    }
+
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_config_mapdir(
+    config: &mut wasi_config_t,
+    alias: *const c_char,
+    dir: *const c_char,
+) -> bool {
+    let alias_cstr = CStr::from_ptr(alias);
+    let alias_bytes = alias_cstr.to_bytes();
+    let alias_str = match std::str::from_utf8(alias_bytes) {
+        Ok(alias_str) => alias_str,
+        Err(e) => {
+            update_last_error(e);
+            return false;
+        }
+    };
+
+    let dir_cstr = CStr::from_ptr(dir);
+    let dir_bytes = dir_cstr.to_bytes();
+    let dir_str = match std::str::from_utf8(dir_bytes) {
+        Ok(dir_str) => dir_str,
+        Err(e) => {
+            update_last_error(e);
+            return false;
+        }
+    };
+
+    if let Err(e) = config.state_builder.map_dir(alias_str, dir_str) {
+        update_last_error(e);
+        return false;
+    }
+
+    true
+}
+
 #[no_mangle]
 pub extern "C" fn wasi_config_inherit_stdout(config: &mut wasi_config_t) {
     config.inherit_stdout = true;

lib/c-api/wasmer_wasm.h

@@ -101,10 +101,18 @@ void wasi_config_inherit_stdin(wasi_config_t *config);
 void wasi_config_inherit_stdout(wasi_config_t *config);
 #endif
 
+#if defined(WASMER_WASI_ENABLED)
+bool wasi_config_mapdir(wasi_config_t *config, const char *alias, const char *dir);
+#endif
+
 #if defined(WASMER_WASI_ENABLED)
 wasi_config_t *wasi_config_new(const char *program_name);
 #endif
 
+#if defined(WASMER_WASI_ENABLED)
+bool wasi_config_preopen_dir(wasi_config_t *config, const char *dir);
+#endif
+
 #if defined(WASMER_WASI_ENABLED)
 void wasi_env_delete(wasi_env_t *_state);
 #endif

lib/cli/src/commands/wasmer_create_exe_main.c

@@ -9,6 +9,9 @@ extern "C" {
 #include <stdio.h>
 #include <stdlib.h>
 
+// TODO: make this define templated so that the Rust code can toggle it on/off
+#define WASI
+
 #ifdef __cplusplus
 }
 #endif
@@ -19,10 +22,91 @@ void print_wasmer_error()
   printf("Error len: `%d`\n", error_len);
   char* error_str = (char*) malloc(error_len);
   wasmer_last_error_message(error_str, error_len);
-    printf("Error str: `%s`\n", error_str);
+  printf("%s\n", error_str);
 }
 
-int main() {
+#ifdef WASI
+int find_colon(char* string) {
+  int colon_location = 0;
+  for (int j = 0; j < strlen(string); ++j) {
+    if (string[j] == ':') {
+      colon_location = j;
+      break;
+    }
+  }
+  return colon_location;
+}
+
+void pass_mapdir_arg(wasi_config_t* wasi_config, char* mapdir) {
+  int colon_location = find_colon(mapdir);
+  if (colon_location == 0) {
+    // error malformed argument
+    fprintf(stderr, "Expected mapdir argument of the form alias:directory\n");
+    exit(-1);
+  }
+  // TODO: triple check for off by one errors
+  int dir_len = strlen(mapdir) - colon_location;
+  char* alias = (char*)malloc(colon_location);
+  char* dir = (char*)malloc(dir_len);
+  int j = 0;
+  for (j = 0; j < colon_location; ++j) {
+    alias[j] = mapdir[j];
+  }
+  alias[j] = 0;
+  for (j = 0; j < dir_len; ++j) {
+    dir[j] = mapdir[j + colon_location];
+  }
+  dir[j] = 0;
+  
+  wasi_config_mapdir(wasi_config, alias, dir);
+  free(alias);
+  free(dir);
+}
+
+// We try to parse out `--dir` and `--mapdir` ahead of time and process those
+// specially. All other arguments are passed to the guest program.
+void handle_arguments(wasi_config_t* wasi_config, int argc, char* argv[]) {
+  for (int i = 1; i < argc; ++i) {
+    // We probably want special args like `--dir` and `--mapdir` to not be passed directly
+    if (strcmp(argv[i], "--dir") == 0) {
+      // next arg is a preopen directory
+      if ((i + 1) < argc ) {
+        i++;
+        wasi_config_preopen_dir(wasi_config, argv[i]);
+      } else {
+        fprintf(stderr, "--dir expects a following argument specifying which directory to preopen\n");
+        exit(-1);
+      }
+    }
+    else if (strcmp(argv[i], "--mapdir") == 0) {
+      // next arg is a mapdir
+      if ((i + 1) < argc ) {
+        i++;
+        pass_mapdir_arg(wasi_config, argv[i]);
+      } else {
+        fprintf(stderr, "--mapdir expects a following argument specifying which directory to preopen in the form alias:directory\n");
+        exit(-1);
+      }
+    }
+    else if (strncmp(argv[i], "--dir=", strlen("--dir=")) == 0 ) {
+      // this arg is a preopen dir
+      char* dir = argv[i] + strlen("--dir=");
+      wasi_config_preopen_dir(wasi_config, dir);
+    }
+    else if (strncmp(argv[i], "--mapdir=", strlen("--mapdir=")) == 0 ) {
+      // this arg is a mapdir
+      char* mapdir = argv[i] + strlen("--mapdir=");
+      pass_mapdir_arg(wasi_config, mapdir);
+    }
+    else {
+      // guest argument
+      wasi_config_arg(wasi_config, argv[i]);
+    }
+  }
+}
+#endif
+
+int main(int argc, char* argv[]) {
   printf("Initializing...\n");
   wasm_config_t* config = wasm_config_new();
   wasm_config_set_engine(config, OBJECT_FILE);
@@ -31,25 +115,24 @@ int main() {
   
   wasm_module_t* module = wasmer_object_file_engine_new(store, "qjs.wasm");
   if (! module) {
-                printf("Failed to create module\n");
+    fprintf(stderr, "Failed to create module\n");
     print_wasmer_error();
     return -1;
   }
 
   // We have now finished the memory buffer book keeping and we have a valid Module.
   
-        // In this example we're passing some JavaScript source code as a command line argument
-        // to a WASI module that can evaluate JavaScript.
-        wasi_config_t* wasi_config = wasi_config_new("constant_value_here");
-        const char* js_string = "function greet(name) { return JSON.stringify('Hello, ' + name); }; print(greet('World'));";
-        wasi_config_arg(wasi_config, "--eval");
-        wasi_config_arg(wasi_config, js_string);
+  #ifdef WASI
+  wasi_config_t* wasi_config = wasi_config_new(argv[0]);
+  handle_arguments(wasi_config, argc, argv);
+
   wasi_env_t* wasi_env = wasi_env_new(wasi_config);
   if (!wasi_env) {
-                printf("> Error building WASI env!\n");
+    fprintf(stderr, "Error building WASI env!\n");
     print_wasmer_error();
     return 1;
   }
+  #endif
   
   wasm_importtype_vec_t import_types;
   wasm_module_imports(module, &import_types);
@@ -57,27 +140,29 @@ int main() {
   wasm_extern_t** imports = (wasm_extern_t**) malloc(num_imports * sizeof(wasm_extern_t*));
   wasm_importtype_vec_delete(&import_types);
   
+  #ifdef WASI
   bool get_imports_result = wasi_get_imports(store, module, wasi_env, imports);
   if (!get_imports_result) {
-                printf("> Error getting WASI imports!\n");
+    fprintf(stderr, "Error getting WASI imports!\n");
     print_wasmer_error();
     return 1;
   }
+  #endif
   
   wasm_instance_t* instance = wasm_instance_new(store, module, (const wasm_extern_t* const*) imports, NULL);
   if (! instance) {
-                printf("Failed to create instance\n");
+    fprintf(stderr, "Failed to create instance\n");
     print_wasmer_error();
     return -1;
   }
-        wasi_env_set_instance(wasi_env, instance);
 
-        // WASI is now set up.
+  #ifdef WASI
+  wasi_env_set_instance(wasi_env, instance);
+  #endif
   
   void* vmctx = wasm_instance_get_vmctx_ptr(instance);
   wasm_val_t* inout[2] = { NULL, NULL };
   
-        fflush(stdout);
   // We're able to call our compiled function directly through a trampoline.
   wasmer_trampoline_function_call__1(vmctx, wasmer_function__1, &inout);
   

tests/integration/cli/src/util.rs

@@ -36,8 +36,10 @@ impl Engine {
     }
 }
 
-pub fn run_code(executable_path: &Path) -> anyhow::Result<String> {
-    let output = Command::new(executable_path.canonicalize()?).output()?;
+pub fn run_code(executable_path: &Path, args: &[String]) -> anyhow::Result<String> {
+    let output = Command::new(executable_path.canonicalize()?)
+        .args(args)
+        .output()?;
 
     if !output.status.success() {
         bail!(

tests/integration/cli/tests/compile.rs

@@ -153,7 +153,7 @@ fn object_file_engine_works() -> anyhow::Result<()> {
     .run()
     .context("Failed to link objects together")?;
 
-    let result = run_code(&executable_path).context("Failed to run generated executable")?;
+    let result = run_code(&executable_path, &[]).context("Failed to run generated executable")?;
     let result_lines = result.lines().collect::<Vec<&str>>();
     assert_eq!(result_lines, vec!["Initializing...", "\"Hello, World\""],);
 

tests/integration/cli/tests/create_exe.rs

@@ -83,7 +83,11 @@ fn create_exe_works() -> anyhow::Result<()> {
     .run()
     .context("Failed to create-exe wasm with Wasmer")?;
 
-    let result = run_code(&executable_path).context("Failed to run generated executable")?;
+    let result = run_code(
+        &executable_path,
+        &["--eval".to_string(), "function greet(name) { return JSON.stringify('Hello, ' + name); }; print(greet('World'));".to_string()],
+    )
+    .context("Failed to run generated executable")?;
     let result_lines = result.lines().collect::<Vec<&str>>();
     assert_eq!(result_lines, vec!["Initializing...", "\"Hello, World\""],);