#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_debug.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 "threadpoolwork-inl.h"

#include "uv.h"

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

#include <errno.h>

#include <cerrno>

#include <cstdio>

#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::ArrayBuffer;

using v8::ArrayBufferView;

using v8::BigInt;

using v8::Context;

using v8::EscapableHandleScope;

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::LocalVector;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Nothing;

using v8::Null;

using v8::Number;

using v8::Object;

using v8::ObjectTemplate;

using v8::Promise;

using v8::String;

using v8::TryCatch;

using v8::Uint32Array;

using v8::Uint8Array;

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

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

#ifdef V8_USE_PERFETTO

#define FS_SYNC_TRACE_END(syscall, ...) \

if (GET_TRACE_ENABLED) \

TRACE_EVENT_END(TRACING_CATEGORY_NODE2(fs, sync), ##__VA_ARGS__);

#else

#define FS_SYNC_TRACE_END(syscall, ...) \

if (GET_TRACE_ENABLED) \

TRACE_EVENT_END( \

TRACING_CATEGORY_NODE2(fs, sync), TRACE_NAME(syscall), ##__VA_ARGS__);

#endif

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

typedef void (*uv_fs_callback_t)(uv_fs_t*);

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

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

tracker->TrackField("enoent_paths", enoent_paths_);

}

FileHandleReadWrap::~FileHandleReadWrap() = default;

FSReqBase::~FSReqBase() = default;

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

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

}

FileHandle::FileHandle(BindingData* binding_data,

}

FileHandle* FileHandle::New(BindingData* binding_data,

int fd,

Local<Object> obj,

std::string original_name,

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

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

}

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,

}

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

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

tracker->TrackField("original_name", original_name_);

}

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

}

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

}

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

}

inline void FileHandle::Close() {

}

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

}

MaybeLocal<Promise> FileHandle::ClosePromise() {

}

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

}

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

}

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

}

int FileHandle::Release() {

}

void FileHandle::AfterClose() {

}

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

}

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

}

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

}

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

args.GetReturnValue().SetUndefined();

}

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

}

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

}

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

}

FSReqAfterScope::~FSReqAfterScope() {

Clear();

}

void FSReqAfterScope::Clear() {

}

void FSReqAfterScope::Reject(uv_fs_t* req) {

}

bool FSReqAfterScope::Proceed() {

}

void AfterNoArgs(uv_fs_t* req) {

}

void AfterStat(uv_fs_t* req) {

}

void AfterStatNoThrowIfNoEntry(uv_fs_t* req) {

}

void AfterStatFs(uv_fs_t* req) {

}

void AfterInteger(uv_fs_t* req) {

}

void AfterOpenFileHandle(uv_fs_t* req) {

}

static void AfterMkstempImpl(uv_fs_t* req, bool as_file_handle) {

}

static void AfterMkstemp(uv_fs_t* req) {

AfterMkstempImpl(req, false);

}

static void AfterMkstempFileHandle(uv_fs_t* req) {

AfterMkstempImpl(req, true);

}

void AfterMkdirp(uv_fs_t* req) {

}

void AfterStringPath(uv_fs_t* req) {

}

void AfterStringPtr(uv_fs_t* req) {

}

void AfterScanDir(uv_fs_t* req) {