@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/crypto/crypto_x509.h

@@ -0,0 +1,140 @@
+#ifndef SRC_CRYPTO_CRYPTO_X509_H_
+#define SRC_CRYPTO_CRYPTO_X509_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "crypto/crypto_util.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "ncrypto.h"
+#include "node_worker.h"
+#include "v8.h"
+
+namespace node {
+namespace crypto {
+
+// The ManagedX509 class is essentially a smart pointer for
+// X509 objects that allows an X509Certificate instance to
+// be cloned at the JS level while pointing at the same
+// underlying X509 instance.
+class ManagedX509 final : public MemoryRetainer {
+ public:
+  ManagedX509() = default;
+  explicit ManagedX509(ncrypto::X509Pointer&& cert);
+  ManagedX509(const ManagedX509& that);
+  ManagedX509& operator=(const ManagedX509& that);
+
+  inline operator bool() const { return !!cert_; }
+  inline X509* get() const { return cert_.get(); }
+  inline ncrypto::X509View view() const { return cert_; }
+  inline operator ncrypto::X509View() const { return cert_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(ManagedX509)
+  SET_SELF_SIZE(ManagedX509)
+
+ private:
+  ncrypto::X509Pointer cert_;
+};
+
+class X509Certificate final : public BaseObject {
+ public:
+  enum class GetPeerCertificateFlag {
+    NONE,
+    SERVER
+  };
+
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static bool HasInstance(Environment* env, v8::Local<v8::Object> object);
+
+  static v8::MaybeLocal<v8::Object> New(
+      Environment* env,
+      ncrypto::X509Pointer cert,
+      STACK_OF(X509) * issuer_chain = nullptr);
+
+  static v8::MaybeLocal<v8::Object> New(
+      Environment* env,
+      std::shared_ptr<ManagedX509> cert,
+      STACK_OF(X509)* issuer_chain = nullptr);
+
+  static v8::MaybeLocal<v8::Object> GetCert(Environment* env,
+                                            const ncrypto::SSLPointer& ssl);
+
+  static v8::MaybeLocal<v8::Object> GetPeerCert(Environment* env,
+                                                const ncrypto::SSLPointer& ssl,
+                                                GetPeerCertificateFlag flag);
+
+  static v8::Local<v8::Object> Wrap(Environment* env,
+                                    v8::Local<v8::Object> object,
+                                    ncrypto::X509Pointer cert);
+
+  inline BaseObjectPtr<X509Certificate> getIssuerCert() const {
+    return issuer_cert_;
+  }
+
+  inline ncrypto::X509View view() const { return *cert_; }
+  inline X509* get() { return cert_->get(); }
+
+  v8::MaybeLocal<v8::Value> toObject(Environment* env);
+  static v8::MaybeLocal<v8::Value> toObject(Environment* env,
+                                            const ncrypto::X509View& cert);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(X509Certificate)
+  SET_SELF_SIZE(X509Certificate)
+
+  class X509CertificateTransferData : public worker::TransferData {
+   public:
+    explicit X509CertificateTransferData(
+        const std::shared_ptr<ManagedX509>& data)
+        : data_(data) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    SET_MEMORY_INFO_NAME(X509CertificateTransferData)
+    SET_SELF_SIZE(X509CertificateTransferData)
+    SET_NO_MEMORY_INFO()
+
+   private:
+    std::shared_ptr<ManagedX509> data_;
+  };
+
+  BaseObject::TransferMode GetTransferMode() const override;
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+ private:
+  X509Certificate(Environment* env,
+                  v8::Local<v8::Object> object,
+                  std::shared_ptr<ManagedX509> cert,
+                  v8::Local<v8::Object> issuer_chain = v8::Local<v8::Object>());
+
+  std::shared_ptr<ManagedX509> cert_;
+  BaseObjectPtr<X509Certificate> issuer_cert_;
+};
+
+inline X509Certificate::GetPeerCertificateFlag operator|(
+    X509Certificate::GetPeerCertificateFlag lhs,
+    X509Certificate::GetPeerCertificateFlag rhs) {
+  return static_cast<X509Certificate::GetPeerCertificateFlag>(
+      static_cast<int>(lhs) | static_cast<int>(rhs));
+}
+
+inline X509Certificate::GetPeerCertificateFlag operator&(
+    X509Certificate::GetPeerCertificateFlag lhs,
+    X509Certificate::GetPeerCertificateFlag rhs) {
+  return static_cast<X509Certificate::GetPeerCertificateFlag>(
+      static_cast<int>(lhs) & static_cast<int>(rhs));
+}
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_X509_H_

package/src/headers/24/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/src/headers/{14 → 24}/debug_utils-inl.h

@@ -5,6 +5,7 @@
 
 #include "debug_utils.h"
 #include "env.h"
+#include "util-inl.h"
 
 #include <type_traits>
 
@@ -26,10 +27,13 @@ struct ToStringHelper {
     return value != nullptr ? value : "(null)";
   }
   static std::string Convert(const std::string& value) { return value; }
+  static std::string Convert(std::string_view value) {
+    return std::string(value);
+  }
   static std::string Convert(bool value) { return value ? "true" : "false"; }
   template <unsigned BASE_BITS,
             typename T,
-            typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
+            typename = std::enable_if_t<std::is_integral_v<T>>>
   static std::string BaseConvert(const T& value) {
     auto v = static_cast<uint64_t>(value);
     char ret[3 * sizeof(T)];
@@ -45,8 +49,8 @@ struct ToStringHelper {
   }
   template <unsigned BASE_BITS,
             typename T,
-            typename std::enable_if<!std::is_integral<T>::value, int>::type = 0>
-  static std::string BaseConvert(T value) {
+            typename = std::enable_if_t<!std::is_integral_v<T>>>
+  static std::string BaseConvert(T& value) {  // NOLINT(runtime/references)
     return Convert(std::forward<T>(value));
   }
 };
@@ -63,7 +67,8 @@ std::string ToBaseString(const T& value) {
 
 inline std::string SPrintFImpl(const char* format) {
   const char* p = strchr(format, '%');
-  if (LIKELY(p == nullptr)) return format;
+  if (p == nullptr) [[unlikely]]
+    return format;
   CHECK_EQ(p[1], '%');  // Only '%%' allowed when there are no arguments.
 
   return std::string(format, p + 1) + SPrintFImpl(p + 2);
@@ -134,14 +139,16 @@ inline void FORCE_INLINE Debug(EnabledDebugList* list,
                                DebugCategory cat,
                                const char* format,
                                Args&&... args) {
-  if (!UNLIKELY(list->enabled(cat))) return;
+  if (!list->enabled(cat)) [[unlikely]]
+    return;
   FPrintF(stderr, format, std::forward<Args>(args)...);
 }
 
 inline void FORCE_INLINE Debug(EnabledDebugList* list,
                                DebugCategory cat,
                                const char* message) {
-  if (!UNLIKELY(list->enabled(cat))) return;
+  if (!list->enabled(cat)) [[unlikely]]
+    return;
   FPrintF(stderr, "%s", message);
 }
 
@@ -190,8 +197,10 @@ inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
                                const char* format,
                                Args&&... args) {
   DCHECK_NOT_NULL(async_wrap);
-  DebugCategory cat = static_cast<DebugCategory>(async_wrap->provider_type());
-  if (!UNLIKELY(async_wrap->env()->enabled_debug_list()->enabled(cat))) return;
+  if (auto cat = static_cast<DebugCategory>(async_wrap->provider_type());
+      !async_wrap->env()->enabled_debug_list()->enabled(cat)) [[unlikely]] {
+    return;
+  }
   UnconditionalAsyncWrapDebug(async_wrap, format, std::forward<Args>(args)...);
 }
 

package/src/headers/{16 → 24}/debug_utils.h

@@ -4,6 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "async_wrap.h"
+#include "util.h"
 
 #include <algorithm>
 #include <sstream>
@@ -35,53 +36,61 @@ template <typename... Args>
 inline std::string SPrintF(const char* format, Args&&... args);
 template <typename... Args>
 inline void FPrintF(FILE* file, const char* format, Args&&... args);
-void FWrite(FILE* file, const std::string& str);
+void NODE_EXTERN_PRIVATE FWrite(FILE* file, const std::string& str);
 
 // Listing the AsyncWrap provider types first enables us to cast directly
 // from a provider type to a debug category.
 #define DEBUG_CATEGORY_NAMES(V)                                                \
   NODE_ASYNC_PROVIDER_TYPES(V)                                                 \
+  V(COMPILE_CACHE)                                                             \
   V(DIAGNOSTICS)                                                               \
   V(HUGEPAGES)                                                                 \
   V(INSPECTOR_SERVER)                                                          \
+  V(INSPECTOR_CLIENT)                                                          \
   V(INSPECTOR_PROFILER)                                                        \
   V(CODE_CACHE)                                                                \
   V(NGTCP2_DEBUG)                                                              \
+  V(SEA)                                                                       \
   V(WASI)                                                                      \
-  V(MKSNAPSHOT)
-
-enum class DebugCategory {
+  V(MODULE)                                                                    \
+  V(MKSNAPSHOT)                                                                \
+  V(SNAPSHOT_SERDES)                                                           \
+  V(PERMISSION_MODEL)                                                          \
+  V(PLATFORM_MINIMAL)                                                          \
+  V(PLATFORM_VERBOSE)                                                          \
+  V(QUIC)
+
+enum class DebugCategory : unsigned int {
 #define V(name) name,
   DEBUG_CATEGORY_NAMES(V)
 #undef V
-      CATEGORY_COUNT
 };
 
-class EnabledDebugList {
+#define V(name) +1
+constexpr unsigned int kDebugCategoryCount = DEBUG_CATEGORY_NAMES(V);
+#undef V
+
+class NODE_EXTERN_PRIVATE EnabledDebugList {
  public:
-  bool enabled(DebugCategory category) const {
-    DCHECK_GE(static_cast<int>(category), 0);
-    DCHECK_LT(static_cast<int>(category),
-              static_cast<int>(DebugCategory::CATEGORY_COUNT));
-    return enabled_[static_cast<int>(category)];
+  bool FORCE_INLINE enabled(DebugCategory category) const {
+    DCHECK_LT(static_cast<unsigned int>(category), kDebugCategoryCount);
+    return enabled_[static_cast<unsigned int>(category)];
   }
 
-  // Uses NODE_DEBUG_NATIVE to initialize the categories. When env is not a
-  // nullptr, the environment variables set in the Environment are used.
-  // Otherwise the system environment variables are used.
+  // Uses NODE_DEBUG_NATIVE to initialize the categories. env->env_vars()
+  // is parsed if it is not a nullptr, otherwise the system environment
+  // variables are parsed.
   void Parse(Environment* env);
 
  private:
-  // Set all categories matching cats to the value of enabled.
-  void Parse(const std::string& cats, bool enabled);
-  void set_enabled(DebugCategory category, bool enabled) {
-    DCHECK_GE(static_cast<int>(category), 0);
-    DCHECK_LT(static_cast<int>(category),
-              static_cast<int>(DebugCategory::CATEGORY_COUNT));
+  // Enable all categories matching cats.
+  void Parse(const std::string& cats);
+  void set_enabled(DebugCategory category) {
+    DCHECK_LT(static_cast<unsigned int>(category), kDebugCategoryCount);
     enabled_[static_cast<int>(category)] = true;
   }
 
-  bool enabled_[static_cast<int>(DebugCategory::CATEGORY_COUNT)] = {false};
+  bool enabled_[kDebugCategoryCount] = {false};
 };
 
 template <typename... Args>
@@ -168,7 +177,7 @@ void CheckedUvLoopClose(uv_loop_t* loop);
 void PrintLibuvHandleInformation(uv_loop_t* loop, FILE* stream);
 
 namespace per_process {
-extern EnabledDebugList enabled_debug_list;
+extern NODE_EXTERN_PRIVATE EnabledDebugList enabled_debug_list;
 
 template <typename... Args>
 inline void FORCE_INLINE Debug(DebugCategory cat,