@encharm/cws 4.3.0 → 4.4.1

package/src/headers/20/crypto_clienthello.h

@@ -0,0 +1,131 @@
+// 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_CRYPTO_CRYPTO_CLIENTHELLO_H_
+#define SRC_CRYPTO_CRYPTO_CLIENTHELLO_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstddef>  // size_t
+#include <cstdint>
+
+namespace node {
+namespace crypto {
+// Parse the client hello so we can do async session resumption. OpenSSL's
+// session resumption uses synchronous callbacks, see SSL_CTX_sess_set_get_cb
+// and get_session_cb.
+//
+// TLS1.3 handshakes masquerade as TLS1.2 session resumption, and to do this,
+// they always include a session_id in the ClientHello, making up a bogus value
+// if necessary. The parser can't know if its a bogus id, and will cause a
+// 'newSession' event to be emitted. This should do no harm, the id won't be
+// found, and the handshake will continue.
+class ClientHelloParser {
+ public:
+  inline ClientHelloParser();
+
+  class ClientHello {
+   public:
+    inline uint8_t session_size() const { return session_size_; }
+    inline const uint8_t* session_id() const { return session_id_; }
+    inline bool has_ticket() const { return has_ticket_; }
+    inline uint8_t servername_size() const { return servername_size_; }
+    inline const uint8_t* servername() const { return servername_; }
+
+   private:
+    uint8_t session_size_;
+    const uint8_t* session_id_;
+    bool has_ticket_;
+    uint8_t servername_size_;
+    const uint8_t* servername_;
+
+    friend class ClientHelloParser;
+  };
+
+  typedef void (*OnHelloCb)(void* arg, const ClientHello& hello);
+  typedef void (*OnEndCb)(void* arg);
+
+  void Parse(const uint8_t* data, size_t avail);
+
+  inline void Reset();
+  inline void Start(OnHelloCb onhello_cb, OnEndCb onend_cb, void* cb_arg);
+  inline void End();
+  inline bool IsPaused() const;
+  inline bool IsEnded() const;
+
+ private:
+  static const size_t kMaxTLSFrameLen = 16 * 1024 + 5;
+  static const size_t kMaxSSLExFrameLen = 32 * 1024;
+  static const uint8_t kServernameHostname = 0;
+  static const size_t kMinStatusRequestSize = 5;
+
+  enum ParseState {
+    kWaiting,
+    kTLSHeader,
+    kPaused,
+    kEnded
+  };
+
+  enum FrameType {
+    kChangeCipherSpec = 20,
+    kAlert = 21,
+    kHandshake = 22,
+    kApplicationData = 23,
+    kOther = 255
+  };
+
+  enum HandshakeType {
+    kClientHello = 1
+  };
+
+  enum ExtensionType {
+    kServerName = 0,
+    kTLSSessionTicket = 35
+  };
+
+  bool ParseRecordHeader(const uint8_t* data, size_t avail);
+  void ParseHeader(const uint8_t* data, size_t avail);
+  void ParseExtension(const uint16_t type,
+                      const uint8_t* data,
+                      size_t len);
+  bool ParseTLSClientHello(const uint8_t* data, size_t avail);
+
+  ParseState state_;
+  OnHelloCb onhello_cb_;
+  OnEndCb onend_cb_;
+  void* cb_arg_;
+  size_t frame_len_ = 0;
+  size_t body_offset_ = 0;
+  size_t extension_offset_ = 0;
+  uint8_t session_size_ = 0;
+  const uint8_t* session_id_ = nullptr;
+  uint16_t servername_size_ = 0;
+  const uint8_t* servername_ = nullptr;
+  uint16_t tls_ticket_size_ = -1;
+  const uint8_t* tls_ticket_ = nullptr;
+};
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CRYPTO_CRYPTO_CLIENTHELLO_H_

package/src/headers/20/debug_utils-inl.h

@@ -0,0 +1,226 @@
+#ifndef SRC_DEBUG_UTILS_INL_H_
+#define SRC_DEBUG_UTILS_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "debug_utils.h"
+#include "env.h"
+
+#include <type_traits>
+
+namespace node {
+
+struct ToStringHelper {
+  template <typename T>
+  static std::string Convert(
+      const T& value,
+      std::string(T::* to_string)() const = &T::ToString) {
+    return (value.*to_string)();
+  }
+  template <typename T,
+            typename test_for_number = typename std::
+                enable_if<std::is_arithmetic<T>::value, bool>::type,
+            typename dummy = bool>
+  static std::string Convert(const T& value) { return std::to_string(value); }
+  static std::string Convert(const char* value) {
+    return value != nullptr ? value : "(null)";
+  }
+  static std::string Convert(const std::string& value) { return value; }
+  static std::string Convert(std::string_view value) {
+    return std::string(value);
+  }
+  static std::string Convert(bool value) { return value ? "true" : "false"; }
+  template <unsigned BASE_BITS,
+            typename T,
+            typename = std::enable_if_t<std::is_integral_v<T>>>
+  static std::string BaseConvert(const T& value) {
+    auto v = static_cast<uint64_t>(value);
+    char ret[3 * sizeof(T)];
+    char* ptr = ret + 3 * sizeof(T) - 1;
+    *ptr = '\0';
+    const char* digits = "0123456789abcdef";
+    do {
+      unsigned digit = v & ((1 << BASE_BITS) - 1);
+      *--ptr =
+          (BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit]);
+    } while ((v >>= BASE_BITS) != 0);
+    return ptr;
+  }
+  template <unsigned BASE_BITS,
+            typename T,
+            typename = std::enable_if_t<!std::is_integral_v<T>>>
+  static std::string BaseConvert(T value) {
+    return Convert(std::forward<T>(value));
+  }
+};
+
+template <typename T>
+std::string ToString(const T& value) {
+  return ToStringHelper::Convert(value);
+}
+
+template <unsigned BASE_BITS, typename T>
+std::string ToBaseString(const T& value) {
+  return ToStringHelper::BaseConvert<BASE_BITS>(value);
+}
+
+inline std::string SPrintFImpl(const char* format) {
+  const char* p = strchr(format, '%');
+  if (LIKELY(p == nullptr)) return format;
+  CHECK_EQ(p[1], '%');  // Only '%%' allowed when there are no arguments.
+
+  return std::string(format, p + 1) + SPrintFImpl(p + 2);
+}
+
+template <typename Arg, typename... Args>
+std::string COLD_NOINLINE SPrintFImpl(  // NOLINT(runtime/string)
+    const char* format, Arg&& arg, Args&&... args) {
+  const char* p = strchr(format, '%');
+  CHECK_NOT_NULL(p);  // If you hit this, you passed in too many arguments.
+  std::string ret(format, p);
+  // Ignore long / size_t modifiers
+  while (strchr("lz", *++p) != nullptr) {}
+  switch (*p) {
+    case '%': {
+      return ret + '%' + SPrintFImpl(p + 1,
+                                     std::forward<Arg>(arg),
+                                     std::forward<Args>(args)...);
+    }
+    default: {
+      return ret + '%' + SPrintFImpl(p,
+                                     std::forward<Arg>(arg),
+                                     std::forward<Args>(args)...);
+    }
+    case 'd':
+    case 'i':
+    case 'u':
+    case 's':
+      ret += ToString(arg);
+      break;
+    case 'o':
+      ret += ToBaseString<3>(arg);
+      break;
+    case 'x':
+      ret += ToBaseString<4>(arg);
+      break;
+    case 'X':
+      ret += node::ToUpper(ToBaseString<4>(arg));
+      break;
+    case 'p': {
+      CHECK(std::is_pointer<typename std::remove_reference<Arg>::type>::value);
+      char out[20];
+      int n = snprintf(out,
+                       sizeof(out),
+                       "%p",
+                       *reinterpret_cast<const void* const*>(&arg));
+      CHECK_GE(n, 0);
+      ret += out;
+      break;
+    }
+  }
+  return ret + SPrintFImpl(p + 1, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+std::string COLD_NOINLINE SPrintF(  // NOLINT(runtime/string)
+    const char* format, Args&&... args) {
+  return SPrintFImpl(format, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+void COLD_NOINLINE FPrintF(FILE* file, const char* format, Args&&... args) {
+  FWrite(file, SPrintF(format, std::forward<Args>(args)...));
+}
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* format,
+                               Args&&... args) {
+  if (!UNLIKELY(list->enabled(cat))) return;
+  FPrintF(stderr, format, std::forward<Args>(args)...);
+}
+
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* message) {
+  if (!UNLIKELY(list->enabled(cat))) return;
+  FPrintF(stderr, "%s", message);
+}
+
+template <typename... Args>
+inline void FORCE_INLINE
+Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args) {
+  Debug(env->enabled_debug_list(), cat, format, std::forward<Args>(args)...);
+}
+
+inline void FORCE_INLINE Debug(Environment* env,
+                               DebugCategory cat,
+                               const char* message) {
+  Debug(env->enabled_debug_list(), cat, message);
+}
+
+template <typename... Args>
+inline void Debug(Environment* env,
+                  DebugCategory cat,
+                  const std::string& format,
+                  Args&&... args) {
+  Debug(env->enabled_debug_list(),
+        cat,
+        format.c_str(),
+        std::forward<Args>(args)...);
+}
+
+// Used internally by the 'real' Debug(AsyncWrap*, ...) functions below, so that
+// the FORCE_INLINE flag on them doesn't apply to the contents of this function
+// as well.
+// We apply COLD_NOINLINE to tell the compiler that it's not worth optimizing
+// this function for speed and it should rather focus on keeping it out of
+// hot code paths. In particular, we want to keep the string concatenating code
+// out of the function containing the original `Debug()` call.
+template <typename... Args>
+void COLD_NOINLINE UnconditionalAsyncWrapDebug(AsyncWrap* async_wrap,
+                                               const char* format,
+                                               Args&&... args) {
+  Debug(async_wrap->env(),
+        static_cast<DebugCategory>(async_wrap->provider_type()),
+        async_wrap->diagnostic_name() + " " + format + "\n",
+        std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const char* format,
+                               Args&&... args) {
+  DCHECK_NOT_NULL(async_wrap);
+  DebugCategory cat = static_cast<DebugCategory>(async_wrap->provider_type());
+  if (!UNLIKELY(async_wrap->env()->enabled_debug_list()->enabled(cat))) return;
+  UnconditionalAsyncWrapDebug(async_wrap, format, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const std::string& format,
+                               Args&&... args) {
+  Debug(async_wrap, format.c_str(), std::forward<Args>(args)...);
+}
+
+namespace per_process {
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(DebugCategory cat,
+                               const char* format,
+                               Args&&... args) {
+  Debug(&enabled_debug_list, cat, format, std::forward<Args>(args)...);
+}
+
+inline void FORCE_INLINE Debug(DebugCategory cat, const char* message) {
+  Debug(&enabled_debug_list, cat, message);
+}
+
+}  // namespace per_process
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DEBUG_UTILS_INL_H_

package/src/headers/20/debug_utils.h

@@ -0,0 +1,188 @@
+#ifndef SRC_DEBUG_UTILS_H_
+#define SRC_DEBUG_UTILS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "util.h"
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+// Use FORCE_INLINE on functions that have a debug-category-enabled check first
+// and then ideally only a single function call following it, to maintain
+// performance for the common case (no debugging used).
+#ifdef __GNUC__
+#define FORCE_INLINE __attribute__((always_inline))
+#define COLD_NOINLINE __attribute__((cold, noinline))
+#else
+#define FORCE_INLINE
+#define COLD_NOINLINE
+#endif
+
+namespace node {
+class Environment;
+
+template <typename T>
+inline std::string ToString(const T& value);
+
+// C++-style variant of sprintf()/fprintf() that:
+// - Returns an std::string
+// - Handles \0 bytes correctly
+// - Supports %p and %s. %d, %i and %u are aliases for %s.
+// - Accepts any class that has a ToString() method for stringification.
+template <typename... Args>
+inline std::string SPrintF(const char* format, Args&&... args);
+template <typename... Args>
+inline void FPrintF(FILE* file, const char* format, Args&&... args);
+void NODE_EXTERN_PRIVATE FWrite(FILE* file, const std::string& str);
+
+// Listing the AsyncWrap provider types first enables us to cast directly
+// from a provider type to a debug category.
+#define DEBUG_CATEGORY_NAMES(V)                                                \
+  NODE_ASYNC_PROVIDER_TYPES(V)                                                 \
+  V(DIAGNOSTICS)                                                               \
+  V(HUGEPAGES)                                                                 \
+  V(INSPECTOR_SERVER)                                                          \
+  V(INSPECTOR_PROFILER)                                                        \
+  V(CODE_CACHE)                                                                \
+  V(NGTCP2_DEBUG)                                                              \
+  V(SEA)                                                                       \
+  V(WASI)                                                                      \
+  V(MKSNAPSHOT)                                                                \
+  V(SNAPSHOT_SERDES)                                                           \
+  V(PERMISSION_MODEL)
+
+enum class DebugCategory : unsigned int {
+#define V(name) name,
+  DEBUG_CATEGORY_NAMES(V)
+#undef V
+};
+
+#define V(name) +1
+constexpr unsigned int kDebugCategoryCount = DEBUG_CATEGORY_NAMES(V);
+#undef V
+
+class NODE_EXTERN_PRIVATE EnabledDebugList {
+ public:
+  bool FORCE_INLINE enabled(DebugCategory category) const {
+    DCHECK_LT(static_cast<unsigned int>(category), kDebugCategoryCount);
+    return enabled_[static_cast<unsigned int>(category)];
+  }
+
+  // Uses NODE_DEBUG_NATIVE to initialize the categories. The env_vars variable
+  // is parsed if it is not a nullptr, otherwise the system environment
+  // variables are parsed.
+  void Parse(std::shared_ptr<KVStore> env_vars = nullptr,
+             v8::Isolate* isolate = nullptr);
+
+ private:
+  // Enable all categories matching cats.
+  void Parse(const std::string& cats);
+  void set_enabled(DebugCategory category) {
+    DCHECK_LT(static_cast<unsigned int>(category), kDebugCategoryCount);
+    enabled_[static_cast<int>(category)] = true;
+  }
+
+  bool enabled_[kDebugCategoryCount] = {false};
+};
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* format,
+                               Args&&... args);
+
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* message);
+
+template <typename... Args>
+inline void FORCE_INLINE
+Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args);
+
+inline void FORCE_INLINE Debug(Environment* env,
+                               DebugCategory cat,
+                               const char* message);
+
+template <typename... Args>
+inline void Debug(Environment* env,
+                  DebugCategory cat,
+                  const std::string& format,
+                  Args&&... args);
+
+// Used internally by the 'real' Debug(AsyncWrap*, ...) functions below, so that
+// the FORCE_INLINE flag on them doesn't apply to the contents of this function
+// as well.
+// We apply COLD_NOINLINE to tell the compiler that it's not worth optimizing
+// this function for speed and it should rather focus on keeping it out of
+// hot code paths. In particular, we want to keep the string concatenating code
+// out of the function containing the original `Debug()` call.
+template <typename... Args>
+void COLD_NOINLINE UnconditionalAsyncWrapDebug(AsyncWrap* async_wrap,
+                                               const char* format,
+                                               Args&&... args);
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const char* format,
+                               Args&&... args);
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const std::string& format,
+                               Args&&... args);
+
+// Debug helper for inspecting the currently running `node` executable.
+class NativeSymbolDebuggingContext {
+ public:
+  static std::unique_ptr<NativeSymbolDebuggingContext> New();
+
+  class SymbolInfo {
+   public:
+    std::string name;
+    std::string filename;
+    size_t line = 0;
+    size_t dis = 0;
+
+    std::string Display() const;
+  };
+
+  NativeSymbolDebuggingContext() = default;
+  virtual ~NativeSymbolDebuggingContext() = default;
+
+  virtual SymbolInfo LookupSymbol(void* address) { return {}; }
+  virtual bool IsMapped(void* address) { return false; }
+  virtual int GetStackTrace(void** frames, int count) { return 0; }
+
+  NativeSymbolDebuggingContext(const NativeSymbolDebuggingContext&) = delete;
+  NativeSymbolDebuggingContext(NativeSymbolDebuggingContext&&) = delete;
+  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&)
+    = delete;
+  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&&)
+    = delete;
+  static std::vector<std::string> GetLoadedLibraries();
+};
+
+// Variant of `uv_loop_close` that tries to be as helpful as possible
+// about giving information on currently existing handles, if there are any,
+// but still aborts the process.
+void CheckedUvLoopClose(uv_loop_t* loop);
+void PrintLibuvHandleInformation(uv_loop_t* loop, FILE* stream);
+
+namespace per_process {
+extern NODE_EXTERN_PRIVATE EnabledDebugList enabled_debug_list;
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(DebugCategory cat,
+                               const char* format,
+                               Args&&... args);
+
+inline void FORCE_INLINE Debug(DebugCategory cat, const char* message);
+}  // namespace per_process
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DEBUG_UTILS_H_

