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

package/dist/node/include/node_sea.h

@@ -0,0 +1,74 @@
+#ifndef SRC_NODE_SEA_H_
+#define SRC_NODE_SEA_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include "node_exit_code.h"
+
+namespace node {
+class Environment;
+namespace sea {
+// A special number that will appear at the beginning of the single executable
+// preparation blobs ready to be injected into the binary. We use this to check
+// that the data given to us are intended for building single executable
+// applications.
+const uint32_t kMagic = 0x143da20;
+
+enum class SeaFlags : uint32_t {
+  kDefault = 0,
+  kDisableExperimentalSeaWarning = 1 << 0,
+  kUseSnapshot = 1 << 1,
+  kUseCodeCache = 1 << 2,
+  kIncludeAssets = 1 << 3,
+  kIncludeExecArgv = 1 << 4,
+};
+
+enum class SeaExecArgvExtension : uint8_t {
+  kNone = 0,
+  kEnv = 1,
+  kCli = 2,
+};
+
+struct SeaResource {
+  SeaFlags flags = SeaFlags::kDefault;
+  SeaExecArgvExtension exec_argv_extension = SeaExecArgvExtension::kEnv;
+  std::string_view code_path;
+  std::string_view main_code_or_snapshot;
+  std::optional<std::string_view> code_cache;
+  std::unordered_map<std::string_view, std::string_view> assets;
+  std::vector<std::string_view> exec_argv;
+
+  bool use_snapshot() const;
+  bool use_code_cache() const;
+
+  static constexpr size_t kHeaderSize =
+      sizeof(kMagic) + sizeof(SeaFlags) + sizeof(SeaExecArgvExtension);
+};
+
+bool IsSingleExecutable();
+SeaResource FindSingleExecutableResource();
+std::tuple<int, char**> FixupArgsForSEA(int argc, char** argv);
+node::ExitCode BuildSingleExecutableBlob(
+    const std::string& config_path,
+    const std::vector<std::string>& args,
+    const std::vector<std::string>& exec_args);
+
+// Try loading the Environment as a single-executable application.
+// Returns true if it is loaded as a single-executable application.
+// Otherwise returns false and the caller is expected to call LoadEnvironment()
+// differently.
+bool MaybeLoadSingleExecutableApplication(Environment* env);
+}  // namespace sea
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SEA_H_

package/dist/node/include/node_shadow_realm.h

@@ -0,0 +1,46 @@
+#ifndef SRC_NODE_SHADOW_REALM_H_
+#define SRC_NODE_SHADOW_REALM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_realm.h"
+#include "v8.h"
+
+namespace node {
+namespace shadow_realm {
+
+class ShadowRealm final : public Realm {
+ public:
+  static ShadowRealm* New(Environment* env);
+
+  SET_MEMORY_INFO_NAME(ShadowRealm)
+  SET_SELF_SIZE(ShadowRealm)
+
+  v8::Local<v8::Context> context() const override;
+
+#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;
+
+ private:
+  static void WeakCallback(const v8::WeakCallbackInfo<ShadowRealm>& data);
+  static void DeleteMe(void* data);
+
+  explicit ShadowRealm(Environment* env);
+  ~ShadowRealm();
+};
+
+v8::MaybeLocal<v8::Context> HostCreateShadowRealmContextCallback(
+    v8::Local<v8::Context> initiator_context);
+
+}  // namespace shadow_realm
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SHADOW_REALM_H_

package/dist/node/include/node_snapshot_builder.h

@@ -0,0 +1,57 @@
+
+#ifndef SRC_NODE_SNAPSHOT_BUILDER_H_
+#define SRC_NODE_SNAPSHOT_BUILDER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+#include "node_exit_code.h"
+#include "node_mutex.h"
+#include "v8.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+struct SnapshotData;
+
+std::optional<SnapshotConfig> ReadSnapshotConfig(const char* path);
+
+class NODE_EXTERN_PRIVATE SnapshotBuilder {
+ public:
+  static ExitCode GenerateAsSource(const char* out_path,
+                                   const std::vector<std::string>& args,
+                                   const std::vector<std::string>& exec_args,
+                                   const SnapshotConfig& config,
+                                   bool use_array_literals = false);
+
+  // Generate the snapshot into out. builder_script_content should match
+  // config.builder_script_path. This is passed separately
+  // in case the script is already read for other purposes.
+  static ExitCode Generate(
+      SnapshotData* out,
+      const std::vector<std::string>& args,
+      const std::vector<std::string>& exec_args,
+      std::optional<std::string_view> builder_script_content,
+      const SnapshotConfig& config);
+
+  // If nullptr is returned, the binary is not built with embedded
+  // snapshot.
+  static const SnapshotData* GetEmbeddedSnapshotData();
+  static void InitializeIsolateParams(const SnapshotData* data,
+                                      v8::Isolate::CreateParams* params);
+
+  static const std::vector<intptr_t>& CollectExternalReferences();
+
+  static ExitCode CreateSnapshot(SnapshotData* out,
+                                 CommonEnvironmentSetup* setup);
+
+ private:
+  static std::unique_ptr<ExternalReferenceRegistry> registry_;
+};
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SNAPSHOT_BUILDER_H_

package/dist/node/include/node_snapshotable.h

@@ -0,0 +1,174 @@
+
+#ifndef SRC_NODE_SNAPSHOTABLE_H_
+#define SRC_NODE_SNAPSHOTABLE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "util.h"
+
+namespace node {
+
+class Environment;
+struct RealmSerializeInfo;
+struct SnapshotData;
+class ExternalReferenceRegistry;
+
+using SnapshotIndex = size_t;
+
+struct PropInfo {
+  std::string name;     // name for debugging
+  uint32_t id;          // In the list - in case there are any empty entries
+  SnapshotIndex index;  // In the snapshot
+};
+
+typedef size_t SnapshotIndex;
+
+bool WithoutCodeCache(const SnapshotFlags& flags);
+bool WithoutCodeCache(const SnapshotConfig& config);
+
+// When serializing an embedder object, we'll serialize the native states
+// into a chunk that can be mapped into a subclass of InternalFieldInfoBase,
+// and pass it into the V8 callback as the payload of StartupData.
+// The memory chunk looks like this:
+//
+// [   type   ] - EmbedderObjectType (a uint8_t)
+// [  length  ] - a size_t
+// [    ...   ] - custom bytes of size |length - header size|
+struct InternalFieldInfoBase {
+ public:
+  EmbedderObjectType type;
+  size_t length;
+
+  template <typename T>
+  static T* New(EmbedderObjectType type) {
+    static_assert(std::is_base_of_v<InternalFieldInfoBase, T> ||
+                      std::is_same_v<InternalFieldInfoBase, T>,
+                  "Can only accept InternalFieldInfoBase subclasses");
+    void* buf = ::operator new[](sizeof(T));
+    memset(buf, 0, sizeof(T));  // Make the padding reproducible.
+    T* result = new (buf) T;
+    result->type = type;
+    result->length = sizeof(T);
+    return result;
+  }
+
+  template <typename T>
+  T* Copy() const {
+    static_assert(std::is_base_of_v<InternalFieldInfoBase, T> ||
+                      std::is_same_v<InternalFieldInfoBase, T>,
+                  "Can only accept InternalFieldInfoBase subclasses");
+    static_assert(std::is_trivially_copyable_v<T>,
+                  "Can only memcpy trivially copyable class");
+    void* buf = ::operator new[](sizeof(T));
+    T* result = new (buf) T;
+    memcpy(result, this, sizeof(T));
+    return result;
+  }
+
+  void Delete() { ::operator delete[](this); }
+
+  InternalFieldInfoBase() = default;
+};
+
+struct EmbedderTypeInfo {
+  enum class MemoryMode : uint8_t { kBaseObject, kCppGC };
+  EmbedderTypeInfo(EmbedderObjectType t, MemoryMode m) : type(t), mode(m) {}
+  EmbedderTypeInfo() = default;
+  EmbedderObjectType type;
+  MemoryMode mode;
+};
+
+// An interface for snapshotable native objects to inherit from.
+// Use the SERIALIZABLE_OBJECT_METHODS() macro in the class to define
+// the following methods to implement:
+//
+// - PrepareForSerialization(): This would be run prior to context
+//   serialization. Use this method to e.g. release references that
+//   can be re-initialized, or perform property store operations
+//   that needs a V8 context.
+// - Serialize(): This would be called during context serialization,
+//   once for each embedder field of the object.
+//   Allocate and construct an InternalFieldInfoBase object that contains
+//   data that can be used to deserialize native states.
+// - Deserialize(): This would be called after the context is
+//   deserialized and the object graph is complete, once for each
+//   embedder field of the object. Use this to restore native states
+//   in the object.
+class SnapshotableObject : public BaseObject {
+ public:
+  SnapshotableObject(Realm* realm,
+                     v8::Local<v8::Object> wrap,
+                     EmbedderObjectType type);
+  std::string GetTypeName() const;
+
+  // If returns false, the object will not be serialized.
+  virtual bool PrepareForSerialization(v8::Local<v8::Context> context,
+                                       v8::SnapshotCreator* creator) = 0;
+  virtual InternalFieldInfoBase* Serialize(int index) = 0;
+  bool is_snapshotable() const override { return true; }
+  // We'll make sure that the type is set in the constructor
+  EmbedderObjectType type() { return type_; }
+
+ private:
+  EmbedderObjectType type_;
+};
+
+#define SERIALIZABLE_OBJECT_METHODS()                                          \
+  bool PrepareForSerialization(v8::Local<v8::Context> context,                 \
+                               v8::SnapshotCreator* creator) override;         \
+  InternalFieldInfoBase* Serialize(int index) override;                        \
+  static void Deserialize(v8::Local<v8::Context> context,                      \
+                          v8::Local<v8::Object> holder,                        \
+                          int index,                                           \
+                          InternalFieldInfoBase* info);
+
+v8::StartupData SerializeNodeContextInternalFields(v8::Local<v8::Object> holder,
+                                                   int index,
+                                                   void* env);
+v8::StartupData SerializeNodeContextData(v8::Local<v8::Context> holder,
+                                         int index,
+                                         void* env);
+void DeserializeNodeInternalFields(v8::Local<v8::Object> holder,
+                                   int index,
+                                   v8::StartupData payload,
+                                   void* env);
+void DeserializeNodeContextData(v8::Local<v8::Context> holder,
+                                int index,
+                                v8::StartupData payload,
+                                void* env);
+void SerializeSnapshotableObjects(Realm* realm,
+                                  v8::SnapshotCreator* creator,
+                                  RealmSerializeInfo* info);
+
+#define DCHECK_IS_SNAPSHOT_SLOT(index) DCHECK_EQ(index, BaseObject::kSlot)
+
+namespace mksnapshot {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex is_building_snapshot_buffer;
+  };
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+  SET_BINDING_ID(mksnapshot_binding_data)
+  SERIALIZABLE_OBJECT_METHODS()
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+ private:
+  AliasedUint8Array is_building_snapshot_buffer_;
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+}  // namespace mksnapshot
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SNAPSHOTABLE_H_

package/dist/node/include/node_sockaddr-inl.h

@@ -0,0 +1,257 @@
+#ifndef SRC_NODE_SOCKADDR_INL_H_
+#define SRC_NODE_SOCKADDR_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+#include "env-inl.h"
+#include "node_internals.h"
+#include "node_sockaddr.h"
+#include "util-inl.h"
+#include "memory_tracker-inl.h"
+
+#include <string>
+
+namespace node {
+
+static constexpr uint32_t kLabelMask = 0xFFFFF;
+
+inline void hash_combine(size_t* seed) { }
+
+template <typename T, typename... Args>
+inline void hash_combine(size_t* seed, const T& value, Args... rest) {
+    *seed ^= std::hash<T>{}(value) + 0x9e3779b9 + (*seed << 6) + (*seed >> 2);
+    hash_combine(seed, rest...);
+}
+
+bool SocketAddress::is_numeric_host(const char* hostname) {
+  return is_numeric_host(hostname, AF_INET) ||
+         is_numeric_host(hostname, AF_INET6);
+}
+
+bool SocketAddress::is_numeric_host(const char* hostname, int family) {
+  in6_addr dst;
+  return inet_pton(family, hostname, &dst) == 1;
+}
+
+int SocketAddress::GetPort(const sockaddr* addr) {
+  CHECK(addr->sa_family == AF_INET || addr->sa_family == AF_INET6);
+  return ntohs(addr->sa_family == AF_INET ?
+      reinterpret_cast<const sockaddr_in*>(addr)->sin_port :
+      reinterpret_cast<const sockaddr_in6*>(addr)->sin6_port);
+}
+
+int SocketAddress::GetPort(const sockaddr_storage* addr) {
+  return GetPort(reinterpret_cast<const sockaddr*>(addr));
+}
+
+std::string SocketAddress::GetAddress(const sockaddr* addr) {
+  CHECK(addr->sa_family == AF_INET || addr->sa_family == AF_INET6);
+  char host[INET6_ADDRSTRLEN];
+  const void* src = addr->sa_family == AF_INET ?
+      static_cast<const void*>(
+          &(reinterpret_cast<const sockaddr_in*>(addr)->sin_addr)) :
+      static_cast<const void*>(
+          &(reinterpret_cast<const sockaddr_in6*>(addr)->sin6_addr));
+  uv_inet_ntop(addr->sa_family, src, host, INET6_ADDRSTRLEN);
+  return std::string(host);
+}
+
+std::string SocketAddress::GetAddress(const sockaddr_storage* addr) {
+  return GetAddress(reinterpret_cast<const sockaddr*>(addr));
+}
+
+size_t SocketAddress::GetLength(const sockaddr* addr) {
+  return addr->sa_family == AF_INET ?
+      sizeof(sockaddr_in) : sizeof(sockaddr_in6);
+}
+
+size_t SocketAddress::GetLength(const sockaddr_storage* addr) {
+  return GetLength(reinterpret_cast<const sockaddr*>(addr));
+}
+
+SocketAddress::SocketAddress(const sockaddr* addr) {
+  memcpy(&address_, addr, GetLength(addr));
+}
+
+SocketAddress::SocketAddress(const SocketAddress& addr) {
+  memcpy(&address_, &addr.address_, addr.length());
+}
+
+SocketAddress& SocketAddress::operator=(const sockaddr* addr) {
+  if (reinterpret_cast<const sockaddr*>(&address_) != addr) {
+    memcpy(&address_, addr, GetLength(addr));
+  }
+  return *this;
+}
+
+SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
+  if (this != &addr) {
+    memcpy(&address_, &addr.address_, addr.length());
+  }
+  return *this;
+}
+
+const sockaddr& SocketAddress::operator*() const {
+  return *data();
+}
+
+const sockaddr* SocketAddress::operator->() const {
+  return data();
+}
+
+size_t SocketAddress::length() const {
+  return GetLength(&address_);
+}
+
+const sockaddr* SocketAddress::data() const {
+  return reinterpret_cast<const sockaddr*>(&address_);
+}
+
+const uint8_t* SocketAddress::raw() const {
+  return reinterpret_cast<const uint8_t*>(&address_);
+}
+
+sockaddr* SocketAddress::storage() {
+  return reinterpret_cast<sockaddr*>(&address_);
+}
+
+int SocketAddress::family() const {
+  return address_.ss_family;
+}
+
+std::string SocketAddress::address() const {
+  return GetAddress(&address_);
+}
+
+int SocketAddress::port() const {
+  return GetPort(&address_);
+}
+
+uint32_t SocketAddress::flow_label() const {
+  if (family() != AF_INET6)
+    return 0;
+  const sockaddr_in6* in = reinterpret_cast<const sockaddr_in6*>(data());
+  return in->sin6_flowinfo;
+}
+
+void SocketAddress::set_flow_label(uint32_t label) {
+  if (family() != AF_INET6)
+    return;
+  CHECK_LE(label, kLabelMask);
+  sockaddr_in6* in = reinterpret_cast<sockaddr_in6*>(&address_);
+  in->sin6_flowinfo = label;
+}
+
+std::string SocketAddress::ToString() const {
+  if (family() != AF_INET && family() != AF_INET6) return "";
+  return (family() == AF_INET6 ?
+              std::string("[") + address() + "]:" :
+              address() + ":") +
+      std::to_string(port());
+}
+
+void SocketAddress::Update(uint8_t* data, size_t len) {
+  CHECK_LE(len, sizeof(address_));
+  memcpy(&address_, data, len);
+}
+
+void SocketAddress::Update(const sockaddr* data, size_t len) {
+  CHECK_LE(len, sizeof(address_));
+  memcpy(&address_, data, len);
+}
+
+v8::MaybeLocal<v8::Object> SocketAddress::ToJS(
+    Environment* env,
+    v8::Local<v8::Object> info) const {
+  return AddressToJS(env, data(), info);
+}
+
+bool SocketAddress::operator==(const SocketAddress& other) const {
+  if (family() != other.family()) return false;
+  return memcmp(raw(), other.raw(), length()) == 0;
+}
+
+bool SocketAddress::operator!=(const SocketAddress& other) const {
+  return !(*this == other);
+}
+
+std::partial_ordering SocketAddress::operator<=>(
+    const SocketAddress& other) const {
+  return compare(other);
+}
+
+template <typename T>
+SocketAddressLRU<T>::SocketAddressLRU(
+    size_t max_size)
+    : max_size_(max_size) {}
+
+template <typename T>
+typename T::Type* SocketAddressLRU<T>::Peek(
+    const SocketAddress& address) const {
+  auto it = map_.find(address);
+  return it == std::end(map_) ? nullptr : &it->second->second;
+}
+
+template <typename T>
+void SocketAddressLRU<T>::CheckExpired() {
+  auto it = list_.rbegin();
+  while (it != list_.rend()) {
+    if (T::CheckExpired(it->first, it->second)) {
+      map_.erase(it->first);
+      list_.pop_back();
+      it = list_.rbegin();
+      continue;
+    } else {
+      break;
+    }
+  }
+}
+
+template <typename T>
+void SocketAddressLRU<T>::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("list", size() * sizeof(Pair));
+}
+
+// If an item already exists for the given address, bump up it's
+// position in the LRU list and return it. If the item does not
+// exist, create it. If an item is created, check the size of the
+// cache and adjust if necessary. Whether the item exists or not,
+// purge expired items.
+template <typename T>
+typename T::Type* SocketAddressLRU<T>::Upsert(
+    const SocketAddress& address) {
+
+  auto on_exit = OnScopeLeave([&]() { CheckExpired(); });
+
+  auto it = map_.find(address);
+  if (it != std::end(map_)) {
+    list_.splice(list_.begin(), list_, it->second);
+    T::Touch(it->first, &it->second->second);
+    return &it->second->second;
+  }
+
+  list_.push_front(Pair(address, { }));
+  map_[address] = list_.begin();
+  T::Touch(list_.begin()->first, &list_.begin()->second);
+
+  // Drop the last item in the list if we are
+  // over the size limit...
+  if (map_.size() > max_size_) {
+    auto last = list_.end();
+    map_.erase((--last)->first);
+    list_.pop_back();
+  }
+
+  return &map_[address]->second;
+}
+
+v8::MaybeLocal<v8::Value> SocketAddressBlockList::Rule::ToV8String(
+    Environment* env) {
+  std::string str = ToString();
+  return ToV8Value(env->context(), str);
+}
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_SOCKADDR_INL_H_