@encharm/cws 4.5.3 → 4.8.0

package/src/headers/26/node_worker.h

@@ -0,0 +1,162 @@
+#ifndef SRC_NODE_WORKER_H_
+#define SRC_NODE_WORKER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <optional>
+#include <unordered_map>
+#include "json_utils.h"
+#include "node_exit_code.h"
+#include "node_messaging.h"
+#include "util.h"
+#include "uv.h"
+
+namespace node {
+
+struct SnapshotData;
+namespace worker {
+
+class WorkerThreadData;
+
+enum ResourceLimits {
+  kMaxYoungGenerationSizeMb,
+  kMaxOldGenerationSizeMb,
+  kCodeRangeSizeMb,
+  kStackSizeMb,
+  kTotalResourceLimitCount
+};
+
+// A worker thread, as represented in its parent thread.
+class Worker : public AsyncWrap {
+ public:
+  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,
+         const SnapshotData* snapshot_data,
+         const bool is_internal);
+  ~Worker() override;
+
+  // Run the worker. This is only called from the worker thread.
+  void Run();
+
+  // 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(ExitCode code,
+            const char* error_code = nullptr,
+            const char* error_message = nullptr);
+
+  // Wait for the worker thread to stop (in a blocking manner).
+  void JoinThread();
+
+  template <typename Fn>
+  inline bool RequestInterrupt(Fn&& cb);
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(Worker)
+  SET_SELF_SIZE(Worker)
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
+
+  bool is_stopped() const;
+  const SnapshotData* snapshot_data() const { return snapshot_data_; }
+  bool is_internal() const { return is_internal_; }
+  std::string_view name() const { return name_; }
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StartThread(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StopThread(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetResourceLimits(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  v8::Local<v8::Float64Array> GetResourceLimits(v8::Isolate* isolate) const;
+  static void TakeHeapSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LoopIdleTime(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LoopStartTime(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetHeapStatistics(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CpuUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StartCpuProfile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StopCpuProfile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StartHeapProfile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StopHeapProfile(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  bool CreateEnvMessagePort(Environment* env);
+  static size_t NearHeapLimit(void* data, size_t current_heap_limit,
+                              size_t initial_heap_limit);
+
+  std::shared_ptr<PerIsolateOptions> per_isolate_opts_;
+  std::vector<std::string> exec_argv_;
+  std::vector<std::string> argv_;
+
+  MultiIsolatePlatform* platform_;
+  v8::Isolate* isolate_ = nullptr;
+  std::optional<uv_thread_t> tid_;  // Set while the thread is running
+
+  std::unique_ptr<InspectorParentHandle> inspector_parent_handle_;
+
+  // This mutex protects access to all variables listed below it.
+  mutable Mutex mutex_;
+
+  const char* custom_error_ = nullptr;
+  std::string custom_error_str_;
+  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];
+  void UpdateResourceConstraints(v8::ResourceConstraints* constraints);
+
+  // Full size of the thread's stack.
+  size_t stack_size_ = 4 * 1024 * 1024;
+  // Stack buffer size that is not available to the JS engine.
+  static constexpr size_t kStackBufferSize = 192 * 1024;
+
+  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
+  // warmup phase.  Once the worker is fully warmed up, use the
+  // async handle of the worker's Environment for the same purpose.
+  bool stopped_ = true;
+
+  bool has_ref_ = true;
+  uint64_t environment_flags_ = EnvironmentFlags::kNoFlags;
+
+  // The real Environment of the worker object. It has a lesser
+  // lifespan than the worker object itself - comes to life
+  // when the worker thread creates a new Environment, and gets
+  // destroyed alongwith the worker thread.
+  Environment* env_ = nullptr;
+
+  const SnapshotData* snapshot_data_ = nullptr;
+  const bool is_internal_;
+  friend class WorkerThreadData;
+};
+
+template <typename Fn>
+bool Worker::RequestInterrupt(Fn&& cb) {
+  Mutex::ScopedLock lock(mutex_);
+  if (env_ == nullptr) return false;
+  env_->RequestInterrupt(std::move(cb));
+  return true;
+}
+
+}  // namespace worker
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+
+#endif  // SRC_NODE_WORKER_H_

package/src/headers/26/path.h

@@ -0,0 +1,36 @@
+#ifndef SRC_PATH_H_
+#define SRC_PATH_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <string>
+#include <vector>
+#include "node_options-inl.h"
+#include "util-inl.h"
+
+namespace node {
+
+constexpr bool IsPathSeparator(const char c) noexcept;
+
+std::string NormalizeString(const std::string_view path,
+                            bool allowAboveRoot,
+                            const std::string_view separator);
+
+std::string PathResolve(Environment* env,
+                        const std::vector<std::string_view>& paths);
+std::string NormalizeFileURLOrPath(Environment* env, std::string_view path);
+bool IsAbsoluteFilePath(std::string_view path);
+
+#ifdef _WIN32
+constexpr bool IsWindowsDeviceRoot(const char c) noexcept;
+constexpr bool IsWindowsDriveLetter(const std::string_view path) noexcept;
+#endif  // _WIN32
+
+void ToNamespacedPath(Environment* env, BufferValue* path);
+void FromNamespacedPath(std::string* path);
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_PATH_H_

package/src/headers/26/permission/boolean_permission.h

@@ -0,0 +1,50 @@
+#ifndef SRC_PERMISSION_BOOLEAN_PERMISSION_H_
+#define SRC_PERMISSION_BOOLEAN_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "permission/permission_base.h"
+
+namespace node::permission {
+
+// A simple boolean permission that either denies or allows access.
+// Used for permission scopes that don't need per-resource granularity.
+template <bool deny_only>
+class BooleanPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             std::span<const std::string> allow,
+             PermissionScope scope) override {
+    flag_ = true;
+  }
+
+  void Drop(Environment* env,
+            PermissionScope scope,
+            std::string_view param) override {
+    flag_ = deny_only;
+  }
+
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  std::string_view param) const override {
+    if constexpr (deny_only) {
+      return !flag_;
+    } else {
+      return flag_;
+    }
+  }
+
+ private:
+  bool flag_ = false;
+};
+
+// Once denied, the permission cannot be re-granted.
+using DenyOnlyPermission = BooleanPermission<true>;
+
+// Apply grants access, Drop revokes.
+using AllowRevokePermission = BooleanPermission<false>;
+
+}  // namespace node::permission
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_BOOLEAN_PERMISSION_H_

package/src/headers/26/permission/fs_permission.h

@@ -0,0 +1,192 @@
+#ifndef SRC_PERMISSION_FS_PERMISSION_H_
+#define SRC_PERMISSION_FS_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <vector>
+#include "permission/permission_base.h"
+#include "util.h"
+
+namespace node::permission {
+
+class FSPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             std::span<const std::string> allow,
+             PermissionScope scope) override;
+  void Drop(Environment* env,
+            PermissionScope scope,
+            std::string_view param) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  std::string_view param) const override;
+
+  struct RadixTree {
+    struct Node {
+      std::string prefix;
+      std::vector<std::pair<char, Node*>> children;
+      Node* wildcard_child = nullptr;
+      bool is_leaf = false;
+
+      explicit Node(std::string_view pre) : prefix(pre) {}
+
+      Node() = default;
+
+      Node* FindChild(char label) const {
+        for (const auto& [c, node] : children) {
+          if (c == label) return node;
+        }
+        return nullptr;
+      }
+
+      void SetChild(char label, Node* node) {
+        for (auto& [c, n] : children) {
+          if (c == label) {
+            n = node;
+            return;
+          }
+        }
+        children.emplace_back(label, node);
+      }
+
+      Node* CreateChild(std::string_view path_prefix) {
+        if (path_prefix.empty() && !is_leaf) {
+          is_leaf = true;
+          return this;
+        }
+
+        CHECK(!path_prefix.empty());
+        char label = path_prefix[0];
+
+        Node* child = FindChild(label);
+        if (child == nullptr) {
+          child = new Node(path_prefix);
+          children.emplace_back(label, child);
+          return child;
+        }
+        bool child_was_end_node = child->IsEndNode();
+
+        // swap prefix
+        size_t i = 0;
+        size_t prefix_len = path_prefix.length();
+        for (; i < child->prefix.length(); ++i) {
+          if (i >= prefix_len || path_prefix[i] != child->prefix[i]) {
+            std::string parent_prefix(child->prefix.substr(0, i));
+            std::string child_prefix(child->prefix.substr(i));
+
+            child->prefix = child_prefix;
+            Node* split_child = new Node(parent_prefix);
+            split_child->children.emplace_back(child_prefix[0], child);
+            SetChild(parent_prefix[0], split_child);
+
+            return split_child->CreateChild(path_prefix.substr(i));
+          }
+        }
+        if (child_was_end_node) {
+          child->is_leaf = true;
+        }
+        return child->CreateChild(path_prefix.substr(i));
+      }
+
+      Node* CreateWildcardChild() {
+        if (wildcard_child != nullptr) {
+          return wildcard_child;
+        }
+        wildcard_child = new Node();
+        return wildcard_child;
+      }
+
+      Node* NextNode(std::string_view path, size_t idx) const {
+        if (idx >= path.length()) {
+          return nullptr;
+        }
+
+        // wildcard node takes precedence
+        if (children.size() > 1) {
+          Node* wc = FindChild('*');
+          if (wc != nullptr) {
+            return wc;
+          }
+        }
+
+        Node* child = FindChild(path[idx]);
+        if (child == nullptr) {
+          return nullptr;
+        }
+        // match prefix
+        size_t prefix_len = child->prefix.length();
+        for (size_t i = 0; i < path.length(); ++i) {
+          if (i >= prefix_len || child->prefix[i] == '*') {
+            return child;
+          }
+
+          // Handle optional trailing
+          // path = /home/subdirectory
+          // child = subdirectory/*
+          if (idx >= path.length()) {
+            if (child->prefix[i] == node::kPathSeparator) {
+              continue;
+            }
+            // Path is exhausted but prefix expects more characters
+            return nullptr;
+          }
+
+          if (path[idx++] != child->prefix[i]) {
+            return nullptr;
+          }
+        }
+        return child;
+      }
+
+      // A node can be a *end* node and have children
+      // E.g: */slower*, */slown* are inserted:
+      // /slow
+      // ---> er
+      // ---> n
+      // If */slow* is inserted right after, it will create an
+      // empty node
+      // /slow
+      // ---> '\000' ASCII (0) || \0
+      // ---> er
+      // ---> n
+      bool IsEndNode() const {
+        if (children.empty()) {
+          return true;
+        }
+        return is_leaf;
+      }
+    };
+
+    RadixTree();
+    ~RadixTree();
+    void Insert(const std::string& s);
+    void Clear();
+    bool Lookup(std::string_view s) const { return Lookup(s, false); }
+    bool Lookup(std::string_view s, bool when_empty_return) const;
+
+   private:
+    Node* root_node_;
+  };
+
+ private:
+  void GrantAccess(PermissionScope scope, const std::string& param);
+  void RevokeAccess(PermissionScope scope, const std::string& param);
+  void RebuildTree(PermissionScope scope);
+  // fs granted on startup
+  RadixTree granted_in_fs_;
+  RadixTree granted_out_fs_;
+
+  std::vector<std::string> granted_paths_in_;
+  std::vector<std::string> granted_paths_out_;
+
+  bool deny_all_in_ = true;
+  bool deny_all_out_ = true;
+
+  bool allow_all_in_ = false;
+  bool allow_all_out_ = false;
+};
+
+}  // namespace node::permission
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_FS_PERMISSION_H_

