#include "env-inl.h"

#include "base_object-inl.h"

#include "debug_utils-inl.h"

#include "memory_tracker-inl.h"

#include "node_mem-inl.h"

#include "util-inl.h"

#include "node.h"

#include "uv.h"

#include "uvwasi.h"

#include "node_wasi.h"

namespace node {

namespace wasi {

static inline bool is_access_oob(size_t mem_size,

uint32_t offset,

uint32_t buf_size) {

return offset + buf_size > mem_size;

}

template <typename... Args>

inline void Debug(WASI* wasi, Args&&... args) {

Debug(wasi->env(), DebugCategory::WASI, std::forward<Args>(args)...);

}

#define RETURN_IF_BAD_ARG_COUNT(args, expected) \

do { \

if ((args).Length() != (expected)) { \

(args).GetReturnValue().Set(UVWASI_EINVAL); \

return; \

} \

} while (0)

#define CHECK_TO_TYPE_OR_RETURN(args, input, type, result) \

do { \

if (!(input)->Is##type()) { \

(args).GetReturnValue().Set(UVWASI_EINVAL); \

return; \

} \

(result) = (input).As<type>()->Value(); \

} while (0)

#define UNWRAP_BIGINT_OR_RETURN(args, input, type, result) \

do { \

if (!(input)->IsBigInt()) { \

(args).GetReturnValue().Set(UVWASI_EINVAL); \

return; \

} \

Local<BigInt> js_value = (input).As<BigInt>(); \

bool lossless; \

(result) = js_value->type ## Value(&lossless); \

} while (0)

#define GET_BACKING_STORE_OR_RETURN(wasi, args, mem_ptr, mem_size) \

do { \

uvwasi_errno_t err = (wasi)->backingStore((mem_ptr), (mem_size)); \

if (err != UVWASI_ESUCCESS) { \

(args).GetReturnValue().Set(err); \

return; \

} \

} while (0)

#define CHECK_BOUNDS_OR_RETURN(args, mem_size, offset, buf_size) \

do { \

if (is_access_oob((mem_size), (offset), (buf_size))) { \

(args).GetReturnValue().Set(UVWASI_EOVERFLOW); \

return; \

} \

} while (0)

using v8::Array;

using v8::ArrayBuffer;

using v8::BackingStore;

using v8::BigInt;

using v8::Context;

using v8::Exception;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::MaybeLocal;

using v8::Object;

using v8::String;

using v8::Uint32;

using v8::Value;

static MaybeLocal<Value> WASIException(Local<Context> context,

int errorno,

const char* syscall) {

Isolate* isolate = context->GetIsolate();

Environment* env = Environment::GetCurrent(context);

CHECK_NOT_NULL(env);

const char* err_name = uvwasi_embedder_err_code_to_string(errorno);

Local<String> js_code = OneByteString(isolate, err_name);

Local<String> js_syscall = OneByteString(isolate, syscall);

Local<String> js_msg = js_code;

js_msg =

String::Concat(isolate, js_msg, FIXED_ONE_BYTE_STRING(isolate, ", "));

js_msg = String::Concat(isolate, js_msg, js_syscall);

Local<Object> e =

Exception::Error(js_msg)->ToObject(context)

.ToLocalChecked();

if (e->Set(context,

env->errno_string(),

Integer::New(isolate, errorno)).IsNothing() ||

e->Set(context, env->code_string(), js_code).IsNothing() ||

e->Set(context, env->syscall_string(), js_syscall).IsNothing()) {

return MaybeLocal<Value>();

}

return e;

}

WASI::WASI(Environment* env,

Local<Object> object,

uvwasi_options_t* options) : BaseObject(env, object) {

MakeWeak();

alloc_info_ = MakeAllocator();

options->allocator = &alloc_info_;

int err = uvwasi_init(&uvw_, options);

if (err != UVWASI_ESUCCESS) {

Local<Context> context = env->context();

MaybeLocal<Value> exception = WASIException(context, err, "uvwasi_init");

if (exception.IsEmpty())

return;

context->GetIsolate()->ThrowException(exception.ToLocalChecked());

}

}

WASI::~WASI() {

uvwasi_destroy(&uvw_);

CHECK_EQ(current_uvwasi_memory_, 0);

}

void WASI::MemoryInfo(MemoryTracker* tracker) const {

tracker->TrackField("memory", memory_);

tracker->TrackFieldWithSize("uvwasi_memory", current_uvwasi_memory_);

}

void WASI::CheckAllocatedSize(size_t previous_size) const {

CHECK_GE(current_uvwasi_memory_, previous_size);

}

void WASI::IncreaseAllocatedSize(size_t size) {

current_uvwasi_memory_ += size;

}

void WASI::DecreaseAllocatedSize(size_t size) {

current_uvwasi_memory_ -= size;

}

void WASI::New(const FunctionCallbackInfo<Value>& args) {

CHECK(args.IsConstructCall());

CHECK_EQ(args.Length(), 3);

CHECK(args[0]->IsArray());

CHECK(args[1]->IsArray());

CHECK(args[2]->IsArray());

Environment* env = Environment::GetCurrent(args);

Local<Context> context = env->context();

Local<Array> argv = args[0].As<Array>();

const uint32_t argc = argv->Length();

uvwasi_options_t options;

options.fd_table_size = 3;

options.argc = argc;

options.argv = argc == 0 ? nullptr : new char*[argc];

for (uint32_t i = 0; i < argc; i++) {

auto arg = argv->Get(context, i).ToLocalChecked();

CHECK(arg->IsString());

node::Utf8Value str(env->isolate(), arg);

options.argv[i] = strdup(*str);

CHECK_NOT_NULL(options.argv[i]);

}

Local<Array> env_pairs = args[1].As<Array>();

const uint32_t envc = env_pairs->Length();

options.envp = new char*[envc + 1];

for (uint32_t i = 0; i < envc; i++) {

auto pair = env_pairs->Get(context, i).ToLocalChecked();

CHECK(pair->IsString());

node::Utf8Value str(env->isolate(), pair);

options.envp[i] = strdup(*str);

CHECK_NOT_NULL(options.envp[i]);

}

options.envp[envc] = nullptr;

Local<Array> preopens = args[2].As<Array>();

CHECK_EQ(preopens->Length() % 2, 0);

options.preopenc = preopens->Length() / 2;

options.preopens = Calloc<uvwasi_preopen_t>(options.preopenc);

int index = 0;

for (uint32_t i = 0; i < preopens->Length(); i += 2) {

auto mapped = preopens->Get(context, i).ToLocalChecked();

auto real = preopens->Get(context, i + 1).ToLocalChecked();

CHECK(mapped->IsString());

CHECK(real->IsString());

node::Utf8Value mapped_path(env->isolate(), mapped);

node::Utf8Value real_path(env->isolate(), real);

options.preopens[index].mapped_path = strdup(*mapped_path);

CHECK_NOT_NULL(options.preopens[index].mapped_path);

options.preopens[index].real_path = strdup(*real_path);

CHECK_NOT_NULL(options.preopens[index].real_path);

index++;

}

new WASI(env, args.This(), &options);

if (options.argv != nullptr) {

for (uint32_t i = 0; i < argc; i++)

free(options.argv[i]);

delete[] options.argv;

}

if (options.envp != nullptr) {

for (uint32_t i = 0; options.envp[i]; i++)

free(options.envp[i]);

delete[] options.envp;

}

if (options.preopens != nullptr) {

for (uint32_t i = 0; i < options.preopenc; i++) {

free(options.preopens[i].mapped_path);

free(options.preopens[i].real_path);

}

delete[] options.preopens;

}

}

void WASI::ArgsGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t argv_offset;

uint32_t argv_buf_offset;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, argv_offset);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, argv_buf_offset);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "args_get(%d, %d)\n", argv_offset, argv_buf_offset);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args,

