// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

#include "aliased_buffer.h"

#include "node_buffer.h"

#include "node_internals.h"

#include "node_stat_watcher.h"

#include "node_file.h"

#include "req_wrap-inl.h"

#include "string_bytes.h"

#include "string_search.h"

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <string.h>

#include <errno.h>

#include <limits.h>

#if defined(__MINGW32__) || defined(_MSC_VER)

# include <io.h>

#endif

#include <memory>

#include <vector>

namespace node {

void FillStatsArray(AliasedBuffer<double, v8::Float64Array>* fields_ptr,

const uv_stat_t* s, int offset) {

AliasedBuffer<double, v8::Float64Array>& fields = *fields_ptr;

fields[offset + 0] = s->st_dev;

fields[offset + 1] = s->st_mode;

fields[offset + 2] = s->st_nlink;

fields[offset + 3] = s->st_uid;

fields[offset + 4] = s->st_gid;

fields[offset + 5] = s->st_rdev;

#if defined(__POSIX__)

fields[offset + 6] = s->st_blksize;

#else

fields[offset + 6] = -1;

#endif

fields[offset + 7] = s->st_ino;

fields[offset + 8] = s->st_size;

#if defined(__POSIX__)

fields[offset + 9] = s->st_blocks;

#else

fields[offset + 9] = -1;

#endif

// Dates.

// NO-LINT because the fields are 'long' and we just want to cast to `unsigned`

#define X(idx, name) \

/* NOLINTNEXTLINE(runtime/int) */ \

fields[offset + idx] = ((unsigned long)(s->st_##name.tv_sec) * 1e3) + \

/* NOLINTNEXTLINE(runtime/int) */ \

((unsigned long)(s->st_##name.tv_nsec) / 1e6); \

X(10, atim)

X(11, mtim)

X(12, ctim)

X(13, birthtim)

#undef X

}

namespace fs {

using v8::Array;

using v8::Context;

using v8::EscapableHandleScope;

using v8::Float64Array;

using v8::Function;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::HandleScope;

using v8::Int32;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::MaybeLocal;

using v8::Number;

using v8::Object;

using v8::ObjectTemplate;

using v8::Promise;

using v8::String;

using v8::Symbol;

using v8::Uint32;

using v8::Undefined;

using v8::Value;

#ifndef MIN

# define MIN(a, b) ((a) < (b) ? (a) : (b))

#endif

#define GET_OFFSET(a) ((a)->IsNumber() ? (a).As<Integer>()->Value() : -1)

// The FileHandle object wraps a file descriptor and will close it on garbage

// collection if necessary. If that happens, a process warning will be

// emitted (or a fatal exception will occur if the fd cannot be closed.)

FileHandle::FileHandle(Environment* env, int fd)

: AsyncWrap(env,

env->fd_constructor_template()

->NewInstance(env->context()).ToLocalChecked(),

AsyncWrap::PROVIDER_FILEHANDLE), fd_(fd) {

MakeWeak<FileHandle>(this);

v8::PropertyAttribute attr =

static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);

object()->DefineOwnProperty(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "fd"),

Integer::New(env->isolate(), fd),

attr).FromJust();

}

FileHandle::~FileHandle() {

CHECK(!closing_); // We should not be deleting while explicitly closing!

Close(); // Close synchronously and emit warning

CHECK(closed_); // We have to be closed at the point

}

// Close the file descriptor if it hasn't already been closed. A process

// warning will be emitted using a SetImmediate to avoid calling back to

// JS during GC. If closing the fd fails at this point, a fatal exception

// will crash the process immediately.

inline void FileHandle::Close() {

if (closed_) return;

closed_ = true;

uv_fs_t req;

int ret = uv_fs_close(env()->event_loop(), &req, fd_, nullptr);

uv_fs_req_cleanup(&req);

struct err_detail { int ret; int fd; };

err_detail* detail = new err_detail { ret, fd_ };

if (ret < 0) {

// Do not unref this

env()->SetImmediate([](Environment* env, void* data) {

char msg[70];

err_detail* detail = static_cast<err_detail*>(data);

snprintf(msg, arraysize(msg),

"Closing file descriptor %d on garbage collection failed",

detail->fd);

// This exception will end up being fatal for the process because

// it is being thrown from within the SetImmediate handler and

// there is no JS stack to bubble it to. In other words, tearing

// down the process is the only reasonable thing we can do here.

env->ThrowUVException(detail->ret, "close", msg);

delete detail;

}, detail);

return;

}

// If the close was successful, we still want to emit a process warning

// to notify that the file descriptor was gc'd. We want to be noisy about

// this because not explicitly closing the FileHandle is a bug.

env()->SetUnrefImmediate([](Environment* env, void* data) {

char msg[70];

err_detail* detail = static_cast<err_detail*>(data);

snprintf(msg, arraysize(msg),

"Closing file descriptor %d on garbage collection",

detail->fd);

delete detail;

ProcessEmitWarning(env, msg);

}, detail);

}

void FileHandle::CloseReq::Resolve() {

HandleScope scope(env()->isolate());

InternalCallbackScope callback_scope(this);

Local<Promise> promise = promise_.Get(env()->isolate());

Local<Promise::Resolver> resolver = promise.As<Promise::Resolver>();

resolver->Resolve(env()->context(), Undefined(env()->isolate())).FromJust();

}

void FileHandle::CloseReq::Reject(Local<Value> reason) {

HandleScope scope(env()->isolate());

InternalCallbackScope callback_scope(this);

Local<Promise> promise = promise_.Get(env()->isolate());

Local<Promise::Resolver> resolver = promise.As<Promise::Resolver>();

resolver->Reject(env()->context(), reason).FromJust();

}

FileHandle* FileHandle::CloseReq::file_handle() {

HandleScope scope(env()->isolate());

Local<Value> val = ref_.Get(env()->isolate());

Local<Object> obj = val.As<Object>();

return Unwrap<FileHandle>(obj);

}

// Closes this FileHandle asynchronously and returns a Promise that will be

// resolved when the callback is invoked, or rejects with a UVException if

// there was a problem closing the fd. This is the preferred mechanism for

// closing the FD object even tho the object will attempt to close

// automatically on gc.

inline MaybeLocal<Promise> FileHandle::ClosePromise() {

Isolate* isolate = env()->isolate();

EscapableHandleScope scope(isolate);

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

auto maybe_resolver = Promise::Resolver::New(context);

CHECK(!maybe_resolver.IsEmpty());

Local<Promise::Resolver> resolver = maybe_resolver.ToLocalChecked();

Local<Promise> promise = resolver.As<Promise>();

if (!closed_ && !closing_) {

closing_ = true;

CloseReq* req = new CloseReq(env(), promise, object());

auto AfterClose = [](uv_fs_t* req) {

CloseReq* close = static_cast<CloseReq*>(req->data);

CHECK_NE(close, nullptr);

close->file_handle()->closing_ = false;

Isolate* isolate = close->env()->isolate();

if (req->result < 0) {

close->Reject(UVException(isolate, req->result, "close"));

} else {

close->file_handle()->closed_ = true;

close->Resolve();

}

delete close;

};

req->Dispatched();

int ret = uv_fs_close(env()->event_loop(), req->req(), fd_, AfterClose);

if (ret < 0) {

req->Reject(UVException(isolate, ret, "close"));

delete req;

}

} else {

// Already closed. Just reject the promise immediately

resolver->Reject(context, UVException(isolate, UV_EBADF, "close"))

.FromJust();

}

return scope.Escape(promise);

}

void FileHandle::Close(const FunctionCallbackInfo<Value>& args) {

FileHandle* fd;

ASSIGN_OR_RETURN_UNWRAP(&fd, args.Holder());

args.GetReturnValue().Set(fd->ClosePromise().ToLocalChecked());

}

void FSReqWrap::Reject(Local<Value> reject) {

MakeCallback(env()->oncomplete_string(), 1, &reject);

}

void FSReqWrap::FillStatsArray(const uv_stat_t* stat) {

node::FillStatsArray(env()->fs_stats_field_array(), stat);

}

void FSReqWrap::ResolveStat() {

Resolve(Undefined(env()->isolate()));

}

void FSReqWrap::Resolve(Local<Value> value) {

Local<Value> argv[2] {

Null(env()->isolate()),

value

};

MakeCallback(env()->oncomplete_string(), arraysize(argv), argv);

}

void FSReqWrap::SetReturnValue(const FunctionCallbackInfo<Value>& args) {

args.GetReturnValue().SetUndefined();

}

void FSReqPromise::SetReturnValue(const FunctionCallbackInfo<Value>& args) {

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

args.GetReturnValue().Set(

object()->Get(context, env()->promise_string()).ToLocalChecked()

.As<Promise::Resolver>()->GetPromise());

}

void NewFSReqWrap(const FunctionCallbackInfo<Value>& args) {

CHECK(args.IsConstructCall());

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

new FSReqWrap(env, args.This());

}

FSReqPromise::FSReqPromise(Environment* env)

: FSReqBase(env,

env->fsreqpromise_constructor_template()

->NewInstance(env->context()).ToLocalChecked(),

AsyncWrap::PROVIDER_FSREQPROMISE),

stats_field_array_(env->isolate(), 14) {

auto resolver = Promise::Resolver::New(env->context()).ToLocalChecked();

object()->Set(env->context(), env->promise_string(),

resolver).FromJust();

}

FSReqPromise::~FSReqPromise() {

// Validate that the promise was explicitly resolved or rejected.

CHECK(finished_);

}

void FSReqPromise::Reject(Local<Value> reject) {

finished_ = true;

HandleScope scope(env()->isolate());

InternalCallbackScope callback_scope(this);

Local<Value> value =

object()->Get(env()->context(),

env()->promise_string()).ToLocalChecked();

Local<Promise::Resolver> resolver = value.As<Promise::Resolver>();

resolver->Reject(env()->context(), reject).FromJust();

}

void FSReqPromise::FillStatsArray(const uv_stat_t* stat) {

node::FillStatsArray(&stats_field_array_, stat);

}

void FSReqPromise::ResolveStat() {

Resolve(stats_field_array_.GetJSArray());

}

void FSReqPromise::Resolve(Local<Value> value) {

finished_ = true;

HandleScope scope(env()->isolate());

InternalCallbackScope callback_scope(this);

Local<Value> val =

object()->Get(env()->context(),

env()->promise_string()).ToLocalChecked();

Local<Promise::Resolver> resolver = val.As<Promise::Resolver>();

resolver->Resolve(env()->context(), value).FromJust();

}

FSReqAfterScope::FSReqAfterScope(FSReqBase* wrap, uv_fs_t* req)

: wrap_(wrap),

req_(req),

handle_scope_(wrap->env()->isolate()),

context_scope_(wrap->env()->context()) {

CHECK_EQ(wrap_->req(), req);

}

FSReqAfterScope::~FSReqAfterScope() {

uv_fs_req_cleanup(wrap_->req());

delete wrap_;

}

// TODO(joyeecheung): create a normal context object, and

// construct the actual errors in the JS land using the context.

// The context should include fds for some fs APIs, currently they are

// missing in the error messages. The path, dest, syscall, fd, .etc

// can be put into the context before the binding is even invoked,

// the only information that has to come from the C++ layer is the

// error number (and possibly the syscall for abstraction),

// which is also why the errors should have been constructed

// in JS for more flexibility.

void FSReqAfterScope::Reject(uv_fs_t* req) {

wrap_->Reject(UVException(wrap_->env()->isolate(),

req->result,

wrap_->syscall(),

nullptr,

req->path,

wrap_->data()));

}

bool FSReqAfterScope::Proceed() {

if (req_->result < 0) {

Reject(req_);

return false;

}

return true;

}

void AfterNoArgs(uv_fs_t* req) {

FSReqBase* req_wrap = static_cast<FSReqBase*>(req->data);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed())

req_wrap->Resolve(Undefined(req_wrap->env()->isolate()));

}

void AfterStat(uv_fs_t* req) {

FSReqBase* req_wrap = static_cast<FSReqBase*>(req->data);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed()) {

req_wrap->FillStatsArray(&req->statbuf);

req_wrap->ResolveStat();

}

}

void AfterInteger(uv_fs_t* req) {

FSReqBase* req_wrap = static_cast<FSReqBase*>(req->data);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed())

req_wrap->Resolve(Integer::New(req_wrap->env()->isolate(), req->result));

}

void AfterOpenFileHandle(uv_fs_t* req) {

FSReqWrap* req_wrap = static_cast<FSReqWrap*>(req->data);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed()) {

FileHandle* fd = new FileHandle(req_wrap->env(), req->result);

req_wrap->Resolve(fd->object());

}

}

