@encharm/cws 4.4.1 → 4.5.1

package/src/headers/22/node_url.h

@@ -0,0 +1,96 @@
+#ifndef SRC_NODE_URL_H_
+#define SRC_NODE_URL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "ada.h"
+#include "aliased_buffer.h"
+#include "node.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+#include <optional>
+#include <string>
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace url {
+
+enum url_update_action {
+  kProtocol = 0,
+  kHost = 1,
+  kHostname = 2,
+  kPort = 3,
+  kUsername = 4,
+  kPassword = 5,
+  kPathname = 6,
+  kSearch = 7,
+  kHash = 8,
+  kHref = 9,
+};
+
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* realm, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(url_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void DomainToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DomainToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CanParse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool FastCanParse(v8::Local<v8::Value> receiver,
+                           const v8::FastOneByteString& input);
+  static bool FastCanParseWithBase(v8::Local<v8::Value> receiver,
+                                   const v8::FastOneByteString& input,
+                                   const v8::FastOneByteString& base);
+
+  static void Format(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetOrigin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Parse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void PathToFileURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Update(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ private:
+  static constexpr size_t kURLComponentsLength = 9;
+  AliasedUint32Array url_components_buffer_;
+
+  void UpdateComponents(const ada::url_components& components,
+                        const ada::scheme::type type);
+
+  static v8::CFunction fast_can_parse_methods_[];
+};
+
+void ThrowInvalidURL(Environment* env,
+                     std::string_view input,
+                     std::optional<std::string> base);
+std::string FromFilePath(std::string_view file_path);
+std::optional<std::string> FileURLToPath(Environment* env,
+                                         const ada::url_aggregator& file_url);
+
+}  // namespace url
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_URL_H_

package/src/headers/22/node_v8.h

@@ -0,0 +1,77 @@
+#ifndef SRC_NODE_V8_H_
+#define SRC_NODE_V8_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <sstream>
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "json_utils.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+struct InternalFieldInfoBase;
+
+namespace v8_utils {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex heap_statistics_buffer;
+    AliasedBufferIndex heap_space_statistics_buffer;
+    AliasedBufferIndex heap_code_statistics_buffer;
+  };
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(v8_binding_data)
+
+  AliasedFloat64Array heap_statistics_buffer;
+  AliasedFloat64Array heap_space_statistics_buffer;
+  AliasedFloat64Array heap_code_statistics_buffer;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+ private:
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+
+class GCProfiler : public BaseObject {
+ public:
+  enum class GCProfilerState { kInitialized, kStarted, kStopped };
+  GCProfiler(Environment* env, v8::Local<v8::Object> object);
+  inline ~GCProfiler() override;
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  JSONWriter* writer();
+
+  std::ostringstream* out_stream();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(GCProfiler)
+  SET_SELF_SIZE(GCProfiler)
+
+  uint64_t start_time;
+  uint8_t current_gc_type;
+  GCProfilerState state;
+
+ private:
+  std::ostringstream out_stream_;
+  JSONWriter writer_;
+};
+
+}  // namespace v8_utils
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_H_

package/src/headers/{14 → 22}/node_v8_platform-inl.h

@@ -4,6 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include <memory>
+#include <string_view>
 
 #include "env-inl.h"
 #include "node.h"
@@ -103,12 +104,13 @@ struct V8Platform {
     platform_ = new NodePlatform(thread_pool_size, controller);
     v8::V8::InitializePlatform(platform_);
   }
-
+  // Make sure V8Platform don not call into Libuv threadpool,
+  // see DefaultProcessExitHandlerInternal in environment.cc
   inline void Dispose() {
     if (!initialized_)
       return;
     initialized_ = false;
-
+    node::tracing::TraceEventHelper::SetAgent(nullptr);
     StopTracingAgent();
     platform_->Shutdown();
     delete platform_;
@@ -116,6 +118,7 @@ struct V8Platform {
     // Destroy tracing after the platform (and platform threads) have been
     // stopped.
     tracing_agent_.reset(nullptr);
+    // The observer remove itself in OnTraceEnabled
     trace_state_observer_.reset(nullptr);
   }
 
@@ -124,15 +127,23 @@ struct V8Platform {
   }
 
   inline void StartTracingAgent() {
+    constexpr auto convert_to_set =
+        [](std::vector<std::string_view> categories) -> std::set<std::string> {
+      std::set<std::string> out;
+      for (const auto& s : categories) {
+        out.emplace(s);
+      }
+      return out;
+    };
     // Attach a new NodeTraceWriter only if this function hasn't been called
     // before.
     if (tracing_file_writer_.IsDefaultHandle()) {
-      std::vector<std::string> categories =
-          SplitString(per_process::cli_options->trace_event_categories, ',');
+      using std::string_view_literals::operator""sv;
+      const std::vector<std::string_view> categories =
+          SplitString(per_process::cli_options->trace_event_categories, ","sv);
 
       tracing_file_writer_ = tracing_agent_->AddClient(
-          std::set<std::string>(std::make_move_iterator(categories.begin()),
-                                std::make_move_iterator(categories.end())),
+          convert_to_set(categories),
           std::unique_ptr<tracing::AsyncTraceWriter>(
               new tracing::NodeTraceWriter(
                   per_process::cli_options->trace_event_file_pattern)),

package/src/headers/{18 → 22}/node_version.h

@@ -22,12 +22,12 @@
 #ifndef SRC_NODE_VERSION_H_
 #define SRC_NODE_VERSION_H_
 
-#define NODE_MAJOR_VERSION 18
-#define NODE_MINOR_VERSION 3
+#define NODE_MAJOR_VERSION 22
+#define NODE_MINOR_VERSION 12
 #define NODE_PATCH_VERSION 0
 
-#define NODE_VERSION_IS_LTS 0
-#define NODE_VERSION_LTS_CODENAME ""
+#define NODE_VERSION_IS_LTS 1
+#define NODE_VERSION_LTS_CODENAME "Jod"
 
 #define NODE_VERSION_IS_RELEASE 1
 
@@ -83,16 +83,28 @@
  * We will, at times update the version of V8 shipped in the release line
  * if it can be made ABI compatible with the previous version.
  *
+ * Embedders building Node.js can define NODE_EMBEDDER_MODULE_VERSION to
+ * override the default value of NODE_MODULE_VERSION.
+ *
  * The registry of used NODE_MODULE_VERSION numbers is located at
  *   https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json
  * Extenders, embedders and other consumers of Node.js that require ABI
  * version matching should open a pull request to reserve a number in this
  * registry.
  */
-#define NODE_MODULE_VERSION 108
+#if defined(NODE_EMBEDDER_MODULE_VERSION)
+#define NODE_MODULE_VERSION NODE_EMBEDDER_MODULE_VERSION
+#else
+#define NODE_MODULE_VERSION 127
+#endif
+
+// The NAPI_VERSION supported by the runtime. This is the inclusive range of
+// versions which the Node.js binary being built supports.
+#define NODE_API_SUPPORTED_VERSION_MAX 9
+#define NODE_API_SUPPORTED_VERSION_MIN 1
 
-// The NAPI_VERSION provided by this version of the runtime. This is the version
-// which the Node binary being built supports.
-#define NAPI_VERSION  8
+// Node API modules use NAPI_VERSION 8 by default if it is not explicitly
+// specified. It must be always 8.
+#define NODE_API_DEFAULT_MODULE_API_VERSION 8
 
 #endif  // SRC_NODE_VERSION_H_

package/src/headers/22/node_wasi.h

@@ -0,0 +1,185 @@
+#ifndef SRC_NODE_WASI_H_
+#define SRC_NODE_WASI_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "node_mem.h"
+#include "uvwasi.h"
+#include "v8-fast-api-calls.h"
+
+namespace node {
+namespace wasi {
+
+struct WasmMemory {
+  char* data;
+  size_t size;
+};
+
+class WASI : public BaseObject,
+             public mem::NgLibMemoryManager<WASI, uvwasi_mem_t> {
+ public:
+  WASI(Environment* env,
+       v8::Local<v8::Object> object,
+       uvwasi_options_t* options);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(WASI)
+  SET_SELF_SIZE(WASI)
+
+  static uint32_t ArgsGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t ArgsSizesGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t ClockResGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t ClockTimeGet(WASI&, WasmMemory, uint32_t, uint64_t, uint32_t);
+  static uint32_t EnvironGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t EnvironSizesGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdAdvise(
+      WASI&, WasmMemory, uint32_t, uint64_t, uint64_t, uint32_t);
+  static uint32_t FdAllocate(WASI&, WasmMemory, uint32_t, uint64_t, uint64_t);
+  static uint32_t FdClose(WASI&, WasmMemory, uint32_t);
+  static uint32_t FdDatasync(WASI&, WasmMemory, uint32_t);
+  static uint32_t FdFdstatGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdFdstatSetFlags(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdFdstatSetRights(
+      WASI&, WasmMemory, uint32_t, uint64_t, uint64_t);
+  static uint32_t FdFilestatGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdFilestatSetSize(WASI&, WasmMemory, uint32_t, uint64_t);
+  static uint32_t FdFilestatSetTimes(
+      WASI&, WasmMemory, uint32_t, uint64_t, uint64_t, uint32_t);
+  static uint32_t FdPread(WASI&,
+                          WasmMemory memory,
+                          uint32_t,
+                          uint32_t,
+                          uint32_t,
+                          uint64_t,
+                          uint32_t);
+  static uint32_t FdPrestatGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdPrestatDirName(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t FdPwrite(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint64_t, uint32_t);
+  static uint32_t FdRead(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t FdReaddir(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint64_t, uint32_t);
+  static uint32_t FdRenumber(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdSeek(
+      WASI&, WasmMemory, uint32_t, int64_t, uint32_t, uint32_t);
+  static uint32_t FdSync(WASI&, WasmMemory, uint32_t);
+  static uint32_t FdTell(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdWrite(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathCreateDirectory(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathFilestatGet(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathFilestatSetTimes(WASI&,
+                                       WasmMemory,
+                                       uint32_t,
+                                       uint32_t,
+                                       uint32_t,
+                                       uint32_t,
+                                       uint64_t,
+                                       uint64_t,
+                                       uint32_t);
+  static uint32_t PathLink(WASI&,
+                           WasmMemory,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t);
+  static uint32_t PathOpen(WASI&,
+                           WasmMemory,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint64_t,
+                           uint64_t,
+                           uint32_t,
+                           uint32_t);
+  static uint32_t PathReadlink(WASI&,
+                               WasmMemory,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t);
+  static uint32_t PathRemoveDirectory(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathRename(WASI&,
+                             WasmMemory,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t);
+  static uint32_t PathSymlink(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathUnlinkFile(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t PollOneoff(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t);
+  static void ProcExit(WASI&, WasmMemory, uint32_t);
+  static uint32_t ProcRaise(WASI&, WasmMemory, uint32_t);
+  static uint32_t RandomGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t SchedYield(WASI&, WasmMemory);
+  static uint32_t SockAccept(WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t SockRecv(WASI&,
+                           WasmMemory,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t);
+  static uint32_t SockSend(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t SockShutdown(WASI&, WasmMemory, uint32_t, uint32_t);
+
+  static void _SetMemory(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // Implementation for mem::NgLibMemoryManager
+  void CheckAllocatedSize(size_t previous_size) const;
+  void IncreaseAllocatedSize(size_t size);
+  void DecreaseAllocatedSize(size_t size);
+
+  // <typename FT, FT F> as a C++14 desugaring of `<auto F>`
+  template <typename FT, FT F, typename R, typename... Args>
+  class WasiFunction {
+   public:
+    static void SetFunction(Environment*,
+                            const char*,
+                            v8::Local<v8::FunctionTemplate>);
+
+   private:
+    static R FastCallback(v8::Local<v8::Object> unused,
+                          v8::Local<v8::Object> receiver,
+                          Args...,
+                          v8::FastApiCallbackOptions&);
+
+    static void SlowCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+  };
+
+ private:
+  ~WASI() override;
+  uvwasi_t uvw_;
+  v8::Global<v8::WasmMemoryObject> memory_;
+  uvwasi_mem_t alloc_info_;
+  size_t current_uvwasi_memory_ = 0;
+};
+
+
+}  // namespace wasi
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_WASI_H_

package/src/headers/{14 → 22}/node_watchdog.h

@@ -110,6 +110,7 @@ class TraceSigintWatchdog : public HandleWrap, public SigintWatchdogBase {
 class SigintWatchdogHelper {
  public:
   static SigintWatchdogHelper* GetInstance() { return &instance; }
+  static Mutex& GetInstanceActionMutex() { return instance_action_mutex_; }
   void Register(SigintWatchdogBase* watchdog);
   void Unregister(SigintWatchdogBase* watchdog);
   bool HasPendingSignal();
@@ -123,6 +124,7 @@ class SigintWatchdogHelper {
 
   static bool InformWatchdogsAboutSignal();
   static SigintWatchdogHelper instance;
+  static Mutex instance_action_mutex_;
 
   int start_stop_count_;
 

package/src/headers/{18 → 22}/node_worker.h

@@ -5,6 +5,7 @@
 
 #include <optional>
 #include <unordered_map>
+#include "node_exit_code.h"
 #include "node_messaging.h"
 #include "uv.h"
 
@@ -29,6 +30,7 @@ class Worker : public AsyncWrap {
   Worker(Environment* env,
          v8::Local<v8::Object> wrap,
          const std::string& url,
+         const std::string& name,
          std::shared_ptr<PerIsolateOptions> per_isolate_opts,
          std::vector<std::string>&& exec_argv,
          std::shared_ptr<KVStore> env_vars,
@@ -41,7 +43,7 @@ class Worker : public AsyncWrap {
   // Forcibly exit the thread with a specified exit code. This may be called
   // from any thread. `error_code` and `error_message` can be used to create
   // a custom `'error'` event before emitting `'exit'`.
-  void Exit(int code,
+  void Exit(ExitCode code,
             const char* error_code = nullptr,
             const char* error_message = nullptr);
 
@@ -95,9 +97,11 @@ class Worker : public AsyncWrap {
 
   const char* custom_error_ = nullptr;
   std::string custom_error_str_;
-  int exit_code_ = 0;
+  ExitCode exit_code_ = ExitCode::kNoFailure;
   ThreadId thread_id_;
   uintptr_t stack_base_ = 0;
+  // Optional name used for debugging in inspector and trace events.
+  std::string name_;
 
   // Custom resource constraints:
   double resource_limits_[kTotalResourceLimitCount];
@@ -110,6 +114,7 @@ class Worker : public AsyncWrap {
 
   std::unique_ptr<MessagePortData> child_port_data_;
   std::shared_ptr<KVStore> env_vars_;
+  EmbedderPreloadCallback embedder_preload_;
 
   // A raw flag that is used by creator and worker threads to
   // sync up on pre-mature termination of worker  - while in the

package/src/headers/22/permission/child_process_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_CHILD_PROCESS_PERMISSION_H_
+#define SRC_PERMISSION_CHILD_PROCESS_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <vector>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class ChildProcessPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param = "") const override;
+
+ private:
+  bool deny_all_;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_CHILD_PROCESS_PERMISSION_H_