mem_size,

argv_buf_offset,

wasi->uvw_.argv_buf_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, argv_offset, wasi->uvw_.argc * 4);

std::vector<char*> argv(wasi->uvw_.argc);

char* argv_buf = &memory[argv_buf_offset];

uvwasi_errno_t err = uvwasi_args_get(&wasi->uvw_, argv.data(), argv_buf);

if (err == UVWASI_ESUCCESS) {

for (size_t i = 0; i < wasi->uvw_.argc; i++) {

uint32_t offset = argv_buf_offset + (argv[i] - argv[0]);

wasi->writeUInt32(memory, offset, argv_offset + (i * 4));

}

}

args.GetReturnValue().Set(err);

}

void WASI::ArgsSizesGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t argc_offset;

uint32_t argv_buf_offset;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, argc_offset);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, argv_buf_offset);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "args_sizes_get(%d, %d)\n", argc_offset, argv_buf_offset);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, argc_offset, 4);

CHECK_BOUNDS_OR_RETURN(args, mem_size, argv_buf_offset, 4);

size_t argc;

size_t argv_buf_size;

uvwasi_errno_t err = uvwasi_args_sizes_get(&wasi->uvw_,

&argc,

&argv_buf_size);

if (err == UVWASI_ESUCCESS) {

wasi->writeUInt32(memory, argc, argc_offset);

wasi->writeUInt32(memory, argv_buf_size, argv_buf_offset);

}

