@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/quic/tokens.h

@@ -0,0 +1,256 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <memory_tracker.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include <node_internals.h>
+#include <node_sockaddr.h>
+#include "cid.h"
+#include "defs.h"
+
+namespace node::quic {
+
+// TokenSecrets are used to generate things like stateless reset tokens,
+// retry tokens, and token packets. They are always QUIC_TOKENSECRET_LEN
+// bytes in length.
+//
+// In the default case, token secrets will always be generated randomly.
+// User code will be given the option to provide a secret directly
+// however.
+class TokenSecret final : public MemoryRetainer {
+ public:
+  static constexpr int QUIC_TOKENSECRET_LEN = 16;
+
+  // Generate a random secret.
+  TokenSecret();
+
+  // Copy the given secret. The uint8_t* is assumed
+  // to be QUIC_TOKENSECRET_LEN in length. Note that
+  // the length is not verified so care must be taken
+  // when this constructor is used.
+  explicit TokenSecret(const uint8_t* secret);
+  ~TokenSecret();
+
+  TokenSecret(const TokenSecret&) = default;
+  TokenSecret& operator=(const TokenSecret&) = default;
+  DISALLOW_MOVE(TokenSecret)
+
+  operator const uint8_t*() const;
+  uint8_t operator[](int pos) const;
+
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TokenSecret)
+  SET_SELF_SIZE(TokenSecret)
+
+ private:
+  operator const char*() const;
+  uint8_t buf_[QUIC_TOKENSECRET_LEN];
+};
+
+// A stateless reset token is used when a QUIC endpoint receives a QUIC packet
+// with a short header but the associated connection ID cannot be matched to any
+// known Session. In such cases, the receiver may choose to send a subtle opaque
+// indication to the sending peer that state for the Session has apparently been
+// lost. For any on- or off- path attacker, a stateless reset packet resembles
+// any other QUIC packet with a short header. In order to be successfully
+// handled as a stateless reset, the peer must have already seen a reset token
+// issued to it associated with the given CID. The token itself is opaque to the
+// peer that receives is but must be possible to statelessly recreate by the
+// peer that originally created it. The actual implementation is Node.js
+// specific but we currently defer to a utility function provided by ngtcp2.
+//
+// QUIC leaves the generation of stateless session tokens up to the
+// implementation to figure out. The idea, however, is that it ought to be
+// possible to generate a stateless reset token reliably even when all state
+// for a connection has been lost. We use the cid as it is the only reliably
+// consistent bit of data we have when a session is destroyed.
+//
+// StatlessResetTokens are always kStatelessTokenLen bytes,
+// as are the secrets used to generate the token.
+class StatelessResetToken final : public MemoryRetainer {
+ public:
+  static constexpr int kStatelessTokenLen = NGTCP2_STATELESS_RESET_TOKENLEN;
+
+  StatelessResetToken();
+
+  // Generates a stateless reset token using HKDF with the cid and token secret
+  // as input. The token secret is either provided by user code when an Endpoint
+  // is created or is generated randomly.
+  StatelessResetToken(const TokenSecret& secret, const CID& cid);
+
+  // Generates a stateless reset token using the given token storage.
+  // The StatelessResetToken wraps the token and does not take ownership.
+  // The token storage must be at least kStatelessTokenLen bytes in length.
+  // The length is not verified so care must be taken when using this
+  // constructor.
+  StatelessResetToken(uint8_t* token,
+                      const TokenSecret& secret,
+                      const CID& cid);
+
+  // Wraps the given token. Does not take over ownership of the token storage.
+  // The token must be at least kStatelessTokenLen bytes in length.
+  // The length is not verified so care must be taken when using this
+  // constructor.
+  explicit StatelessResetToken(const uint8_t* token);
+
+  StatelessResetToken(const StatelessResetToken& other);
+  DISALLOW_MOVE(StatelessResetToken)
+
+  std::string ToString() const;
+
+  operator const uint8_t*() const;
+  operator bool() const;
+
+  bool operator==(const StatelessResetToken& other) const;
+  bool operator!=(const StatelessResetToken& other) const;
+
+  struct Hash {
+    size_t operator()(const StatelessResetToken& token) const;
+  };
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(StatelessResetToken)
+  SET_SELF_SIZE(StatelessResetToken)
+
+  template <typename T>
+  using Map =
+      std::unordered_map<StatelessResetToken, T, StatelessResetToken::Hash>;
+
+  static StatelessResetToken kInvalid;
+
+ private:
+  operator const char*() const;
+
+  const uint8_t* ptr_;
+  uint8_t buf_[NGTCP2_STATELESS_RESET_TOKENLEN];
+};
+
+// A RETRY packet communicates a retry token to the client. Retry tokens are
+// generated only by QUIC servers for the purpose of validating the network path
+// between a client and server. The content payload of the RETRY packet is
+// opaque to the clientand must not be guessable by on- or off-path attackers.
+//
+// A QUIC server sends a RETRY token as a way of initiating explicit path
+// validation in response to an initial QUIC packet. The client, upon receiving
+// a RETRY, must abandon the initial connection attempt and try again with the
+// received retry token included with the new initial packet sent to the server.
+// If the server is performing explicit validation, it will look for the
+// presence of the retry token and attempt to validate it if found. The internal
+// structure of the retry token must be meaningful to the server, and the server
+// must be able to validate that the token is correct without relying on any
+// state left over from the previous connection attempt. We use an
+// implementation that is provided by ngtcp2.
+//
+// The token secret must be kept private on the QUIC server that generated the
+// retry. When multiple QUIC servers are used in a cluster, it cannot be
+// guaranteed that the same QUIC server instance will receive the subsequent new
+// Initial packet. Therefore, all QUIC servers in the cluster should either
+// share or be aware of the same token secret or a mechanism needs to be
+// implemented to ensure that subsequent packets are routed to the same QUIC
+// server instance.
+class RetryToken final : public MemoryRetainer {
+ public:
+  // The token prefix that is used to differentiate between a retry token
+  // and a regular token.
+  static constexpr uint8_t kTokenMagic = NGTCP2_CRYPTO_TOKEN_MAGIC_RETRY;
+  static constexpr int kRetryTokenLen = NGTCP2_CRYPTO_MAX_RETRY_TOKENLEN;
+
+  static constexpr uint64_t QUIC_DEFAULT_RETRYTOKEN_EXPIRATION =
+      10 * NGTCP2_SECONDS;
+  static constexpr uint64_t QUIC_MIN_RETRYTOKEN_EXPIRATION = 1 * NGTCP2_SECONDS;
+
+  // Generates a new retry token.
+  RetryToken(uint32_t version,
+             const SocketAddress& address,
+             const CID& retry_cid,
+             const CID& odcid,
+             const TokenSecret& token_secret);
+
+  // Wraps the given retry token
+  RetryToken(const uint8_t* token, size_t length);
+
+  // Validates the retry token given the input. If the token is valid,
+  // the embedded original CID will be extracted from the token an
+  // returned. If the token is invalid, std::nullopt will be returned.
+  std::optional<CID> Validate(
+      uint32_t version,
+      const SocketAddress& address,
+      const CID& cid,
+      const TokenSecret& token_secret,
+      uint64_t verification_expiration = QUIC_DEFAULT_RETRYTOKEN_EXPIRATION);
+
+  operator const ngtcp2_vec&() const;
+  operator const ngtcp2_vec*() const;
+  operator bool() const;
+
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(RetryToken)
+  SET_SELF_SIZE(RetryToken)
+
+ private:
+  operator const char*() const;
+  uint8_t buf_[kRetryTokenLen];
+  const ngtcp2_vec ptr_;
+};
+
+// A NEW_TOKEN packet communicates a regular token to a client that the server
+// would like the client to send in the header of an initial packet for a
+// future connection. It is similar to RETRY and used for the same purpose,
+// except a NEW_TOKEN is used in advance of the client establishing a new
+// connection and a RETRY is sent in response to the client trying to open
+// a new connection.
+class RegularToken final : public MemoryRetainer {
+ public:
+  // The token prefix that is used to differentiate between a retry token
+  // and a regular token.
+  static constexpr uint8_t kTokenMagic = NGTCP2_CRYPTO_TOKEN_MAGIC_REGULAR;
+  static constexpr int kRegularTokenLen = NGTCP2_CRYPTO_MAX_REGULAR_TOKENLEN;
+  static constexpr uint64_t QUIC_DEFAULT_REGULARTOKEN_EXPIRATION =
+      10 * NGTCP2_SECONDS;
+  static constexpr uint64_t QUIC_MIN_REGULARTOKEN_EXPIRATION =
+      1 * NGTCP2_SECONDS;
+
+  RegularToken();
+
+  // Generates a new retry token.
+  RegularToken(uint32_t version,
+               const SocketAddress& address,
+               const TokenSecret& token_secret);
+
+  // Wraps the given retry token
+  RegularToken(const uint8_t* token, size_t length);
+
+  // Validates the retry token given the input.
+  bool Validate(
+      uint32_t version,
+      const SocketAddress& address,
+      const TokenSecret& token_secret,
+      uint64_t verification_expiration = QUIC_DEFAULT_REGULARTOKEN_EXPIRATION);
+
+  operator const ngtcp2_vec&() const;
+  operator const ngtcp2_vec*() const;
+
+  operator bool() const;
+
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(RetryToken)
+  SET_SELF_SIZE(RetryToken)
+
+ private:
+  operator const char*() const;
+  uint8_t buf_[kRegularTokenLen];
+  const ngtcp2_vec ptr_;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/dist/node/include/quic/transportparams.h

@@ -0,0 +1,165 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <env.h>
+#include <memory_tracker.h>
+#include <ngtcp2/ngtcp2.h>
+#include <node_sockaddr.h>
+#include <optional>
+#include "bindingdata.h"
+#include "cid.h"
+#include "data.h"
+#include "tokens.h"
+
+namespace node::quic {
+
+class Endpoint;
+class Session;
+
+// The Transport Params are the set of configuration options that are sent to
+// the remote peer. They communicate the protocol options the other peer
+// should use when communicating with this session.
+class TransportParams final {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+
+  static constexpr int QUIC_TRANSPORT_PARAMS_V1 = NGTCP2_TRANSPORT_PARAMS_V1;
+  static constexpr int QUIC_TRANSPORT_PARAMS_VERSION =
+      NGTCP2_TRANSPORT_PARAMS_VERSION;
+  static constexpr uint64_t DEFAULT_MAX_STREAM_DATA = 256 * 1024;
+  static constexpr uint64_t DEFAULT_MAX_DATA = 1 * 1024 * 1024;
+  static constexpr uint64_t DEFAULT_MAX_IDLE_TIMEOUT = 10;  // seconds
+  static constexpr uint64_t DEFAULT_MAX_STREAMS_BIDI = 100;
+  static constexpr uint64_t DEFAULT_MAX_STREAMS_UNI = 3;
+  static constexpr uint64_t DEFAULT_ACTIVE_CONNECTION_ID_LIMIT = 2;
+
+  struct Config {
+    Side side;
+    const CID& ocid;
+    const CID& retry_scid;
+    Config(Side side,
+           const CID& ocid = CID::kInvalid,
+           const CID& retry_scid = CID::kInvalid);
+  };
+
+  struct Options : public MemoryRetainer {
+    int transportParamsVersion = QUIC_TRANSPORT_PARAMS_V1;
+
+    // Set only on server Sessions, the preferred address communicates the IP
+    // address and port that the server would prefer the client to use when
+    // communicating with it. See the QUIC specification for more detail on how
+    // the preferred address mechanism works.
+    std::optional<SocketAddress> preferred_address_ipv4{};
+    std::optional<SocketAddress> preferred_address_ipv6{};
+
+    // The initial size of the flow control window of locally initiated streams.
+    // This is the maximum number of bytes that the *remote* endpoint can send
+    // when the connection is started.
+    uint64_t initial_max_stream_data_bidi_local = DEFAULT_MAX_STREAM_DATA;
+
+    // The initial size of the flow control window of remotely initiated
+    // streams. This is the maximum number of bytes that the remote endpoint can
+    // send when the connection is started.
+    uint64_t initial_max_stream_data_bidi_remote = DEFAULT_MAX_STREAM_DATA;
+
+    // The initial size of the flow control window of remotely initiated
+    // unidirectional streams. This is the maximum number of bytes that the
+    // remote endpoint can send when the connection is started.
+    uint64_t initial_max_stream_data_uni = DEFAULT_MAX_STREAM_DATA;
+
+    // The initial size of the session-level flow control window.
+    uint64_t initial_max_data = DEFAULT_MAX_DATA;
+
+    // The initial maximum number of concurrent bidirectional streams the remote
+    // endpoint is permitted to open.
+    uint64_t initial_max_streams_bidi = DEFAULT_MAX_STREAMS_BIDI;
+
+    // The initial maximum number of concurrent unidirectional streams the
+    // remote endpoint is permitted to open.
+    uint64_t initial_max_streams_uni = DEFAULT_MAX_STREAMS_UNI;
+
+    // The maximum amount of time that a Session is permitted to remain idle
+    // before it is silently closed and state is discarded.
+    uint64_t max_idle_timeout = DEFAULT_MAX_IDLE_TIMEOUT;
+
+    // The maximum number of Connection IDs that the peer can store. A single
+    // Session may have several connection IDs over it's lifetime.
+    uint64_t active_connection_id_limit = DEFAULT_ACTIVE_CONNECTION_ID_LIMIT;
+
+    // Establishes the exponent used in ACK Delay field in the ACK frame. See
+    // the QUIC specification for details. This is an advanced option that
+    // should rarely be modified and only if there is really good reason.
+    uint64_t ack_delay_exponent = NGTCP2_DEFAULT_ACK_DELAY_EXPONENT;
+
+    // The maximum amount of time by which the endpoint will delay sending
+    // acknowledgements. This is an advanced option that should rarely be
+    // modified and only if there is a really good reason. It is used to
+    // determine how long a Session will wait to determine that a packet has
+    // been lost.
+    uint64_t max_ack_delay = NGTCP2_DEFAULT_MAX_ACK_DELAY;
+
+    // The maximum size of DATAGRAM frames that the endpoint will accept.
+    // Setting the value to 0 will disable DATAGRAM support.
+    uint64_t max_datagram_frame_size = kDefaultMaxPacketLength;
+
+    // When true, communicates that the Session does not support active
+    // connection migration. See the QUIC specification for more details on
+    // connection migration.
+    bool disable_active_migration = false;
+
+    static const Options kDefault;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(TransportParams::Options)
+    SET_SELF_SIZE(Options)
+
+    static v8::Maybe<Options> From(Environment* env,
+                                   v8::Local<v8::Value> value);
+
+    std::string ToString() const;
+  };
+
+  explicit TransportParams();
+
+  // Creates an instance of TransportParams wrapping the existing const
+  // ngtcp2_transport_params pointer.
+  TransportParams(const ngtcp2_transport_params* ptr);
+
+  TransportParams(const Config& config, const Options& options);
+
+  // Creates an instance of TransportParams by decoding the given buffer.
+  // If the parameters cannot be successfully decoded, the error()
+  // property will be set with an appropriate QuicError and the bool()
+  // operator will return false.
+  TransportParams(const ngtcp2_vec& buf,
+                  int version = QUIC_TRANSPORT_PARAMS_V1);
+
+  void GenerateSessionTokens(Session* session);
+  void GenerateStatelessResetToken(const Endpoint& endpoint, const CID& cid);
+  void GeneratePreferredAddressToken(Session* session);
+  void SetPreferredAddress(const SocketAddress& address);
+
+  operator const ngtcp2_transport_params&() const;
+  operator const ngtcp2_transport_params*() const;
+
+  operator bool() const;
+
+  const QuicError& error() const;
+
+  // Returns an ArrayBuffer containing the encoded transport parameters.
+  // If an error occurs during encoding, an empty shared_ptr will be returned
+  // and the error() property will be set to an appropriate QuicError.
+  Store Encode(Environment* env, int version = QUIC_TRANSPORT_PARAMS_V1);
+
+ private:
+  ngtcp2_transport_params params_{};
+  const ngtcp2_transport_params* ptr_;
+  QuicError error_ = QuicError::TRANSPORT_NO_ERROR;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/dist/node/include/req_wrap-inl.h

@@ -0,0 +1,171 @@
+#ifndef SRC_REQ_WRAP_INL_H_
+#define SRC_REQ_WRAP_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "req_wrap.h"
+#include "async_wrap-inl.h"
+#include "uv.h"
+
+namespace node {
+
+ReqWrapBase::ReqWrapBase(Environment* env) {
+  CHECK(env->has_run_bootstrapping_code());
+  env->req_wrap_queue()->PushBack(this);
+}
+
+template <typename T>
+ReqWrap<T>::ReqWrap(Environment* env,
+                    v8::Local<v8::Object> object,
+                    AsyncWrap::ProviderType provider)
+    : AsyncWrap(env, object, provider),
+      ReqWrapBase(env) {
+  MakeWeak();
+  Reset();
+}
+
+template <typename T>
+ReqWrap<T>::~ReqWrap() {}
+
+template <typename T>
+void ReqWrap<T>::Dispatched() {
+  req_.data = this;
+}
+
+template <typename T>
+void ReqWrap<T>::Reset() {
+  original_callback_ = nullptr;
+  req_.data = nullptr;
+}
+
+template <typename T>
+ReqWrap<T>* ReqWrap<T>::from_req(T* req) {
+  return ContainerOf(&ReqWrap<T>::req_, req);
+}
+
+template <typename T>
+void ReqWrap<T>::Cancel() {
+  if (req_.data == this)  // Only cancel if already dispatched.
+    uv_cancel(reinterpret_cast<uv_req_t*>(&req_));
+}
+
+template <typename T>
+AsyncWrap* ReqWrap<T>::GetAsyncWrap() {
+  return this;
+}
+
+// Below is dark template magic designed to invoke libuv functions that
+// initialize uv_req_t instances in a unified fashion, to allow easier
+// tracking of active/inactive requests.
+
+// Invoke a generic libuv function that initializes uv_req_t instances.
+// This is, unfortunately, necessary since they come in three different
+// variants that can not all be invoked in the same way:
+// - int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);
+// - int uv_foo(uv_req_t* request, ...);
+// - void uv_foo(uv_req_t* request, ...);
+template <typename ReqT, typename T>
+struct CallLibuvFunction;
+
+// Detect `int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);`.
+template <typename ReqT, typename... Args>
+struct CallLibuvFunction<ReqT, int(*)(uv_loop_t*, ReqT*, Args...)> {
+  using T = int(*)(uv_loop_t*, ReqT*, Args...);
+  template <typename... PassedArgs>
+  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
+    return fn(loop, req, args...);
+  }
+};
+
+// Detect `int uv_foo(uv_req_t* request, ...);`.
+template <typename ReqT, typename... Args>
+struct CallLibuvFunction<ReqT, int(*)(ReqT*, Args...)> {
+  using T = int(*)(ReqT*, Args...);
+  template <typename... PassedArgs>
+  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
+    return fn(req, args...);
+  }
+};
+
+// Detect `void uv_foo(uv_req_t* request, ...);`.
+template <typename ReqT, typename... Args>
+struct CallLibuvFunction<ReqT, void(*)(ReqT*, Args...)> {
+  using T = void(*)(ReqT*, Args...);
+  template <typename... PassedArgs>
+  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
+    fn(req, args...);
+    return 0;
+  }
+};
+
+// This is slightly darker magic: This template is 'applied' to each parameter
+// passed to the libuv function. If the parameter type (aka `T`) is a
+// function type, it is assumed that this it is the request callback, and a
+// wrapper that calls the original callback is created.
+// If not, the parameter is passed through verbatim.
+template <typename ReqT, typename T>
+struct MakeLibuvRequestCallback {
+  static T For(ReqWrap<ReqT>* req_wrap, T v) {
+    static_assert(!is_callable<T>,
+                  "MakeLibuvRequestCallback missed a callback");
+    return v;
+  }
+};
+
+// Match the `void callback(uv_req_t*, ...);` signature that all libuv
+// callbacks use.
+template <typename ReqT, typename... Args>
+struct MakeLibuvRequestCallback<ReqT, void(*)(ReqT*, Args...)> {
+  using F = void(*)(ReqT* req, Args... args);
+
+  static void Wrapper(ReqT* req, Args... args) {
+    BaseObjectPtr<ReqWrap<ReqT>> req_wrap{ReqWrap<ReqT>::from_req(req)};
+    req_wrap->Detach();
+    req_wrap->env()->DecreaseWaitingRequestCounter();
+    F original_callback = reinterpret_cast<F>(req_wrap->original_callback_);
+    original_callback(req, args...);
+  }
+
+  static F For(ReqWrap<ReqT>* req_wrap, F v) {
+    CHECK_NULL(req_wrap->original_callback_);
+    req_wrap->original_callback_ =
+        reinterpret_cast<typename ReqWrap<ReqT>::callback_t>(v);
+    return Wrapper;
+  }
+};
+
+template <typename T>
+template <typename LibuvFunction, typename... Args>
+int ReqWrap<T>::Dispatch(LibuvFunction fn, Args... args) {
+  Dispatched();
+  // This expands as:
+  //
+  // int err = fn(env()->event_loop(), req(), arg1, arg2, Wrapper, arg3, ...)
+  //              ^                                       ^        ^
+  //              |                                       |        |
+  //              \-- Omitted if `fn` has no              |        |
+  //                  first `uv_loop_t*` argument         |        |
+  //                                                      |        |
+  //        A function callback whose first argument      |        |
+  //        matches the libuv request type is replaced ---/        |
+  //        by the `Wrapper` method defined above                  |
+  //                                                               |
+  //               Other (non-function) arguments are passed  -----/
+  //               through verbatim
+  int err = CallLibuvFunction<T, LibuvFunction>::Call(
+      fn,
+      env()->event_loop(),
+      req(),
+      MakeLibuvRequestCallback<T, Args>::For(this, args)...);
+  if (err >= 0) {
+    ClearWeak();
+    env()->IncreaseWaitingRequestCounter();
+  }
+  return err;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_REQ_WRAP_INL_H_

package/dist/node/include/req_wrap.h

@@ -0,0 +1,77 @@
+#ifndef SRC_REQ_WRAP_H_
+#define SRC_REQ_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+
+class ReqWrapBase {
+ public:
+  explicit inline ReqWrapBase(Environment* env);
+
+  virtual ~ReqWrapBase() = default;
+
+  virtual void Cancel() = 0;
+  virtual AsyncWrap* GetAsyncWrap() = 0;
+
+ private:
+  friend int GenDebugSymbols();
+  friend class Environment;
+
+  ListNode<ReqWrapBase> req_wrap_queue_;
+};
+
+template <typename T>
+class ReqWrap : public AsyncWrap, public ReqWrapBase {
+ public:
+  inline ReqWrap(Environment* env,
+                 v8::Local<v8::Object> object,
+                 AsyncWrap::ProviderType provider);
+  inline ~ReqWrap() override;
+  // Call this after the req has been dispatched, if that did not already
+  // happen by using Dispatch().
+  inline void Dispatched();
+  // Call this after a request has finished, if re-using this object is planned.
+  inline void Reset();
+  T* req() { return &req_; }
+  inline void Cancel() final;
+  inline AsyncWrap* GetAsyncWrap() override;
+
+  static ReqWrap* from_req(T* req);
+
+  template <typename LibuvFunction, typename... Args>
+  inline int Dispatch(LibuvFunction fn, Args... args);
+
+ private:
+  friend int GenDebugSymbols();
+
+  // Adding `friend struct MakeLibuvRequestCallback` is not enough anymore
+  // for some reason. Consider this private.
+ public:
+  typedef void (*callback_t)();
+  callback_t original_callback_ = nullptr;
+
+ protected:
+  // req_wrap_queue_ needs to be at a fixed offset from the start of the class
+  // because it is used by ContainerOf to calculate the address of the embedding
+  // ReqWrap. ContainerOf compiles down to simple, fixed pointer arithmetic. It
+  // is also used by src/node_postmortem_metadata.cc to calculate offsets and
+  // generate debug symbols for ReqWrap, which assumes that the position of
+  // members in memory are predictable. sizeof(req_) depends on the type of T,
+  // so req_wrap_queue_ would no longer be at a fixed offset if it came after
+  // req_. For more information please refer to
+  // `doc/contributing/node-postmortem-support.md`
+  T req_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_REQ_WRAP_H_