@encharm/cws 4.4.1 → 4.5.2

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

@@ -1,94 +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_ASYNC_WRAP_INL_H_
-#define SRC_ASYNC_WRAP_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "base_object-inl.h"
-#include "node_internals.h"
-
-namespace node {
-
-inline AsyncWrap::ProviderType AsyncWrap::provider_type() const {
-  return provider_type_;
-}
-
-inline AsyncWrap::ProviderType AsyncWrap::set_provider_type(
-    AsyncWrap::ProviderType provider) {
-  provider_type_ = provider;
-  return provider_type_;
-}
-
-inline double AsyncWrap::get_async_id() const {
-  return async_id_;
-}
-
-
-inline double AsyncWrap::get_trigger_async_id() const {
-  return trigger_async_id_;
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::String> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  return MakeCallback(symbol.As<v8::Name>(), argc, argv);
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::Symbol> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  return MakeCallback(symbol.As<v8::Name>(), argc, argv);
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::Name> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  v8::Local<v8::Value> cb_v;
-  if (!object()->Get(env()->context(), symbol).ToLocal(&cb_v))
-    return v8::MaybeLocal<v8::Value>();
-  if (!cb_v->IsFunction()) {
-    v8::Isolate* isolate = env()->isolate();
-    return Undefined(isolate);
-  }
-  return MakeCallback(cb_v.As<v8::Function>(), argc, argv);
-}
-
-
-// Defined here to avoid a circular dependency with env-inl.h.
-inline AsyncHooks::DefaultTriggerAsyncIdScope ::DefaultTriggerAsyncIdScope(
-    AsyncWrap* async_wrap)
-    : DefaultTriggerAsyncIdScope(async_wrap->env(),
-                                 async_wrap->get_async_id()) {}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ASYNC_WRAP_INL_H_

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

@@ -1,189 +0,0 @@
-#ifndef SRC_BASE64_INL_H_
-#define SRC_BASE64_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base64.h"
-#include "util.h"
-
-namespace node {
-
-extern const int8_t unbase64_table[256];
-
-
-inline static int8_t unbase64(uint8_t x) {
-  return unbase64_table[x];
-}
-
-
-inline uint32_t ReadUint32BE(const unsigned char* p) {
-  return static_cast<uint32_t>(p[0] << 24U) |
-         static_cast<uint32_t>(p[1] << 16U) |
-         static_cast<uint32_t>(p[2] << 8U) |
-         static_cast<uint32_t>(p[3]);
-}
-
-#ifdef _MSC_VER
-#pragma warning(push)
-// MSVC C4003: not enough actual parameters for macro 'identifier'
-#pragma warning(disable : 4003)
-#endif
-
-template <typename TypeName>
-bool base64_decode_group_slow(char* const dst, const size_t dstlen,
-                              const TypeName* const src, const size_t srclen,
-                              size_t* const i, size_t* const k) {
-  uint8_t hi;
-  uint8_t lo;
-#define V(expr)                                                                \
-  for (;;) {                                                                   \
-    const uint8_t c = static_cast<uint8_t>(src[*i]);                           \
-    lo = unbase64(c);                                                          \
-    *i += 1;                                                                   \
-    if (lo < 64) break;                         /* Legal character. */         \
-    if (c == '=' || *i >= srclen) return false; /* Stop decoding. */           \
-  }                                                                            \
-  expr;                                                                        \
-  if (*i >= srclen) return false;                                              \
-  if (*k >= dstlen) return false;                                              \
-  hi = lo;
-  V(/* Nothing. */);
-  V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
-  V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));
-  V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));
-#undef V
-  return true;  // Continue decoding.
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-template <typename TypeName>
-size_t base64_decode_fast(char* const dst, const size_t dstlen,
-                          const TypeName* const src, const size_t srclen,
-                          const size_t decoded_size) {
-  const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
-  const size_t max_k = available / 3 * 3;
-  size_t max_i = srclen / 4 * 4;
-  size_t i = 0;
-  size_t k = 0;
-  while (i < max_i && k < max_k) {
-    const unsigned char txt[] = {
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
-    };
-
-    const uint32_t v = ReadUint32BE(txt);
-    // If MSB is set, input contains whitespace or is not valid base64.
-    if (v & 0x80808080) {
-      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
-        return k;
-      max_i = i + (srclen - i) / 4 * 4;  // Align max_i again.
-    } else {
-      dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03);
-      dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F);
-      dst[k + 2] = ((v >>  2) & 0xC0) | ((v >>  0) & 0x3F);
-      i += 4;
-      k += 3;
-    }
-  }
-  if (i < srclen && k < dstlen) {
-    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
-  }
-  return k;
-}
-
-
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName* src, size_t size) {
-  // 1-byte input cannot be decoded
-  if (size < 2)
-    return 0;
-
-  if (src[size - 1] == '=') {
-    size--;
-    if (src[size - 1] == '=')
-      size--;
-  }
-  return base64_decoded_size_fast(size);
-}
-
-
-template <typename TypeName>
-size_t base64_decode(char* const dst, const size_t dstlen,
-                     const TypeName* const src, const size_t srclen) {
-  const size_t decoded_size = base64_decoded_size(src, srclen);
-  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
-}
-
-
-inline size_t base64_encode(const char* src,
-                            size_t slen,
-                            char* dst,
-                            size_t dlen,
-                            Base64Mode mode) {
-  // We know how much we'll write, just make sure that there's space.
-  CHECK(dlen >= base64_encoded_size(slen, mode) &&
-        "not enough space provided for base64 encode");
-
-  dlen = base64_encoded_size(slen, mode);
-
-  unsigned a;
-  unsigned b;
-  unsigned c;
-  unsigned i;
-  unsigned k;
-  unsigned n;
-
-  const char* table = base64_select_table(mode);
-
-  i = 0;
-  k = 0;
-  n = slen / 3 * 3;
-
-  while (i < n) {
-    a = src[i + 0] & 0xff;
-    b = src[i + 1] & 0xff;
-    c = src[i + 2] & 0xff;
-
-    dst[k + 0] = table[a >> 2];
-    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
-    dst[k + 3] = table[c & 0x3f];
-
-    i += 3;
-    k += 4;
-  }
-
-  switch (slen - n) {
-    case 1:
-      a = src[i + 0] & 0xff;
-      dst[k + 0] = table[a >> 2];
-      dst[k + 1] = table[(a & 3) << 4];
-      if (mode == Base64Mode::NORMAL) {
-        dst[k + 2] = '=';
-        dst[k + 3] = '=';
-      }
-      break;
-    case 2:
-      a = src[i + 0] & 0xff;
-      b = src[i + 1] & 0xff;
-      dst[k + 0] = table[a >> 2];
-      dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-      dst[k + 2] = table[(b & 0x0f) << 2];
-      if (mode == Base64Mode::NORMAL)
-        dst[k + 3] = '=';
-      break;
-  }
-
-  return dlen;
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_BASE64_INL_H_

package/src/headers/16/base64.h

@@ -1,69 +0,0 @@
-#ifndef SRC_BASE64_H_
-#define SRC_BASE64_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "util.h"
-
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-
-namespace node {
-//// Base 64 ////
-
-enum class Base64Mode {
-  NORMAL,
-  URL
-};
-
-static constexpr char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                       "abcdefghijklmnopqrstuvwxyz"
-                                       "0123456789+/";
-
-static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                           "abcdefghijklmnopqrstuvwxyz"
-                                           "0123456789-_";
-
-static inline const char* base64_select_table(Base64Mode mode) {
-  switch (mode) {
-    case Base64Mode::NORMAL: return base64_table;
-    case Base64Mode::URL: return base64_table_url;
-    default: UNREACHABLE();
-  }
-}
-
-static inline constexpr size_t base64_encoded_size(
-    size_t size,
-    Base64Mode mode = Base64Mode::NORMAL) {
-  return mode == Base64Mode::NORMAL ? ((size + 2) / 3 * 4)
-                                    : static_cast<size_t>(std::ceil(
-                                          static_cast<double>(size * 4) / 3));
-}
-
-// Doesn't check for padding at the end.  Can be 1-2 bytes over.
-static inline constexpr size_t base64_decoded_size_fast(size_t size) {
-  // 1-byte input cannot be decoded
-  return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
-}
-
-inline uint32_t ReadUint32BE(const unsigned char* p);
-
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName* src, size_t size);
-
-template <typename TypeName>
-size_t base64_decode(char* const dst, const size_t dstlen,
-                     const TypeName* const src, const size_t srclen);
-
-inline size_t base64_encode(const char* src,
-                            size_t slen,
-                            char* dst,
-                            size_t dlen,
-                            Base64Mode mode = Base64Mode::NORMAL);
-}  // namespace node
-
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_BASE64_H_

