// 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 "tracing/trace_event.h"

#include "req_wrap-inl.h"

#include "stream_base-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>

namespace node {

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)

#define TRACE_NAME(name) "fs.sync." #name

#define GET_TRACE_ENABLED \

(*TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED \

(TRACING_CATEGORY_NODE2(fs, sync)) != 0)

#define FS_SYNC_TRACE_BEGIN(syscall, ...) \

if (GET_TRACE_ENABLED) \

TRACE_EVENT_BEGIN(TRACING_CATEGORY_NODE2(fs, sync), TRACE_NAME(syscall), \

##__VA_ARGS__);

#define FS_SYNC_TRACE_END(syscall, ...) \

if (GET_TRACE_ENABLED) \

TRACE_EVENT_END(TRACING_CATEGORY_NODE2(fs, sync), TRACE_NAME(syscall), \

##__VA_ARGS__);

// We sometimes need to convert a C++ lambda function to a raw C-style function.

// This is helpful, because ReqWrap::Dispatch() does not recognize lambda

// functions, and thus does not wrap them properly.

typedef void(*uv_fs_callback_t)(uv_fs_t*);

// 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, Local<Object> obj)

: AsyncWrap(env,

obj.IsEmpty() ? env->fd_constructor_template()

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

AsyncWrap::PROVIDER_FILEHANDLE),

StreamBase(env),

fd_(fd) {

MakeWeak();

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();

}

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

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

CHECK(args.IsConstructCall());

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

FileHandle* handle =

new FileHandle(env, args[0].As<Int32>()->Value(), args.This());

if (args[1]->IsNumber())

handle->read_offset_ = args[1]->IntegerValue(env->context()).FromJust();

if (args[2]->IsNumber())

handle->read_length_ = args[2]->IntegerValue(env->context()).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;

uv_fs_t req;

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

uv_fs_req_cleanup(&req);

AfterClose();

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.

HandleScope handle_scope(env->isolate());

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>();

CHECK(!reading_);

if (!closed_ && !closing_) {

closing_ = true;

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

auto AfterClose = uv_fs_callback_t{[](uv_fs_t* req) {

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

CHECK_NOT_NULL(close);

close->file_handle()->AfterClose();

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

if (req->result < 0) {

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

} else {

close->Resolve();

}

delete close;

}};

int ret = req->Dispatch(uv_fs_close, 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 FileHandle::ReleaseFD(const FunctionCallbackInfo<Value>& args) {

FileHandle* fd;

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

// Just act as if this FileHandle has been closed.

fd->AfterClose();

}

void FileHandle::AfterClose() {

closing_ = false;

closed_ = true;

if (reading_ && !persistent().IsEmpty())

EmitRead(UV_EOF);

}

FileHandleReadWrap::FileHandleReadWrap(FileHandle* handle, Local<Object> obj)

: ReqWrap(handle->env(), obj, AsyncWrap::PROVIDER_FSREQWRAP),

file_handle_(handle) {}

int FileHandle::ReadStart() {

if (!IsAlive() || IsClosing())

return UV_EOF;

reading_ = true;

if (current_read_)

return 0;

std::unique_ptr<FileHandleReadWrap> read_wrap;

if (read_length_ == 0) {

EmitRead(UV_EOF);

return 0;

}

{

// Create a new FileHandleReadWrap or re-use one.

// Either way, we need these two scopes for AsyncReset() or otherwise

// for creating the new instance.

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

AsyncHooks::DefaultTriggerAsyncIdScope trigger_scope(this);

auto& freelist = env()->file_handle_read_wrap_freelist();

if (freelist.size() > 0) {

read_wrap = std::move(freelist.back());

freelist.pop_back();

read_wrap->AsyncReset();

read_wrap->file_handle_ = this;

} else {

Local<Object> wrap_obj = env()->filehandlereadwrap_template()

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

read_wrap.reset(new FileHandleReadWrap(this, wrap_obj));

}

}

int64_t recommended_read = 65536;

if (read_length_ >= 0 && read_length_ <= recommended_read)

recommended_read = read_length_;

read_wrap->buffer_ = EmitAlloc(recommended_read);

current_read_ = std::move(read_wrap);

current_read_->Dispatch(uv_fs_read,

fd_,

&current_read_->buffer_,

1,

read_offset_,

uv_fs_callback_t{[](uv_fs_t* req) {

FileHandle* handle;

{

FileHandleReadWrap* req_wrap = FileHandleReadWrap::from_req(req);

handle = req_wrap->file_handle_;

CHECK_EQ(handle->current_read_.get(), req_wrap);

}

// ReadStart() checks whether current_read_ is set to determine whether

// a read is in progress. Moving it into a local variable makes sure that

// the ReadStart() call below doesn't think we're still actively reading.

std::unique_ptr<FileHandleReadWrap> read_wrap =

std::move(handle->current_read_);

int result = req->result;

uv_buf_t buffer = read_wrap->buffer_;

uv_fs_req_cleanup(req);

// Push the read wrap back to the freelist, or let it be destroyed

// once we’re exiting the current scope.

constexpr size_t wanted_freelist_fill = 100;

auto& freelist = handle->env()->file_handle_read_wrap_freelist();

if (freelist.size() < wanted_freelist_fill) {

read_wrap->Reset();

freelist.emplace_back(std::move(read_wrap));

}

if (result >= 0) {

// Read at most as many bytes as we originally planned to.

if (handle->read_length_ >= 0 && handle->read_length_ < result)

result = handle->read_length_;

// If we read data and we have an expected length, decrease it by

// how much we have read.

if (handle->read_length_ >= 0)

handle->read_length_ -= result;

// If we have an offset, increase it by how much we have read.

if (handle->read_offset_ >= 0)

handle->read_offset_ += result;

}

// Reading 0 bytes from a file always means EOF, or that we reached

// the end of the requested range.

if (result == 0)

result = UV_EOF;

handle->EmitRead(result, buffer);

// Start over, if EmitRead() didn’t tell us to stop.

if (handle->reading_)

handle->ReadStart();

}});

return 0;

}

int FileHandle::ReadStop() {

reading_ = false;

return 0;

}

typedef SimpleShutdownWrap<ReqWrap<uv_fs_t>> FileHandleCloseWrap;

ShutdownWrap* FileHandle::CreateShutdownWrap(Local<Object> object) {

return new FileHandleCloseWrap(this, object);

}

int FileHandle::DoShutdown(ShutdownWrap* req_wrap) {

FileHandleCloseWrap* wrap = static_cast<FileHandleCloseWrap*>(req_wrap);

closing_ = true;

wrap->Dispatch(uv_fs_close, fd_, uv_fs_callback_t{[](uv_fs_t* req) {

FileHandleCloseWrap* wrap = static_cast<FileHandleCloseWrap*>(

FileHandleCloseWrap::from_req(req));

FileHandle* handle = static_cast<FileHandle*>(wrap->stream());

handle->AfterClose();

int result = req->result;

uv_fs_req_cleanup(req);

wrap->Done(result);

}});

return 0;

}

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

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

}

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

Resolve(node::FillGlobalStatsArray(env(), stat));

}

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

Local<Value> argv[2] {

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

value

};

MakeCallback(env()->oncomplete_string(),

value->IsUndefined() ? 1 : arraysize(argv),

argv);

}

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

args.GetReturnValue().SetUndefined();

}

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