void AfterStringPath(uv_fs_t* req) {

FSReqBase* req_wrap = static_cast<FSReqBase*>(req->data);

FSReqAfterScope after(req_wrap, req);

MaybeLocal<Value> link;

Local<Value> error;

if (after.Proceed()) {

link = StringBytes::Encode(req_wrap->env()->isolate(),

static_cast<const char*>(req->path),

req_wrap->encoding(),

&error);

if (link.IsEmpty())

req_wrap->Reject(error);

else

req_wrap->Resolve(link.ToLocalChecked());

}

}

void AfterStringPtr(uv_fs_t* req) {

FSReqBase* req_wrap = static_cast<FSReqBase*>(req->data);

FSReqAfterScope after(req_wrap, req);

MaybeLocal<Value> link;

Local<Value> error;

if (after.Proceed()) {

link = StringBytes::Encode(req_wrap->env()->isolate(),

static_cast<const char*>(req->ptr),

req_wrap->encoding(),

&error);

if (link.IsEmpty())

req_wrap->Reject(error);

else

req_wrap->Resolve(link.ToLocalChecked());

}

}

void AfterScanDir(uv_fs_t* req) {

FSReqBase* req_wrap = static_cast<FSReqBase*>(req->data);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed()) {

Environment* env = req_wrap->env();

Local<Value> error;

int r;

Local<Array> names = Array::New(env->isolate(), 0);

Local<Function> fn = env->push_values_to_array_function();

Local<Value> name_argv[NODE_PUSH_VAL_TO_ARRAY_MAX];

size_t name_idx = 0;

for (int i = 0; ; i++) {

uv_dirent_t ent;

r = uv_fs_scandir_next(req, &ent);

if (r == UV_EOF)

break;

if (r != 0) {

return req_wrap->Reject(

UVException(r, nullptr, req_wrap->syscall(),

static_cast<const char*>(req->path)));

}

MaybeLocal<Value> filename =

StringBytes::Encode(env->isolate(),

ent.name,

req_wrap->encoding(),

&error);

if (filename.IsEmpty())

return req_wrap->Reject(error);

name_argv[name_idx++] = filename.ToLocalChecked();

if (name_idx >= arraysize(name_argv)) {

fn->Call(env->context(), names, name_idx, name_argv)

.ToLocalChecked();

name_idx = 0;

}

}

if (name_idx > 0) {

fn->Call(env->context(), names, name_idx, name_argv)

.ToLocalChecked();

}

req_wrap->Resolve(names);

}

}

