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

#include "aliased_buffer-inl.h"

#include "memory_tracker-inl.h"

#include "node_buffer.h"

#include "node_errors.h"

#include "node_external_reference.h"

#include "node_file-inl.h"

#include "node_metadata.h"

#include "node_process-inl.h"

#include "node_stat_watcher.h"

#include "node_url.h"

#include "path.h"

#include "permission/permission.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 "uv.h"

#include "v8-fast-api-calls.h"

#include <filesystem>

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

# include <io.h>

#endif

#ifdef _WIN32

#include <windows.h>

#else

#include <unistd.h>

#endif

namespace node {

namespace fs {

using v8::Array;

using v8::BigInt;

using v8::Context;

using v8::EscapableHandleScope;

using v8::FastApiCallbackOptions;

using v8::FastOneByteString;

using v8::Function;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::HandleScope;

using v8::Int32;

using v8::Integer;

using v8::Isolate;

using v8::JustVoid;

using v8::Local;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Nothing;

using v8::Number;

using v8::Object;

using v8::ObjectTemplate;

using v8::Promise;

using v8::String;

using v8::Undefined;

using v8::Value;

#ifndef S_ISDIR

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

#endif

inline int64_t GetOffset(Local<Value> value) {

return IsSafeJsInt(value) ? value.As<Integer>()->Value() : -1;

}

static const char* get_fs_func_name_by_type(uv_fs_type req_type) {

switch (req_type) {

#define FS_TYPE_TO_NAME(type, name) \

case UV_FS_##type: \

return name;

FS_TYPE_TO_NAME(OPEN, "open")

FS_TYPE_TO_NAME(CLOSE, "close")

FS_TYPE_TO_NAME(READ, "read")

FS_TYPE_TO_NAME(WRITE, "write")

FS_TYPE_TO_NAME(SENDFILE, "sendfile")

FS_TYPE_TO_NAME(STAT, "stat")

FS_TYPE_TO_NAME(LSTAT, "lstat")

FS_TYPE_TO_NAME(FSTAT, "fstat")

FS_TYPE_TO_NAME(FTRUNCATE, "ftruncate")

FS_TYPE_TO_NAME(UTIME, "utime")

FS_TYPE_TO_NAME(FUTIME, "futime")

FS_TYPE_TO_NAME(ACCESS, "access")

FS_TYPE_TO_NAME(CHMOD, "chmod")

FS_TYPE_TO_NAME(FCHMOD, "fchmod")

FS_TYPE_TO_NAME(FSYNC, "fsync")

FS_TYPE_TO_NAME(FDATASYNC, "fdatasync")

FS_TYPE_TO_NAME(UNLINK, "unlink")

FS_TYPE_TO_NAME(RMDIR, "rmdir")

FS_TYPE_TO_NAME(MKDIR, "mkdir")

FS_TYPE_TO_NAME(MKDTEMP, "mkdtemp")

FS_TYPE_TO_NAME(RENAME, "rename")

FS_TYPE_TO_NAME(SCANDIR, "scandir")

FS_TYPE_TO_NAME(LINK, "link")

FS_TYPE_TO_NAME(SYMLINK, "symlink")

FS_TYPE_TO_NAME(READLINK, "readlink")

FS_TYPE_TO_NAME(CHOWN, "chown")

FS_TYPE_TO_NAME(FCHOWN, "fchown")

FS_TYPE_TO_NAME(REALPATH, "realpath")

FS_TYPE_TO_NAME(COPYFILE, "copyfile")

FS_TYPE_TO_NAME(LCHOWN, "lchown")

FS_TYPE_TO_NAME(STATFS, "statfs")

FS_TYPE_TO_NAME(MKSTEMP, "mkstemp")

FS_TYPE_TO_NAME(LUTIME, "lutime")

#undef FS_TYPE_TO_NAME

default:

return "unknown";

}

}

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

#define FS_ASYNC_TRACE_BEGIN0(fs_type, id) \

TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(TRACING_CATEGORY_NODE2(fs, async), \

get_fs_func_name_by_type(fs_type), \

id);

#define FS_ASYNC_TRACE_END0(fs_type, id) \

TRACE_EVENT_NESTABLE_ASYNC_END0(TRACING_CATEGORY_NODE2(fs, async), \

get_fs_func_name_by_type(fs_type), \

id);

#define FS_ASYNC_TRACE_BEGIN1(fs_type, id, name, value) \

TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(TRACING_CATEGORY_NODE2(fs, async), \

get_fs_func_name_by_type(fs_type), \

id, \

name, \

value);

#define FS_ASYNC_TRACE_END1(fs_type, id, name, value) \

TRACE_EVENT_NESTABLE_ASYNC_END1(TRACING_CATEGORY_NODE2(fs, async), \

get_fs_func_name_by_type(fs_type), \

id, \

name, \

value);

#define FS_ASYNC_TRACE_BEGIN2(fs_type, id, name1, value1, name2, value2) \

TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(TRACING_CATEGORY_NODE2(fs, async), \

get_fs_func_name_by_type(fs_type), \

id, \

name1, \

value1, \

name2, \

value2);

#define FS_ASYNC_TRACE_END2(fs_type, id, name1, value1, name2, value2) \

TRACE_EVENT_NESTABLE_ASYNC_END2(TRACING_CATEGORY_NODE2(fs, async), \

get_fs_func_name_by_type(fs_type), \

id, \

name1, \

value1, \

name2, \

value2);

// 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() = default;

FSReqBase::~FSReqBase() = default;

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,

std::optional<int64_t> maybeOffset,

std::optional<int64_t> maybeLength) {

Environment* env = binding_data->env();

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

->NewInstance(env->context())

.ToLocal(&obj)) {

return nullptr;

}

auto handle = new FileHandle(binding_data, obj, fd);

if (maybeOffset.has_value()) handle->read_offset_ = maybeOffset.value();

if (maybeLength.has_value()) handle->read_length_ = maybeLength.value();

return handle;

}

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

