@encharm/cws 4.4.1 → 4.5.1

package/src/headers/18/node_context_data.h

@@ -1,44 +0,0 @@
-#ifndef SRC_NODE_CONTEXT_DATA_H_
-#define SRC_NODE_CONTEXT_DATA_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-namespace node {
-
-// Pick an index that's hopefully out of the way when we're embedded inside
-// another application. Performance-wise or memory-wise it doesn't matter:
-// Context::SetAlignedPointerInEmbedderData() is backed by a FixedArray,
-// worst case we pay a one-time penalty for resizing the array.
-#ifndef NODE_CONTEXT_EMBEDDER_DATA_INDEX
-#define NODE_CONTEXT_EMBEDDER_DATA_INDEX 32
-#endif
-
-#ifndef NODE_CONTEXT_SANDBOX_OBJECT_INDEX
-#define NODE_CONTEXT_SANDBOX_OBJECT_INDEX 33
-#endif
-
-#ifndef NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX
-#define NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX 34
-#endif
-
-#ifndef NODE_CONTEXT_TAG
-#define NODE_CONTEXT_TAG 35
-#endif
-
-#ifndef NODE_BINDING_LIST
-#define NODE_BINDING_LIST_INDEX 36
-#endif
-
-enum ContextEmbedderIndex {
-  kEnvironment = NODE_CONTEXT_EMBEDDER_DATA_INDEX,
-  kSandboxObject = NODE_CONTEXT_SANDBOX_OBJECT_INDEX,
-  kAllowWasmCodeGeneration = NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX,
-  kContextTag = NODE_CONTEXT_TAG,
-  kBindingListIndex = NODE_BINDING_LIST_INDEX
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_CONTEXT_DATA_H_

package/src/headers/18/node_contextify.h

@@ -1,196 +0,0 @@
-#ifndef SRC_NODE_CONTEXTIFY_H_
-#define SRC_NODE_CONTEXTIFY_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object-inl.h"
-#include "node_context_data.h"
-#include "node_errors.h"
-
-namespace node {
-class ExternalReferenceRegistry;
-
-namespace contextify {
-
-class MicrotaskQueueWrap : public BaseObject {
- public:
-  MicrotaskQueueWrap(Environment* env, v8::Local<v8::Object> obj);
-
-  const std::shared_ptr<v8::MicrotaskQueue>& microtask_queue() const;
-
-  static void Init(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  // This could have methods for running the microtask queue, if we ever decide
-  // to make that fully customizable from userland.
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(MicrotaskQueueWrap)
-  SET_SELF_SIZE(MicrotaskQueueWrap)
-
- private:
-  std::shared_ptr<v8::MicrotaskQueue> microtask_queue_;
-};
-
-struct ContextOptions {
-  v8::Local<v8::String> name;
-  v8::Local<v8::String> origin;
-  v8::Local<v8::Boolean> allow_code_gen_strings;
-  v8::Local<v8::Boolean> allow_code_gen_wasm;
-  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap;
-};
-
-class ContextifyContext {
- public:
-  enum InternalFields { kSlot, kInternalFieldCount };
-  ContextifyContext(Environment* env,
-                    v8::Local<v8::Object> sandbox_obj,
-                    const ContextOptions& options);
-  ~ContextifyContext();
-  static void CleanupHook(void* arg);
-
-  v8::MaybeLocal<v8::Object> CreateDataWrapper(Environment* env);
-  v8::MaybeLocal<v8::Context> CreateV8Context(Environment* env,
-                                              v8::Local<v8::Object> sandbox_obj,
-                                              const ContextOptions& options);
-  static void Init(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-
-  static ContextifyContext* ContextFromContextifiedSandbox(
-      Environment* env,
-      const v8::Local<v8::Object>& sandbox);
-
-  inline Environment* env() const {
-    return env_;
-  }
-
-  inline v8::Local<v8::Context> context() const {
-    return PersistentToLocal::Default(env()->isolate(), context_);
-  }
-
-  inline v8::Local<v8::Object> global_proxy() const {
-    return context()->Global();
-  }
-
-  inline v8::Local<v8::Object> sandbox() const {
-    return context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject)
-        .As<v8::Object>();
-  }
-
-  inline std::shared_ptr<v8::MicrotaskQueue> microtask_queue() const {
-    if (!microtask_queue_wrap_) return {};
-    return microtask_queue_wrap_->microtask_queue();
-  }
-
-
-  template <typename T>
-  static ContextifyContext* Get(const v8::PropertyCallbackInfo<T>& args);
-
- private:
-  static void MakeContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void IsContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CompileFunction(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void WeakCallback(
-      const v8::WeakCallbackInfo<ContextifyContext>& data);
-  static void PropertyGetterCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertySetterCallback(
-      v8::Local<v8::Name> property,
-      v8::Local<v8::Value> value,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertyDescriptorCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertyDefinerCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyDescriptor& desc,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertyDeleterCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Boolean>& args);
-  static void PropertyEnumeratorCallback(
-      const v8::PropertyCallbackInfo<v8::Array>& args);
-  static void IndexedPropertyGetterCallback(
-      uint32_t index,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertySetterCallback(
-      uint32_t index,
-      v8::Local<v8::Value> value,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertyDescriptorCallback(
-      uint32_t index,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertyDefinerCallback(
-      uint32_t index,
-      const v8::PropertyDescriptor& desc,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertyDeleterCallback(
-      uint32_t index,
-      const v8::PropertyCallbackInfo<v8::Boolean>& args);
-  Environment* const env_;
-  v8::Global<v8::Context> context_;
-  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap_;
-};
-
-class ContextifyScript : public BaseObject {
- public:
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(ContextifyScript)
-  SET_SELF_SIZE(ContextifyScript)
-
-  ContextifyScript(Environment* env, v8::Local<v8::Object> object);
-  ~ContextifyScript() override;
-
-  static void Init(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static bool InstanceOf(Environment* env, const v8::Local<v8::Value>& args);
-  static void CreateCachedData(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RunInThisContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RunInContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static bool EvalMachine(Environment* env,
-                          const int64_t timeout,
-                          const bool display_errors,
-                          const bool break_on_sigint,
-                          const bool break_on_first_line,
-                          std::shared_ptr<v8::MicrotaskQueue> microtask_queue,
-                          const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  inline uint32_t id() { return id_; }
-
- private:
-  v8::Global<v8::UnboundScript> script_;
-  uint32_t id_;
-};
-
-class CompiledFnEntry final : public BaseObject {
- public:
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(CompiledFnEntry)
-  SET_SELF_SIZE(CompiledFnEntry)
-
-  CompiledFnEntry(Environment* env,
-                  v8::Local<v8::Object> object,
-                  uint32_t id,
-                  v8::Local<v8::ScriptOrModule> script);
-  ~CompiledFnEntry();
-
-  bool IsNotIndicativeOfMemoryLeakAtExit() const override { return true; }
-
- private:
-  uint32_t id_;
-  v8::Global<v8::ScriptOrModule> script_;
-
-  static void WeakCallback(const v8::WeakCallbackInfo<CompiledFnEntry>& data);
-};
-
-}  // namespace contextify
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_CONTEXTIFY_H_

package/src/headers/18/node_crypto.h

@@ -1,57 +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_CRYPTO_H_
-#define SRC_NODE_CRYPTO_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-// All of the crypto definitions previously contained in this header
-// have been split across multiple headers in src/crypto. This header
-// remains for convenience for any code that still imports it. New
-// code should include the relevant src/crypto headers directly.
-#include "crypto/crypto_aes.h"
-#include "crypto/crypto_bio.h"
-#include "crypto/crypto_cipher.h"
-#include "crypto/crypto_context.h"
-#include "crypto/crypto_dh.h"
-#include "crypto/crypto_dsa.h"
-#include "crypto/crypto_ec.h"
-#include "crypto/crypto_groups.h"
-#include "crypto/crypto_hash.h"
-#include "crypto/crypto_hkdf.h"
-#include "crypto/crypto_hmac.h"
-#include "crypto/crypto_keygen.h"
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_pbkdf2.h"
-#include "crypto/crypto_random.h"
-#include "crypto/crypto_rsa.h"
-#include "crypto/crypto_scrypt.h"
-#include "crypto/crypto_sig.h"
-#include "crypto/crypto_spkac.h"
-#include "crypto/crypto_tls.h"
-#include "crypto/crypto_timing.h"
-#include "crypto/crypto_util.h"
-#include "crypto/crypto_x509.h"
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_CRYPTO_H_

package/src/headers/18/node_dir.h

@@ -1,52 +0,0 @@
-#ifndef SRC_NODE_DIR_H_
-#define SRC_NODE_DIR_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_file.h"
-
-namespace node {
-
-namespace fs_dir {
-
-// Needed to propagate `uv_dir_t`.
-class DirHandle : public AsyncWrap {
- public:
-  static DirHandle* New(Environment* env, uv_dir_t* dir);
-  ~DirHandle() override;
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  inline uv_dir_t* dir() { return dir_; }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(DirHandle)
-  SET_SELF_SIZE(DirHandle)
-
-  DirHandle(const DirHandle&) = delete;
-  DirHandle& operator=(const DirHandle&) = delete;
-  DirHandle(const DirHandle&&) = delete;
-  DirHandle& operator=(const DirHandle&&) = delete;
-
- private:
-  DirHandle(Environment* env, v8::Local<v8::Object> obj, uv_dir_t* dir);
-
-  // Synchronous close that emits a warning
-  void GCClose();
-
-  uv_dir_t* dir_;
-  // Multiple entries are read through a single libuv call.
-  std::vector<uv_dirent_t> dirents_;
-  bool closing_ = false;
-  bool closed_ = false;
-};
-
-}  // namespace fs_dir
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_DIR_H_

package/src/headers/18/node_dtrace.h

@@ -1,86 +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_DTRACE_H_
-#define SRC_NODE_DTRACE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "v8.h"
-
-extern "C" {
-/*
- * The following structures are passed directly to DTrace when probes are fired.
- * Translators in node.d translate these structures into the corresponding D
- * structures, taking care of dealing with the user process data model (32-bit
- * or 64-bit) and structure versions (see node_dtrace_http_server_request_t
- * below).
- */
-
-typedef struct {
-  int32_t fd;
-  int32_t port;
-  char* remote;
-  int32_t buffered;
-} node_dtrace_connection_t;
-
-typedef struct {
-  char* url;
-  char* method;
-} node_dtrace_http_client_request_t;
-
-/*
- * The original version of this structure contained only a url and method, just
- * like the client request above.  To add the new forwardedFor field, the
- * structure layout was changed to begin with an integer version.  The
- * translator knows whether it's looking at an old- or new-version structure
- * based on whether the version field's value is a reasonable pointer (i.e.
- * address greater than 4K).  No doubt this is filthy, but there's not much else
- * we can do, and it works reliably.
- *
- * This version of the structure also contains padding that should be zeroed out
- * by the consumer so that future versions of the translator can simply check if
- * a field is present by checking it against nullptr.
- */
-typedef struct {
-  union {
-    uint32_t version;
-    uintptr_t unused;  /* for compat. with old 64-bit struct */
-  } _un;
-  char* url;
-  char* method;
-  char* forwardedFor;
-  char* _pad[8];
-} node_dtrace_http_server_request_t;
-
-}  // extern "C"
-
-namespace node {
-
-class Environment;
-
-void InitDTrace(Environment* env);
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_DTRACE_H_

package/src/headers/18/node_external_reference.h

@@ -1,145 +0,0 @@
-#ifndef SRC_NODE_EXTERNAL_REFERENCE_H_
-#define SRC_NODE_EXTERNAL_REFERENCE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cinttypes>
-#include <vector>
-#include "v8-fast-api-calls.h"
-#include "v8.h"
-
-namespace node {
-
-using CFunctionCallback = void (*)(v8::Local<v8::Value> receiver);
-
-// This class manages the external references from the V8 heap
-// to the C++ addresses in Node.js.
-class ExternalReferenceRegistry {
- public:
-  ExternalReferenceRegistry();
-
-#define ALLOWED_EXTERNAL_REFERENCE_TYPES(V)                                    \
-  V(CFunctionCallback)                                                         \
-  V(const v8::CFunctionInfo*)                                                  \
-  V(v8::FunctionCallback)                                                      \
-  V(v8::AccessorGetterCallback)                                                \
-  V(v8::AccessorSetterCallback)                                                \
-  V(v8::AccessorNameGetterCallback)                                            \
-  V(v8::AccessorNameSetterCallback)                                            \
-  V(v8::GenericNamedPropertyDefinerCallback)                                   \
-  V(v8::GenericNamedPropertyDeleterCallback)                                   \
-  V(v8::GenericNamedPropertyEnumeratorCallback)                                \
-  V(v8::GenericNamedPropertyQueryCallback)                                     \
-  V(v8::GenericNamedPropertySetterCallback)
-
-#define V(ExternalReferenceType)                                               \
-  void Register(ExternalReferenceType addr) { RegisterT(addr); }
-  ALLOWED_EXTERNAL_REFERENCE_TYPES(V)
-#undef V
-
-  // This can be called only once.
-  const std::vector<intptr_t>& external_references();
-
-  bool is_empty() { return external_references_.empty(); }
-
- private:
-  template <typename T>
-  void RegisterT(T* address) {
-    external_references_.push_back(reinterpret_cast<intptr_t>(address));
-  }
-  bool is_finalized_ = false;
-  std::vector<intptr_t> external_references_;
-};
-
-#define EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                \
-  V(async_wrap)                                                                \
-  V(binding)                                                                   \
-  V(blob)                                                                      \
-  V(buffer)                                                                    \
-  V(contextify)                                                                \
-  V(credentials)                                                               \
-  V(env_var)                                                                   \
-  V(errors)                                                                    \
-  V(fs)                                                                        \
-  V(fs_dir)                                                                    \
-  V(fs_event_wrap)                                                             \
-  V(handle_wrap)                                                               \
-  V(heap_utils)                                                                \
-  V(messaging)                                                                 \
-  V(mksnapshot)                                                                \
-  V(native_module)                                                             \
-  V(options)                                                                   \
-  V(os)                                                                        \
-  V(performance)                                                               \
-  V(process_methods)                                                           \
-  V(process_object)                                                            \
-  V(report)                                                                    \
-  V(task_queue)                                                                \
-  V(tcp_wrap)                                                                  \
-  V(tty_wrap)                                                                  \
-  V(url)                                                                       \
-  V(util)                                                                      \
-  V(pipe_wrap)                                                                 \
-  V(serdes)                                                                    \
-  V(string_decoder)                                                            \
-  V(stream_wrap)                                                               \
-  V(signal_wrap)                                                               \
-  V(trace_events)                                                              \
-  V(timers)                                                                    \
-  V(types)                                                                     \
-  V(uv)                                                                        \
-  V(v8)                                                                        \
-  V(zlib)                                                                      \
-  V(wasm_web_api)                                                              \
-  V(worker)
-
-#if NODE_HAVE_I18N_SUPPORT
-#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V) V(icu)
-#else
-#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)
-#endif  // NODE_HAVE_I18N_SUPPORT
-
-#if HAVE_INSPECTOR
-#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                           \
-  V(inspector)                                                                 \
-  V(profiler)
-#else
-#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)
-#endif  // HAVE_INSPECTOR
-
-#if HAVE_DTRACE || HAVE_ETW
-#define EXTERNAL_REFERENCE_BINDING_LIST_DTRACE(V) V(dtrace)
-#else
-#define EXTERNAL_REFERENCE_BINDING_LIST_DTRACE(V)
-#endif
-
-#if HAVE_OPENSSL
-#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V) V(crypto) V(tls_wrap)
-#else
-#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)
-#endif  // HAVE_OPENSSL
-
-#define EXTERNAL_REFERENCE_BINDING_LIST(V)                                     \
-  EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                      \
-  EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                                 \
-  EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)                                      \
-  EXTERNAL_REFERENCE_BINDING_LIST_DTRACE(V)                                    \
-  EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)
-
-}  // namespace node
-
-// Declare all the external reference registration functions here,
-// and define them later with #NODE_MODULE_EXTERNAL_REFERENCE(modname, func);
-#define V(modname)                                                             \
-  void _register_external_reference_##modname(                                 \
-      node::ExternalReferenceRegistry* registry);
-EXTERNAL_REFERENCE_BINDING_LIST(V)
-#undef V
-
-#define NODE_MODULE_EXTERNAL_REFERENCE(modname, func)                          \
-  void _register_external_reference_##modname(                                 \
-      node::ExternalReferenceRegistry* registry) {                             \
-    func(registry);                                                            \
-  }
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_NODE_EXTERNAL_REFERENCE_H_