Implement wasi.environ_{get,sizes_get}. (proxy-wasm#126)

Signed-off-by: Takeshi Yoneda <[email protected]>

Author: mathetake

bazel/wasm.bzl

@@ -19,6 +19,11 @@ def _wasm_rust_transition_impl(settings, attr):
         "//command_line_option:platforms": "@rules_rust//rust/platform:wasm",
     }
 
+def _wasi_rust_transition_impl(settings, attr):
+    return {
+        "//command_line_option:platforms": "@rules_rust//rust/platform:wasi",
+    }
+
 wasm_rust_transition = transition(
     implementation = _wasm_rust_transition_impl,
     inputs = [],
@@ -27,6 +32,14 @@ wasm_rust_transition = transition(
     ],
 )
 
+wasi_rust_transition = transition(
+    implementation = _wasi_rust_transition_impl,
+    inputs = [],
+    outputs = [
+        "//command_line_option:platforms",
+    ],
+)
+
 def _wasm_binary_impl(ctx):
     out = ctx.actions.declare_file(ctx.label.name)
     ctx.actions.run(
@@ -49,7 +62,12 @@ wasm_rust_binary_rule = rule(
     attrs = _wasm_attrs(wasm_rust_transition),
 )
 
-def wasm_rust_binary(name, tags = [], **kwargs):
+wasi_rust_binary_rule = rule(
+    implementation = _wasm_binary_impl,
+    attrs = _wasm_attrs(wasi_rust_transition),
+)
+
+def wasm_rust_binary(name, tags = [], wasi = False, **kwargs):
     wasm_name = "_wasm_" + name.replace(".", "_")
     kwargs.setdefault("visibility", ["//visibility:public"])
 
@@ -62,7 +80,11 @@ def wasm_rust_binary(name, tags = [], **kwargs):
         **kwargs
     )
 