CHECK(args.IsConstructCall());

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

Realm* realm = Realm::GetCurrent(args);

BindingData* binding_data = realm->GetBindingData<BindingData>();

std::optional<int64_t> maybeOffset = std::nullopt;

std::optional<int64_t> maybeLength = std::nullopt;

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

maybeOffset = args[1]->IntegerValue(realm->context()).FromJust();

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

maybeLength = args[2]->IntegerValue(realm->context()).FromJust();

FileHandle::New(binding_data,

args[0].As<Int32>()->Value(),

args.This(),

maybeOffset,

maybeLength);

}

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

}

BaseObject::TransferMode FileHandle::GetTransferMode() const {

return reading_ || closing_ || closed_

? TransferMode::kDisallowCloneAndTransfer

: TransferMode::kTransferable;

}

std::unique_ptr<worker::TransferData> FileHandle::TransferForMessaging() {

CHECK_NE(GetTransferMode(), TransferMode::kDisallowCloneAndTransfer);

auto ret = std::make_unique<TransferData>(fd_);

closed_ = true;

return ret;

}

FileHandle::TransferData::TransferData(int fd) : fd_(fd) {}

FileHandle::TransferData::~TransferData() {

if (fd_ > 0) {

uv_fs_t close_req;

CHECK_NE(fd_, -1);

FS_SYNC_TRACE_BEGIN(close);

CHECK_EQ(0, uv_fs_close(nullptr, &close_req, fd_, nullptr));

FS_SYNC_TRACE_END(close);

uv_fs_req_cleanup(&close_req);

}

}

BaseObjectPtr<BaseObject> FileHandle::TransferData::Deserialize(

Environment* env,

v8::Local<v8::Context> context,

std::unique_ptr<worker::TransferData> self) {

BindingData* bd = Realm::GetBindingData<BindingData>(context);

if (bd == nullptr) return {};

int fd = fd_;

fd_ = -1;

return BaseObjectPtr<BaseObject> { FileHandle::New(bd, fd) };

}

// 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_ || closing_) return;

uv_fs_t req;

CHECK_NE(fd_, -1);

FS_SYNC_TRACE_BEGIN(close);

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

FS_SYNC_TRACE_END(close);

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

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

}

}, CallbackFlags::kUnrefed);

}

void FileHandle::CloseReq::Resolve() {

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

HandleScope scope(isolate);

Context::Scope context_scope(env()->context());

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

Context::Scope context_scope(env()->context());

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

Local<Value> close_resolver =

object()->GetInternalField(FileHandle::kClosingPromiseSlot).As<Value>();

if (close_resolver->IsPromise()) {

return close_resolver.As<Promise>();

}

CHECK(!closed_);

CHECK(!closing_);

CHECK(!reading_);

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

CHECK(!maybe_resolver.IsEmpty());

Local<Promise::Resolver> resolver;

if (!maybe_resolver.ToLocal(&resolver)) return {};

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

Local<Object> close_req_obj;

if (!env()->fdclose_constructor_template()

->NewInstance(env()->context()).ToLocal(&close_req_obj)) {

return MaybeLocal<Promise>();

}

closing_ = true;

object()->SetInternalField(FileHandle::kClosingPromiseSlot, promise);

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

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

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

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

BaseObjectPtr<CloseReq> close(req_wrap);

CHECK(close);

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

if (!close->env()->can_call_into_js()) return;

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

if (req->result < 0) {

HandleScope handle_scope(isolate);

close->Reject(

UVException(isolate, static_cast<int>(req->result), "close"));

} else {

close->Resolve();

}

}};

CHECK_NE(fd_, -1);

FS_ASYNC_TRACE_BEGIN0(UV_FS_CLOSE, req)

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

if (ret < 0) {

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

delete req;

}

return scope.Escape(promise);

}

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

FileHandle* fd;

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

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

fd->Release();

}

int FileHandle::Release() {

int fd = GetFD();

// Just pretend that Close was called and we're all done.

AfterClose();

return fd;

}

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

FS_ASYNC_TRACE_BEGIN0(UV_FS_READ, current_read_.get())

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

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

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

