@encharm/cws 4.4.1 → 4.5.2

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

@@ -0,0 +1,145 @@
+#ifndef SRC_NODE_REALM_INL_H_
+#define SRC_NODE_REALM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "cleanup_queue-inl.h"
+#include "node_realm.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));
+}
+
+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 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 <typename T, typename... Args>
+inline T* Realm::AddBindingData(v8::Local<v8::Object> target, Args&&... args) {
+  // This won't compile if T is not a BaseObject subclass.
+  static_assert(std::is_base_of_v<BaseObject, T>);
+  // 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 {
+  cleanup_queue_.ForEachBaseObject(std::forward<T>(iterator));
+}
+
+void Realm::modify_base_object_count(int64_t delta) {
+  base_object_count_ += delta;
+}
+
+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::AddCleanupHook(CleanupQueue::Callback fn, void* arg) {
+  cleanup_queue_.Add(fn, arg);
+}
+
+void Realm::RemoveCleanupHook(CleanupQueue::Callback fn, void* arg) {
+  cleanup_queue_.Remove(fn, arg);
+}
+
+bool Realm::HasCleanupHooks() const {
+  return !cleanup_queue_.empty();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_REALM_INL_H_

package/src/headers/22/node_realm.h

@@ -0,0 +1,184 @@
+#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 "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)>;
+
+/**
+ * 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 AddCleanupHook(CleanupQueue::Callback cb, void* arg);
+  inline void RemoveCleanupHook(CleanupQueue::Callback cb, void* arg);
+  inline bool HasCleanupHooks() 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;
+  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 <typename 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 void modify_base_object_count(int64_t delta);
+  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;
+
+#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;
+
+ protected:
+  ~Realm();
+
+  virtual v8::MaybeLocal<v8::Value> BootstrapRealm() = 0;
+
+  Environment* env_;
+  // Shorthand for isolate pointer.
+  v8::Isolate* isolate_;
+  v8::Global<v8::Context> context_;
+
+#define V(PropertyName, TypeName) v8::Global<TypeName> PropertyName##_;
+  PER_REALM_STRONG_PERSISTENT_VALUES(V)
+#undef V
+
+ 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_;
+
+  CleanupQueue cleanup_queue_;
+};
+
+class PrincipalRealm : 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/{16 → 22}/node_report.h

@@ -1,4 +1,7 @@
-#pragma once
+#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"
@@ -11,25 +14,13 @@
 #endif
 
 #include <iomanip>
+#include <sstream>
 
+namespace node {
 namespace report {
-
-// Function declarations - functions in src/node_report.cc
-std::string TriggerNodeReport(v8::Isolate* isolate,
-                              node::Environment* env,
-                              const char* message,
-                              const char* trigger,
-                              const std::string& name,
-                              v8::Local<v8::Value> error);
-void GetNodeReport(v8::Isolate* isolate,
-                   node::Environment* env,
-                   const char* message,
-                   const char* trigger,
-                   v8::Local<v8::Value> error,
-                   std::ostream& out);
-
 // Function declarations - utility functions in src/node_report_utils.cc
-void WalkHandle(uv_handle_t* h, void* arg);
+void WalkHandleNetwork(uv_handle_t* h, void* arg);
+void WalkHandleNoNetwork(uv_handle_t* h, void* arg);
 
 template <typename T>
 std::string ValueToHexString(T value) {
@@ -45,3 +36,8 @@ 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/{16 → 22}/node_revert.h

@@ -11,12 +11,12 @@
  * a given LTS or Stable may be added to this list, and only with TSC
  * consensus.
  *
- * For *master* this list should always be empty!
+ * For *main* this list should always be empty!
  **/
 namespace node {
 
-#define SECURITY_REVERSIONS(XX)                                            \
-//  XX(CVE_2016_PEND, "CVE-2016-PEND", "Vulnerability Title")
+#define SECURITY_REVERSIONS(XX)                                                \
+  //  XX(CVE_2016_PEND, "CVE-2016-PEND", "Vulnerability Title")
 
 enum reversion {
 #define V(code, ...) SECURITY_REVERT_##code,