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

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

@@ -0,0 +1,127 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#include <memory_tracker.h>
+#include <ngtcp2/ngtcp2.h>
+#include <string>
+#include "defs.h"
+
+namespace node::quic {
+
+// CIDS are used to identify endpoints participating in a QUIC session.
+// Once created, CID instances are immutable.
+//
+// CIDs contain between 1 to 20 bytes. Most typically they are selected
+// randomly but there is a spec for creating "routable" CIDs that encode
+// a specific structure that is meaningful only to the side that creates
+// the CID. For most purposes, CIDs should be treated as opaque tokens.
+//
+// Each peer in a QUIC session generates one or more CIDs that the *other*
+// peer will use to identify the session. When a QUIC client initiates a
+// brand new session, it will initially generates a CID of its own (its
+// source CID) and a random placeholder CID for the server (the original
+// destination CID). When the server receives the initial packet, it will
+// generate its own source CID and use the clients source CID as the
+// server's destination CID.
+//
+//       Client                 Server
+// -------------------------------------------
+//     Source CID   <====> Destination CID
+//  Destination CID <====>   Source CID
+//
+// While the connection is being established, it is possible for either
+// peer to generate additional CIDs that are also associated with the
+// connection.
+class CID final : public MemoryRetainer {
+ public:
+  static constexpr size_t kMinLength = NGTCP2_MIN_CIDLEN;
+  static constexpr size_t kMaxLength = NGTCP2_MAX_CIDLEN;
+
+  // Copy the given ngtcp2_cid.
+  explicit CID(const ngtcp2_cid& cid);
+
+  // Copy the given buffer as a CID. The len must be within
+  // kMinLength and kMaxLength.
+  explicit CID(const uint8_t* data, size_t len);
+
+  // Wrap the given ngtcp2_cid. The CID does not take ownership
+  // of the underlying ngtcp2_cid.
+  explicit CID(const ngtcp2_cid* cid);
+
+  CID(const CID& other);
+  CID& operator=(const CID& other);
+  CID(CID&&) = delete;
+
+  struct Hash final {
+    size_t operator()(const CID& cid) const;
+  };
+
+  bool operator==(const CID& other) const noexcept;
+  bool operator!=(const CID& other) const noexcept;
+
+  operator const uint8_t*() const;
+  operator const ngtcp2_cid&() const;
+  operator const ngtcp2_cid*() const;
+
+  // True if the CID length is at least kMinLength;
+  operator bool() const;
+  size_t length() const;
+
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(CID)
+  SET_SELF_SIZE(CID)
+
+  template <typename T>
+  using Map = std::unordered_map<CID, T, CID::Hash>;
+
+  // A CID::Factory, as the name suggests, is used to create new CIDs.
+  // Per https://datatracker.ietf.org/doc/draft-ietf-quic-load-balancers/, QUIC
+  // implementations MAY use the Connection ID associated with a QUIC session
+  // as a routing mechanism, with each CID instance securely encoding the
+  // routing information. By default, our implementation creates CIDs randomly
+  // but will allow user code to provide their own CID::Factory implementation.
+  class Factory;
+
+  static CID kInvalid;
+
+  // The default constructor creates an empty, zero-length CID.
+  // Zero-length CIDs are not usable. We use them as a placeholder
+  // for a missing or empty CID value. This is public only because
+  // it is required for the CID::Map implementation. It should not
+  // be used. Use kInvalid instead.
+  CID();
+
+ private:
+  ngtcp2_cid cid_;
+  const ngtcp2_cid* ptr_;
+
+  friend struct Hash;
+};
+
+class CID::Factory {
+ public:
+  virtual ~Factory() = default;
+
+  // Generate a new CID. The length_hint must be between CID::kMinLength
+  // and CID::kMaxLength. The implementation can choose to ignore the length.
+  virtual CID Generate(size_t length_hint = CID::kMaxLength) const = 0;
+
+  // Generate a new CID into the given ngtcp2_cid. This variation of
+  // Generate should be used far less commonly.
+  virtual CID GenerateInto(ngtcp2_cid* cid,
+                           size_t length_hint = CID::kMaxLength) const = 0;
+
+  // The default random CID generator instance.
+  static const Factory& random();
+
+  // TODO(@jasnell): This will soon also include additional implementations
+  // of CID::Factory that implement the QUIC Load Balancers spec.
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

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

@@ -0,0 +1,148 @@
+#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 <nghttp3/nghttp3.h>
+#include <ngtcp2/ngtcp2.h>
+#include <node_internals.h>
+#include <node_sockaddr.h>
+#include <v8.h>
+#include <string>
+#include "defs.h"
+
+namespace node::quic {
+
+struct Path final : public ngtcp2_path {
+  Path(const SocketAddress& local, const SocketAddress& remote);
+  inline operator ngtcp2_path*() { return this; }
+  std::string ToString() const;
+};
+
+struct PathStorage final : public ngtcp2_path_storage {
+  PathStorage();
+  operator ngtcp2_path();
+
+  void Reset();
+  void CopyTo(PathStorage* path) const;
+
+  bool operator==(const PathStorage& other) const;
+  bool operator!=(const PathStorage& other) const;
+};
+
+class Store final : public MemoryRetainer {
+ public:
+  Store() = default;
+
+  Store(std::shared_ptr<v8::BackingStore> store,
+        size_t length,
+        size_t offset = 0);
+  Store(std::unique_ptr<v8::BackingStore> store,
+        size_t length,
+        size_t offset = 0);
+
+  enum class Option {
+    NONE,
+    DETACH,
+  };
+
+  Store(v8::Local<v8::ArrayBuffer> buffer, Option option = Option::NONE);
+  Store(v8::Local<v8::ArrayBufferView> view, Option option = Option::NONE);
+
+  v8::Local<v8::Uint8Array> ToUint8Array(Environment* env) const;
+
+  operator uv_buf_t() const;
+  operator ngtcp2_vec() const;
+  operator nghttp3_vec() const;
+  operator bool() const;
+  size_t length() const;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Store)
+  SET_SELF_SIZE(Store)
+
+ private:
+  template <typename T, typename t>
+  T convert() const;
+  std::shared_ptr<v8::BackingStore> store_;
+  size_t length_ = 0;
+  size_t offset_ = 0;
+};
+
+class QuicError final : public MemoryRetainer {
+ public:
+  static constexpr error_code QUIC_NO_ERROR = NGTCP2_NO_ERROR;
+  static constexpr error_code QUIC_APP_NO_ERROR = 65280;
+
+  enum class Type {
+    TRANSPORT = NGTCP2_CCERR_TYPE_TRANSPORT,
+    APPLICATION = NGTCP2_CCERR_TYPE_APPLICATION,
+    VERSION_NEGOTIATION = NGTCP2_CCERR_TYPE_VERSION_NEGOTIATION,
+    IDLE_CLOSE = NGTCP2_CCERR_TYPE_IDLE_CLOSE,
+  };
+
+  explicit QuicError(const std::string& reason = "");
+  explicit QuicError(const ngtcp2_ccerr* ptr);
+  explicit QuicError(const ngtcp2_ccerr& error);
+
+  Type type() const;
+  error_code code() const;
+  const std::string_view reason() const;
+  uint64_t frame_type() const;
+
+  operator const ngtcp2_ccerr&() const;
+  operator const ngtcp2_ccerr*() const;
+
+  // Returns false if the QuicError uses a no_error code with type
+  // transport or application.
+  operator bool() const;
+
+  bool is_crypto() const;
+  std::optional<int> crypto_error() const;
+
+  bool operator==(const QuicError& other) const;
+  bool operator!=(const QuicError& other) const;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(QuicError)
+  SET_SELF_SIZE(QuicError)
+
+  std::string ToString() const;
+  v8::MaybeLocal<v8::Value> ToV8Value(Environment* env) const;
+
+  static std::string reason_for_liberr(int liberr);
+  static std::string reason_for_h3_liberr(int liberr);
+  static bool is_fatal_liberror(int liberr);
+  static bool is_fatal_h3_liberror(int liberr);
+  static error_code liberr_to_code(int liberr);
+  static error_code h3_liberr_to_code(int liberr);
+
+  static QuicError ForTransport(error_code code, std::string reason = "");
+  static QuicError ForApplication(error_code code, std::string reason = "");
+  static QuicError ForVersionNegotiation(std::string reason = "");
+  static QuicError ForIdleClose(std::string reason = "");
+  static QuicError ForNgtcp2Error(int code, std::string reason = "");
+  static QuicError ForTlsAlert(int code, std::string reason = "");
+
+  static QuicError FromConnectionClose(ngtcp2_conn* session);
+
+  static QuicError TRANSPORT_NO_ERROR;
+  static QuicError APPLICATION_NO_ERROR;
+  static QuicError VERSION_NEGOTIATION;
+  static QuicError IDLE_CLOSE;
+  static QuicError INTERNAL_ERROR;
+
+ private:
+  const uint8_t* reason_c_str() const;
+
+  std::string reason_;
+  ngtcp2_ccerr error_;
+  const ngtcp2_ccerr* ptr_ = nullptr;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

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

@@ -0,0 +1,245 @@
+#pragma once
+
+#include <aliased_struct.h>
+#include <env.h>
+#include <nghttp3/nghttp3.h>
+#include <ngtcp2/ngtcp2.h>
+#include <node_errors.h>
+#include <uv.h>
+#include <v8.h>
+#include <limits>
+
+namespace node::quic {
+
+#define NGTCP2_SUCCESS 0
+#define NGTCP2_ERR(V) (V != NGTCP2_SUCCESS)
+#define NGTCP2_OK(V) (V == NGTCP2_SUCCESS)
+
+#define IF_QUIC_DEBUG(env)                                                     \
+  if (env->enabled_debug_list()->enabled(DebugCategory::QUIC)) [[unlikely]]
+
+#define DISALLOW_COPY(Name)                                                    \
+  Name(const Name&) = delete;                                                  \
+  Name& operator=(const Name&) = delete;
+
+#define DISALLOW_MOVE(Name)                                                    \
+  Name(Name&&) = delete;                                                       \
+  Name& operator=(Name&&) = delete;
+
+#define DISALLOW_COPY_AND_MOVE(Name)                                           \
+  DISALLOW_COPY(Name)                                                          \
+  DISALLOW_MOVE(Name)
+
+template <typename Opt, std::string Opt::*member>
+bool SetOption(Environment* env,
+               Opt* options,
+               const v8::Local<v8::Object>& object,
+               const v8::Local<v8::String>& name) {
+  v8::Local<v8::Value> value;
+  if (!object->Get(env->context(), name).ToLocal(&value)) return false;
+  if (!value->IsUndefined()) {
+    Utf8Value utf8(env->isolate(), value);
+    options->*member = utf8.ToString();
+  }
+  return true;
+}
+
+template <typename Opt, bool Opt::*member>
+bool SetOption(Environment* env,
+               Opt* options,
+               const v8::Local<v8::Object>& object,
+               const v8::Local<v8::String>& name) {
+  v8::Local<v8::Value> value;
+  if (!object->Get(env->context(), name).ToLocal(&value)) return false;
+  if (!value->IsUndefined()) {
+    options->*member = value->BooleanValue(env->isolate());
+  }
+  return true;
+}
+
+template <typename Opt, uint32_t Opt::*member>
+bool SetOption(Environment* env,
+               Opt* options,
+               const v8::Local<v8::Object>& object,
+               const v8::Local<v8::String>& name) {
+  v8::Local<v8::Value> value;
+  if (!object->Get(env->context(), name).ToLocal(&value)) return false;
+  if (!value->IsUndefined()) {
+    if (!value->IsUint32()) {
+      Utf8Value nameStr(env->isolate(), name);
+      THROW_ERR_INVALID_ARG_VALUE(
+          env, "The %s option must be an uint32", *nameStr);
+      return false;
+    }
+    v8::Local<v8::Uint32> num;
+    if (!value->ToUint32(env->context()).ToLocal(&num)) {
+      Utf8Value nameStr(env->isolate(), name);
+      THROW_ERR_INVALID_ARG_VALUE(
+          env, "The %s option must be an uint32", *nameStr);
+      return false;
+    }
+    options->*member = num->Value();
+  }
+  return true;
+}
+
+template <typename Opt, uint64_t Opt::*member>
+bool SetOption(Environment* env,
+               Opt* options,
+               const v8::Local<v8::Object>& object,
+               const v8::Local<v8::String>& name) {
+  v8::Local<v8::Value> value;
+  if (!object->Get(env->context(), name).ToLocal(&value)) return false;
+
+  if (!value->IsUndefined()) {
+    if (!value->IsBigInt() && !value->IsNumber()) {
+      Utf8Value nameStr(env->isolate(), name);
+      THROW_ERR_INVALID_ARG_VALUE(
+          env, "option %s must be a bigint or number", *nameStr);
+      return false;
+    }
+    DCHECK_IMPLIES(!value->IsBigInt(), value->IsNumber());
+
+    uint64_t val = 0;
+    if (value->IsBigInt()) {
+      bool lossless = true;
+      val = value.As<v8::BigInt>()->Uint64Value(&lossless);
+      if (!lossless) {
+        Utf8Value label(env->isolate(), name);
+        THROW_ERR_INVALID_ARG_VALUE(env, "option %s is out of range", *label);
+        return false;
+      }
+    } else {
+      double dbl = value.As<v8::Number>()->Value();
+      if (dbl < 0) {
+        Utf8Value label(env->isolate(), name);
+        THROW_ERR_INVALID_ARG_VALUE(env, "option %s is out of range", *label);
+        return false;
+      }
+      val = static_cast<uint64_t>(dbl);
+    }
+    options->*member = val;
+  }
+  return true;
+}
+
+// Utilities used to update the stats for Endpoint, Session, and Stream
+// objects. The stats themselves are maintained in an AliasedStruct within
+// each of the relevant classes.
+
+template <typename Stats, uint64_t Stats::*member>
+void IncrementStat(Stats* stats, uint64_t amt = 1) {
+  stats->*member += amt;
+}
+
+template <typename Stats, uint64_t Stats::*member>
+void RecordTimestampStat(Stats* stats) {
+  stats->*member = uv_hrtime();
+}
+
+template <typename Stats, uint64_t Stats::*member>
+void SetStat(Stats* stats, uint64_t val) {
+  stats->*member = val;
+}
+
+template <typename Stats, uint64_t Stats::*member>
+uint64_t GetStat(Stats* stats) {
+  return stats->*member;
+}
+
+#define STAT_INCREMENT(Type, name)                                             \
+  IncrementStat<Type, &Type::name>(stats_.Data());
+#define STAT_INCREMENT_N(Type, name, amt)                                      \
+  IncrementStat<Type, &Type::name>(stats_.Data(), amt);
+#define STAT_RECORD_TIMESTAMP(Type, name)                                      \
+  RecordTimestampStat<Type, &Type::name>(stats_.Data());
+#define STAT_SET(Type, name, val) SetStat<Type, &Type::name>(stats_.Data(), val)
+#define STAT_GET(Type, name) GetStat<Type, &Type::name>(stats_.Data())
+#define STAT_FIELD(_, name) uint64_t name;
+#define STAT_STRUCT(klass, name)                                               \
+  struct klass::Stats final {                                                  \
+    name##_STATS(STAT_FIELD)                                                   \
+  };
+
+#define JS_METHOD(name)                                                        \
+  static void name(const v8::FunctionCallbackInfo<v8::Value>& args)
+
+enum class Side : uint8_t {
+  CLIENT,
+  SERVER,
+};
+
+enum class EndpointLabel : uint8_t {
+  LOCAL,
+  REMOTE,
+};
+
+enum class Direction : uint8_t {
+  BIDIRECTIONAL,
+  UNIDIRECTIONAL,
+};
+
+enum class HeadersKind : uint8_t {
+  HINTS,
+  INITIAL,
+  TRAILING,
+};
+
+enum class HeadersFlags : uint8_t {
+  NONE,
+  TERMINAL,
+};
+
+enum class StreamPriority : uint8_t {
+  DEFAULT = NGHTTP3_DEFAULT_URGENCY,
+  LOW = NGHTTP3_URGENCY_LOW,
+  HIGH = NGHTTP3_URGENCY_HIGH,
+};
+
+enum class StreamPriorityFlags : uint8_t {
+  NONE,
+  NON_INCREMENTAL,
+};
+
+enum class PathValidationResult : uint8_t {
+  SUCCESS = NGTCP2_PATH_VALIDATION_RESULT_SUCCESS,
+  FAILURE = NGTCP2_PATH_VALIDATION_RESULT_FAILURE,
+  ABORTED = NGTCP2_PATH_VALIDATION_RESULT_ABORTED,
+};
+
+enum class DatagramStatus : uint8_t {
+  ACKNOWLEDGED,
+  LOST,
+};
+
+constexpr uint64_t NGTCP2_APP_NOERROR = 65280;
+constexpr size_t kDefaultMaxPacketLength = NGTCP2_MAX_UDP_PAYLOAD_SIZE;
+constexpr size_t kMaxSizeT = std::numeric_limits<size_t>::max();
+constexpr uint64_t kMaxSafeJsInteger = 9007199254740991;
+constexpr auto kSocketAddressInfoTimeout = 60 * NGTCP2_SECONDS;
+constexpr size_t kMaxVectorCount = 16;
+
+using error_code = uint64_t;
+
+class DebugIndentScope {
+ public:
+  inline DebugIndentScope() { ++indent_; }
+  DISALLOW_COPY_AND_MOVE(DebugIndentScope)
+  inline ~DebugIndentScope() { --indent_; }
+  inline std::string Prefix() const {
+    std::string res("\n");
+    res.append(indent_, '\t');
+    return res;
+  }
+  inline std::string Close() const {
+    std::string res("\n");
+    res.append(indent_ - 1, '\t');
+    res += "}";
+    return res;
+  }
+
+ private:
+  static int indent_;
+};
+
+}  // namespace node::quic