args.GetReturnValue().Set(err);

}

void WASI::ClockResGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t clock_id;

uint32_t resolution_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, clock_id);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, resolution_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "clock_res_get(%d, %d)\n", clock_id, resolution_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, resolution_ptr, 8);

uvwasi_timestamp_t resolution;

uvwasi_errno_t err = uvwasi_clock_res_get(&wasi->uvw_,

clock_id,

&resolution);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt64(memory, resolution, resolution_ptr);

args.GetReturnValue().Set(err);

}

void WASI::ClockTimeGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t clock_id;

uint64_t precision;

uint32_t time_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 3);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, clock_id);

UNWRAP_BIGINT_OR_RETURN(args, args[1], Uint64, precision);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, time_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "clock_time_get(%d, %d, %d)\n", clock_id, precision, time_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, time_ptr, 8);

uvwasi_timestamp_t time;

uvwasi_errno_t err = uvwasi_clock_time_get(&wasi->uvw_,

clock_id,

precision,

&time);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt64(memory, time, time_ptr);

args.GetReturnValue().Set(err);

}

void WASI::EnvironGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t environ_offset;

uint32_t environ_buf_offset;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, environ_offset);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, environ_buf_offset);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "environ_get(%d, %d)\n", environ_offset, environ_buf_offset);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args,

mem_size,

environ_buf_offset,

wasi->uvw_.env_buf_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, environ_offset, wasi->uvw_.envc * 4);

std::vector<char*> environment(wasi->uvw_.envc);

char* environ_buf = &memory[environ_buf_offset];

uvwasi_errno_t err = uvwasi_environ_get(&wasi->uvw_,

environment.data(),

environ_buf);

if (err == UVWASI_ESUCCESS) {

for (size_t i = 0; i < wasi->uvw_.envc; i++) {

uint32_t offset = environ_buf_offset + (environment[i] - environment[0]);

wasi->writeUInt32(memory, offset, environ_offset + (i * 4));

}

}

args.GetReturnValue().Set(err);

}

void WASI::EnvironSizesGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t envc_offset;

uint32_t env_buf_offset;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, envc_offset);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, env_buf_offset);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "environ_sizes_get(%d, %d)\n", envc_offset, env_buf_offset);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, envc_offset, 4);

CHECK_BOUNDS_OR_RETURN(args, mem_size, env_buf_offset, 4);

size_t envc;

size_t env_buf_size;

uvwasi_errno_t err = uvwasi_environ_sizes_get(&wasi->uvw_,

&envc,

&env_buf_size);

if (err == UVWASI_ESUCCESS) {

wasi->writeUInt32(memory, envc, envc_offset);

wasi->writeUInt32(memory, env_buf_size, env_buf_offset);

}

args.GetReturnValue().Set(err);

}

