// 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 "node_file.h" // NOLINT(build/include_inline)

#include "node_file-inl.h"

#include "aliased_buffer.h"

#include "memory_tracker-inl.h"

#include "node_buffer.h"

#include "node_process.h"

#include "node_stat_watcher.h"

#include "util-inl.h"

#include "tracing/trace_event.h"

#include "req_wrap-inl.h"

#include "stream_base-inl.h"

#include "string_bytes.h"

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <cstring>

#include <cerrno>

#include <climits>

#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::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 S_ISDIR

# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)

#endif

#ifdef __POSIX__

constexpr char kPathSeparator = '/';

#else

const char* const kPathSeparator = "\\/";

#endif

std::string Basename(const std::string& str, const std::string& extension) {

std::string ret = str;

// Remove everything leading up to and including the final path separator.

std::string::size_type pos = ret.find_last_of(kPathSeparator);

if (pos != std::string::npos) ret = ret.substr(pos + 1);

// Strip away the extension, if any.

if (ret.size() >= extension.size() &&

ret.substr(ret.size() - extension.size()) == extension) {

ret = ret.substr(0, ret.size() - extension.size());

}

return ret;

}

inline int64_t GetOffset(Local<Value> value) {

return IsSafeJsInt(value) ? value.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*);

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

tracker->TrackField("paths", paths_);

}

FileHandleReadWrap::~FileHandleReadWrap() {}

FSReqBase::~FSReqBase() {}

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

tracker->TrackField("continuation_data", continuation_data_);

}

// 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(BindingData* binding_data,

Local<Object> obj, int fd)

: AsyncWrap(binding_data->env(), obj, AsyncWrap::PROVIDER_FILEHANDLE),

StreamBase(env()),

fd_(fd),

binding_data_(binding_data) {

MakeWeak();

StreamBase::AttachToObject(GetObject());

}

FileHandle* FileHandle::New(BindingData* binding_data,

int fd, Local<Object> obj) {

Environment* env = binding_data->env();

if (obj.IsEmpty() && !env->fd_constructor_template()

->NewInstance(env->context())

.ToLocal(&obj)) {

return nullptr;

}

return new FileHandle(binding_data, obj, fd);

}

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

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

Environment* env = binding_data->env();

CHECK(args.IsConstructCall());

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

FileHandle* handle =

FileHandle::New(binding_data, args[0].As<Int32>()->Value(), args.This());

if (handle == nullptr) return;

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

}

int FileHandle::DoWrite(WriteWrap* w,

uv_buf_t* bufs,

size_t count,

uv_stream_t* send_handle) {

return UV_ENOSYS; // Not implemented (yet).

}

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

tracker->TrackField("current_read", current_read_);

}

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

struct err_detail { int ret; int fd; };

err_detail detail { ret, fd_ };

AfterClose();

if (ret < 0) {

// Do not unref this

env()->SetImmediate([detail](Environment* env) {

char msg[70];

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

});

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()->SetImmediate([detail](Environment* env) {

ProcessEmitWarning(env,

"Closing file descriptor %d on garbage collection",

detail.fd);

if (env->filehandle_close_warning()) {

env->set_filehandle_close_warning(false);

ProcessEmitDeprecationWarning(

env,

"Closing a FileHandle object on garbage collection is deprecated. "

"Please close FileHandle objects explicitly using "

"FileHandle.prototype.close(). In the future, an error will be "

"thrown if a file descriptor is closed during garbage collection.",

"DEP0137").IsNothing();

}

}, CallbackFlags::kUnrefed);

}

void FileHandle::CloseReq::Resolve() {

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

HandleScope scope(isolate);

InternalCallbackScope callback_scope(this);

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

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

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

}

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

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

HandleScope scope(isolate);

InternalCallbackScope callback_scope(this);

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

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

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

}

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

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

HandleScope scope(isolate);

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

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

return Unwrap<FileHandle>(obj);

}

FileHandle::CloseReq::CloseReq(Environment* env,

Local<Object> obj,

Local<Promise> promise,

Local<Value> ref)

: ReqWrap(env, obj, AsyncWrap::PROVIDER_FILEHANDLECLOSEREQ) {

promise_.Reset(env->isolate(), promise);

ref_.Reset(env->isolate(), ref);

}

