@encharm/cws 4.0.2 → 4.3.0

package/src/headers/12/node_crypto_bio.h

@@ -1,195 +0,0 @@
-// 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.
-
-#ifndef SRC_NODE_CRYPTO_BIO_H_
-#define SRC_NODE_CRYPTO_BIO_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_crypto.h"
-#include "openssl/bio.h"
-#include "util.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-
-namespace crypto {
-
-// This class represents buffers for OpenSSL I/O, implemented as a singly-linked
-// list of chunks. It can be used either for writing data from Node to OpenSSL,
-// or for reading data back, but not both.
-// The structure is only accessed, and owned by, the OpenSSL BIOPointer
-// (a.k.a. std::unique_ptr<BIO>).
-class NodeBIO : public MemoryRetainer {
- public:
-  ~NodeBIO() override;
-
-  static BIOPointer New(Environment* env = nullptr);
-
-  // NewFixed takes a copy of `len` bytes from `data` and returns a BIO that,
-  // when read from, returns those bytes followed by EOF.
-  static BIOPointer NewFixed(const char* data, size_t len,
-                             Environment* env = nullptr);
-
-  // Move read head to next buffer if needed
-  void TryMoveReadHead();
-
-  // Allocate new buffer for write if needed
-  void TryAllocateForWrite(size_t hint);
-
-  // Read `len` bytes maximum into `out`, return actual number of read bytes
-  size_t Read(char* out, size_t size);
-
-  // Memory optimization:
-  // Deallocate children of write head's child if they're empty
-  void FreeEmpty();
-
-  // Return pointer to internal data and amount of
-  // contiguous data available to read
-  char* Peek(size_t* size);
-
-  // Return pointers and sizes of multiple internal data chunks available for
-  // reading
-  size_t PeekMultiple(char** out, size_t* size, size_t* count);
-
-  // Find first appearance of `delim` in buffer or `limit` if `delim`
-  // wasn't found.
-  size_t IndexOf(char delim, size_t limit);
-
-  // Discard all available data
-  void Reset();
-
-  // Put `len` bytes from `data` into buffer
-  void Write(const char* data, size_t size);
-
-  // Return pointer to contiguous block of reserved data and the size available
-  // for future writes. Call Commit() once the write is complete.
-  char* PeekWritable(size_t* size);
-
-  // Specify how much data was written into the block returned by
-  // PeekWritable().
-  void Commit(size_t size);
-
-
-  // Return size of buffer in bytes
-  inline size_t Length() const {
-    return length_;
-  }
-
-  // Provide a hint about the size of the next pending set of writes. TLS
-  // writes records of a maximum length of 16k of data plus a 5-byte header,
-  // a MAC (up to 20 bytes for SSLv3, TLS 1.0, TLS 1.1, and up to 32 bytes
-  // for TLS 1.2), and padding if a block cipher is used.  If there is a
-  // large write this will result in potentially many buffers being
-  // allocated and gc'ed which can cause long pauses. By providing a
-  // guess about the amount of buffer space that will be needed in the
-  // next allocation this overhead is removed.
-  inline void set_allocate_tls_hint(size_t size) {
-    constexpr size_t kThreshold = 16 * 1024;
-    if (size >= kThreshold) {
-      allocate_hint_ = (size / kThreshold + 1) * (kThreshold + 5 + 32);
-    }
-  }
-
-  inline void set_eof_return(int num) {
-    eof_return_ = num;
-  }
-
-  inline int eof_return() {
-    return eof_return_;
-  }
-
-  inline void set_initial(size_t initial) {
-    initial_ = initial;
-  }
-
-  static NodeBIO* FromBIO(BIO* bio);
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackFieldWithSize("buffer", length_, "NodeBIO::Buffer");
-  }
-
-  SET_MEMORY_INFO_NAME(NodeBIO)
-  SET_SELF_SIZE(NodeBIO)
-
- private:
-  static int New(BIO* bio);
-  static int Free(BIO* bio);
-  static int Read(BIO* bio, char* out, int len);
-  static int Write(BIO* bio, const char* data, int len);
-  static int Puts(BIO* bio, const char* str);
-  static int Gets(BIO* bio, char* out, int size);
-  static long Ctrl(BIO* bio, int cmd, long num,  // NOLINT(runtime/int)
-                   void* ptr);
-
-  static const BIO_METHOD* GetMethod();
-
-  // Enough to handle the most of the client hellos
-  static const size_t kInitialBufferLength = 1024;
-  static const size_t kThroughputBufferLength = 16384;
-
-  class Buffer {
-   public:
-    Buffer(Environment* env, size_t len) : env_(env),
-                                           read_pos_(0),
-                                           write_pos_(0),
-                                           len_(len),
-                                           next_(nullptr) {
-      data_ = new char[len];
-      if (env_ != nullptr)
-        env_->isolate()->AdjustAmountOfExternalAllocatedMemory(len);
-    }
-
-    ~Buffer() {
-      delete[] data_;
-      if (env_ != nullptr) {
-        const int64_t len = static_cast<int64_t>(len_);
-        env_->isolate()->AdjustAmountOfExternalAllocatedMemory(-len);
-      }
-    }
-
-    Environment* env_;
-    size_t read_pos_;
-    size_t write_pos_;
-    size_t len_;
-    Buffer* next_;
-    char* data_;
-  };
-
-  Environment* env_ = nullptr;
-  size_t initial_ = kInitialBufferLength;
-  size_t length_ = 0;
-  size_t allocate_hint_ = 0;
-  int eof_return_ = -1;
-  Buffer* read_head_ = nullptr;
-  Buffer* write_head_ = nullptr;
-
-  friend void node::crypto::InitCryptoOnce();
-};
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_CRYPTO_BIO_H_