void WASI::FdAdvise(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint64_t offset;

uint64_t len;

uint8_t advice;

RETURN_IF_BAD_ARG_COUNT(args, 4);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

UNWRAP_BIGINT_OR_RETURN(args, args[1], Uint64, offset);

UNWRAP_BIGINT_OR_RETURN(args, args[2], Uint64, len);

CHECK_TO_TYPE_OR_RETURN(args, args[3], Uint32, advice);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_advise(%d, %d, %d, %d)\n", fd, offset, len, advice);

uvwasi_errno_t err = uvwasi_fd_advise(&wasi->uvw_, fd, offset, len, advice);

args.GetReturnValue().Set(err);

}

void WASI::FdAllocate(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint64_t offset;

uint64_t len;

RETURN_IF_BAD_ARG_COUNT(args, 3);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

UNWRAP_BIGINT_OR_RETURN(args, args[1], Uint64, offset);

UNWRAP_BIGINT_OR_RETURN(args, args[2], Uint64, len);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_allocate(%d, %d, %d)\n", fd, offset, len);

uvwasi_errno_t err = uvwasi_fd_allocate(&wasi->uvw_, fd, offset, len);

args.GetReturnValue().Set(err);

}

void WASI::FdClose(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

RETURN_IF_BAD_ARG_COUNT(args, 1);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_close(%d)\n", fd);

uvwasi_errno_t err = uvwasi_fd_close(&wasi->uvw_, fd);

args.GetReturnValue().Set(err);

}

void WASI::FdDatasync(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

RETURN_IF_BAD_ARG_COUNT(args, 1);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_datasync(%d)\n", fd);

uvwasi_errno_t err = uvwasi_fd_datasync(&wasi->uvw_, fd);

args.GetReturnValue().Set(err);

}

void WASI::FdFdstatGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t buf;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, buf);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_fdstat_get(%d, %d)\n", fd, buf);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, buf, 24);

uvwasi_fdstat_t stats;

uvwasi_errno_t err = uvwasi_fd_fdstat_get(&wasi->uvw_, fd, &stats);

if (err == UVWASI_ESUCCESS) {

wasi->writeUInt8(memory, stats.fs_filetype, buf);

wasi->writeUInt16(memory, stats.fs_flags, buf + 2);

wasi->writeUInt64(memory, stats.fs_rights_base, buf + 8);

wasi->writeUInt64(memory, stats.fs_rights_inheriting, buf + 16);

}

args.GetReturnValue().Set(err);

}

void WASI::FdFdstatSetFlags(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint16_t flags;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, flags);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_fdstat_set_flags(%d, %d)\n", fd, flags);

uvwasi_errno_t err = uvwasi_fd_fdstat_set_flags(&wasi->uvw_, fd, flags);

args.GetReturnValue().Set(err);

}

void WASI::FdFdstatSetRights(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint64_t fs_rights_base;

uint64_t fs_rights_inheriting;

RETURN_IF_BAD_ARG_COUNT(args, 3);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

UNWRAP_BIGINT_OR_RETURN(args, args[1], Uint64, fs_rights_base);

UNWRAP_BIGINT_OR_RETURN(args, args[2], Uint64, fs_rights_inheriting);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi,

"fd_fdstat_set_rights(%d, %d, %d)\n",

fd,

fs_rights_base,

fs_rights_inheriting);

uvwasi_errno_t err = uvwasi_fd_fdstat_set_rights(&wasi->uvw_,

fd,

fs_rights_base,

fs_rights_inheriting);

args.GetReturnValue().Set(err);

}

void WASI::FdFilestatGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t buf;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, buf);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_filestat_get(%d, %d)\n", fd, buf);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, buf, 64);

uvwasi_filestat_t stats;

uvwasi_errno_t err = uvwasi_fd_filestat_get(&wasi->uvw_, fd, &stats);

