@encharm/cws 4.1.0 → 4.2.0

package/src/headers/13/node_sockaddr-inl.h

@@ -1,170 +0,0 @@
-#ifndef SRC_NODE_SOCKADDR_INL_H_
-#define SRC_NODE_SOCKADDR_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include "node_internals.h"
-#include "node_sockaddr.h"
-#include "util-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) {
-  memcpy(&address_, addr, GetLength(addr));
-  return *this;
-}
-
-SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
-  memcpy(&address_, &addr.address_, addr.length());
-  return *this;
-}
-
-const sockaddr& SocketAddress::operator*() const {
-  return *this->data();
-}
-
-const sockaddr* SocketAddress::operator->() const {
-  return this->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);
-}
-
-v8::Local<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);
-}
-}  // namespace node
-
-#endif  // NODE_WANT_INTERNALS
-#endif  // SRC_NODE_SOCKADDR_INL_H_

package/src/headers/13/node_sockaddr.h

@@ -1,123 +0,0 @@
-#ifndef SRC_NODE_SOCKADDR_H_
-#define SRC_NODE_SOCKADDR_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "memory_tracker.h"
-#include "node.h"
-#include "uv.h"
-#include "v8.h"
-
-#include <string>
-#include <unordered_map>
-
-namespace node {
-
-class Environment;
-
-class SocketAddress : public MemoryRetainer {
- public:
-  struct Hash {
-    size_t operator()(const SocketAddress& addr) const;
-  };
-
-  inline bool operator==(const SocketAddress& other) const;
-  inline bool operator!=(const SocketAddress& other) const;
-
-  inline static bool is_numeric_host(const char* hostname);
-  inline static bool is_numeric_host(const char* hostname, int family);
-
-  // Returns true if converting {family, host, port} to *addr succeeded.
-  static bool ToSockAddr(
-      int32_t family,
-      const char* host,
-      uint32_t port,
-      sockaddr_storage* addr);
-
-  // Returns true if converting {family, host, port} to *addr succeeded.
-  static bool New(
-      int32_t family,
-      const char* host,
-      uint32_t port,
-      SocketAddress* addr);
-
-  static bool New(
-      const char* host,
-      uint32_t port,
-      SocketAddress* addr);
-
-  // Returns the port for an IPv4 or IPv6 address.
-  inline static int GetPort(const sockaddr* addr);
-  inline static int GetPort(const sockaddr_storage* addr);
-
-  // Returns the numeric host as a string for an IPv4 or IPv6 address.
-  inline static std::string GetAddress(const sockaddr* addr);
-  inline static std::string GetAddress(const sockaddr_storage* addr);
-
-  // Returns the struct length for an IPv4, IPv6 or UNIX domain.
-  inline static size_t GetLength(const sockaddr* addr);
-  inline static size_t GetLength(const sockaddr_storage* addr);
-
-  SocketAddress() = default;
-
-  inline explicit SocketAddress(const sockaddr* addr);
-  inline SocketAddress(const SocketAddress& addr);
-  inline SocketAddress& operator=(const sockaddr* other);
-  inline SocketAddress& operator=(const SocketAddress& other);
-
-  inline const sockaddr& operator*() const;
-  inline const sockaddr* operator->() const;
-
-  inline const sockaddr* data() const;
-  inline const uint8_t* raw() const;
-  inline sockaddr* storage();
-  inline size_t length() const;
-
-  inline int family() const;
-  inline std::string address() const;
-  inline int port() const;
-
-  // If the SocketAddress is an IPv6 address, returns the
-  // current value of the IPv6 flow label, if set. Otherwise
-  // returns 0.
-  inline uint32_t flow_label() const;
-
-  // If the SocketAddress is an IPv6 address, sets the
-  // current value of the IPv6 flow label. If not an
-  // IPv6 address, set_flow_label is a non-op. It
-  // is important to note that the flow label,
-  // while represented as an uint32_t, the flow
-  // label is strictly limited to 20 bits, and
-  // this will assert if any value larger than
-  // 20-bits is specified.
-  inline void set_flow_label(uint32_t label = 0);
-
-  inline void Update(uint8_t* data, size_t len);
-
-  static SocketAddress FromSockName(const uv_udp_t& handle);
-  static SocketAddress FromSockName(const uv_tcp_t& handle);
-  static SocketAddress FromPeerName(const uv_udp_t& handle);
-  static SocketAddress FromPeerName(const uv_tcp_t& handle);
-
-  inline v8::Local<v8::Object> ToJS(
-      Environment* env,
-      v8::Local<v8::Object> obj = v8::Local<v8::Object>()) const;
-
-  inline std::string ToString() const;
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(SocketAddress)
-  SET_SELF_SIZE(SocketAddress)
-
-  template <typename T>
-  using Map = std::unordered_map<SocketAddress, T, Hash>;
-
- private:
-  sockaddr_storage address_;
-};
-
-}  // namespace node
-
-#endif  // NOE_WANT_INTERNALS
-
-#endif  // SRC_NODE_SOCKADDR_H_

