@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/node_webstorage.h

@@ -0,0 +1,60 @@
+#ifndef SRC_NODE_WEBSTORAGE_H_
+#define SRC_NODE_WEBSTORAGE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "node_mem.h"
+#include "sqlite3.h"
+#include "util.h"
+
+namespace node {
+namespace webstorage {
+
+struct conn_deleter {
+  void operator()(sqlite3* conn) const noexcept {
+    CHECK_EQ(sqlite3_close(conn), SQLITE_OK);
+  }
+};
+using conn_unique_ptr = std::unique_ptr<sqlite3, conn_deleter>;
+
+struct stmt_deleter {
+  void operator()(sqlite3_stmt* stmt) const noexcept { sqlite3_finalize(stmt); }
+};
+using stmt_unique_ptr = std::unique_ptr<sqlite3_stmt, stmt_deleter>;
+
+static constexpr std::string_view kInMemoryPath = ":memory:";
+
+class Storage : public BaseObject {
+ public:
+  Storage(Environment* env,
+          v8::Local<v8::Object> object,
+          std::string_view location);
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  v8::Maybe<void> Clear();
+  v8::MaybeLocal<v8::Array> Enumerate();
+  v8::MaybeLocal<v8::Value> Length();
+  v8::MaybeLocal<v8::Value> Load(v8::Local<v8::Name> key);
+  v8::MaybeLocal<v8::Value> LoadKey(const int index);
+  v8::Maybe<void> Remove(v8::Local<v8::Name> key);
+  v8::Maybe<void> Store(v8::Local<v8::Name> key, v8::Local<v8::Value> value);
+
+  SET_MEMORY_INFO_NAME(Storage)
+  SET_SELF_SIZE(Storage)
+
+ private:
+  v8::Maybe<void> Open();
+
+  ~Storage() override;
+  std::string location_;
+  conn_unique_ptr db_;
+  v8::Global<v8::Map> symbols_;
+};
+
+}  // namespace webstorage
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_WEBSTORAGE_H_

package/dist/node/include/node_worker.h

@@ -0,0 +1,158 @@
+#ifndef SRC_NODE_WORKER_H_
+#define SRC_NODE_WORKER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <optional>
+#include <unordered_map>
+#include "node_exit_code.h"
+#include "node_messaging.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);
+
+ 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/dist/node/include/path.h

@@ -0,0 +1,33 @@
+#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);
+
+#ifdef _WIN32
+constexpr bool IsWindowsDeviceRoot(const char c) 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/dist/node/include/permission/addon_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_ADDON_PERMISSION_H_
+#define SRC_PERMISSION_ADDON_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <string>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class AddonPermission 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_ADDON_PERMISSION_H_

package/dist/node/include/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_

package/dist/node/include/permission/fs_permission.h

@@ -0,0 +1,167 @@
+#ifndef SRC_PERMISSION_FS_PERMISSION_H_
+#define SRC_PERMISSION_FS_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "v8.h"
+
+#include <unordered_map>
+#include "permission/permission_base.h"
+#include "util.h"
+
+namespace node {
+
+namespace permission {
+
+class FSPermission 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;
+
+  struct RadixTree {
+    struct Node {
+      std::string prefix;
+      std::unordered_map<char, Node*> children;
+      Node* wildcard_child;
+      bool is_leaf;
+
+      explicit Node(const std::string& pre)
+          : prefix(pre), wildcard_child(nullptr), is_leaf(false) {}
+
+      Node() : wildcard_child(nullptr), is_leaf(false) {}
+
+      Node* CreateChild(const std::string& path_prefix) {
+        if (path_prefix.empty() && !is_leaf) {
+          is_leaf = true;
+          return this;
+        }
+
+        CHECK(!path_prefix.empty());
+        char label = path_prefix[0];
+
+        Node* child = children[label];
+        if (child == nullptr) {
+          children[label] = new Node(path_prefix);
+          return children[label];
+        }
+
+        // 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[child_prefix[0]] = child;
+            children[parent_prefix[0]] = split_child;
+
+            return split_child->CreateChild(path_prefix.substr(i));
+          }
+        }
+        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(const std::string& path, size_t idx) const {
+        if (idx >= path.length()) {
+          return nullptr;
+        }
+
+        // wildcard node takes precedence
+        if (children.size() > 1) {
+          auto it = children.find('*');
+          if (it != children.end()) {
+            return it->second;
+          }
+        }
+
+        auto it = children.find(path[idx]);
+        if (it == children.end()) {
+          return nullptr;
+        }
+        auto child = it->second;
+        // 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() &&
+              child->prefix[i] == node::kPathSeparator) {
+            continue;
+          }
+
+          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);
+    bool Lookup(const std::string_view& s) const { return Lookup(s, false); }
+    bool Lookup(const std::string_view& s, bool when_empty_return) const;
+
+   private:
+    Node* root_node_;
+  };
+
+ private:
+  void GrantAccess(PermissionScope scope, const std::string& param);
+  // fs granted on startup
+  RadixTree granted_in_fs_;
+  RadixTree granted_out_fs_;
+
+  bool deny_all_in_ = true;
+  bool deny_all_out_ = true;
+
+  bool allow_all_in_ = false;
+  bool allow_all_out_ = false;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_FS_PERMISSION_H_

package/dist/node/include/permission/inspector_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_INSPECTOR_PERMISSION_H_
+#define SRC_PERMISSION_INSPECTOR_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <string>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class InspectorPermission 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_INSPECTOR_PERMISSION_H_

package/dist/node/include/permission/permission.h

@@ -0,0 +1,138 @@
+#ifndef SRC_PERMISSION_PERMISSION_H_
+#define SRC_PERMISSION_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "debug_utils.h"
+#include "node_options.h"
+#include "permission/addon_permission.h"
+#include "permission/child_process_permission.h"
+#include "permission/fs_permission.h"
+#include "permission/inspector_permission.h"
+#include "permission/permission_base.h"
+#include "permission/wasi_permission.h"
+#include "permission/worker_permission.h"
+#include "v8.h"
+
+#include <string_view>
+#include <unordered_map>
+
+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]] {                                                         \
+      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]] {                                                         \
+      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]] {                                                         \
+      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,
+                               const PermissionScope permission,
+                               const std::string_view& res = "") const {
+    if (!enabled_) [[likely]] {
+      return true;
+    }
+    return is_scope_granted(env, permission, res);
+  }
+
+  FORCE_INLINE bool enabled() const { return enabled_; }
+
+  static PermissionScope StringToPermission(const std::string& perm);
+  static const char* PermissionToString(PermissionScope perm);
+  static void ThrowAccessDenied(Environment* env,
+                                PermissionScope perm,
+                                const std::string_view& res);
+  static void AsyncThrowAccessDenied(Environment* env,
+                                     fs::FSReqBase* req_wrap,
+                                     PermissionScope perm,
+                                     const std::string_view& res);
+
+  // CLI Call
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope);
+  void EnablePermissions();
+
+ private:
+  COLD_NOINLINE bool is_scope_granted(Environment* env,
+                                      const PermissionScope permission,
+                                      const std::string_view& res = "") const {
+    auto perm_node = nodes_.find(permission);
+    if (perm_node != nodes_.end()) {
+      return perm_node->second->is_granted(env, permission, res);
+    }
+    return false;
+  }
+
+  std::unordered_map<PermissionScope, std::shared_ptr<PermissionBase>> nodes_;
+  bool enabled_;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_PERMISSION_H_