// This struct is only used on sync fs calls.

// For async calls FSReqWrap is used.

class fs_req_wrap {

public:

fs_req_wrap() {}

~fs_req_wrap() { uv_fs_req_cleanup(&req); }

uv_fs_t req;

private:

DISALLOW_COPY_AND_ASSIGN(fs_req_wrap);

};

// Returns nullptr if the operation fails from the start.

template <typename Func, typename... Args>

inline FSReqBase* AsyncDestCall(Environment* env,

FSReqBase* req_wrap,

const FunctionCallbackInfo<Value>& args,

const char* syscall, const char* dest, size_t len,

enum encoding enc, uv_fs_cb after, Func fn, Args... fn_args) {

CHECK_NE(req_wrap, nullptr);

req_wrap->Init(syscall, dest, len, enc);

int err = fn(env->event_loop(), req_wrap->req(), fn_args..., after);

req_wrap->Dispatched();

if (err < 0) {

uv_fs_t* uv_req = req_wrap->req();

uv_req->result = err;

uv_req->path = nullptr;

after(uv_req); // after may delete req_wrap if there is an error

req_wrap = nullptr;

} else {

req_wrap->SetReturnValue(args);

}

return req_wrap;

}

// Returns nullptr if the operation fails from the start.

template <typename Func, typename... Args>