FileHandle::CloseReq::~CloseReq() {

uv_fs_req_cleanup(req());

promise_.Reset();

ref_.Reset();

}

void FileHandle::CloseReq::MemoryInfo(MemoryTracker* tracker) const {

tracker->TrackField("promise", promise_);

tracker->TrackField("ref", ref_);

}

// 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.

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;

Local<Object> close_req_obj;

if (!env()

->fdclose_constructor_template()

->NewInstance(env()->context())

.ToLocal(&close_req_obj)) {

return MaybeLocal<Promise>();

}

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

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

std::unique_ptr<CloseReq> close(CloseReq::from_req(req));

CHECK_NOT_NULL(close);

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

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

if (req->result < 0) {

HandleScope handle_scope(isolate);

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

} else {

close->Resolve();

}

}};

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"))

.Check();

}

return scope.Escape(promise);

}

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

FileHandle* fd;

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

Local<Promise> ret;

if (!fd->ClosePromise().ToLocal(&ret)) return;

args.GetReturnValue().Set(ret);

}

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;

fd_ = -1;

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

EmitRead(UV_EOF);

}

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

tracker->TrackField("buffer", buffer_);

tracker->TrackField("file_handle", this->file_handle_);

}

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

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

file_handle_(handle) {}

int FileHandle::ReadStart() {

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

return UV_EOF;

reading_ = true;

if (current_read_)

return 0;

BaseObjectPtr<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 = binding_data_->file_handle_read_wrap_freelist;

if (freelist.size() > 0) {

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

freelist.pop_back();

// Use a fresh async resource.

// Lifetime is ensured via AsyncWrap::resource_.

Local<Object> resource = Object::New(env()->isolate());

USE(resource->Set(

env()->context(), env()->handle_string(), read_wrap->object()));

read_wrap->AsyncReset(resource);

read_wrap->file_handle_ = this;

} else {

Local<Object> wrap_obj;

if (!env()

->filehandlereadwrap_template()

->NewInstance(env()->context())

.ToLocal(&wrap_obj)) {

return UV_EBUSY;

}

read_wrap = MakeDetachedBaseObject<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.

BaseObjectPtr<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->binding_data_->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 FSReqCallback::Reject(Local<Value> reject) {

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

}

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

Resolve(FillGlobalStatsArray(binding_data(), use_bigint(), stat));

}

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

Local<Value> argv[2] {

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

value

};

MakeCallback(env()->oncomplete_string(),

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

argv);

}

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

args.GetReturnValue().SetUndefined();

}

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

CHECK(args.IsConstructCall());

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

new FSReqCallback(binding_data, args.This(), args[0]->IsTrue());

}

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

Clear();

}

void FSReqAfterScope::Clear() {

if (!wrap_) return;

uv_fs_req_cleanup(wrap_->req());

wrap_->Detach();

wrap_.reset();

}

// 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) {

BaseObjectPtr<FSReqBase> wrap { wrap_ };

Local<Value> exception =

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

req->result,

wrap_->syscall(),

nullptr,

req->path,

wrap_->data());

Clear();

wrap->Reject(exception);

}

bool FSReqAfterScope::Proceed() {

if (req_->result < 0) {

Reject(req_);

return false;

}

return true;

}

void AfterNoArgs(uv_fs_t* req) {

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

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 = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed()) {

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

}

}

void AfterInteger(uv_fs_t* req) {

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

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) {

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

FSReqAfterScope after(req_wrap, req);

if (after.Proceed()) {

FileHandle* fd = FileHandle::New(req_wrap->binding_data(), req->result);

if (fd == nullptr) return;

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

}

}

// Reverse the logic applied by path.toNamespacedPath() to create a

// namespace-prefixed path.

void FromNamespacedPath(std::string* path) {

#ifdef _WIN32

if (path->compare(0, 8, "\\\\?\\UNC\\", 8) == 0) {

*path = path->substr(8);

path->insert(0, "\\\\");

} else if (path->compare(0, 4, "\\\\?\\", 4) == 0) {

*path = path->substr(4);

}

#endif

}