package/src/headers/13/node_stat_watcher.h

@@ -1,66 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_NODE_STAT_WATCHER_H_
-#define SRC_NODE_STAT_WATCHER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include "handle_wrap.h"
-#include "uv.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-
-class StatWatcher : public HandleWrap {
- public:
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-
- protected:
-  StatWatcher(Environment* env,
-              v8::Local<v8::Object> wrap,
-              bool use_bigint);
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(StatWatcher)
-  SET_SELF_SIZE(StatWatcher)
-
- private:
-  static void Callback(uv_fs_poll_t* handle,
-                       int status,
-                       const uv_stat_t* prev,
-                       const uv_stat_t* curr);
-
-  uv_fs_poll_t watcher_;
-  const bool use_bigint_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_STAT_WATCHER_H_

package/src/headers/13/node_union_bytes.h

@@ -1,103 +0,0 @@
-
-#ifndef SRC_NODE_UNION_BYTES_H_
-#define SRC_NODE_UNION_BYTES_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-// A union of const uint8_t* or const uint16_t* data that can be
-// turned into external v8::String when given an isolate.
-
-#include "v8.h"
-
-namespace node {
-
-class NonOwningExternalOneByteResource
-    : public v8::String::ExternalOneByteStringResource {
- public:
-  explicit NonOwningExternalOneByteResource(const uint8_t* data, size_t length)
-      : data_(data), length_(length) {}
-  ~NonOwningExternalOneByteResource() override = default;
-
-  const char* data() const override {
-    return reinterpret_cast<const char*>(data_);
-  }
-  size_t length() const override { return length_; }
-
-  NonOwningExternalOneByteResource(const NonOwningExternalOneByteResource&) =
-      delete;
-  NonOwningExternalOneByteResource& operator=(
-      const NonOwningExternalOneByteResource&) = delete;
-
- private:
-  const uint8_t* data_;
-  size_t length_;
-};
-
-class NonOwningExternalTwoByteResource
-    : public v8::String::ExternalStringResource {
- public:
-  explicit NonOwningExternalTwoByteResource(const uint16_t* data, size_t length)
-      : data_(data), length_(length) {}
-  ~NonOwningExternalTwoByteResource() override = default;
-
-  const uint16_t* data() const override { return data_; }
-  size_t length() const override { return length_; }
-
-  NonOwningExternalTwoByteResource(const NonOwningExternalTwoByteResource&) =
-      delete;
-  NonOwningExternalTwoByteResource& operator=(
-      const NonOwningExternalTwoByteResource&) = delete;
-
- private:
-  const uint16_t* data_;
-  size_t length_;
-};
-
-// Similar to a v8::String, but it's independent from Isolates
-// and can be materialized in Isolates as external Strings
-// via ToStringChecked. The data pointers are owned by the caller.
-class UnionBytes {
- public:
-  UnionBytes(const uint16_t* data, size_t length)
-      : one_bytes_(nullptr), two_bytes_(data), length_(length) {}
-  UnionBytes(const uint8_t* data, size_t length)
-      : one_bytes_(data), two_bytes_(nullptr), length_(length) {}
-
-  UnionBytes(const UnionBytes&) = default;
-  UnionBytes& operator=(const UnionBytes&) = default;
-  UnionBytes(UnionBytes&&) = default;
-  UnionBytes& operator=(UnionBytes&&) = default;
-
-  bool is_one_byte() const { return one_bytes_ != nullptr; }
-  const uint16_t* two_bytes_data() const {
-    CHECK_NOT_NULL(two_bytes_);
-    return two_bytes_;
-  }
-  const uint8_t* one_bytes_data() const {
-    CHECK_NOT_NULL(one_bytes_);
-    return one_bytes_;
-  }
-  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const {
-    if (is_one_byte()) {
-      NonOwningExternalOneByteResource* source =
-          new NonOwningExternalOneByteResource(one_bytes_data(), length_);
-      return v8::String::NewExternalOneByte(isolate, source).ToLocalChecked();
-    } else {
-      NonOwningExternalTwoByteResource* source =
-          new NonOwningExternalTwoByteResource(two_bytes_data(), length_);
-      return v8::String::NewExternalTwoByte(isolate, source).ToLocalChecked();
-    }
-  }
-  size_t length() { return length_; }
-
- private:
-  const uint8_t* one_bytes_;
-  const uint16_t* two_bytes_;
-  size_t length_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_UNION_BYTES_H_

package/src/headers/13/node_v8_platform-inl.h

@@ -1,184 +0,0 @@
-#ifndef SRC_NODE_V8_PLATFORM_INL_H_
-#define SRC_NODE_V8_PLATFORM_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <memory>
-
-#include "env-inl.h"
-#include "node.h"
-#include "node_metadata.h"
-#include "node_options.h"
-#include "tracing/node_trace_writer.h"
-#include "tracing/trace_event.h"
-#include "tracing/traced_value.h"
-
-namespace node {
-
-// Ensures that __metadata trace events are only emitted
-// when tracing is enabled.
-class NodeTraceStateObserver
-    : public v8::TracingController::TraceStateObserver {
- public:
-  inline void OnTraceEnabled() override {
-    std::string title = GetProcessTitle("");
-    if (!title.empty()) {
-      // Only emit the metadata event if the title can be retrieved
-      // successfully. Ignore it otherwise.
-      TRACE_EVENT_METADATA1(
-          "__metadata", "process_name", "name", TRACE_STR_COPY(title.c_str()));
-    }
-    TRACE_EVENT_METADATA1("__metadata",
-                          "version",
-                          "node",
-                          per_process::metadata.versions.node.c_str());
-    TRACE_EVENT_METADATA1(
-        "__metadata", "thread_name", "name", "JavaScriptMainThread");
-
-    auto trace_process = tracing::TracedValue::Create();
-    trace_process->BeginDictionary("versions");
-
-#define V(key)                                                                 \
-  trace_process->SetString(#key, per_process::metadata.versions.key.c_str());
-
-    NODE_VERSIONS_KEYS(V)
-#undef V
-
-    trace_process->EndDictionary();
-
-    trace_process->SetString("arch", per_process::metadata.arch.c_str());
-    trace_process->SetString("platform",
-                             per_process::metadata.platform.c_str());
-
-    trace_process->BeginDictionary("release");
-    trace_process->SetString("name",
-                             per_process::metadata.release.name.c_str());
-#if NODE_VERSION_IS_LTS
-    trace_process->SetString("lts", per_process::metadata.release.lts.c_str());
-#endif
-    trace_process->EndDictionary();
-    TRACE_EVENT_METADATA1(
-        "__metadata", "node", "process", std::move(trace_process));
-
-    // This only runs the first time tracing is enabled
-    controller_->RemoveTraceStateObserver(this);
-  }
-
-  inline void OnTraceDisabled() override {
-    // Do nothing here. This should never be called because the
-    // observer removes itself when OnTraceEnabled() is called.
-    UNREACHABLE();
-  }
-
-  explicit NodeTraceStateObserver(v8::TracingController* controller)
-      : controller_(controller) {}
-  ~NodeTraceStateObserver() override = default;
-
- private:
-  v8::TracingController* controller_;
-};
-
-struct V8Platform {
-#if NODE_USE_V8_PLATFORM
-  inline void Initialize(int thread_pool_size) {
-    tracing_agent_ = std::make_unique<tracing::Agent>();
-    node::tracing::TraceEventHelper::SetAgent(tracing_agent_.get());
-    node::tracing::TracingController* controller =
-        tracing_agent_->GetTracingController();
-    trace_state_observer_ =
-        std::make_unique<NodeTraceStateObserver>(controller);
-    controller->AddTraceStateObserver(trace_state_observer_.get());
-    tracing_file_writer_ = tracing_agent_->DefaultHandle();
-    // Only start the tracing agent if we enabled any tracing categories.
-    if (!per_process::cli_options->trace_event_categories.empty()) {
-      StartTracingAgent();
-    }
-    // Tracing must be initialized before platform threads are created.
-    platform_ = new NodePlatform(thread_pool_size, controller);
-    v8::V8::InitializePlatform(platform_);
-  }
-
-  inline void Dispose() {
-    StopTracingAgent();
-    platform_->Shutdown();
-    delete platform_;
-    platform_ = nullptr;
-    // Destroy tracing after the platform (and platform threads) have been
-    // stopped.
-    tracing_agent_.reset(nullptr);
-    trace_state_observer_.reset(nullptr);
-  }
-
-  inline void DrainVMTasks(v8::Isolate* isolate) {
-    platform_->DrainTasks(isolate);
-  }
-
-  inline void StartTracingAgent() {
-    // 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, ',');
-
-      tracing_file_writer_ = tracing_agent_->AddClient(
-          std::set<std::string>(std::make_move_iterator(categories.begin()),
-                                std::make_move_iterator(categories.end())),
-          std::unique_ptr<tracing::AsyncTraceWriter>(
-              new tracing::NodeTraceWriter(
-                  per_process::cli_options->trace_event_file_pattern)),
-          tracing::Agent::kUseDefaultCategories);
-    }
-  }
-
-  inline void StopTracingAgent() { tracing_file_writer_.reset(); }
-
-  inline tracing::AgentWriterHandle* GetTracingAgentWriter() {
-    return &tracing_file_writer_;
-  }
-
-  inline NodePlatform* Platform() { return platform_; }
-
-  std::unique_ptr<NodeTraceStateObserver> trace_state_observer_;
-  std::unique_ptr<tracing::Agent> tracing_agent_;
-  tracing::AgentWriterHandle tracing_file_writer_;
-  NodePlatform* platform_;
-#else   // !NODE_USE_V8_PLATFORM
-  inline void Initialize(int thread_pool_size) {}
-  inline void Dispose() {}
-  inline void DrainVMTasks(v8::Isolate* isolate) {}
-  inline void StartTracingAgent() {
-    if (!per_process::cli_options->trace_event_categories.empty()) {
-      fprintf(stderr,
-              "Node compiled with NODE_USE_V8_PLATFORM=0, "
-              "so event tracing is not available.\n");
-    }
-  }
-  inline void StopTracingAgent() {}
-
-  inline tracing::AgentWriterHandle* GetTracingAgentWriter() { return nullptr; }
-
-  inline NodePlatform* Platform() { return nullptr; }
-#endif  // !NODE_USE_V8_PLATFORM
-};
-
-namespace per_process {
-extern struct V8Platform v8_platform;
-}
-
-inline void StartTracingAgent() {
-  return per_process::v8_platform.StartTracingAgent();
-}
-
-inline tracing::AgentWriterHandle* GetTracingAgentWriter() {
-  return per_process::v8_platform.GetTracingAgentWriter();
-}
-
-inline void DisposePlatform() {
-  per_process::v8_platform.Dispose();
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_V8_PLATFORM_INL_H_