package/src/headers/26/permission/permission.h

@@ -0,0 +1,155 @@
+#ifndef SRC_PERMISSION_PERMISSION_H_
+#define SRC_PERMISSION_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "debug_utils.h"
+#include "node_diagnostics_channel.h"
+#include "permission/permission_base.h"
+
+#include <array>
+#include <string_view>
+
+namespace node {
+
+class Environment;
+
+namespace fs {
+class FSReqBase;
+}
+
+namespace permission {
+
+#define THROW_IF_INSUFFICIENT_PERMISSIONS(env, perm, resource, ...)            \
+  do {                                                                         \
+    node::Environment* env__ = (env);                                          \
+    const node::permission::PermissionScope perm__ = (perm);                   \
+    const auto resource__ = (resource);                                        \
+    if (!env__->permission()->is_granted(env__, perm__, resource__))           \
+        [[unlikely]] {                                                         \
+      if (!env__->permission()->warning_only()) {                              \
+        node::permission::Permission::ThrowAccessDenied(                       \
+            env__, perm__, resource__);                                        \
+        return __VA_ARGS__;                                                    \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+#define ASYNC_THROW_IF_INSUFFICIENT_PERMISSIONS(                               \
+    env, wrap, perm, resource, ...)                                            \
+  do {                                                                         \
+    node::Environment* env__ = (env);                                          \
+    const node::permission::PermissionScope perm__ = (perm);                   \
+    const auto resource__ = (resource);                                        \
+    if (!env__->permission()->is_granted(env__, perm__, resource__))           \
+        [[unlikely]] {                                                         \
+      if (!env__->permission()->warning_only()) {                              \
+        node::permission::Permission::AsyncThrowAccessDenied(                  \
+            env__, (wrap), perm__, resource__);                                \
+        return __VA_ARGS__;                                                    \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+#define ERR_ACCESS_DENIED_IF_INSUFFICIENT_PERMISSIONS(                         \
+    env, perm, resource, args, ...)                                            \
+  do {                                                                         \
+    node::Environment* env__ = (env);                                          \
+    const node::permission::PermissionScope perm__ = (perm);                   \
+    const auto resource__ = (resource);                                        \
+    if (!env__->permission()->is_granted(env__, perm__, resource__))           \
+        [[unlikely]] {                                                         \
+      if (!env__->permission()->warning_only()) {                              \
+        Local<Value> err_access;                                               \
+        if (node::permission::CreateAccessDeniedError(                         \
+                env__, perm__, resource__)                                     \
+                .ToLocal(&err_access)) {                                       \
+          args.GetReturnValue().Set(err_access);                               \
+        } else {                                                               \
+          args.GetReturnValue().Set(UV_EACCES);                                \
+        }                                                                      \
+        return __VA_ARGS__;                                                    \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+#define SET_INSUFFICIENT_PERMISSION_ERROR_CALLBACK(scope)                      \
+  void InsufficientPermissionError(std::string_view resource) {                \
+    v8::HandleScope handle_scope(env()->isolate());                            \
+    v8::Context::Scope context_scope(env()->context());                        \
+    v8::Local<v8::Value> arg;                                                  \
+    if (!permission::CreateAccessDeniedError(env(), (scope), resource)         \
+             .ToLocal(&arg)) {                                                 \
+    }                                                                          \
+    MakeCallback(env()->oncomplete_string(), 1, &arg);                         \
+  }
+
+class Permission {
+ public:
+  Permission();
+
+  FORCE_INLINE bool is_granted(Environment* env,
+                               PermissionScope permission,
+                               std::string_view res = "") const {
+    if (!enabled_) [[likely]] {
+      return true;
+    }
+    return is_scope_granted(env, permission, res);
+  }
+
+  FORCE_INLINE bool enabled() const { return enabled_; }
+
+  FORCE_INLINE bool warning_only() const { return warning_only_; }
+
+  static PermissionScope StringToPermission(std::string_view perm);
+  static v8::Local<v8::String> PermissionToString(Environment* env,
+                                                  PermissionScope perm);
+  static void ThrowAccessDenied(Environment* env,
+                                PermissionScope perm,
+                                std::string_view res);
+  static void AsyncThrowAccessDenied(Environment* env,
+                                     fs::FSReqBase* req_wrap,
+                                     PermissionScope perm,
+                                     std::string_view res);
+
+  // CLI Call
+  void Apply(Environment* env,
+             std::span<const std::string> allow,
+             PermissionScope scope);
+  // Runtime Call
+  void Drop(Environment* env, PermissionScope scope, std::string_view param);
+  void EnablePermissions();
+  void EnableWarningOnly();
+
+ private:
+  COLD_NOINLINE bool is_scope_granted(Environment* env,
+                                      PermissionScope permission,
+                                      std::string_view res = "") const;
+
+  BaseObjectPtr<diagnostics_channel::Channel> GetOrCreateChannel(
+      Environment* env, PermissionScope scope) const;
+
+  static constexpr size_t kPermissionCount =
+      static_cast<size_t>(PermissionScope::kPermissionsCount);
+
+  std::array<std::shared_ptr<PermissionBase>, kPermissionCount> nodes_;
+  bool enabled_;
+  bool warning_only_;
+  mutable bool publishing_ = false;
+  // Weak refs: BindingData (via BaseObjectPtr) is the sole owner of Channels.
+  // Using weak refs here avoids keeping Channels alive past Realm teardown.
+  mutable std::array<BaseObjectWeakPtr<diagnostics_channel::Channel>,
+                     kPermissionCount>
+      channels_;
+};
+
+v8::MaybeLocal<v8::Value> CreateAccessDeniedError(Environment* env,
+                                                  PermissionScope perm,
+                                                  std::string_view res);
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_PERMISSION_H_

package/src/headers/26/permission/permission_base.h

@@ -0,0 +1,79 @@
+#ifndef SRC_PERMISSION_PERMISSION_BASE_H_
+#define SRC_PERMISSION_PERMISSION_BASE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <span>
+#include <string>
+#include <string_view>
+
+namespace node {
+
+class Environment;
+
+namespace permission {
+
+#define FILESYSTEM_PERMISSIONS(V)                                              \
+  V(FileSystem, "fs", PermissionsRoot, "")                                     \
+  V(FileSystemRead, "fs.read", FileSystem, "--allow-fs-read")                  \
+  V(FileSystemWrite, "fs.write", FileSystem, "--allow-fs-write")
+
+#define CHILD_PROCESS_PERMISSIONS(V)                                           \
+  V(ChildProcess, "child", PermissionsRoot, "--allow-child-process")
+
+#define WASI_PERMISSIONS(V) V(WASI, "wasi", PermissionsRoot, "--allow-wasi")
+
+#define WORKER_THREADS_PERMISSIONS(V)                                          \
+  V(WorkerThreads, "worker", PermissionsRoot, "--allow-worker")
+
+#define INSPECTOR_PERMISSIONS(V)                                               \
+  V(Inspector, "inspector", PermissionsRoot, "--allow-inspector")
+
+#define NET_PERMISSIONS(V) V(Net, "net", PermissionsRoot, "--allow-net")
+
+#define ADDON_PERMISSIONS(V)                                                   \
+  V(Addon, "addon", PermissionsRoot, "--allow-addons")
+
+#define FFI_PERMISSIONS(V) V(FFI, "ffi", PermissionsRoot, "--allow-ffi")
+
+#define OPENSSL_STORE_PERMISSIONS(V)                                           \
+  V(OpenSSLStore, "openssl.store", PermissionsRoot, "--allow-openssl-store")
+
+#define PERMISSIONS(V)                                                         \
+  FILESYSTEM_PERMISSIONS(V)                                                    \
+  CHILD_PROCESS_PERMISSIONS(V)                                                 \
+  WASI_PERMISSIONS(V)                                                          \
+  WORKER_THREADS_PERMISSIONS(V)                                                \
+  INSPECTOR_PERMISSIONS(V)                                                     \
+  NET_PERMISSIONS(V)                                                           \
+  ADDON_PERMISSIONS(V)                                                         \
+  FFI_PERMISSIONS(V)                                                           \
+  OPENSSL_STORE_PERMISSIONS(V)
+
+#define V(name, _, __, ___) k##name,
+enum class PermissionScope {
+  kPermissionsRoot = -1,
+  PERMISSIONS(V) kPermissionsCount
+};
+#undef V
+
+class PermissionBase {
+ public:
+  virtual ~PermissionBase() = default;
+  virtual void Apply(Environment* env,
+                     std::span<const std::string> allow,
+                     PermissionScope scope) = 0;
+  virtual void Drop(Environment* env,
+                    PermissionScope scope,
+                    std::string_view param) = 0;
+  virtual bool is_granted(Environment* env,
+                          PermissionScope perm,
+                          std::string_view param) const = 0;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_PERMISSION_BASE_H_