void AfterMkdirp(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

MaybeLocal<Value> path;

Local<Value> error;

if (after.Proceed()) {

if (!req_wrap->continuation_data()->first_path().empty()) {

std::string first_path(req_wrap->continuation_data()->first_path());

FromNamespacedPath(&first_path);

path = StringBytes::Encode(req_wrap->env()->isolate(), first_path.c_str(),

req_wrap->encoding(),

&error);

if (path.IsEmpty())

req_wrap->Reject(error);

else

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

} else {

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

}

}

}

void AfterStringPath(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

MaybeLocal<Value> link;

Local<Value> error;

if (after.Proceed()) {

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

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 = FSReqBase::from_req(req);

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 = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (!after.Proceed()) {

return;

}

Environment* env = req_wrap->env();

Local<Value> error;

int r;

std::vector<Local<Value>> name_v;

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(

env->isolate(), r, nullptr, req_wrap->syscall(), req->path));

}

MaybeLocal<Value> filename =

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

ent.name,

req_wrap->encoding(),

&error);

if (filename.IsEmpty())

return req_wrap->Reject(error);

name_v.push_back(filename.ToLocalChecked());

}

req_wrap->Resolve(Array::New(env->isolate(), name_v.data(), name_v.size()));

}

void AfterScanDirWithTypes(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

if (!after.Proceed()) {

return;

}

Environment* env = req_wrap->env();

Isolate* isolate = env->isolate();

Local<Value> error;

int r;

std::vector<Local<Value>> name_v;

std::vector<Local<Value>> type_v;

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(isolate, r, nullptr, req_wrap->syscall(), req->path));

}

MaybeLocal<Value> filename =

StringBytes::Encode(isolate,

ent.name,

req_wrap->encoding(),

&error);

if (filename.IsEmpty())

return req_wrap->Reject(error);

name_v.push_back(filename.ToLocalChecked());

type_v.emplace_back(Integer::New(isolate, ent.type));

}

Local<Value> result[] = {

Array::New(isolate, name_v.data(), name_v.size()),

Array::New(isolate, type_v.data(), type_v.size())

};

req_wrap->Resolve(Array::New(isolate, result, arraysize(result)));

}

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

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

Isolate* isolate = env->isolate();

HandleScope scope(isolate);

const int argc = args.Length();

CHECK_GE(argc, 2);

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

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

BufferValue path(isolate, args[0]);

CHECK_NOT_NULL(*path);

FSReqBase* req_wrap_async = GetReqWrap(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(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);

Isolate* isolate = env->isolate();

uv_loop_t* loop = env->event_loop();

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

node::Utf8Value path(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;

}

auto defer_close = OnScopeLeave([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;

char* p = &chars[start];

char* pe = &chars[size];

char* pos[2];

char** ppos = &pos[0];

while (p < pe) {

char c = *p++;

if (c == '\\' && p < pe && *p == '"') p++;

if (c != '"') continue;

*ppos++ = p;

if (ppos < &pos[2]) continue;

ppos = &pos[0];

char* s = &pos[0][0];

char* se = &pos[1][-1]; // Exclude quote.

size_t n = se - s;

if (n == 4) {

if (0 == memcmp(s, "main", 4)) break;

if (0 == memcmp(s, "name", 4)) break;

if (0 == memcmp(s, "type", 4)) break;

} else if (n == 7) {

if (0 == memcmp(s, "exports", 7)) break;

}

}

Local<String> return_value;

if (p < pe) {

return_value =

String::NewFromUtf8(isolate,

&chars[start],

v8::NewStringType::kNormal,

size).ToLocalChecked();

} else {

return_value = env->empty_object_string();

}

args.GetReturnValue().Set(return_value);

}

// 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) {

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

Environment* env = binding_data->env();

const int argc = args.Length();

CHECK_GE(argc, 2);

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

CHECK_NOT_NULL(*path);

bool use_bigint = args[1]->IsTrue();

FSReqBase* req_wrap_async = GetReqWrap(args, 2, use_bigint);

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

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

uv_fs_stat, *path);

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

CHECK_EQ(argc, 4);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(stat);

int err = SyncCall(env, args[3], &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 = FillGlobalStatsArray(binding_data, use_bigint,

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

args.GetReturnValue().Set(arr);

}

}

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

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

Environment* env = binding_data->env();

const int argc = args.Length();

CHECK_GE(argc, 3);

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

CHECK_NOT_NULL(*path);