@encharm/cws 4.5.2 → 4.6.0

package/src/headers/26/node_profiling.h

@@ -0,0 +1,38 @@
+#ifndef SRC_NODE_PROFILING_H_
+#define SRC_NODE_PROFILING_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "v8-profiler.h"
+#include "v8.h"
+
+#include <cstdint>
+#include <sstream>
+
+namespace node {
+
+struct HeapProfileOptions {
+  uint64_t sample_interval = 512 * 1024;
+  int stack_depth = 16;
+  v8::HeapProfiler::SamplingFlags flags =
+      v8::HeapProfiler::SamplingFlags::kSamplingNoFlags;
+};
+
+HeapProfileOptions ParseHeapProfileOptions(
+    const v8::FunctionCallbackInfo<v8::Value>& args);
+
+bool SerializeHeapProfile(v8::Isolate* isolate, std::ostringstream& out_stream);
+
+struct CpuProfileOptions {
+  int sampling_interval_us = 0;
+  uint32_t max_samples = v8::CpuProfilingOptions::kNoSampleLimit;
+};
+
+CpuProfileOptions ParseCpuProfileOptions(
+    const v8::FunctionCallbackInfo<v8::Value>& args);
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PROFILING_H_

package/src/headers/26/node_realm-inl.h

@@ -0,0 +1,156 @@
+#ifndef SRC_NODE_REALM_INL_H_
+#define SRC_NODE_REALM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_context_data.h"
+#include "node_realm.h"
+#include "util-inl.h"
+
+namespace node {
+
+inline Realm* Realm::GetCurrent(v8::Isolate* isolate) {
+  if (!isolate->InContext()) [[unlikely]] {
+    return nullptr;
+  }
+  v8::HandleScope handle_scope(isolate);
+  return GetCurrent(isolate->GetCurrentContext());
+}
+
+inline Realm* Realm::GetCurrent(v8::Local<v8::Context> context) {
+  if (!ContextEmbedderTag::IsNodeContext(context)) [[unlikely]] {
+    return nullptr;
+  }
+  return static_cast<Realm*>(context->GetAlignedPointerFromEmbedderData(
+      ContextEmbedderIndex::kRealm, EmbedderDataTag::kPerContextData));
+}
+
+inline Realm* Realm::GetCurrent(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  return GetCurrent(info.GetIsolate()->GetCurrentContext());
+}
+
+template <typename T>
+inline Realm* Realm::GetCurrent(const v8::PropertyCallbackInfo<T>& info) {
+  return GetCurrent(info.GetIsolate()->GetCurrentContext());
+}
+
+inline IsolateData* Realm::isolate_data() const {
+  return env_->isolate_data();
+}
+
+inline Environment* Realm::env() const {
+  return env_;
+}
+
+inline v8::Isolate* Realm::isolate() const {
+  return isolate_;
+}
+
+inline v8::Local<v8::Context> Realm::context() const {
+  return PersistentToLocal::Strong(context_);
+}
+
+inline Realm::Kind Realm::kind() const {
+  return kind_;
+}
+
+inline bool Realm::has_run_bootstrapping_code() const {
+  return has_run_bootstrapping_code_;
+}
+
+// static
+template <typename T, typename U>
+inline T* Realm::GetBindingData(const v8::PropertyCallbackInfo<U>& info) {
+  return GetBindingData<T>(info.GetIsolate()->GetCurrentContext());
+}
+
+// static
+template <typename T>
+inline T* Realm::GetBindingData(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  return GetBindingData<T>(info.GetIsolate()->GetCurrentContext());
+}
+
+// static
+template <typename T>
+inline T* Realm::GetBindingData(v8::Local<v8::Context> context) {
+  Realm* realm = GetCurrent(context);
+  return realm->GetBindingData<T>();
+}
+
+template <typename T>
+inline T* Realm::GetBindingData() {
+  constexpr size_t binding_index = static_cast<size_t>(T::binding_type_int);
+  static_assert(binding_index < std::tuple_size_v<BindingDataStore>);
+  auto ptr = binding_data_store_[binding_index];
+  if (!ptr) [[unlikely]] {
+    return nullptr;
+  }
+  T* result = static_cast<T*>(ptr.get());
+  DCHECK_NOT_NULL(result);
+  return result;
+}
+
+template <std::derived_from<BaseObject> T, typename... Args>
+inline T* Realm::AddBindingData(v8::Local<v8::Object> target, Args&&... args) {
+  // The binding data must be weak so that it won't keep the realm reachable
+  // from strong GC roots indefinitely. The wrapper object of binding data
+  // should be referenced from JavaScript, thus the binding data should be
+  // reachable throughout the lifetime of the realm.
+  BaseObjectWeakPtr<T> item =
+      MakeWeakBaseObject<T>(this, target, std::forward<Args>(args)...);
+  constexpr size_t binding_index = static_cast<size_t>(T::binding_type_int);
+  static_assert(binding_index < std::tuple_size_v<BindingDataStore>);
+  // Each slot is expected to be assigned only once.
+  CHECK(!binding_data_store_[binding_index]);
+  binding_data_store_[binding_index] = item;
+  return item.get();
+}
+
+inline BindingDataStore* Realm::binding_data_store() {
+  return &binding_data_store_;
+}
+
+template <typename T>
+void Realm::ForEachBaseObject(T&& iterator) const {
+  for (auto bo : base_object_list_) {
+    iterator(bo);
+  }
+}
+
+int64_t Realm::base_object_created_after_bootstrap() const {
+  return base_object_count_ - base_object_created_by_bootstrap_;
+}
+
+int64_t Realm::base_object_count() const {
+  return base_object_count_;
+}
+
+void Realm::TrackBaseObject(BaseObject* bo) {
+  DCHECK_EQ(bo->realm(), this);
+  base_object_list_.PushBack(bo);
+  ++base_object_count_;
+}
+
+CppgcWrapperListNode::CppgcWrapperListNode(CppgcMixin* ptr) : persistent(ptr) {}
+
+void Realm::TrackCppgcWrapper(CppgcMixin* handle) {
+  DCHECK_EQ(handle->realm(), this);
+  cppgc_wrapper_list_.PushFront(new CppgcWrapperListNode(handle));
+}
+
+void Realm::UntrackBaseObject(BaseObject* bo) {
+  DCHECK_EQ(bo->realm(), this);
+  --base_object_count_;
+}
+
+bool Realm::PendingCleanup() const {
+  return !base_object_list_.IsEmpty();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_REALM_INL_H_

package/src/headers/26/node_realm.h

@@ -0,0 +1,236 @@
+#ifndef SRC_NODE_REALM_H_
+#define SRC_NODE_REALM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <v8.h>
+#include <unordered_map>
+#include "cleanup_queue.h"
+#include "cppgc_helpers.h"
+#include "env_properties.h"
+#include "memory_tracker.h"
+#include "node_snapshotable.h"
+
+namespace node {
+
+struct RealmSerializeInfo {
+  std::vector<std::string> builtins;
+  std::vector<PropInfo> persistent_values;
+  std::vector<PropInfo> native_objects;
+
+  SnapshotIndex context;
+  friend std::ostream& operator<<(std::ostream& o, const RealmSerializeInfo& i);
+};
+
+using BindingDataStore =
+    std::array<BaseObjectWeakPtr<BaseObject>,
+               static_cast<size_t>(BindingDataType::kBindingDataTypeCount)>;
+
+/**
+ * This is a wrapper around a weak persistent of CppgcMixin, used in the
+ * CppgcWrapperList to avoid accessing already garbage collected CppgcMixins.
+ */
+class CppgcWrapperListNode {
+ public:
+  explicit inline CppgcWrapperListNode(CppgcMixin* ptr);
+  inline explicit operator bool() const { return !persistent; }
+  inline CppgcMixin* operator->() const { return persistent.Get(); }
+  inline CppgcMixin* operator*() const { return persistent.Get(); }
+
+  cppgc::WeakPersistent<CppgcMixin> persistent;
+  // Used by ContainerOf in the ListNode implementation for fast manipulation of
+  // CppgcWrapperList.
+  ListNode<CppgcWrapperListNode> wrapper_list_node;
+};
+
+/**
+ * A per-realm list of weak persistent of cppgc wrappers, which implements
+ * iterations that require iterate over cppgc wrappers created by Node.js.
+ */
+class CppgcWrapperList
+    : public ListHead<CppgcWrapperListNode,
+                      &CppgcWrapperListNode::wrapper_list_node>,
+      public MemoryRetainer {
+ public:
+  void Cleanup();
+  void PurgeEmpty();
+
+  SET_MEMORY_INFO_NAME(CppgcWrapperList)
+  SET_SELF_SIZE(CppgcWrapperList)
+  void MemoryInfo(MemoryTracker* tracker) const override;
+};
+
+/**
+ * node::Realm is a container for a set of JavaScript objects and functions
+ * that associated with a particular global environment.
+ *
+ * An ECMAScript realm (https://tc39.es/ecma262/#sec-code-realms) representing
+ * a global environment in which script is run. Each ECMAScript realm comes
+ * with a global object and a set of intrinsic objects. An ECMAScript realm has
+ * a [[HostDefined]] field, which contains the node::Realm object.
+ *
+ * Realm can be a principal realm or a synthetic realm. A principal realm is
+ * created with an Environment as its principal global environment to evaluate
+ * scripts. A synthetic realm is created with JS APIs like ShadowRealm.
+ *
+ * Native bindings and builtin modules can be evaluated in either a principal
+ * realm or a synthetic realm.
+ */
+class Realm : public MemoryRetainer {
+ public:
+  enum Kind {
+    kPrincipal,
+    kShadowRealm,
+  };
+
+  static inline Realm* GetCurrent(v8::Isolate* isolate);
+  static inline Realm* GetCurrent(v8::Local<v8::Context> context);
+  static inline Realm* GetCurrent(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  template <typename T>
+  static inline Realm* GetCurrent(const v8::PropertyCallbackInfo<T>& info);
+
+  Realm(Environment* env, v8::Local<v8::Context> context, Kind kind);
+
+  Realm(const Realm&) = delete;
+  Realm& operator=(const Realm&) = delete;
+  Realm(Realm&&) = delete;
+  Realm& operator=(Realm&&) = delete;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
+  void CreateProperties();
+  RealmSerializeInfo Serialize(v8::SnapshotCreator* creator);
+  void DeserializeProperties(const RealmSerializeInfo* info);
+
+  v8::MaybeLocal<v8::Value> ExecuteBootstrapper(const char* id);
+  v8::MaybeLocal<v8::Value> RunBootstrapping();
+
+  inline void TrackBaseObject(BaseObject* bo);
+  inline void UntrackBaseObject(BaseObject* bo);
+  inline bool PendingCleanup() const;
+  void RunCleanup();
+
+  template <typename T>
+  void ForEachBaseObject(T&& iterator) const;
+
+  void PrintInfoForSnapshot();
+  void VerifyNoStrongBaseObjects();
+
+  inline IsolateData* isolate_data() const;
+  inline Environment* env() const;
+  inline v8::Isolate* isolate() const;
+  inline Kind kind() const;
+  inline virtual v8::Local<v8::Context> context() const;
+  inline bool has_run_bootstrapping_code() const;
+
+  // Methods created using SetMethod(), SetPrototypeMethod(), etc. inside
+  // this scope can access the created T* object using
+  // GetBindingData<T>(args) later.
+  template <std::derived_from<BaseObject> T, typename... Args>
+  T* AddBindingData(v8::Local<v8::Object> target, Args&&... args);
+  template <typename T, typename U>
+  static inline T* GetBindingData(const v8::PropertyCallbackInfo<U>& info);
+  template <typename T>
+  static inline T* GetBindingData(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  template <typename T>
+  static inline T* GetBindingData(v8::Local<v8::Context> context);
+  template <typename T>
+  inline T* GetBindingData();
+  inline BindingDataStore* binding_data_store();
+
+  // The BaseObject count is a debugging helper that makes sure that there are
+  // no memory leaks caused by BaseObjects staying alive longer than expected
+  // (in particular, no circular BaseObjectPtr references).
+  inline int64_t base_object_count() const;
+
+  // Base object count created after the bootstrap of the realm.
+  inline int64_t base_object_created_after_bootstrap() const;
+
+  inline void TrackCppgcWrapper(CppgcMixin* handle);
+  inline CppgcWrapperList* cppgc_wrapper_list() { return &cppgc_wrapper_list_; }
+
+#define V(PropertyName, TypeName)                                              \
+  virtual v8::Local<TypeName> PropertyName() const = 0;                        \
+  virtual void set_##PropertyName(v8::Local<TypeName> value) = 0;
+  PER_REALM_STRONG_PERSISTENT_VALUES(V)
+#undef V
+
+  std::set<struct node_module*> internal_bindings;
+  std::set<std::string> builtins_with_cache;
+  std::set<std::string> builtins_without_cache;
+  // This is only filled during deserialization. We use a vector since
+  // it's only used for tests.
+  std::vector<std::string> builtins_in_snapshot;
+
+  // This used during the destruction of cppgc wrappers to inform a GC epilogue
+  // callback to clean up the weak persistents used to track cppgc wrappers if
+  // the wrappers are already garbage collected to prevent holding on to
+  // excessive useless persistents.
+  inline void set_should_purge_empty_cppgc_wrappers(bool value) {
+    should_purge_empty_cppgc_wrappers_ = value;
+  }
+
+ protected:
+  ~Realm();
+
+  virtual v8::MaybeLocal<v8::Value> BootstrapRealm() = 0;
+
+  Environment* env_;
+  // Shorthand for isolate pointer.
+  v8::Isolate* isolate_;
+  v8::Global<v8::Context> context_;
+  bool should_purge_empty_cppgc_wrappers_ = false;
+
+#define V(PropertyName, TypeName) v8::Global<TypeName> PropertyName##_;
+  PER_REALM_STRONG_PERSISTENT_VALUES(V)
+#undef V
+
+  static void PurgeEmptyCppgcWrappers(v8::Isolate* isolate,
+                                      v8::GCType type,
+                                      v8::GCCallbackFlags flags,
+                                      void* data);
+
+ private:
+  void InitializeContext(v8::Local<v8::Context> context,
+                         const RealmSerializeInfo* realm_info);
+  void DoneBootstrapping();
+
+  Kind kind_;
+  bool has_run_bootstrapping_code_ = false;
+
+  int64_t base_object_count_ = 0;
+  int64_t base_object_created_by_bootstrap_ = 0;
+
+  BindingDataStore binding_data_store_;
+
+  BaseObjectList base_object_list_;
+  CppgcWrapperList cppgc_wrapper_list_;
+};
+
+class PrincipalRealm final : public Realm {
+ public:
+  PrincipalRealm(Environment* env,
+                 v8::Local<v8::Context> context,
+                 const RealmSerializeInfo* realm_info);
+  ~PrincipalRealm();
+
+  SET_MEMORY_INFO_NAME(PrincipalRealm)
+  SET_SELF_SIZE(PrincipalRealm)
+
+#define V(PropertyName, TypeName)                                              \
+  v8::Local<TypeName> PropertyName() const override;                           \
+  void set_##PropertyName(v8::Local<TypeName> value) override;
+  PER_REALM_STRONG_PERSISTENT_VALUES(V)
+#undef V
+
+ protected:
+  v8::MaybeLocal<v8::Value> BootstrapRealm() override;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_REALM_H_

package/src/headers/26/node_report.h

@@ -0,0 +1,43 @@
+#ifndef SRC_NODE_REPORT_H_
+#define SRC_NODE_REPORT_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+#include "node_buffer.h"
+#include "uv.h"
+#include "util.h"
+
+#ifndef _WIN32
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#include <iomanip>
+#include <sstream>
+
+namespace node {
+namespace report {
+// Function declarations - utility functions in src/node_report_utils.cc
+void WalkHandleNetwork(uv_handle_t* h, void* arg);
+void WalkHandleNoNetwork(uv_handle_t* h, void* arg);
+
+template <std::integral T>
+std::string ValueToHexString(T value) {
+  std::stringstream hex;
+
+  hex << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex <<
+    value;
+  return hex.str();
+}
+
+// Function declarations - export functions in src/node_report_module.cc
+void WriteReport(const v8::FunctionCallbackInfo<v8::Value>& info);
+void GetReport(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+}  // namespace report
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_REPORT_H_

package/src/headers/26/node_revert.h

@@ -0,0 +1,82 @@
+#ifndef SRC_NODE_REVERT_H_
+#define SRC_NODE_REVERT_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+
+/**
+ * Note that it is expected for this list to vary across specific LTS and
+ * Stable versions! Only CVE's whose fixes require *breaking* changes within
+ * a given LTS or Stable may be added to this list, and only with TSC
+ * consensus.
+ *
+ * For *main* this list should always be empty!
+ **/
+namespace node {
+
+#define SECURITY_REVERSIONS(XX)                                                \
+  //  XX(CVE_2016_PEND, "CVE-2016-PEND", "Vulnerability Title")
+
+enum reversion {
+#define V(code, ...) SECURITY_REVERT_##code,
+  SECURITY_REVERSIONS(V)
+#undef V
+};
+
+namespace per_process {
+extern unsigned int reverted_cve;
+}
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// MSVC C4065: switch statement contains 'default' but no 'case' labels
+#pragma warning(disable : 4065)
+#endif
+
+inline const char* RevertMessage(const reversion cve) {
+#define V(code, label, msg) case SECURITY_REVERT_##code: return label ": " msg;
+  switch (cve) {
+    SECURITY_REVERSIONS(V)
+    default:
+      return "Unknown";
+  }
+#undef V
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+inline void Revert(const reversion cve) {
+  per_process::reverted_cve |= 1 << cve;
+  printf("SECURITY WARNING: Reverting %s\n", RevertMessage(cve));
+}
+
+inline void Revert(const char* cve, std::string* error) {
+#define V(code, label, _)                                                     \
+  if (strcmp(cve, label) == 0) return Revert(SECURITY_REVERT_##code);
+  SECURITY_REVERSIONS(V)
+#undef V
+  *error = "Error: Attempt to revert an unknown CVE [";
+  *error += cve;
+  *error += ']';
+}
+
+inline bool IsReverted(const reversion cve) {
+  return per_process::reverted_cve & (1 << cve);
+}
+
+inline bool IsReverted(const char* cve) {
+#define V(code, label, _)                                                     \
+  if (strcmp(cve, label) == 0) return IsReverted(SECURITY_REVERT_##code);
+  SECURITY_REVERSIONS(V)
+  return false;
+#undef V
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_REVERT_H_