if (err == UVWASI_ESUCCESS) {

wasi->writeUInt64(memory, stats.st_dev, buf);

wasi->writeUInt64(memory, stats.st_ino, buf + 8);

wasi->writeUInt8(memory, stats.st_filetype, buf + 16);

wasi->writeUInt64(memory, stats.st_nlink, buf + 24);

wasi->writeUInt64(memory, stats.st_size, buf + 32);

wasi->writeUInt64(memory, stats.st_atim, buf + 40);

wasi->writeUInt64(memory, stats.st_mtim, buf + 48);

wasi->writeUInt64(memory, stats.st_ctim, buf + 56);

}

args.GetReturnValue().Set(err);

}

void WASI::FdFilestatSetSize(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint64_t st_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

UNWRAP_BIGINT_OR_RETURN(args, args[1], Uint64, st_size);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_filestat_set_size(%d, %d)\n", fd, st_size);

uvwasi_errno_t err = uvwasi_fd_filestat_set_size(&wasi->uvw_, fd, st_size);

args.GetReturnValue().Set(err);

}

void WASI::FdFilestatSetTimes(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint64_t st_atim;

uint64_t st_mtim;

uint16_t fst_flags;

RETURN_IF_BAD_ARG_COUNT(args, 4);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

UNWRAP_BIGINT_OR_RETURN(args, args[1], Uint64, st_atim);

UNWRAP_BIGINT_OR_RETURN(args, args[2], Uint64, st_mtim);

CHECK_TO_TYPE_OR_RETURN(args, args[3], Uint32, fst_flags);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi,

"fd_filestat_set_times(%d, %d, %d, %d)\n",

fd,

st_atim,

st_mtim,

fst_flags);

uvwasi_errno_t err = uvwasi_fd_filestat_set_times(&wasi->uvw_,

fd,

st_atim,

st_mtim,

fst_flags);

args.GetReturnValue().Set(err);

}

void WASI::FdPread(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t iovs_ptr;

uint32_t iovs_len;

uint64_t offset;

uint32_t nread_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 5);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, iovs_ptr);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, iovs_len);

UNWRAP_BIGINT_OR_RETURN(args, args[3], Uint64, offset);

CHECK_TO_TYPE_OR_RETURN(args, args[4], Uint32, nread_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi,

"uvwasi_fd_pread(%d, %d, %d, %d, %d)\n",

fd,

iovs_ptr,

iovs_len,

offset,

nread_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, iovs_ptr, iovs_len * 8);

CHECK_BOUNDS_OR_RETURN(args, mem_size, nread_ptr, 4);

uvwasi_iovec_t* iovs = UncheckedCalloc<uvwasi_iovec_t>(iovs_len);

if (iovs == nullptr) {

args.GetReturnValue().Set(UVWASI_ENOMEM);

return;

}

for (uint32_t i = 0; i < iovs_len; ++i) {

uint32_t buf_ptr;

uint32_t buf_len;

wasi->readUInt32(memory, &buf_ptr, iovs_ptr);

wasi->readUInt32(memory, &buf_len, iovs_ptr + 4);

if (is_access_oob(mem_size, buf_ptr, buf_len)) {

free(iovs);

args.GetReturnValue().Set(UVWASI_EOVERFLOW);

return;

}

iovs_ptr += 8;

iovs[i].buf = static_cast<void*>(&memory[buf_ptr]);

iovs[i].buf_len = buf_len;

}

size_t nread;

uvwasi_errno_t err = uvwasi_fd_pread(&wasi->uvw_,

fd,

iovs,

iovs_len,

offset,

&nread);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt32(memory, nread, nread_ptr);

free(iovs);

args.GetReturnValue().Set(err);

}

void WASI::FdPrestatGet(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t buf;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, buf);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_prestat_get(%d, %d)\n", fd, buf);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, buf, 8);

uvwasi_prestat_t prestat;

uvwasi_errno_t err = uvwasi_fd_prestat_get(&wasi->uvw_, fd, &prestat);

if (err == UVWASI_ESUCCESS) {

wasi->writeUInt32(memory, prestat.pr_type, buf);

wasi->writeUInt32(memory, prestat.u.dir.pr_name_len, buf + 4);

}