inline FSReqBase* AsyncCall(Environment* env,

FSReqBase* req_wrap,

const FunctionCallbackInfo<Value>& args,

const char* syscall, enum encoding enc,

uv_fs_cb after, Func fn, Args... fn_args) {

return AsyncDestCall(env, req_wrap, args,

syscall, nullptr, 0, enc,

after, fn, fn_args...);

}

// Template counterpart of SYNC_CALL, except that it only puts

// the error number and the syscall in the context instead of

// creating an error in the C++ land.

// ctx must be checked using value->IsObject() before being passed.

template <typename Func, typename... Args>

inline int SyncCall(Environment* env, Local<Value> ctx, fs_req_wrap* req_wrap,

const char* syscall, Func fn, Args... args) {

env->PrintSyncTrace();

int err = fn(env->event_loop(), &(req_wrap->req), args..., nullptr);

if (err < 0) {

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

Local<Object> ctx_obj = ctx.As<Object>();

Isolate *isolate = env->isolate();

ctx_obj->Set(context,

env->errno_string(),

Integer::New(isolate, err)).FromJust();

ctx_obj->Set(context,

env->syscall_string(),

OneByteString(isolate, syscall)).FromJust();

}

return err;

}

#define SYNC_DEST_CALL(func, path, dest, ...) \