-    wasm_rust_binary_rule(
+    bin_rule = wasm_rust_binary_rule
+    if wasi:
+        bin_rule = wasi_rust_binary_rule
+
+    bin_rule(
         name = name,
         binary = ":" + wasm_name,
         tags = tags + ["manual"],

include/proxy-wasm/null_vm.h

@@ -43,6 +43,7 @@ struct NullVm : public WasmVm {
   bool setMemory(uint64_t pointer, uint64_t size, const void *data) override;
   bool setWord(uint64_t pointer, Word data) override;
   bool getWord(uint64_t pointer, Word *data) override;
+  size_t getWordSize() override;
   std::string_view getCustomSection(std::string_view name) override;
   std::string_view getPrecompiledSectionName() override;
 

include/proxy-wasm/wasm.h

@@ -53,6 +53,7 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
 public:
   WasmBase(std::unique_ptr<WasmVm> wasm_vm, std::string_view vm_id,
            std::string_view vm_configuration, std::string_view vm_key,
+           std::unordered_map<std::string, std::string> envs,
            AllowedCapabilitiesMap allowed_capabilities);
   WasmBase(const std::shared_ptr<WasmHandleBase> &other, WasmVmFactory factory);
   virtual ~WasmBase();
@@ -136,6 +137,8 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
 
   AbiVersion abiVersion() { return abi_version_; }
 
+  const std::unordered_map<std::string, std::string> &envs() { return envs_; }
+
   // Called to raise the flag which indicates that the context should stop iteration regardless of
   // returned filter status from Proxy-Wasm extensions. For example, we ignore
   // FilterHeadersStatus::Continue after a local reponse is sent by the host.
@@ -190,6 +193,8 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
   std::unordered_map<uint32_t, ContextBase *> contexts_;                 // Contains all contexts.
   std::unordered_map<uint32_t, std::chrono::milliseconds> timer_period_; // per root_id.
   std::unique_ptr<ShutdownHandle> shutdown_handle_;
+  std::unordered_map<std::string, std::string>
+      envs_; // environment variables passed through wasi.environ_get
 
   WasmCallVoid<0> _initialize_; /* Emscripten v1.39.17+ */
   WasmCallVoid<0> _start_;      /* Emscripten v1.39.0+ */

include/proxy-wasm/wasm_vm.h

@@ -243,6 +243,11 @@ class WasmVm {
    */
   virtual bool setWord(uint64_t pointer, Word data) = 0;
 
+  /**
+   * @return the Word size in this VM.
+   */
+  virtual size_t getWordSize() = 0;
+
   /**
    * Get the contents of the custom section with the given name or "" if it does not exist.
    * @param name the name of the custom section to get.

src/exports.cc

@@ -767,18 +767,46 @@ Word wasi_unstable_fd_fdstat_get(void *raw_context, Word fd, Word statOut) {
 }
 
 // __wasi_errno_t __wasi_environ_get(char **environ, char *environ_buf);
-Word wasi_unstable_environ_get(void *, Word, Word) {
+Word wasi_unstable_environ_get(void *raw_context, Word environ_array_ptr, Word environ_buf) {
+  auto context = WASM_CONTEXT(raw_context);
+  auto word_size = context->wasmVm()->getWordSize();
+  auto &envs = context->wasm()->envs();
+  for (auto e : envs) {
+    if (!context->wasmVm()->setWord(environ_array_ptr, environ_buf)) {
+      return 21; // __WASI_EFAULT
+    }
+
+    std::string data;
+    data.reserve(e.first.size() + e.second.size() + 2);
+    data.append(e.first);
+    data.append("=");
+    data.append(e.second);
+    data.append("\x0");
+    if (!context->wasmVm()->setMemory(environ_buf, data.size(), data.c_str())) {
+      return 21; // __WASI_EFAULT
+    }
+    environ_buf = environ_buf.u64_ + data.size();
+    environ_array_ptr = environ_array_ptr.u64_ + word_size;
+  }
+
   return 0; // __WASI_ESUCCESS
 }
 
 // __wasi_errno_t __wasi_environ_sizes_get(size_t *environ_count, size_t
 // *environ_buf_size);
 Word wasi_unstable_environ_sizes_get(void *raw_context, Word count_ptr, Word buf_size_ptr) {
   auto context = WASM_CONTEXT(raw_context);
-  if (!context->wasmVm()->setWord(count_ptr, Word(0))) {
+  auto &envs = context->wasm()->envs();
+  if (!context->wasmVm()->setWord(count_ptr, Word(envs.size()))) {
     return 21; // __WASI_EFAULT
   }
-  if (!context->wasmVm()->setWord(buf_size_ptr, Word(0))) {
+
+  size_t size = 0;
+  for (auto e : envs) {
+    // len(key) + len(value) + 1('=') + 1(null terminator)
+    size += e.first.size() + e.second.size() + 2;
+  }
+  if (!context->wasmVm()->setWord(buf_size_ptr, Word(size))) {
     return 21; // __WASI_EFAULT
   }
   return 0; // __WASI_ESUCCESS

src/null/null_vm.cc

@@ -102,6 +102,8 @@ bool NullVm::getWord(uint64_t pointer, Word *data) {
   return true;
 }
 
+size_t NullVm::getWordSize() { return sizeof(uint64_t); }
+
 std::string_view NullVm::getCustomSection(std::string_view /* name */) {
   // Return nothing: there is no WASM file.
   return {};

src/v8/v8.cc

@@ -67,6 +67,7 @@ class V8 : public WasmVm {
   bool setMemory(uint64_t pointer, uint64_t size, const void *data) override;
   bool getWord(uint64_t pointer, Word *word) override;
   bool setWord(uint64_t pointer, Word word) override;
+  size_t getWordSize() override { return sizeof(uint32_t); };
 
 #define _REGISTER_HOST_FUNCTION(T)                                                                 \
   void registerCallback(std::string_view module_name, std::string_view function_name, T,           \

src/wasm.cc

@@ -193,6 +193,7 @@ WasmBase::WasmBase(const std::shared_ptr<WasmHandleBase> &base_wasm_handle, Wasm
     : std::enable_shared_from_this<WasmBase>(*base_wasm_handle->wasm()),
       vm_id_(base_wasm_handle->wasm()->vm_id_), vm_key_(base_wasm_handle->wasm()->vm_key_),
       started_from_(base_wasm_handle->wasm()->wasm_vm()->cloneable()),
+      envs_(base_wasm_handle->wasm()->envs()),
       allowed_capabilities_(base_wasm_handle->wasm()->allowed_capabilities_),
       base_wasm_handle_(base_wasm_handle) {
   if (started_from_ != Cloneable::NotCloneable) {
@@ -209,9 +210,10 @@ WasmBase::WasmBase(const std::shared_ptr<WasmHandleBase> &base_wasm_handle, Wasm
 
 WasmBase::WasmBase(std::unique_ptr<WasmVm> wasm_vm, std::string_view vm_id,
                    std::string_view vm_configuration, std::string_view vm_key,
+                   std::unordered_map<std::string, std::string> envs,
                    AllowedCapabilitiesMap allowed_capabilities)
     : vm_id_(std::string(vm_id)), vm_key_(std::string(vm_key)), wasm_vm_(std::move(wasm_vm)),
-      allowed_capabilities_(std::move(allowed_capabilities)),
+      envs_(envs), allowed_capabilities_(std::move(allowed_capabilities)),
       vm_configuration_(std::string(vm_configuration)), vm_id_handle_(getVmIdHandle(vm_id)) {
   if (!wasm_vm_) {
     failed_ = FailState::UnableToCreateVM;

src/wasmtime/wasmtime.cc

@@ -65,6 +65,7 @@ class Wasmtime : public WasmVm {
   bool setMemory(uint64_t pointer, uint64_t size, const void *data) override;
   bool getWord(uint64_t pointer, Word *word) override;
   bool setWord(uint64_t pointer, Word word) override;
+  size_t getWordSize() override { return sizeof(uint32_t); };
 
 #define _REGISTER_HOST_FUNCTION(T)                                                                 \
   void registerCallback(std::string_view module_name, std::string_view function_name, T,           \

src/wavm/wavm.cc

@@ -229,6 +229,7 @@ struct Wavm : public WasmVm {
   bool setMemory(uint64_t pointer, uint64_t size, const void *data) override;
   bool getWord(uint64_t pointer, Word *data) override;
   bool setWord(uint64_t pointer, Word data) override;
+  size_t getWordSize() override { return sizeof(uint32_t); };
   std::string_view getCustomSection(std::string_view name) override;
   std::string_view getPrecompiledSectionName() override;
   AbiVersion getAbiVersion() override;