args.GetReturnValue().Set(err);

}

void WASI::FdPrestatDirName(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t path_ptr;

uint32_t path_len;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 3);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, path_ptr);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, path_len);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_prestat_dir_name(%d, %d, %d)\n", fd, path_ptr, path_len);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, path_ptr, path_len);

uvwasi_errno_t err = uvwasi_fd_prestat_dir_name(&wasi->uvw_,

fd,

&memory[path_ptr],

path_len);

args.GetReturnValue().Set(err);

}

void WASI::FdPwrite(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t iovs_ptr;

uint32_t iovs_len;

uint64_t offset;

uint32_t nwritten_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 5);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, iovs_ptr);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, iovs_len);

UNWRAP_BIGINT_OR_RETURN(args, args[3], Uint64, offset);

CHECK_TO_TYPE_OR_RETURN(args, args[4], Uint32, nwritten_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi,

"uvwasi_fd_pwrite(%d, %d, %d, %d, %d)\n",

fd,

iovs_ptr,

iovs_len,

offset,

nwritten_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, iovs_ptr, iovs_len * 8);

CHECK_BOUNDS_OR_RETURN(args, mem_size, nwritten_ptr, 4);

uvwasi_ciovec_t* iovs = UncheckedCalloc<uvwasi_ciovec_t>(iovs_len);

if (iovs == nullptr) {

args.GetReturnValue().Set(UVWASI_ENOMEM);

return;

}

for (uint32_t i = 0; i < iovs_len; ++i) {

uint32_t buf_ptr;

uint32_t buf_len;

wasi->readUInt32(memory, &buf_ptr, iovs_ptr);

wasi->readUInt32(memory, &buf_len, iovs_ptr + 4);

if (is_access_oob(mem_size, buf_ptr, buf_len)) {

free(iovs);

args.GetReturnValue().Set(UVWASI_EOVERFLOW);

return;

}

iovs_ptr += 8;

iovs[i].buf = static_cast<void*>(&memory[buf_ptr]);

iovs[i].buf_len = buf_len;

}

size_t nwritten;

uvwasi_errno_t err = uvwasi_fd_pwrite(&wasi->uvw_,

fd,

iovs,

iovs_len,

offset,

&nwritten);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt32(memory, nwritten, nwritten_ptr);

free(iovs);

args.GetReturnValue().Set(err);

}

void WASI::FdRead(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t iovs_ptr;

uint32_t iovs_len;

uint32_t nread_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 4);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, iovs_ptr);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, iovs_len);

CHECK_TO_TYPE_OR_RETURN(args, args[3], Uint32, nread_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_read(%d, %d, %d, %d)\n", fd, iovs_ptr, iovs_len, nread_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, iovs_ptr, iovs_len * 8);

CHECK_BOUNDS_OR_RETURN(args, mem_size, nread_ptr, 4);

uvwasi_iovec_t* iovs = UncheckedCalloc<uvwasi_iovec_t>(iovs_len);

if (iovs == nullptr) {

args.GetReturnValue().Set(UVWASI_ENOMEM);

return;

}

for (uint32_t i = 0; i < iovs_len; ++i) {

uint32_t buf_ptr;

uint32_t buf_len;

wasi->readUInt32(memory, &buf_ptr, iovs_ptr);

wasi->readUInt32(memory, &buf_len, iovs_ptr + 4);

if (is_access_oob(mem_size, buf_ptr, buf_len)) {

free(iovs);

args.GetReturnValue().Set(UVWASI_EOVERFLOW);

return;

}

iovs_ptr += 8;

iovs[i].buf = static_cast<void*>(&memory[buf_ptr]);

iovs[i].buf_len = buf_len;

}

size_t nread;

uvwasi_errno_t err = uvwasi_fd_read(&wasi->uvw_,

fd,

iovs,

iovs_len,

&nread);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt32(memory, nread, nread_ptr);

free(iovs);

args.GetReturnValue().Set(err);

}

void WASI::FdReaddir(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t buf_ptr;

uint32_t buf_len;

uint64_t cookie;

uint32_t bufused_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 5);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, buf_ptr);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, buf_len);