fs_req_wrap sync_wrap; \

env->PrintSyncTrace(); \

int err = uv_fs_ ## func(env->event_loop(), \

&sync_wrap.req, \

__VA_ARGS__, \

nullptr); \

if (err < 0) { \

return env->ThrowUVException(err, #func, nullptr, path, dest); \

} \

#define SYNC_CALL(func, path, ...) \

SYNC_DEST_CALL(func, path, nullptr, __VA_ARGS__) \

#define SYNC_REQ sync_wrap.req

#define SYNC_RESULT err

inline FSReqBase* GetReqWrap(Environment* env, Local<Value> value) {

if (value->IsObject()) {

return Unwrap<FSReqBase>(value.As<Object>());

} else if (value->StrictEquals(env->fs_use_promises_symbol())) {

return new FSReqPromise(env);

}

return nullptr;

}

void Access(const FunctionCallbackInfo<Value>& args) {

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

HandleScope scope(env->isolate());

const int argc = args.Length();

CHECK_GE(argc, 2);

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

int mode = args[1].As<Int32>()->Value();

BufferValue path(env->isolate(), args[0]);

CHECK_NE(*path, nullptr);

FSReqBase* req_wrap = GetReqWrap(env, args[2]);

if (req_wrap != nullptr) { // access(path, mode, req)

AsyncCall(env, req_wrap, args, "access", UTF8, AfterNoArgs,

uv_fs_access, *path, mode);

} else { // access(path, mode, undefined, ctx)

CHECK_EQ(argc, 4);

fs_req_wrap req_wrap;

SyncCall(env, args[3], &req_wrap, "access", uv_fs_access, *path, mode);

}

}

void Close(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 2);

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

int fd = args[0].As<Int32>()->Value();

FSReqBase* req_wrap = GetReqWrap(env, args[1]);

if (req_wrap != nullptr) { // close(fd, req)

AsyncCall(env, req_wrap, args, "close", UTF8, AfterNoArgs,

uv_fs_close, fd);

} else { // close(fd, undefined, ctx)

CHECK_EQ(argc, 3);

fs_req_wrap req_wrap;

SyncCall(env, args[2], &req_wrap, "close", uv_fs_close, fd);

}

}