package/src/headers/20/diagnosticfilename-inl.h

@@ -0,0 +1,33 @@
+#ifndef SRC_DIAGNOSTICFILENAME_INL_H_
+#define SRC_DIAGNOSTICFILENAME_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+namespace node {
+
+class Environment;
+
+inline DiagnosticFilename::DiagnosticFilename(
+    Environment* env,
+    const char* prefix,
+    const char* ext) :
+  filename_(MakeFilename(env->thread_id(), prefix, ext)) {
+}
+
+inline DiagnosticFilename::DiagnosticFilename(
+    uint64_t thread_id,
+    const char* prefix,
+    const char* ext) :
+  filename_(MakeFilename(thread_id, prefix, ext)) {
+}
+
+inline const char* DiagnosticFilename::operator*() const {
+  return filename_.c_str();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DIAGNOSTICFILENAME_INL_H_

package/src/headers/20/encoding_binding.h

@@ -0,0 +1,59 @@
+#ifndef SRC_ENCODING_BINDING_H_
+#define SRC_ENCODING_BINDING_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "aliased_buffer.h"
+#include "node_snapshotable.h"
+#include "v8-fast-api-calls.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace encoding_binding {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex encode_into_results_buffer;
+  };
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(encoding_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void EncodeInto(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EncodeUtf8String(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DecodeUTF8(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void ToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static constexpr size_t kEncodeIntoResultsLength = 2;
+  AliasedUint32Array encode_into_results_buffer_;
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+
+}  // namespace encoding_binding
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ENCODING_BINDING_H_