UNWRAP_BIGINT_OR_RETURN(args, args[3], Uint64, cookie);

CHECK_TO_TYPE_OR_RETURN(args, args[4], Uint32, bufused_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi,

"uvwasi_fd_readdir(%d, %d, %d, %d, %d)\n",

fd,

buf_ptr,

buf_len,

cookie,

bufused_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, buf_ptr, buf_len);

CHECK_BOUNDS_OR_RETURN(args, mem_size, bufused_ptr, 4);

size_t bufused;

uvwasi_errno_t err = uvwasi_fd_readdir(&wasi->uvw_,

fd,

&memory[buf_ptr],

buf_len,

cookie,

&bufused);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt32(memory, bufused, bufused_ptr);

args.GetReturnValue().Set(err);

}

void WASI::FdRenumber(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t from;

uint32_t to;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, from);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, to);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_renumber(%d, %d)\n", from, to);

uvwasi_errno_t err = uvwasi_fd_renumber(&wasi->uvw_, from, to);

args.GetReturnValue().Set(err);

}

void WASI::FdSeek(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

int64_t offset;

uint8_t whence;

uint32_t newoffset_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 4);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

UNWRAP_BIGINT_OR_RETURN(args, args[1], Int64, offset);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, whence);

CHECK_TO_TYPE_OR_RETURN(args, args[3], Uint32, newoffset_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_seek(%d, %d, %d, %d)\n", fd, offset, whence, newoffset_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, newoffset_ptr, 8);

uvwasi_filesize_t newoffset;

uvwasi_errno_t err = uvwasi_fd_seek(&wasi->uvw_,

fd,

offset,

whence,

&newoffset);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt64(memory, newoffset, newoffset_ptr);

args.GetReturnValue().Set(err);

}

void WASI::FdSync(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

RETURN_IF_BAD_ARG_COUNT(args, 1);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_sync(%d)\n", fd);

uvwasi_errno_t err = uvwasi_fd_sync(&wasi->uvw_, fd);

args.GetReturnValue().Set(err);

}

void WASI::FdTell(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t offset_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 2);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, offset_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi, "fd_tell(%d, %d)\n", fd, offset_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, offset_ptr, 8);

uvwasi_filesize_t offset;

uvwasi_errno_t err = uvwasi_fd_tell(&wasi->uvw_, fd, &offset);

if (err == UVWASI_ESUCCESS)

wasi->writeUInt64(memory, offset, offset_ptr);

args.GetReturnValue().Set(err);

}

void WASI::FdWrite(const FunctionCallbackInfo<Value>& args) {

WASI* wasi;

uint32_t fd;

uint32_t iovs_ptr;

uint32_t iovs_len;

uint32_t nwritten_ptr;

char* memory;

size_t mem_size;

RETURN_IF_BAD_ARG_COUNT(args, 4);

CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);

CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, iovs_ptr);

CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, iovs_len);

CHECK_TO_TYPE_OR_RETURN(args, args[3], Uint32, nwritten_ptr);

ASSIGN_OR_RETURN_UNWRAP(&wasi, args.This());

Debug(wasi,

"fd_write(%d, %d, %d, %d)\n",

fd,

iovs_ptr,

iovs_len,

nwritten_ptr);

GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);

CHECK_BOUNDS_OR_RETURN(args, mem_size, iovs_ptr, iovs_len * 8);

CHECK_BOUNDS_OR_RETURN(args, mem_size, nwritten_ptr, 4);

uvwasi_ciovec_t* iovs = UncheckedCalloc<uvwasi_ciovec_t>(iovs_len);

if (iovs == nullptr) {

args.GetReturnValue().Set(UVWASI_ENOMEM);

return;

}

for (uint32_t i = 0; i < iovs_len; ++i) {

uint32_t buf_ptr;

uint32_t buf_len;

wasi->readUInt32(memory, &buf_ptr, iovs_ptr);

wasi->readUInt32(memory, &buf_len, iovs_ptr + 4);