// Used to speed up module loading. Returns the contents of the file as

// a string or undefined when the file cannot be opened or "main" is not found

// in the file.

static void InternalModuleReadJSON(const FunctionCallbackInfo<Value>& args) {

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

uv_loop_t* loop = env->event_loop();

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

node::Utf8Value path(env->isolate(), args[0]);

if (strlen(*path) != path.length())

return; // Contains a nul byte.

uv_fs_t open_req;

const int fd = uv_fs_open(loop, &open_req, *path, O_RDONLY, 0, nullptr);

uv_fs_req_cleanup(&open_req);

if (fd < 0) {

return;

}

std::shared_ptr<void> defer_close(nullptr, [fd, loop] (...) {

uv_fs_t close_req;

CHECK_EQ(0, uv_fs_close(loop, &close_req, fd, nullptr));

uv_fs_req_cleanup(&close_req);

});

const size_t kBlockSize = 32 << 10;

std::vector<char> chars;

int64_t offset = 0;

ssize_t numchars;

do {

const size_t start = chars.size();

chars.resize(start + kBlockSize);

uv_buf_t buf;

buf.base = &chars[start];

buf.len = kBlockSize;

uv_fs_t read_req;

numchars = uv_fs_read(loop, &read_req, fd, &buf, 1, offset, nullptr);

uv_fs_req_cleanup(&read_req);

if (numchars < 0)

return;

offset += numchars;

} while (static_cast<size_t>(numchars) == kBlockSize);

size_t start = 0;

if (offset >= 3 && 0 == memcmp(&chars[0], "\xEF\xBB\xBF", 3)) {

start = 3; // Skip UTF-8 BOM.

}

const size_t size = offset - start;

if (size == 0 || size == SearchString(&chars[start], size, "\"main\"")) {

return;

} else {

Local<String> chars_string =

String::NewFromUtf8(env->isolate(),

&chars[start],

String::kNormalString,

size);

args.GetReturnValue().Set(chars_string);

}

}

// Used to speed up module loading. Returns 0 if the path refers to

// a file, 1 when it's a directory or < 0 on error (usually -ENOENT.)

// The speedup comes from not creating thousands of Stat and Error objects.

static void InternalModuleStat(const FunctionCallbackInfo<Value>& args) {

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

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

node::Utf8Value path(env->isolate(), args[0]);

uv_fs_t req;

int rc = uv_fs_stat(env->event_loop(), &req, *path, nullptr);

if (rc == 0) {

const uv_stat_t* const s = static_cast<const uv_stat_t*>(req.ptr);

rc = !!(s->st_mode & S_IFDIR);

}

uv_fs_req_cleanup(&req);

args.GetReturnValue().Set(rc);

}

static void Stat(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 1);

BufferValue path(env->isolate(), args[0]);

CHECK_NE(*path, nullptr);

FSReqBase* req_wrap = GetReqWrap(env, args[1]);

if (req_wrap != nullptr) { // stat(path, req)

AsyncCall(env, req_wrap, args, "stat", UTF8, AfterStat,

uv_fs_stat, *path);

} else { // stat(path, undefined, ctx)

CHECK_EQ(argc, 3);

fs_req_wrap req_wrap;

int err = SyncCall(env, args[2], &req_wrap, "stat", uv_fs_stat, *path);

if (err == 0) {

FillStatsArray(env->fs_stats_field_array(),

static_cast<const uv_stat_t*>(req_wrap.req.ptr));

}

}

}