package/src/headers/16/crypto/crypto_aes.h

@@ -1,89 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_AES_H_
-#define SRC_CRYPTO_CRYPTO_AES_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "crypto/crypto_cipher.h"
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
-#include "env.h"
-#include "v8.h"
-
-namespace node {
-namespace crypto {
-constexpr size_t kAesBlockSize = 16;
-constexpr unsigned kNoAuthTagLength = static_cast<unsigned>(-1);
-constexpr const char* kDefaultWrapIV = "\xa6\xa6\xa6\xa6\xa6\xa6\xa6\xa6";
-
-#define VARIANTS(V)                                                           \
-  V(CTR_128, AES_CTR_Cipher)                                                  \
-  V(CTR_192, AES_CTR_Cipher)                                                  \
-  V(CTR_256, AES_CTR_Cipher)                                                  \
-  V(CBC_128, AES_Cipher)                                                      \
-  V(CBC_192, AES_Cipher)                                                      \
-  V(CBC_256, AES_Cipher)                                                      \
-  V(GCM_128, AES_Cipher)                                                      \
-  V(GCM_192, AES_Cipher)                                                      \
-  V(GCM_256, AES_Cipher)                                                      \
-  V(KW_128, AES_Cipher)                                                       \
-  V(KW_192, AES_Cipher)                                                       \
-  V(KW_256, AES_Cipher)
-
-enum AESKeyVariant {
-#define V(name, _) kKeyVariantAES_ ## name,
-  VARIANTS(V)
-#undef V
-};
-
-struct AESCipherConfig final : public MemoryRetainer {
-  CryptoJobMode mode;
-  AESKeyVariant variant;
-  const EVP_CIPHER* cipher;
-  size_t length;
-  ByteSource iv;  // Used for both iv or counter
-  ByteSource additional_data;
-  ByteSource tag;  // Used only for authenticated modes (GCM)
-
-  AESCipherConfig() = default;
-
-  AESCipherConfig(AESCipherConfig&& other) noexcept;
-
-  AESCipherConfig& operator=(AESCipherConfig&& other) noexcept;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(AESCipherConfig)
-  SET_SELF_SIZE(AESCipherConfig)
-};
-
-struct AESCipherTraits final {
-  static constexpr const char* JobName = "AESCipherJob";
-
-  using AdditionalParameters = AESCipherConfig;
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int offset,
-      WebCryptoCipherMode cipher_mode,
-      AESCipherConfig* config);
-
-  static WebCryptoCipherStatus DoCipher(
-      Environment* env,
-      std::shared_ptr<KeyObjectData> key_data,
-      WebCryptoCipherMode cipher_mode,
-      const AESCipherConfig& params,
-      const ByteSource& in,
-      ByteSource* out);
-};
-
-using AESCryptoJob = CipherJob<AESCipherTraits>;
-
-namespace AES {
-void Initialize(Environment* env, v8::Local<v8::Object> target);
-}  // namespace AES
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_AES_H_