package/src/headers/12/node_crypto_clienthello-inl.h

@@ -1,91 +0,0 @@
-// 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.
-
-#ifndef SRC_NODE_CRYPTO_CLIENTHELLO_INL_H_
-#define SRC_NODE_CRYPTO_CLIENTHELLO_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_crypto_clienthello.h"
-#include "util.h"
-
-namespace node {
-namespace crypto {
-
-inline ClientHelloParser::ClientHelloParser()
-    : state_(kEnded),
-      onhello_cb_(nullptr),
-      onend_cb_(nullptr),
-      cb_arg_(nullptr) {
-  Reset();
-}
-
-inline void ClientHelloParser::Reset() {
-  frame_len_ = 0;
-  body_offset_ = 0;
-  extension_offset_ = 0;
-  session_size_ = 0;
-  session_id_ = nullptr;
-  tls_ticket_size_ = -1;
-  tls_ticket_ = nullptr;
-  servername_size_ = 0;
-  servername_ = nullptr;
-}
-
-inline void ClientHelloParser::Start(ClientHelloParser::OnHelloCb onhello_cb,
-                                     ClientHelloParser::OnEndCb onend_cb,
-                                     void* onend_arg) {
-  if (!IsEnded())
-    return;
-  Reset();
-
-  CHECK_NOT_NULL(onhello_cb);
-
-  state_ = kWaiting;
-  onhello_cb_ = onhello_cb;
-  onend_cb_ = onend_cb;
-  cb_arg_ = onend_arg;
-}
-
-inline void ClientHelloParser::End() {
-  if (state_ == kEnded)
-    return;
-  state_ = kEnded;
-  if (onend_cb_ != nullptr) {
-    onend_cb_(cb_arg_);
-    onend_cb_ = nullptr;
-  }
-}
-
-inline bool ClientHelloParser::IsEnded() const {
-  return state_ == kEnded;
-}
-
-inline bool ClientHelloParser::IsPaused() const {
-  return state_ == kPaused;
-}
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_CRYPTO_CLIENTHELLO_INL_H_

package/src/headers/12/node_crypto_clienthello.h

@@ -1,132 +0,0 @@
-// 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.
-
-#ifndef SRC_NODE_CRYPTO_CLIENTHELLO_H_
-#define SRC_NODE_CRYPTO_CLIENTHELLO_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cstddef>  // size_t
-#include <cstdint>
-
-namespace node {
-namespace crypto {
-
-// Parse the client hello so we can do async session resumption. OpenSSL's
-// session resumption uses synchronous callbacks, see SSL_CTX_sess_set_get_cb
-// and get_session_cb.
-//
-// TLS1.3 handshakes masquerade as TLS1.2 session resumption, and to do this,
-// they always include a session_id in the ClientHello, making up a bogus value
-// if necessary. The parser can't know if its a bogus id, and will cause a
-// 'newSession' event to be emitted. This should do no harm, the id won't be
-// found, and the handshake will continue.
-class ClientHelloParser {
- public:
-  inline ClientHelloParser();
-
-  class ClientHello {
-   public:
-    inline uint8_t session_size() const { return session_size_; }
-    inline const uint8_t* session_id() const { return session_id_; }
-    inline bool has_ticket() const { return has_ticket_; }
-    inline uint8_t servername_size() const { return servername_size_; }
-    inline const uint8_t* servername() const { return servername_; }
-
-   private:
-    uint8_t session_size_;
-    const uint8_t* session_id_;
-    bool has_ticket_;
-    uint8_t servername_size_;
-    const uint8_t* servername_;
-
-    friend class ClientHelloParser;
-  };
-
-  typedef void (*OnHelloCb)(void* arg, const ClientHello& hello);
-  typedef void (*OnEndCb)(void* arg);
-
-  void Parse(const uint8_t* data, size_t avail);
-
-  inline void Reset();
-  inline void Start(OnHelloCb onhello_cb, OnEndCb onend_cb, void* onend_arg);
-  inline void End();
-  inline bool IsPaused() const;
-  inline bool IsEnded() const;
-
- private:
-  static const size_t kMaxTLSFrameLen = 16 * 1024 + 5;
-  static const size_t kMaxSSLExFrameLen = 32 * 1024;
-  static const uint8_t kServernameHostname = 0;
-  static const size_t kMinStatusRequestSize = 5;
-
-  enum ParseState {
-    kWaiting,
-    kTLSHeader,
-    kPaused,
-    kEnded
-  };
-
-  enum FrameType {
-    kChangeCipherSpec = 20,
-    kAlert = 21,
-    kHandshake = 22,
-    kApplicationData = 23,
-    kOther = 255
-  };
-
-  enum HandshakeType {
-    kClientHello = 1
-  };
-
-  enum ExtensionType {
-    kServerName = 0,
-    kTLSSessionTicket = 35
-  };
-
-  bool ParseRecordHeader(const uint8_t* data, size_t avail);
-  void ParseHeader(const uint8_t* data, size_t avail);
-  void ParseExtension(const uint16_t type,
-                      const uint8_t* data,
-                      size_t len);
-  bool ParseTLSClientHello(const uint8_t* data, size_t avail);
-
-  ParseState state_;
-  OnHelloCb onhello_cb_;
-  OnEndCb onend_cb_;
-  void* cb_arg_;
-  size_t frame_len_ = 0;
-  size_t body_offset_ = 0;
-  size_t extension_offset_ = 0;
-  uint8_t session_size_ = 0;
-  const uint8_t* session_id_ = nullptr;
-  uint16_t servername_size_ = 0;
-  const uint8_t* servername_ = nullptr;
-  uint16_t tls_ticket_size_ = -1;
-  const uint8_t* tls_ticket_ = nullptr;
-};
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_CRYPTO_CLIENTHELLO_H_

package/src/headers/12/node_file-inl.h

@@ -1,289 +0,0 @@
-#ifndef SRC_NODE_FILE_INL_H_
-#define SRC_NODE_FILE_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_file.h"
-#include "req_wrap-inl.h"
-
-namespace node {
-namespace fs {
-
-FSContinuationData::FSContinuationData(uv_fs_t* req, int mode, uv_fs_cb done_cb)
-  : done_cb_(done_cb), req_(req), mode_(mode) {
-}
-
-void FSContinuationData::PushPath(std::string&& path) {
-  paths_.emplace_back(std::move(path));
-}
-
-void FSContinuationData::PushPath(const std::string& path) {
-  paths_.push_back(path);
-}
-
-void FSContinuationData::MaybeSetFirstPath(const std::string& path) {
-  if (first_path_.empty()) {
-    first_path_ = path;
-  }
-}
-
-std::string FSContinuationData::PopPath() {
-  CHECK_GT(paths_.size(), 0);
-  std::string path = std::move(paths_.back());
-  paths_.pop_back();
-  return path;
-}
-
-void FSContinuationData::Done(int result) {
-  req_->result = result;
-  done_cb_(req_);
-}
-
-FSReqBase::FSReqBase(Environment* env,
-          v8::Local<v8::Object> req,
-          AsyncWrap::ProviderType type,
-          bool use_bigint)
-  : ReqWrap(env, req, type), use_bigint_(use_bigint) {
-}
-
-void FSReqBase::Init(const char* syscall,
-                     const char* data,
-                     size_t len,
-                     enum encoding encoding) {
-  syscall_ = syscall;
-  encoding_ = encoding;
-
-  if (data != nullptr) {
-    CHECK(!has_data_);
-    buffer_.AllocateSufficientStorage(len + 1);
-    buffer_.SetLengthAndZeroTerminate(len);
-    memcpy(*buffer_, data, len);
-    has_data_ = true;
-  }
-}
-
-FSReqBase::FSReqBuffer&
-FSReqBase::Init(const char* syscall, size_t len, enum encoding encoding) {
-  syscall_ = syscall;
-  encoding_ = encoding;
-
-  buffer_.AllocateSufficientStorage(len + 1);
-  has_data_ = false;  // so that the data does not show up in error messages
-  return buffer_;
-}
-
-FSReqCallback::FSReqCallback(Environment* env,
-                             v8::Local<v8::Object> req, bool use_bigint)
-  : FSReqBase(env, req, AsyncWrap::PROVIDER_FSREQCALLBACK, use_bigint) {}
-
-template <typename NativeT, typename V8T>
-void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
-                    const uv_stat_t* s,
-                    const size_t offset) {
-#define SET_FIELD_WITH_STAT(stat_offset, stat)                               \
-  fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset), \
-                   static_cast<NativeT>(stat))
-
-#define SET_FIELD_WITH_TIME_STAT(stat_offset, stat)                          \
-  /* NOLINTNEXTLINE(runtime/int) */                                          \
-  SET_FIELD_WITH_STAT(stat_offset, static_cast<unsigned long>(stat))
-
-  SET_FIELD_WITH_STAT(kDev, s->st_dev);
-  SET_FIELD_WITH_STAT(kMode, s->st_mode);
-  SET_FIELD_WITH_STAT(kNlink, s->st_nlink);
-  SET_FIELD_WITH_STAT(kUid, s->st_uid);
-  SET_FIELD_WITH_STAT(kGid, s->st_gid);
-  SET_FIELD_WITH_STAT(kRdev, s->st_rdev);
-  SET_FIELD_WITH_STAT(kBlkSize, s->st_blksize);
-  SET_FIELD_WITH_STAT(kIno, s->st_ino);
-  SET_FIELD_WITH_STAT(kSize, s->st_size);
-  SET_FIELD_WITH_STAT(kBlocks, s->st_blocks);
-
-  SET_FIELD_WITH_TIME_STAT(kATimeSec, s->st_atim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kATimeNsec, s->st_atim.tv_nsec);
-  SET_FIELD_WITH_TIME_STAT(kMTimeSec, s->st_mtim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kMTimeNsec, s->st_mtim.tv_nsec);
-  SET_FIELD_WITH_TIME_STAT(kCTimeSec, s->st_ctim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kCTimeNsec, s->st_ctim.tv_nsec);
-  SET_FIELD_WITH_TIME_STAT(kBirthTimeSec, s->st_birthtim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kBirthTimeNsec, s->st_birthtim.tv_nsec);
-
-#undef SET_FIELD_WITH_TIME_STAT
-#undef SET_FIELD_WITH_STAT
-}
-
-v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
-                                          const bool use_bigint,
-                                          const uv_stat_t* s,
-                                          const bool second) {
-  const ptrdiff_t offset =
-      second ? static_cast<ptrdiff_t>(FsStatsOffset::kFsStatsFieldsNumber) : 0;
-  if (use_bigint) {
-    auto* const arr = env->fs_stats_field_bigint_array();
-    FillStatsArray(arr, s, offset);
-    return arr->GetJSArray();
-  } else {
-    auto* const arr = env->fs_stats_field_array();
-    FillStatsArray(arr, s, offset);
-    return arr->GetJSArray();
-  }
-}
-
-template <typename AliasedBufferT>
-FSReqPromise<AliasedBufferT>*
-FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
-  v8::Local<v8::Object> obj;
-  if (!env->fsreqpromise_constructor_template()
-           ->NewInstance(env->context())
-           .ToLocal(&obj)) {
-    return nullptr;
-  }
-  v8::Local<v8::Promise::Resolver> resolver;
-  if (!v8::Promise::Resolver::New(env->context()).ToLocal(&resolver) ||
-      obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {
-    return nullptr;
-  }
-  return new FSReqPromise(env, obj, use_bigint);
-}
-
-template <typename AliasedBufferT>
-FSReqPromise<AliasedBufferT>::~FSReqPromise() {
-  // Validate that the promise was explicitly resolved or rejected.
-  CHECK(finished_);
-}
-
-template <typename AliasedBufferT>
-FSReqPromise<AliasedBufferT>::FSReqPromise(
-    Environment* env,
-    v8::Local<v8::Object> obj,
-    bool use_bigint)
-  : FSReqBase(env, obj, AsyncWrap::PROVIDER_FSREQPROMISE, use_bigint),
-    stats_field_array_(
-        env->isolate(),
-        static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::Reject(v8::Local<v8::Value> reject) {
-  finished_ = true;
-  v8::HandleScope scope(env()->isolate());
-  InternalCallbackScope callback_scope(this);
-  v8::Local<v8::Value> value =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
-  v8::Local<v8::Promise::Resolver> resolver = value.As<v8::Promise::Resolver>();
-  USE(resolver->Reject(env()->context(), reject).FromJust());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::Resolve(v8::Local<v8::Value> value) {
-  finished_ = true;
-  v8::HandleScope scope(env()->isolate());
-  InternalCallbackScope callback_scope(this);
-  v8::Local<v8::Value> val =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
-  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
-  USE(resolver->Resolve(env()->context(), value).FromJust());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::ResolveStat(const uv_stat_t* stat) {
-  FillStatsArray(&stats_field_array_, stat);
-  Resolve(stats_field_array_.GetJSArray());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::SetReturnValue(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Local<v8::Value> val =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
-  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
-  args.GetReturnValue().Set(resolver->GetPromise());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
-  FSReqBase::MemoryInfo(tracker);
-  tracker->TrackField("stats_field_array", stats_field_array_);
-}
-
-FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
-                      bool use_bigint) {
-  if (value->IsObject()) {
-    return Unwrap<FSReqBase>(value.As<v8::Object>());
-  } else if (value->StrictEquals(env->fs_use_promises_symbol())) {
-    if (use_bigint) {
-      return FSReqPromise<AliasedBigUint64Array>::New(env, use_bigint);
-    } else {
-      return FSReqPromise<AliasedFloat64Array>::New(env, use_bigint);
-    }
-  }
-  return nullptr;
-}
-
-// Returns nullptr if the operation fails from the start.
-template <typename Func, typename... Args>
-FSReqBase* AsyncDestCall(Environment* env, FSReqBase* req_wrap,
-                         const v8::FunctionCallbackInfo<v8::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>
-FSReqBase* AsyncCall(Environment* env,
-                     FSReqBase* req_wrap,
-                     const v8::FunctionCallbackInfo<v8::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>
-int SyncCall(Environment* env, v8::Local<v8::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) {
-    v8::Local<v8::Context> context = env->context();
-    v8::Local<v8::Object> ctx_obj = ctx.As<v8::Object>();
-    v8::Isolate* isolate = env->isolate();
-    ctx_obj->Set(context,
-                 env->errno_string(),
-                 v8::Integer::New(isolate, err)).Check();
-    ctx_obj->Set(context,
-                 env->syscall_string(),
-                 OneByteString(isolate, syscall)).Check();
-  }
-  return err;
-}
-
-}  // namespace fs
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_FILE_INL_H_