static void LStat(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 1);

BufferValue path(env->isolate(), args[0]);

CHECK_NE(*path, nullptr);

FSReqBase* req_wrap = GetReqWrap(env, args[1]);

if (req_wrap != nullptr) { // lstat(path, req)

AsyncCall(env, req_wrap, args, "lstat", UTF8, AfterStat,

uv_fs_lstat, *path);

} else { // lstat(path, undefined, ctx)

CHECK_EQ(argc, 3);

fs_req_wrap req_wrap;

int err = SyncCall(env, args[2], &req_wrap, "lstat", uv_fs_lstat, *path);

if (err == 0) {

FillStatsArray(env->fs_stats_field_array(),

static_cast<const uv_stat_t*>(req_wrap.req.ptr));

}

}

}

static void FStat(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 1);

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

int fd = args[0].As<Int32>()->Value();

FSReqBase* req_wrap = GetReqWrap(env, args[1]);

if (req_wrap != nullptr) { // fstat(fd, req)

AsyncCall(env, req_wrap, args, "fstat", UTF8, AfterStat,

uv_fs_fstat, fd);

} else { // fstat(fd, undefined, ctx)

CHECK_EQ(argc, 3);

fs_req_wrap req_wrap;

int err = SyncCall(env, args[2], &req_wrap, "fstat", uv_fs_fstat, fd);

if (err == 0) {

FillStatsArray(env->fs_stats_field_array(),

static_cast<const uv_stat_t*>(req_wrap.req.ptr));

}

}

}

static void Symlink(const FunctionCallbackInfo<Value>& args) {

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

int argc = args.Length();

CHECK_GE(argc, 4);

BufferValue target(env->isolate(), args[0]);

CHECK_NE(*target, nullptr);

BufferValue path(env->isolate(), args[1]);

CHECK_NE(*path, nullptr);

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

int flags = args[2].As<Int32>()->Value();

FSReqBase* req_wrap = GetReqWrap(env, args[3]);

if (req_wrap != nullptr) { // symlink(target, path, flags, req)

AsyncDestCall(env, req_wrap, args, "symlink", *path, path.length(), UTF8,

AfterNoArgs, uv_fs_symlink, *target, *path, flags);

} else { // symlink(target, path, flags, undefinec, ctx)

CHECK_EQ(argc, 5);

fs_req_wrap req;

SyncCall(env, args[4], &req, "symlink",

uv_fs_symlink, *target, *path, flags);

}

}

static void Link(const FunctionCallbackInfo<Value>& args) {

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

int argc = args.Length();

CHECK_GE(argc, 3);

BufferValue src(env->isolate(), args[0]);

CHECK_NE(*src, nullptr);

BufferValue dest(env->isolate(), args[1]);

CHECK_NE(*dest, nullptr);

FSReqBase* req_wrap = GetReqWrap(env, args[2]);

if (req_wrap != nullptr) { // link(src, dest, req)

AsyncDestCall(env, req_wrap, args, "link", *dest, dest.length(), UTF8,

AfterNoArgs, uv_fs_link, *src, *dest);

} else { // link(src, dest)

CHECK_EQ(argc, 4);

fs_req_wrap req;

SyncCall(env, args[3], &req, "link",

uv_fs_link, *src, *dest);

}

}