ssize_t 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 kWantedFreelistFill = 100;

auto& freelist = handle->binding_data_->file_handle_read_wrap_freelist;

if (freelist.size() < kWantedFreelistFill) {

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

if (closing_ || closed_) {

req_wrap->Done(0);

return 1;

}

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

closing_ = true;

CHECK_NE(fd_, -1);

FS_ASYNC_TRACE_BEGIN0(UV_FS_CLOSE, wrap)

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

FileHandleCloseWrap* wrap = static_cast<FileHandleCloseWrap*>(

FileHandleCloseWrap::from_req(req));

FS_ASYNC_TRACE_END1(

req->fs_type, wrap, "result", static_cast<int>(req->result))

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

handle->AfterClose();

int result = static_cast<int>(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::ResolveStatFs(const uv_statfs_t* stat) {

Resolve(FillGlobalStatFsArray(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 = Realm::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(),

static_cast<int>(req->result),

wrap_->syscall(),

nullptr,

req->path,

wrap_->data());

Clear();

wrap->Reject(exception);

}

bool FSReqAfterScope::Proceed() {

if (!wrap_->env()->can_call_into_js()) {

return false;

}

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

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

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

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

if (after.Proceed()) {

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

}

}

void AfterStatFs(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

if (after.Proceed()) {

req_wrap->ResolveStatFs(static_cast<uv_statfs_t*>(req->ptr));

}

}

void AfterInteger(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

int result = static_cast<int>(req->result);

if (result >= 0 && req_wrap->is_plain_open())

req_wrap->env()->AddUnmanagedFd(result);

if (after.Proceed())

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

}

void AfterOpenFileHandle(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

if (after.Proceed()) {

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

static_cast<int>(req->result));

if (fd == nullptr) return;

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

}

}

void AfterMkdirp(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

if (after.Proceed()) {

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

if (first_path.empty())

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

Local<Value> path;

Local<Value> error;

if (!StringBytes::Encode(req_wrap->env()->isolate(), first_path.c_str(),

req_wrap->encoding(),

&error).ToLocal(&path)) {

return req_wrap->Reject(error);

}

return req_wrap->Resolve(path);

}

}

void AfterStringPath(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

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 {

Local<Value> val;

if (link.ToLocal(&val)) req_wrap->Resolve(val);

}

}

}

void AfterStringPtr(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

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 {

Local<Value> val;

if (link.ToLocal(&val)) req_wrap->Resolve(val);

}

}

}

void AfterScanDir(uv_fs_t* req) {

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

FSReqAfterScope after(req_wrap, req);

FS_ASYNC_TRACE_END1(

req->fs_type, req_wrap, "result", static_cast<int>(req->result))

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;

const bool with_file_types = req_wrap->with_file_types();

for (;;) {

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

}

Local<Value> filename;

if (!StringBytes::Encode(isolate, ent.name, req_wrap->encoding(), &error)

.ToLocal(&filename)) {

return req_wrap->Reject(error);

}

name_v.push_back(filename);

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

}

if (with_file_types) {

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

} else {

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

}

}

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

int mode;

if (!GetValidFileMode(env, args[1], UV_FS_ACCESS).To(&mode)) {

return;

}

BufferValue path(isolate, args[0]);

CHECK_NOT_NULL(*path);

ToNamespacedPath(env, &path);

if (argc > 2) { // access(path, mode, req)

FSReqBase* req_wrap_async = GetReqWrap(args, 2);

CHECK_NOT_NULL(req_wrap_async);

ASYNC_THROW_IF_INSUFFICIENT_PERMISSIONS(

env,

req_wrap_async,

permission::PermissionScope::kFileSystemRead,

path.ToStringView());

FS_ASYNC_TRACE_BEGIN1(

UV_FS_ACCESS, req_wrap_async, "path", TRACE_STR_COPY(*path))

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

uv_fs_access, *path, mode);

} else { // access(path, mode)

THROW_IF_INSUFFICIENT_PERMISSIONS(

env, permission::PermissionScope::kFileSystemRead, path.ToStringView());

FSReqWrapSync req_wrap_sync("access", *path);

FS_SYNC_TRACE_BEGIN(access);

SyncCallAndThrowOnError(env, &req_wrap_sync, 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, 1);

int fd;

if (!GetValidatedFd(env, args[0]).To(&fd)) {

return;

}

env->RemoveUnmanagedFd(fd);

if (argc > 1) { // close(fd, req)

FSReqBase* req_wrap_async = GetReqWrap(args, 1);

CHECK_NOT_NULL(req_wrap_async);

FS_ASYNC_TRACE_BEGIN0(UV_FS_CLOSE, req_wrap_async)

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

uv_fs_close, fd);

} else { // close(fd)

FSReqWrapSync req_wrap_sync("close");

FS_SYNC_TRACE_BEGIN(close);

SyncCallAndThrowOnError(env, &req_wrap_sync, uv_fs_close, fd);

FS_SYNC_TRACE_END(close);

}

}

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