@encharm/cws 4.4.1 → 4.5.1

package/src/headers/22/cjs_module_lexer_version.h

@@ -0,0 +1,6 @@
+// This is an auto generated file, please do not edit.
+// Refer to tools/dep_updaters/update-cjs-module-lexer.sh
+#ifndef SRC_CJS_MODULE_LEXER_VERSION_H_
+#define SRC_CJS_MODULE_LEXER_VERSION_H_
+#define CJS_MODULE_LEXER_VERSION "1.4.1"
+#endif  // SRC_CJS_MODULE_LEXER_VERSION_H_

package/src/headers/22/cleanup_queue-inl.h

@@ -0,0 +1,62 @@
+#ifndef SRC_CLEANUP_QUEUE_INL_H_
+#define SRC_CLEANUP_QUEUE_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "cleanup_queue.h"
+#include "memory_tracker-inl.h"
+#include "util.h"
+
+namespace node {
+
+inline void CleanupQueue::MemoryInfo(MemoryTracker* tracker) const {
+  ForEachBaseObject([&](BaseObject* obj) {
+    if (obj->IsDoneInitializing()) tracker->Track(obj);
+  });
+}
+
+inline size_t CleanupQueue::SelfSize() const {
+  return sizeof(CleanupQueue) +
+         cleanup_hooks_.size() * sizeof(CleanupHookCallback);
+}
+
+bool CleanupQueue::empty() const {
+  return cleanup_hooks_.empty();
+}
+
+void CleanupQueue::Add(Callback cb, void* arg) {
+  auto insertion_info =
+      cleanup_hooks_.emplace(cb, arg, cleanup_hook_counter_++);
+  // Make sure there was no existing element with these values.
+  CHECK_EQ(insertion_info.second, true);
+}
+
+void CleanupQueue::Remove(Callback cb, void* arg) {
+  CleanupHookCallback search{cb, arg, 0};
+  cleanup_hooks_.erase(search);
+}
+
+template <typename T>
+void CleanupQueue::ForEachBaseObject(T&& iterator) const {
+  std::vector<CleanupHookCallback> callbacks = GetOrdered();
+
+  for (const auto& hook : callbacks) {
+    BaseObject* obj = GetBaseObject(hook);
+    if (obj != nullptr) iterator(obj);
+  }
+}
+
+BaseObject* CleanupQueue::GetBaseObject(
+    const CleanupHookCallback& callback) const {
+  if (callback.fn_ == BaseObject::DeleteMe)
+    return static_cast<BaseObject*>(callback.arg_);
+  else
+    return nullptr;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CLEANUP_QUEUE_INL_H_

package/src/headers/22/cleanup_queue.h

@@ -0,0 +1,85 @@
+#ifndef SRC_CLEANUP_QUEUE_H_
+#define SRC_CLEANUP_QUEUE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstddef>
+#include <cstdint>
+#include <unordered_set>
+#include <vector>
+
+#include "memory_tracker.h"
+
+namespace node {
+
+class BaseObject;
+
+class CleanupQueue : public MemoryRetainer {
+ public:
+  typedef void (*Callback)(void*);
+
+  CleanupQueue() = default;
+
+  // Not copyable.
+  CleanupQueue(const CleanupQueue&) = delete;
+
+  SET_MEMORY_INFO_NAME(CleanupQueue)
+  inline void MemoryInfo(node::MemoryTracker* tracker) const override;
+  inline size_t SelfSize() const override;
+
+  inline bool empty() const;
+
+  inline void Add(Callback cb, void* arg);
+  inline void Remove(Callback cb, void* arg);
+  void Drain();
+
+  template <typename T>
+  inline void ForEachBaseObject(T&& iterator) const;
+
+ private:
+  class CleanupHookCallback {
+   public:
+    CleanupHookCallback(Callback fn,
+                        void* arg,
+                        uint64_t insertion_order_counter)
+        : fn_(fn),
+          arg_(arg),
+          insertion_order_counter_(insertion_order_counter) {}
+
+    // Only hashes `arg_`, since that is usually enough to identify the hook.
+    struct Hash {
+      size_t operator()(const CleanupHookCallback& cb) const;
+    };
+
+    // Compares by `fn_` and `arg_` being equal.
+    struct Equal {
+      bool operator()(const CleanupHookCallback& a,
+                      const CleanupHookCallback& b) const;
+    };
+
+   private:
+    friend class CleanupQueue;
+    Callback fn_;
+    void* arg_;
+
+    // We keep track of the insertion order for these objects, so that we can
+    // call the callbacks in reverse order when we are cleaning up.
+    uint64_t insertion_order_counter_;
+  };
+
+  std::vector<CleanupHookCallback> GetOrdered() const;
+  inline BaseObject* GetBaseObject(const CleanupHookCallback& callback) const;
+
+  // Use an unordered_set, so that we have efficient insertion and removal.
+  std::unordered_set<CleanupHookCallback,
+                     CleanupHookCallback::Hash,
+                     CleanupHookCallback::Equal>
+      cleanup_hooks_;
+  uint64_t cleanup_hook_counter_ = 0;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CLEANUP_QUEUE_H_

package/src/headers/22/compile_cache.h

@@ -0,0 +1,104 @@
+#ifndef SRC_COMPILE_CACHE_H_
+#define SRC_COMPILE_CACHE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include "v8.h"
+
+namespace node {
+class Environment;
+
+// TODO(joyeecheung): move it into a CacheHandler class.
+enum class CachedCodeType : uint8_t {
+  kCommonJS = 0,
+  kESM,
+};
+
+struct CompileCacheEntry {
+  std::unique_ptr<v8::ScriptCompiler::CachedData> cache{nullptr};
+  uint32_t cache_key;
+  uint32_t code_hash;
+  uint32_t code_size;
+
+  std::string cache_filename;
+  std::string source_filename;
+  CachedCodeType type;
+  bool refreshed = false;
+  bool persisted = false;
+
+  // Copy the cache into a new store for V8 to consume. Caller takes
+  // ownership.
+  v8::ScriptCompiler::CachedData* CopyCache() const;
+};
+
+#define COMPILE_CACHE_STATUS(V)                                                \
+  V(FAILED)          /* Failed to enable the cache */                          \
+  V(ENABLED)         /* Was not enabled before, and now enabled. */            \
+  V(ALREADY_ENABLED) /* Was already enabled. */                                \
+  V(DISABLED)        /* Has been disabled by NODE_DISABLE_COMPILE_CACHE. */
+
+enum class CompileCacheEnableStatus : uint8_t {
+#define V(status) status,
+  COMPILE_CACHE_STATUS(V)
+#undef V
+};
+
+struct CompileCacheEnableResult {
+  CompileCacheEnableStatus status;
+  std::string cache_directory;
+  std::string message;  // Set in case of failure.
+};
+
+class CompileCacheHandler {
+ public:
+  explicit CompileCacheHandler(Environment* env);
+  CompileCacheEnableResult Enable(Environment* env, const std::string& dir);
+
+  void Persist();
+
+  CompileCacheEntry* GetOrInsert(v8::Local<v8::String> code,
+                                 v8::Local<v8::String> filename,
+                                 CachedCodeType type);
+  void MaybeSave(CompileCacheEntry* entry,
+                 v8::Local<v8::Function> func,
+                 bool rejected);
+  void MaybeSave(CompileCacheEntry* entry,
+                 v8::Local<v8::Module> mod,
+                 bool rejected);
+  std::string_view cache_dir() { return compile_cache_dir_; }
+
+ private:
+  void ReadCacheFile(CompileCacheEntry* entry);
+
+  template <typename T>
+  void MaybeSaveImpl(CompileCacheEntry* entry,
+                     v8::Local<T> func_or_mod,
+                     bool rejected);
+
+  template <typename... Args>
+  inline void Debug(const char* format, Args&&... args) const;
+
+  static constexpr size_t kMagicNumberOffset = 0;
+  static constexpr size_t kCodeSizeOffset = 1;
+  static constexpr size_t kCacheSizeOffset = 2;
+  static constexpr size_t kCodeHashOffset = 3;
+  static constexpr size_t kCacheHashOffset = 4;
+  static constexpr size_t kHeaderCount = 5;
+
+  v8::Isolate* isolate_ = nullptr;
+  bool is_debug_ = false;
+
+  std::string compile_cache_dir_;
+  std::unordered_map<uint32_t, std::unique_ptr<CompileCacheEntry>>
+      compiler_cache_store_;
+};
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_COMPILE_CACHE_H_

package/src/headers/{18 → 22}/crypto/crypto_clienthello.h

@@ -66,7 +66,7 @@ class ClientHelloParser {
   void Parse(const uint8_t* data, size_t avail);
 
   inline void Reset();
-  inline void Start(OnHelloCb onhello_cb, OnEndCb onend_cb, void* onend_arg);
+  inline void Start(OnHelloCb onhello_cb, OnEndCb onend_cb, void* cb_arg);
   inline void End();
   inline bool IsPaused() const;
   inline bool IsEnded() const;

package/src/headers/{18 → 22}/crypto/crypto_context.h

@@ -3,8 +3,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "crypto/crypto_util.h"
 #include "base_object.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "v8.h"
@@ -18,11 +19,10 @@ constexpr int kMaxSupportedVersion = TLS1_3_VERSION;
 void GetRootCertificates(
     const v8::FunctionCallbackInfo<v8::Value>& args);
 
-void IsExtraRootCertsFileLoaded(
-    const v8::FunctionCallbackInfo<v8::Value>& args);
-
 X509_STORE* NewRootCertStore();
 
+X509_STORE* GetOrCreateRootCertStore();
+
 BIOPointer LoadBIO(Environment* env, v8::Local<v8::Value> v);
 
 class SecureContext final : public BaseObject {
@@ -43,6 +43,10 @@ class SecureContext final : public BaseObject {
 
   const SSLCtxPointer& ctx() const { return ctx_; }
 
+  // Non-const ctx() that allows for non-default initialization of
+  // the SecureContext.
+  SSLCtxPointer& ctx() { return ctx_; }
+
   SSLPointer CreateSSL();
 
   void SetGetSessionCallback(GetSessionCb cb);
@@ -50,6 +54,19 @@ class SecureContext final : public BaseObject {
   void SetNewSessionCallback(NewSessionCb cb);
   void SetSelectSNIContextCallback(SelectSNIContextCb cb);
 
+  inline const X509Pointer& issuer() const { return issuer_; }
+  inline const X509Pointer& cert() const { return cert_; }
+
+  v8::Maybe<void> AddCert(Environment* env, BIOPointer&& bio);
+  v8::Maybe<void> SetCRL(Environment* env, const BIOPointer& bio);
+  v8::Maybe<void> UseKey(Environment* env, const KeyObjectData& key);
+
+  void SetCACert(const BIOPointer& bio);
+  void SetRootCerts();
+
+  void SetX509StoreFlag(unsigned long flags);  // NOLINT(runtime/int)
+  X509_STORE* GetCertStoreOwnedByThisSecureContext();
+
   // TODO(joyeecheung): track the memory used by OpenSSL types
   SET_NO_MEMORY_INFO()
   SET_MEMORY_INFO_NAME(SecureContext)
@@ -76,6 +93,8 @@ class SecureContext final : public BaseObject {
 #endif  // !OPENSSL_NO_ENGINE
   static void SetCert(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AddCACert(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAllowPartialTrustChain(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AddCRL(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AddRootCerts(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetCipherSuites(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -100,8 +119,6 @@ class SecureContext final : public BaseObject {
 #endif  // !OPENSSL_NO_ENGINE
   static void GetTicketKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetTicketKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetFreeListLength(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void EnableTicketKeyCallback(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CtxGetter(const v8::FunctionCallbackInfo<v8::Value>& info);
@@ -130,9 +147,11 @@ class SecureContext final : public BaseObject {
   SSLCtxPointer ctx_;
   X509Pointer cert_;
   X509Pointer issuer_;
+  // Non-owning cache for SSL_CTX_get_cert_store(ctx_.get())
+  X509_STORE* own_cert_store_cache_ = nullptr;
 #ifndef OPENSSL_NO_ENGINE
   bool client_cert_engine_provided_ = false;
-  EnginePointer private_key_engine_;
+  ncrypto::EnginePointer private_key_engine_;
 #endif  // !OPENSSL_NO_ENGINE
 
   unsigned char ticket_key_name_[16];
@@ -140,6 +159,11 @@ class SecureContext final : public BaseObject {
   unsigned char ticket_key_hmac_[16];
 };
 
+int SSL_CTX_use_certificate_chain(SSL_CTX* ctx,
+                                  BIOPointer&& in,
+                                  X509Pointer* cert,
+                                  X509Pointer* issuer);
+
 }  // namespace crypto
 }  // namespace node