@encharm/cws 4.5.1 → 4.5.2

package/src/headers/24/debug_utils.h

@@ -0,0 +1,193 @@
+#ifndef SRC_DEBUG_UTILS_H_
+#define SRC_DEBUG_UTILS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "util.h"
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+// Use FORCE_INLINE on functions that have a debug-category-enabled check first
+// and then ideally only a single function call following it, to maintain
+// performance for the common case (no debugging used).
+#ifdef __GNUC__
+#define FORCE_INLINE __attribute__((always_inline))
+#define COLD_NOINLINE __attribute__((cold, noinline))
+#else
+#define FORCE_INLINE
+#define COLD_NOINLINE
+#endif
+
+namespace node {
+class Environment;
+
+template <typename T>
+inline std::string ToString(const T& value);
+
+// C++-style variant of sprintf()/fprintf() that:
+// - Returns an std::string
+// - Handles \0 bytes correctly
+// - Supports %p and %s. %d, %i and %u are aliases for %s.
+// - Accepts any class that has a ToString() method for stringification.
+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 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(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
+};
+
+#define V(name) +1
+constexpr unsigned int kDebugCategoryCount = DEBUG_CATEGORY_NAMES(V);
+#undef V
+
+class NODE_EXTERN_PRIVATE EnabledDebugList {
+ public:
+  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. env->env_vars()
+  // is parsed if it is not a nullptr, otherwise the system environment
+  // variables are parsed.
+  void Parse(Environment* env);
+
+ private:
+  // 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_[kDebugCategoryCount] = {false};
+};
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* format,
+                               Args&&... args);
+
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* message);
+
+template <typename... Args>
+inline void FORCE_INLINE
+Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args);
+
+inline void FORCE_INLINE Debug(Environment* env,
+                               DebugCategory cat,
+                               const char* message);
+
+template <typename... Args>
+inline void Debug(Environment* env,
+                  DebugCategory cat,
+                  const std::string& format,
+                  Args&&... args);
+
+// Used internally by the 'real' Debug(AsyncWrap*, ...) functions below, so that
+// the FORCE_INLINE flag on them doesn't apply to the contents of this function
+// as well.
+// We apply COLD_NOINLINE to tell the compiler that it's not worth optimizing
+// this function for speed and it should rather focus on keeping it out of
+// hot code paths. In particular, we want to keep the string concatenating code
+// out of the function containing the original `Debug()` call.
+template <typename... Args>
+void COLD_NOINLINE UnconditionalAsyncWrapDebug(AsyncWrap* async_wrap,
+                                               const char* format,
+                                               Args&&... args);
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const char* format,
+                               Args&&... args);
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const std::string& format,
+                               Args&&... args);
+
+// Debug helper for inspecting the currently running `node` executable.
+class NativeSymbolDebuggingContext {
+ public:
+  static std::unique_ptr<NativeSymbolDebuggingContext> New();
+
+  class SymbolInfo {
+   public:
+    std::string name;
+    std::string filename;
+    size_t line = 0;
+    size_t dis = 0;
+
+    std::string Display() const;
+  };
+
+  NativeSymbolDebuggingContext() = default;
+  virtual ~NativeSymbolDebuggingContext() = default;
+
+  virtual SymbolInfo LookupSymbol(void* address) { return {}; }
+  virtual bool IsMapped(void* address) { return false; }
+  virtual int GetStackTrace(void** frames, int count) { return 0; }
+
+  NativeSymbolDebuggingContext(const NativeSymbolDebuggingContext&) = delete;
+  NativeSymbolDebuggingContext(NativeSymbolDebuggingContext&&) = delete;
+  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&)
+    = delete;
+  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&&)
+    = delete;
+  static std::vector<std::string> GetLoadedLibraries();
+};
+
+// Variant of `uv_loop_close` that tries to be as helpful as possible
+// about giving information on currently existing handles, if there are any,
+// but still aborts the process.
+void CheckedUvLoopClose(uv_loop_t* loop);
+void PrintLibuvHandleInformation(uv_loop_t* loop, FILE* stream);
+
+namespace per_process {
+extern NODE_EXTERN_PRIVATE EnabledDebugList enabled_debug_list;
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(DebugCategory cat,
+                               const char* format,
+                               Args&&... args);
+
+inline void FORCE_INLINE Debug(DebugCategory cat, const char* message);
+}  // namespace per_process
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DEBUG_UTILS_H_

package/src/headers/24/defs.h

@@ -0,0 +1,254 @@
+#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;
+  }
+  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,
+};
+
+#define CC_ALGOS(V)                                                            \
+  V(RENO, reno)                                                                \
+  V(CUBIC, cubic)                                                              \
+  V(BBR, bbr)
+
+#define V(name, _) static constexpr auto CC_ALGO_##name = NGTCP2_CC_ALGO_##name;
+CC_ALGOS(V)
+#undef V
+
+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

package/src/headers/24/diagnosticfilename-inl.h

@@ -0,0 +1,33 @@
+#ifndef SRC_DIAGNOSTICFILENAME_INL_H_
+#define SRC_DIAGNOSTICFILENAME_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+namespace node {
+
+class Environment;
+
+inline DiagnosticFilename::DiagnosticFilename(
+    Environment* env,
+    const char* prefix,
+    const char* ext) :
+  filename_(MakeFilename(env->thread_id(), prefix, ext)) {
+}
+
+inline DiagnosticFilename::DiagnosticFilename(
+    uint64_t thread_id,
+    const char* prefix,
+    const char* ext) :
+  filename_(MakeFilename(thread_id, prefix, ext)) {
+}
+
+inline const char* DiagnosticFilename::operator*() const {
+  return filename_.c_str();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DIAGNOSTICFILENAME_INL_H_

package/src/headers/24/embedded_data.h

@@ -0,0 +1,17 @@
+#ifndef SRC_EMBEDDED_DATA_H_
+#define SRC_EMBEDDED_DATA_H_
+
+#include <cinttypes>
+#include <string>
+
+// This file must not depend on node.h or other code that depends on
+// the full Node.js implementation because it is used during the
+// compilation of the Node.js implementation itself (especially js2c).
+
+namespace node {
+
+const std::string& GetOctalCode(uint8_t index);
+
+}  // namespace node
+
+#endif  // SRC_EMBEDDED_DATA_H_

package/src/headers/24/encoding_binding.h

@@ -0,0 +1,60 @@
+#ifndef SRC_ENCODING_BINDING_H_
+#define SRC_ENCODING_BINDING_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "aliased_buffer.h"
+#include "node_snapshotable.h"
+#include "v8-fast-api-calls.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace encoding_binding {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex encode_into_results_buffer;
+  };
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(encoding_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void EncodeInto(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EncodeUtf8String(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DecodeUTF8(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DecodeLatin1(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void ToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static constexpr size_t kEncodeIntoResultsLength = 2;
+  AliasedUint32Array encode_into_results_buffer_;
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+
+}  // namespace encoding_binding
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ENCODING_BINDING_H_