@encharm/cws 4.4.1 → 4.5.1

package/src/headers/16/node_internals.h

@@ -1,421 +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_INTERNALS_H_
-#define SRC_NODE_INTERNALS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "env.h"
-#include "node.h"
-#include "node_binding.h"
-#include "node_mutex.h"
-#include "tracing/trace_event.h"
-#include "util.h"
-#include "uv.h"
-#include "v8.h"
-
-#include <cstdint>
-#include <cstdlib>
-
-#include <string>
-#include <vector>
-
-struct sockaddr;
-
-namespace node {
-
-namespace native_module {
-class NativeModuleLoader;
-}
-
-namespace per_process {
-extern Mutex env_var_mutex;
-extern uint64_t node_start_time;
-}  // namespace per_process
-
-// Forward declaration
-class Environment;
-
-// Convert a struct sockaddr to a { address: '1.2.3.4', port: 1234 } JS object.
-// Sets address and port properties on the info object and returns it.
-// If |info| is omitted, a new object is returned.
-v8::Local<v8::Object> AddressToJS(
-    Environment* env,
-    const sockaddr* addr,
-    v8::Local<v8::Object> info = v8::Local<v8::Object>());
-
-template <typename T, int (*F)(const typename T::HandleType*, sockaddr*, int*)>
-void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  T* wrap;
-  ASSIGN_OR_RETURN_UNWRAP(&wrap,
-                          args.Holder(),
-                          args.GetReturnValue().Set(UV_EBADF));
-  CHECK(args[0]->IsObject());
-  sockaddr_storage storage;
-  int addrlen = sizeof(storage);
-  sockaddr* const addr = reinterpret_cast<sockaddr*>(&storage);
-  const int err = F(&wrap->handle_, addr, &addrlen);
-  if (err == 0)
-    AddressToJS(wrap->env(), addr, args[0].As<v8::Object>());
-  args.GetReturnValue().Set(err);
-}
-
-void PrintStackTrace(v8::Isolate* isolate, v8::Local<v8::StackTrace> stack);
-void PrintCaughtException(v8::Isolate* isolate,
-                          v8::Local<v8::Context> context,
-                          const v8::TryCatch& try_catch);
-
-void ResetStdio();  // Safe to call more than once and from signal handlers.
-#ifdef __POSIX__
-void SignalExit(int signal, siginfo_t* info, void* ucontext);
-#endif
-
-std::string GetProcessTitle(const char* default_title);
-std::string GetHumanReadableProcessName();
-
-v8::Maybe<bool> InitializeContextRuntime(v8::Local<v8::Context> context);
-bool InitializePrimordials(v8::Local<v8::Context> context);
-
-class NodeArrayBufferAllocator : public ArrayBufferAllocator {
- public:
-  inline uint32_t* zero_fill_field() { return &zero_fill_field_; }
-
-  void* Allocate(size_t size) override;  // Defined in src/node.cc
-  void* AllocateUninitialized(size_t size) override;
-  void Free(void* data, size_t size) override;
-  void* Reallocate(void* data, size_t old_size, size_t size) override;
-  virtual void RegisterPointer(void* data, size_t size) {
-    total_mem_usage_.fetch_add(size, std::memory_order_relaxed);
-  }
-  virtual void UnregisterPointer(void* data, size_t size) {
-    total_mem_usage_.fetch_sub(size, std::memory_order_relaxed);
-  }
-
-  NodeArrayBufferAllocator* GetImpl() final { return this; }
-  inline uint64_t total_mem_usage() const {
-    return total_mem_usage_.load(std::memory_order_relaxed);
-  }
-
- private:
-  uint32_t zero_fill_field_ = 1;  // Boolean but exposed as uint32 to JS land.
-  std::atomic<size_t> total_mem_usage_ {0};
-};
-
-class DebuggingArrayBufferAllocator final : public NodeArrayBufferAllocator {
- public:
-  ~DebuggingArrayBufferAllocator() override;
-  void* Allocate(size_t size) override;
-  void* AllocateUninitialized(size_t size) override;
-  void Free(void* data, size_t size) override;
-  void* Reallocate(void* data, size_t old_size, size_t size) override;
-  void RegisterPointer(void* data, size_t size) override;
-  void UnregisterPointer(void* data, size_t size) override;
-
- private:
-  void RegisterPointerInternal(void* data, size_t size);
-  void UnregisterPointerInternal(void* data, size_t size);
-  Mutex mutex_;
-  std::unordered_map<void*, size_t> allocations_;
-};
-
-namespace Buffer {
-v8::MaybeLocal<v8::Object> Copy(Environment* env, const char* data, size_t len);
-v8::MaybeLocal<v8::Object> New(Environment* env, size_t size);
-// Takes ownership of |data|.
-v8::MaybeLocal<v8::Object> New(Environment* env,
-                               char* data,
-                               size_t length,
-                               void (*callback)(char* data, void* hint),
-                               void* hint);
-// Takes ownership of |data|.  Must allocate |data| with the current Isolate's
-// ArrayBuffer::Allocator().
-v8::MaybeLocal<v8::Object> New(Environment* env,
-                               char* data,
-                               size_t length);
-// Creates a Buffer instance over an existing ArrayBuffer.
-v8::MaybeLocal<v8::Uint8Array> New(Environment* env,
-                                   v8::Local<v8::ArrayBuffer> ab,
-                                   size_t byte_offset,
-                                   size_t length);
-// Construct a Buffer from a MaybeStackBuffer (and also its subclasses like
-// Utf8Value and TwoByteValue).
-// If |buf| is invalidated, an empty MaybeLocal is returned, and nothing is
-// changed.
-// If |buf| contains actual data, this method takes ownership of |buf|'s
-// underlying buffer. However, |buf| itself can be reused even after this call,
-// but its capacity, if increased through AllocateSufficientStorage, is not
-// guaranteed to stay the same.
-template <typename T>
-static v8::MaybeLocal<v8::Object> New(Environment* env,
-                                      MaybeStackBuffer<T>* buf) {
-  v8::MaybeLocal<v8::Object> ret;
-  char* src = reinterpret_cast<char*>(buf->out());
-  const size_t len_in_bytes = buf->length() * sizeof(buf->out()[0]);
-
-  if (buf->IsAllocated())
-    ret = New(env, src, len_in_bytes);
-  else if (!buf->IsInvalidated())
-    ret = Copy(env, src, len_in_bytes);
-
-  if (ret.IsEmpty())
-    return ret;
-
-  if (buf->IsAllocated())
-    buf->Release();
-
-  return ret;
-}
-}  // namespace Buffer
-
-v8::MaybeLocal<v8::Value> InternalMakeCallback(
-    Environment* env,
-    v8::Local<v8::Object> resource,
-    v8::Local<v8::Object> recv,
-    const v8::Local<v8::Function> callback,
-    int argc,
-    v8::Local<v8::Value> argv[],
-    async_context asyncContext);
-
-v8::MaybeLocal<v8::Value> MakeSyncCallback(v8::Isolate* isolate,
-                                           v8::Local<v8::Object> recv,
-                                           v8::Local<v8::Function> callback,
-                                           int argc,
-                                           v8::Local<v8::Value> argv[]);
-
-class InternalCallbackScope {
- public:
-  enum Flags {
-    kNoFlags = 0,
-    // Indicates whether 'before' and 'after' hooks should be skipped.
-    kSkipAsyncHooks = 1,
-    // Indicates whether nextTick and microtask queues should be skipped.
-    // This should only be used when there is no call into JS in this scope.
-    // (The HTTP parser also uses it for some weird backwards
-    // compatibility issues, but it shouldn't.)
-    kSkipTaskQueues = 2
-  };
-  InternalCallbackScope(Environment* env,
-                        v8::Local<v8::Object> object,
-                        const async_context& asyncContext,
-                        int flags = kNoFlags);
-  // Utility that can be used by AsyncWrap classes.
-  explicit InternalCallbackScope(AsyncWrap* async_wrap, int flags = 0);
-  ~InternalCallbackScope();
-  void Close();
-
-  inline bool Failed() const { return failed_; }
-  inline void MarkAsFailed() { failed_ = true; }
-
- private:
-  Environment* env_;
-  async_context async_context_;
-  v8::Local<v8::Object> object_;
-  bool skip_hooks_;
-  bool skip_task_queues_;
-  bool failed_ = false;
-  bool pushed_ids_ = false;
-  bool closed_ = false;
-};
-
-class DebugSealHandleScope {
- public:
-  explicit inline DebugSealHandleScope(v8::Isolate* isolate = nullptr)
-#ifdef DEBUG
-    : actual_scope_(isolate != nullptr ? isolate : v8::Isolate::GetCurrent())
-#endif
-  {}
-
- private:
-#ifdef DEBUG
-  v8::SealHandleScope actual_scope_;
-#endif
-};
-
-class ThreadPoolWork {
- public:
-  explicit inline ThreadPoolWork(Environment* env) : env_(env) {
-    CHECK_NOT_NULL(env);
-  }
-  inline virtual ~ThreadPoolWork() = default;
-
-  inline void ScheduleWork();
-  inline int CancelWork();
-
-  virtual void DoThreadPoolWork() = 0;
-  virtual void AfterThreadPoolWork(int status) = 0;
-
-  Environment* env() const { return env_; }
-
- private:
-  Environment* env_;
-  uv_work_t work_req_;
-};
-
-#define TRACING_CATEGORY_NODE "node"
-#define TRACING_CATEGORY_NODE1(one)                                           \
-    TRACING_CATEGORY_NODE ","                                                 \
-    TRACING_CATEGORY_NODE "." #one
-#define TRACING_CATEGORY_NODE2(one, two)                                      \
-    TRACING_CATEGORY_NODE ","                                                 \
-    TRACING_CATEGORY_NODE "." #one ","                                        \
-    TRACING_CATEGORY_NODE "." #one "." #two
-
-// Functions defined in node.cc that are exposed via the bootstrapper object
-
-#if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
-#define NODE_IMPLEMENTS_POSIX_CREDENTIALS 1
-#endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
-
-namespace credentials {
-bool SafeGetenv(const char* key, std::string* text, Environment* env = nullptr);
-}  // namespace credentials
-
-void DefineZlibConstants(v8::Local<v8::Object> target);
-v8::Isolate* NewIsolate(v8::Isolate::CreateParams* params,
-                        uv_loop_t* event_loop,
-                        MultiIsolatePlatform* platform);
-// This overload automatically picks the right 'main_script_id' if no callback
-// was provided by the embedder.
-v8::MaybeLocal<v8::Value> StartExecution(Environment* env,
-                                         StartExecutionCallback cb = nullptr);
-v8::MaybeLocal<v8::Object> GetPerContextExports(v8::Local<v8::Context> context);
-v8::MaybeLocal<v8::Value> ExecuteBootstrapper(
-    Environment* env,
-    const char* id,
-    std::vector<v8::Local<v8::String>>* parameters,
-    std::vector<v8::Local<v8::Value>>* arguments);
-void MarkBootstrapComplete(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-struct InitializationResult {
-  int exit_code = 0;
-  std::vector<std::string> args;
-  std::vector<std::string> exec_args;
-  bool early_return = false;
-};
-
-enum InitializationSettingsFlags : uint64_t {
-  kDefaultInitialization = 1 << 0,
-  kInitializeV8 = 1 << 1,
-  kRunPlatformInit = 1 << 2,
-  kInitOpenSSL = 1 << 3
-};
-
-// TODO(codebytere): eventually document and expose to embedders.
-InitializationResult InitializeOncePerProcess(int argc, char** argv);
-InitializationResult InitializeOncePerProcess(
-  int argc,
-  char** argv,
-  InitializationSettingsFlags flags);
-void TearDownOncePerProcess();
-void SetIsolateErrorHandlers(v8::Isolate* isolate, const IsolateSettings& s);
-void SetIsolateMiscHandlers(v8::Isolate* isolate, const IsolateSettings& s);
-void SetIsolateCreateParamsForNode(v8::Isolate::CreateParams* params);
-
-#if HAVE_INSPECTOR
-namespace profiler {
-void StartProfilers(Environment* env);
-}
-#endif  // HAVE_INSPECTOR
-
-#ifdef __POSIX__
-static constexpr unsigned kMaxSignal = 32;
-#endif
-
-bool HasSignalJSHandler(int signum);
-
-#ifdef _WIN32
-typedef SYSTEMTIME TIME_TYPE;
-#else  // UNIX, OSX
-typedef struct tm TIME_TYPE;
-#endif
-
-double GetCurrentTimeInMicroseconds();
-int WriteFileSync(const char* path, uv_buf_t buf);
-int WriteFileSync(v8::Isolate* isolate,
-                  const char* path,
-                  v8::Local<v8::String> string);
-
-class DiagnosticFilename {
- public:
-  static void LocalTime(TIME_TYPE* tm_struct);
-
-  inline DiagnosticFilename(Environment* env,
-                            const char* prefix,
-                            const char* ext);
-
-  inline DiagnosticFilename(uint64_t thread_id,
-                            const char* prefix,
-                            const char* ext);
-
-  inline const char* operator*() const;
-
- private:
-  static std::string MakeFilename(
-      uint64_t thread_id,
-      const char* prefix,
-      const char* ext);
-
-  std::string filename_;
-};
-
-namespace heap {
-bool WriteSnapshot(v8::Isolate* isolate, const char* filename);
-}
-
-class TraceEventScope {
- public:
-  TraceEventScope(const char* category,
-                  const char* name,
-                  void* id) : category_(category), name_(name), id_(id) {
-    TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(category_, name_, id_);
-  }
-  ~TraceEventScope() {
-    TRACE_EVENT_NESTABLE_ASYNC_END0(category_, name_, id_);
-  }
-
- private:
-  const char* category_;
-  const char* name_;
-  void* id_;
-};
-
-namespace heap {
-
-void DeleteHeapSnapshot(const v8::HeapSnapshot* snapshot);
-using HeapSnapshotPointer =
-  DeleteFnPtr<const v8::HeapSnapshot, DeleteHeapSnapshot>;
-
-BaseObjectPtr<AsyncWrap> CreateHeapSnapshotStream(
-    Environment* env, HeapSnapshotPointer&& snapshot);
-}  // namespace heap
-
-namespace fs {
-std::string Basename(const std::string& str, const std::string& extension);
-}  // namespace fs
-
-node_module napi_module_to_node_module(const napi_module* mod);
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_INTERNALS_H_

package/src/headers/16/node_main_instance.h

@@ -1,103 +0,0 @@
-#ifndef SRC_NODE_MAIN_INSTANCE_H_
-#define SRC_NODE_MAIN_INSTANCE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cstddef>
-#include <memory>
-
-#include "node.h"
-#include "util.h"
-#include "uv.h"
-#include "v8.h"
-
-namespace node {
-
-class ExternalReferenceRegistry;
-struct EnvSerializeInfo;
-
-// TODO(joyeecheung): align this with the Worker/WorkerThreadData class.
-// We may be able to create an abstract class to reuse some of the routines.
-class NodeMainInstance {
- public:
-  // To create a main instance that does not own the isolate,
-  // The caller needs to do:
-  //
-  //   Isolate* isolate = Isolate::Allocate();
-  //   platform->RegisterIsolate(isolate, loop);
-  //   isolate->Initialize(...);
-  //   isolate->Enter();
-  //   std::unique_ptr<NodeMainInstance> main_instance =
-  //       NodeMainInstance::Create(isolate, loop, args, exec_args);
-  //
-  // When tearing it down:
-  //
-  //   main_instance->Cleanup();  // While the isolate is entered
-  //   isolate->Exit();
-  //   isolate->Dispose();
-  //   platform->UnregisterIsolate(isolate);
-  //
-  // After calling Dispose() the main_instance is no longer accessible.
-  static std::unique_ptr<NodeMainInstance> Create(
-      v8::Isolate* isolate,
-      uv_loop_t* event_loop,
-      MultiIsolatePlatform* platform,
-      const std::vector<std::string>& args,
-      const std::vector<std::string>& exec_args);
-
-  void Dispose();
-
-  // Create a main instance that owns the isolate
-  NodeMainInstance(
-      v8::Isolate::CreateParams* params,
-      uv_loop_t* event_loop,
-      MultiIsolatePlatform* platform,
-      const std::vector<std::string>& args,
-      const std::vector<std::string>& exec_args,
-      const std::vector<size_t>* per_isolate_data_indexes = nullptr);
-  ~NodeMainInstance();
-
-  // Start running the Node.js instances, return the exit code when finished.
-  int Run(const EnvSerializeInfo* env_info);
-  void Run(int* exit_code, Environment* env);
-
-  IsolateData* isolate_data() { return isolate_data_.get(); }
-
-  DeleteFnPtr<Environment, FreeEnvironment> CreateMainEnvironment(
-      int* exit_code, const EnvSerializeInfo* env_info);
-
-  // If nullptr is returned, the binary is not built with embedded
-  // snapshot.
-  static const std::vector<size_t>* GetIsolateDataIndices();
-  static v8::StartupData* GetEmbeddedSnapshotBlob();
-  static const EnvSerializeInfo* GetEnvSerializeInfo();
-  static const std::vector<intptr_t>& CollectExternalReferences();
-
-  static const size_t kNodeContextIndex = 0;
-  NodeMainInstance(const NodeMainInstance&) = delete;
-  NodeMainInstance& operator=(const NodeMainInstance&) = delete;
-  NodeMainInstance(NodeMainInstance&&) = delete;
-  NodeMainInstance& operator=(NodeMainInstance&&) = delete;
-
- private:
-  NodeMainInstance(v8::Isolate* isolate,
-                   uv_loop_t* event_loop,
-                   MultiIsolatePlatform* platform,
-                   const std::vector<std::string>& args,
-                   const std::vector<std::string>& exec_args);
-
-  static std::unique_ptr<ExternalReferenceRegistry> registry_;
-  std::vector<std::string> args_;
-  std::vector<std::string> exec_args_;
-  std::unique_ptr<ArrayBufferAllocator> array_buffer_allocator_;
-  v8::Isolate* isolate_;
-  MultiIsolatePlatform* platform_;
-  std::unique_ptr<IsolateData> isolate_data_;
-  bool owns_isolate_ = false;
-  bool deserialize_mode_ = false;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_NODE_MAIN_INSTANCE_H_

package/src/headers/16/node_mem-inl.h

@@ -1,112 +0,0 @@
-#ifndef SRC_NODE_MEM_INL_H_
-#define SRC_NODE_MEM_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_mem.h"
-#include "node_internals.h"
-
-namespace node {
-namespace mem {
-
-template <typename Class, typename AllocatorStruct>
-AllocatorStruct NgLibMemoryManager<Class, AllocatorStruct>::MakeAllocator() {
-  return AllocatorStruct {
-    static_cast<void*>(static_cast<Class*>(this)),
-    MallocImpl,
-    FreeImpl,
-    CallocImpl,
-    ReallocImpl
-  };
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr,
-                                             size_t size,
-                                             void* user_data) {
-  Class* manager = static_cast<Class*>(user_data);
-
-  size_t previous_size = 0;
-  char* original_ptr = nullptr;
-
-  // We prepend each allocated buffer with a size_t containing the full
-  // size of the allocation.
-  if (size > 0) size += sizeof(size_t);
-
-  if (ptr != nullptr) {
-    // We are free()ing or re-allocating.
-    original_ptr = static_cast<char*>(ptr) - sizeof(size_t);
-    previous_size = *reinterpret_cast<size_t*>(original_ptr);
-    // This means we called StopTracking() on this pointer before.
-    if (previous_size == 0) {
-      // Fall back to the standard Realloc() function.
-      char* ret = UncheckedRealloc(original_ptr, size);
-      if (ret != nullptr)
-        ret += sizeof(size_t);
-      return ret;
-    }
-  }
-
-  manager->CheckAllocatedSize(previous_size);
-
-  char* mem = UncheckedRealloc(original_ptr, size);
-
-  if (mem != nullptr) {
-    // Adjust the memory info counter.
-    // TODO(addaleax): Avoid the double bookkeeping we do with
-    // current_nghttp2_memory_ + AdjustAmountOfExternalAllocatedMemory
-    // and provide versions of our memory allocation utilities that take an
-    // Environment*/Isolate* parameter and call the V8 method transparently.
-    const int64_t new_size = size - previous_size;
-    manager->IncreaseAllocatedSize(new_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        new_size);
-    *reinterpret_cast<size_t*>(mem) = size;
-    mem += sizeof(size_t);
-  } else if (size == 0) {
-    manager->DecreaseAllocatedSize(previous_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        -static_cast<int64_t>(previous_size));
-  }
-  return mem;
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::MallocImpl(size_t size, void* user_data) {
-  return ReallocImpl(nullptr, size, user_data);
-}
-
-template <typename Class, typename T>
-void NgLibMemoryManager<Class, T>::FreeImpl(void* ptr, void* user_data) {
-  if (ptr == nullptr) return;
-  CHECK_NULL(ReallocImpl(ptr, 0, user_data));
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::CallocImpl(size_t nmemb,
-                                            size_t size,
-                                            void* user_data) {
-  size_t real_size = MultiplyWithOverflowCheck(nmemb, size);
-  void* mem = MallocImpl(real_size, user_data);
-  if (mem != nullptr)
-    memset(mem, 0, real_size);
-  return mem;
-}
-
-template <typename Class, typename T>
-void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) {
-  size_t* original_ptr = reinterpret_cast<size_t*>(
-      static_cast<char*>(ptr) - sizeof(size_t));
-  Class* manager = static_cast<Class*>(this);
-  manager->DecreaseAllocatedSize(*original_ptr);
-  manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-      -static_cast<int64_t>(*original_ptr));
-  *original_ptr = 0;
-}
-
-}  // namespace mem
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_MEM_INL_H_