static void ReadLink(const FunctionCallbackInfo<Value>& args) {

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

int argc = args.Length();

CHECK_GE(argc, 3);

BufferValue path(env->isolate(), args[0]);

CHECK_NE(*path, nullptr);

const enum encoding encoding = ParseEncoding(env->isolate(), args[1], UTF8);

FSReqBase* req_wrap = GetReqWrap(env, args[2]);

if (req_wrap != nullptr) { // readlink(path, encoding, req)

AsyncCall(env, req_wrap, args, "readlink", encoding, AfterStringPtr,

uv_fs_readlink, *path);

} else {

CHECK_EQ(argc, 4);

fs_req_wrap req;

int err = SyncCall(env, args[3], &req, "readlink",

uv_fs_readlink, *path);

if (err < 0) {

return; // syscall failed, no need to continue, error info is in ctx

}

const char* link_path = static_cast<const char*>(req.req.ptr);

Local<Value> error;

MaybeLocal<Value> rc = StringBytes::Encode(env->isolate(),

link_path,

encoding,

&error);

if (rc.IsEmpty()) {

Local<Object> ctx = args[3].As<Object>();

ctx->Set(env->context(), env->error_string(), error).FromJust();

return;

}

args.GetReturnValue().Set(rc.ToLocalChecked());

}

}

static void Rename(const FunctionCallbackInfo<Value>& args) {

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

int argc = args.Length();

CHECK_GE(argc, 3);

BufferValue old_path(env->isolate(), args[0]);

CHECK_NE(*old_path, nullptr);

BufferValue new_path(env->isolate(), args[1]);

CHECK_NE(*new_path, nullptr);

FSReqBase* req_wrap = GetReqWrap(env, args[2]);

if (req_wrap != nullptr) {

AsyncDestCall(env, req_wrap, args, "rename", *new_path, new_path.length(),

UTF8, AfterNoArgs, uv_fs_rename, *old_path, *new_path);

} else {

CHECK_EQ(argc, 4);

fs_req_wrap req;

SyncCall(env, args[3], &req, "rename", uv_fs_rename, *old_path, *new_path);

}

}

static void FTruncate(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 3);

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

const int fd = args[0].As<Int32>()->Value();

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

const int64_t len = args[1].As<Integer>()->Value();

FSReqBase* req_wrap = GetReqWrap(env, args[2]);

if (req_wrap != nullptr) {

AsyncCall(env, req_wrap, args, "ftruncate", UTF8, AfterNoArgs,

uv_fs_ftruncate, fd, len);

} else {

CHECK_EQ(argc, 4);

fs_req_wrap req;

SyncCall(env, args[3], &req, "ftruncate", uv_fs_ftruncate, fd, len);

}

}

static void Fdatasync(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 2);

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

const int fd = args[0].As<Int32>()->Value();

FSReqBase* req_wrap = GetReqWrap(env, args[1]);

if (req_wrap != nullptr) {

AsyncCall(env, req_wrap, args, "fdatasync", UTF8, AfterNoArgs,

uv_fs_fdatasync, fd);

} else {

CHECK_EQ(argc, 3);

fs_req_wrap req;

SyncCall(env, args[2], &req, "fdatasync", uv_fs_fdatasync, fd);

}

}

static void Fsync(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 2);

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

const int fd = args[0].As<Int32>()->Value();

FSReqBase* req_wrap = GetReqWrap(env, args[1]);

if (req_wrap != nullptr) {

AsyncCall(env, req_wrap, args, "fsync", UTF8, AfterNoArgs,

uv_fs_fsync, fd);

} else {

CHECK_EQ(argc, 3);

fs_req_wrap req;

SyncCall(env, args[2], &req, "fsync", uv_fs_fsync, fd);

}

}

static void Unlink(const FunctionCallbackInfo<Value>& args) {

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

const int argc = args.Length();

CHECK_GE(argc, 2);

BufferValue path(env->isolate(), args[0]);

CHECK_NE(*path, nullptr);

FSReqBase* req_wrap = GetReqWrap(env, args[1]);

if (req_wrap != nullptr) {

AsyncCall(env, req_wrap, args, "unlink", UTF8, AfterNoArgs,

uv_fs_unlink, *path);

} else {

CHECK_EQ(argc, 3);

fs_req_wrap req;