CHECK(args.IsConstructCall());

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

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

}

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->ResolveStat(&req->statbuf);

}

}

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 class is only used on sync fs calls.

// For async calls FSReqWrap is used.

class FSReqWrapSync {

public:

FSReqWrapSync() {}

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

uv_fs_t req;

private:

DISALLOW_COPY_AND_ASSIGN(FSReqWrapSync);

};

// 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_NOT_NULL(req_wrap);

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

int err = req_wrap->Dispatch(fn, fn_args..., after);

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, FSReqWrapSync* 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;

}

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<double, Float64Array>(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_NOT_NULL(*path);

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

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

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

uv_fs_access, *path, mode);

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

CHECK_EQ(argc, 4);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(access);

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

FS_SYNC_TRACE_END(access);

}

}

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_async = GetReqWrap(env, args[1]);

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

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

uv_fs_close, fd);

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

CHECK_EQ(argc, 3);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(close);

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

FS_SYNC_TRACE_END(close);

}

}

// 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, 2);

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

CHECK_NOT_NULL(*path);

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

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

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

uv_fs_stat, *path);

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

CHECK_EQ(argc, 3);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(stat);

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

FS_SYNC_TRACE_END(stat);

if (err != 0) {

return; // error info is in ctx

}

Local<Value> arr = node::FillGlobalStatsArray(env,

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

args.GetReturnValue().Set(arr);

}

}

static void LStat(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_NOT_NULL(*path);

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

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

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

uv_fs_lstat, *path);

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

CHECK_EQ(argc, 3);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(lstat);

int err = SyncCall(env, args[2], &req_wrap_sync, "lstat", uv_fs_lstat,

*path);

FS_SYNC_TRACE_END(lstat);

if (err != 0) {

return; // error info is in ctx

}

Local<Value> arr = node::FillGlobalStatsArray(env,

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

args.GetReturnValue().Set(arr);

}

}

static void FStat(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_async = GetReqWrap(env, args[1]);

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

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

uv_fs_fstat, fd);

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

CHECK_EQ(argc, 3);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(fstat);

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

FS_SYNC_TRACE_END(fstat);

if (err != 0) {

return; // error info is in ctx

}

Local<Value> arr = node::FillGlobalStatsArray(env,

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

args.GetReturnValue().Set(arr);

}

}

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_NOT_NULL(*target);

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

CHECK_NOT_NULL(*path);

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

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

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

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

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

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

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

CHECK_EQ(argc, 5);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(symlink);

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

uv_fs_symlink, *target, *path, flags);

FS_SYNC_TRACE_END(symlink);

}

}

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_NOT_NULL(*src);

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

CHECK_NOT_NULL(*dest);

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

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

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

AfterNoArgs, uv_fs_link, *src, *dest);

} else { // link(src, dest)

CHECK_EQ(argc, 4);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(link);

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

uv_fs_link, *src, *dest);

FS_SYNC_TRACE_END(link);

}

}

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_NOT_NULL(*path);

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

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

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

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

uv_fs_readlink, *path);

} else {

CHECK_EQ(argc, 4);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(readlink);

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

uv_fs_readlink, *path);

FS_SYNC_TRACE_END(readlink);

if (err < 0) {

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

}

const char* link_path = static_cast<const char*>(req_wrap_sync.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());

}