Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/nodejs/node.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--node.gyp2
-rw-r--r--src/allocated_buffer-inl.h110
-rw-r--r--src/allocated_buffer.h63
-rw-r--r--src/env-inl.h88
-rw-r--r--src/env.cc2
-rw-r--r--src/env.h37
-rw-r--r--src/inspector_io.cc1
-rw-r--r--src/node.cc1
-rw-r--r--src/node_buffer.cc13
-rw-r--r--src/node_crypto.cc37
-rw-r--r--src/node_crypto.h1
-rw-r--r--src/node_crypto_bio.cc1
-rw-r--r--src/node_crypto_common.cc7
-rw-r--r--src/node_http2.cc14
-rw-r--r--src/node_http2.h1
-rw-r--r--src/stream_base-inl.h1
-rw-r--r--src/stream_base.cc9
-rw-r--r--src/stream_base.h1
-rw-r--r--src/stream_pipe.cc3
-rw-r--r--src/stream_pipe.h1
-rw-r--r--src/tls_wrap.cc5
-rw-r--r--src/tls_wrap.h1
-rw-r--r--src/udp_wrap.cc3
23 files changed, 241 insertions, 161 deletions
diff --git a/node.gyp b/node.gyp
index b0927572312..94b6846b2de 100644
--- a/node.gyp
+++ b/node.gyp
@@ -643,6 +643,8 @@
'src/aliased_buffer.h',
'src/aliased_struct.h',
'src/aliased_struct-inl.h',
+ 'src/allocated_buffer.h',
+ 'src/allocated_buffer-inl.h'
'src/async_wrap.h',
'src/async_wrap-inl.h',
'src/base_object.h',
diff --git a/src/allocated_buffer-inl.h b/src/allocated_buffer-inl.h
new file mode 100644
index 00000000000..22956b2f2c1
--- /dev/null
+++ b/src/allocated_buffer-inl.h
@@ -0,0 +1,110 @@
+#ifndef SRC_ALLOCATED_BUFFER_INL_H_
+#define SRC_ALLOCATED_BUFFER_INL_H_
+
+#include "allocated_buffer.h"
+#include "base_object-inl.h"
+#include "node_buffer.h"
+#include "env-inl.h"
+#include "uv.h"
+#include "v8.h"
+#include "util-inl.h"
+#include "node_internals.h"
+
+namespace node {
+
+AllocatedBuffer AllocatedBuffer::AllocateManaged(
+ Environment* env,
+ size_t size,
+ int flags) {
+ char* data = flags & ALLOCATE_MANAGED_UNCHECKED ?
+ env->AllocateUnchecked(size) :
+ env->Allocate(size);
+ if (data == nullptr) size = 0;
+ return AllocatedBuffer(env, uv_buf_init(data, size));
+}
+
+inline AllocatedBuffer::AllocatedBuffer(Environment* env, uv_buf_t buf)
+ : env_(env), buffer_(buf) {}
+
+inline void AllocatedBuffer::Resize(size_t len) {
+ // The `len` check is to make sure we don't end up with `nullptr` as our base.
+ char* new_data = env_->Reallocate(buffer_.base, buffer_.len,
+ len > 0 ? len : 1);
+ CHECK_NOT_NULL(new_data);
+ buffer_ = uv_buf_init(new_data, len);
+}
+
+inline uv_buf_t AllocatedBuffer::release() {
+ uv_buf_t ret = buffer_;
+ buffer_ = uv_buf_init(nullptr, 0);
+ return ret;
+}
+
+inline char* AllocatedBuffer::data() {
+ return buffer_.base;
+}
+
+inline const char* AllocatedBuffer::data() const {
+ return buffer_.base;
+}
+
+inline size_t AllocatedBuffer::size() const {
+ return buffer_.len;
+}
+
+inline AllocatedBuffer::AllocatedBuffer(Environment* env)
+ : env_(env), buffer_(uv_buf_init(nullptr, 0)) {}
+
+inline AllocatedBuffer::AllocatedBuffer(AllocatedBuffer&& other)
+ : AllocatedBuffer() {
+ *this = std::move(other);
+}
+
+inline AllocatedBuffer& AllocatedBuffer::operator=(AllocatedBuffer&& other) {
+ clear();
+ env_ = other.env_;
+ buffer_ = other.release();
+ return *this;
+}
+
+inline AllocatedBuffer::~AllocatedBuffer() {
+ clear();
+}
+
+inline void AllocatedBuffer::clear() {
+ uv_buf_t buf = release();
+ if (buf.base != nullptr) {
+ CHECK_NOT_NULL(env_);
+ env_->Free(buf.base, buf.len);
+ }
+}
+
+inline v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
+ CHECK_NOT_NULL(env_);
+ v8::MaybeLocal<v8::Object> obj = Buffer::New(env_, data(), size(), false);
+ if (!obj.IsEmpty()) release();
+ return obj;
+}
+
+inline v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
+ CHECK_NOT_NULL(env_);
+ uv_buf_t buf = release();
+ auto callback = [](void* data, size_t length, void* deleter_data){
+ CHECK_NOT_NULL(deleter_data);
+
+ static_cast<v8::ArrayBuffer::Allocator*>(deleter_data)
+ ->Free(data, length);
+ };
+ std::unique_ptr<v8::BackingStore> backing =
+ v8::ArrayBuffer::NewBackingStore(buf.base,
+ buf.len,
+ callback,
+ env_->isolate()
+ ->GetArrayBufferAllocator());
+ return v8::ArrayBuffer::New(env_->isolate(),
+ std::move(backing));
+}
+
+} // namespace node
+
+#endif // SRC_ALLOCATED_BUFFER_INL_H_
diff --git a/src/allocated_buffer.h b/src/allocated_buffer.h
new file mode 100644
index 00000000000..b54f74b2d27
--- /dev/null
+++ b/src/allocated_buffer.h
@@ -0,0 +1,63 @@
+#ifndef SRC_ALLOCATED_BUFFER_H_
+#define SRC_ALLOCATED_BUFFER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "uv.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+
+// A unique-pointer-ish object that is compatible with the JS engine's
+// ArrayBuffer::Allocator.
+struct AllocatedBuffer {
+ public:
+ enum AllocateManagedFlags {
+ ALLOCATE_MANAGED_FLAG_NONE,
+ ALLOCATE_MANAGED_UNCHECKED
+ };
+
+ // Utilities that allocate memory using the Isolate's ArrayBuffer::Allocator.
+ // In particular, using AllocateManaged() will provide a RAII-style object
+ // with easy conversion to `Buffer` and `ArrayBuffer` objects.
+ inline static AllocatedBuffer AllocateManaged(
+ Environment* env,
+ size_t size,
+ int flags = ALLOCATE_MANAGED_FLAG_NONE);
+
+ explicit inline AllocatedBuffer(Environment* env = nullptr);
+ inline AllocatedBuffer(Environment* env, uv_buf_t buf);
+ inline ~AllocatedBuffer();
+ inline void Resize(size_t len);
+
+ inline uv_buf_t release();
+ inline char* data();
+ inline const char* data() const;
+ inline size_t size() const;
+ inline void clear();
+
+ inline v8::MaybeLocal<v8::Object> ToBuffer();
+ inline v8::Local<v8::ArrayBuffer> ToArrayBuffer();
+
+ inline AllocatedBuffer(AllocatedBuffer&& other);
+ inline AllocatedBuffer& operator=(AllocatedBuffer&& other);
+ AllocatedBuffer(const AllocatedBuffer& other) = delete;
+ AllocatedBuffer& operator=(const AllocatedBuffer& other) = delete;
+
+ private:
+ Environment* env_;
+ // We do not pass this to libuv directly, but uv_buf_t is a convenient way
+ // to represent a chunk of memory, and plays nicely with other parts of core.
+ uv_buf_t buffer_;
+
+ friend class Environment;
+};
+
+} // namespace node
+
+#endif // NODE_WANT_INTERNALS
+
+#endif // SRC_ALLOCATED_BUFFER_H_
diff --git a/src/env-inl.h b/src/env-inl.h
index 97ccc24f809..3afda388bc9 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -883,68 +883,6 @@ inline void Environment::Free(char* data, size_t size) {
isolate_data()->allocator()->Free(data, size);
}
-inline AllocatedBuffer Environment::AllocateManaged(size_t size, bool checked) {
- char* data = checked ? Allocate(size) : AllocateUnchecked(size);
- if (data == nullptr) size = 0;
- return AllocatedBuffer(this, uv_buf_init(data, size));
-}
-
-inline AllocatedBuffer::AllocatedBuffer(Environment* env, uv_buf_t buf)
- : env_(env), buffer_(buf) {}
-
-inline void AllocatedBuffer::Resize(size_t len) {
- // The `len` check is to make sure we don't end up with `nullptr` as our base.
- char* new_data = env_->Reallocate(buffer_.base, buffer_.len,
- len > 0 ? len : 1);
- CHECK_NOT_NULL(new_data);
- buffer_ = uv_buf_init(new_data, len);
-}
-
-inline uv_buf_t AllocatedBuffer::release() {
- uv_buf_t ret = buffer_;
- buffer_ = uv_buf_init(nullptr, 0);
- return ret;
-}
-
-inline char* AllocatedBuffer::data() {
- return buffer_.base;
-}
-
-inline const char* AllocatedBuffer::data() const {
- return buffer_.base;
-}
-
-inline size_t AllocatedBuffer::size() const {
- return buffer_.len;
-}
-
-inline AllocatedBuffer::AllocatedBuffer(Environment* env)
- : env_(env), buffer_(uv_buf_init(nullptr, 0)) {}
-
-inline AllocatedBuffer::AllocatedBuffer(AllocatedBuffer&& other)
- : AllocatedBuffer() {
- *this = std::move(other);
-}
-
-inline AllocatedBuffer& AllocatedBuffer::operator=(AllocatedBuffer&& other) {
- clear();
- env_ = other.env_;
- buffer_ = other.release();
- return *this;
-}
-
-inline AllocatedBuffer::~AllocatedBuffer() {
- clear();
-}
-
-inline void AllocatedBuffer::clear() {
- uv_buf_t buf = release();
- if (buf.base != nullptr) {
- CHECK_NOT_NULL(env_);
- env_->Free(buf.base, buf.len);
- }
-}
-
// It's a bit awkward to define this Buffer::New() overload here, but it
// avoids a circular dependency with node_internals.h.
namespace Buffer {
@@ -954,32 +892,6 @@ v8::MaybeLocal<v8::Object> New(Environment* env,
bool uses_malloc);
}
-inline v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
- CHECK_NOT_NULL(env_);
- v8::MaybeLocal<v8::Object> obj = Buffer::New(env_, data(), size(), false);
- if (!obj.IsEmpty()) release();
- return obj;
-}
-
-inline v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
- CHECK_NOT_NULL(env_);
- uv_buf_t buf = release();
- auto callback = [](void* data, size_t length, void* deleter_data){
- CHECK_NOT_NULL(deleter_data);
-
- static_cast<v8::ArrayBuffer::Allocator*>(deleter_data)
- ->Free(data, length);
- };
- std::unique_ptr<v8::BackingStore> backing =
- v8::ArrayBuffer::NewBackingStore(buf.base,
- buf.len,
- callback,
- env_->isolate()
- ->GetArrayBufferAllocator());
- return v8::ArrayBuffer::New(env_->isolate(),
- std::move(backing));
-}
-
inline void Environment::ThrowError(const char* errmsg) {
ThrowError(v8::Exception::Error, errmsg);
}
diff --git a/src/env.cc b/src/env.cc
index 4e7c975902b..a28679728e5 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -1,5 +1,5 @@
#include "env.h"
-
+#include "allocated_buffer-inl.h"
#include "async_wrap.h"
#include "base_object-inl.h"
#include "debug_utils-inl.h"
diff --git a/src/env.h b/src/env.h
index 1ef085ee867..eb6e63dc3fc 100644
--- a/src/env.h
+++ b/src/env.h
@@ -472,6 +472,7 @@ constexpr size_t kFsStatsBufferLength =
V(url_constructor_function, v8::Function)
class Environment;
+struct AllocatedBuffer;
class IsolateData : public MemoryRetainer {
public:
@@ -558,38 +559,6 @@ struct ContextInfo {
class EnabledDebugList;
-// A unique-pointer-ish object that is compatible with the JS engine's
-// ArrayBuffer::Allocator.
-struct AllocatedBuffer {
- public:
- explicit inline AllocatedBuffer(Environment* env = nullptr);
- inline AllocatedBuffer(Environment* env, uv_buf_t buf);
- inline ~AllocatedBuffer();
- inline void Resize(size_t len);
-
- inline uv_buf_t release();
- inline char* data();
- inline const char* data() const;
- inline size_t size() const;
- inline void clear();
-
- inline v8::MaybeLocal<v8::Object> ToBuffer();
- inline v8::Local<v8::ArrayBuffer> ToArrayBuffer();
-
- inline AllocatedBuffer(AllocatedBuffer&& other);
- inline AllocatedBuffer& operator=(AllocatedBuffer&& other);
- AllocatedBuffer(const AllocatedBuffer& other) = delete;
- AllocatedBuffer& operator=(const AllocatedBuffer& other) = delete;
-
- private:
- Environment* env_;
- // We do not pass this to libuv directly, but uv_buf_t is a convenient way
- // to represent a chunk of memory, and plays nicely with other parts of core.
- uv_buf_t buffer_;
-
- friend class Environment;
-};
-
class KVStore {
public:
KVStore() = default;
@@ -957,10 +926,6 @@ class Environment : public MemoryRetainer {
inline IsolateData* isolate_data() const;
- // Utilities that allocate memory using the Isolate's ArrayBuffer::Allocator.
- // In particular, using AllocateManaged() will provide a RAII-style object
- // with easy conversion to `Buffer` and `ArrayBuffer` objects.
- inline AllocatedBuffer AllocateManaged(size_t size, bool checked = true);
inline char* Allocate(size_t size);
inline char* AllocateUnchecked(size_t size);
char* Reallocate(char* data, size_t old_size, size_t size);
diff --git a/src/inspector_io.cc b/src/inspector_io.cc
index 75290317d2f..d3bd1911214 100644
--- a/src/inspector_io.cc
+++ b/src/inspector_io.cc
@@ -3,6 +3,7 @@
#include "inspector_socket_server.h"
#include "inspector/main_thread_interface.h"
#include "inspector/node_string.h"
+#include "allocated_buffer-inl.h" // Inlined functions needed by node_crypto.h.
#include "base_object-inl.h"
#include "debug_utils-inl.h"
#include "node.h"
diff --git a/src/node.cc b/src/node.cc
index bc8017bdd06..3895b2b4076 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -41,6 +41,7 @@
#include "node_version.h"
#if HAVE_OPENSSL
+#include "allocated_buffer-inl.h" // Inlined functions needed by node_crypto.h
#include "node_crypto.h"
#endif
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index fd20415936e..398d5860849 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -20,6 +20,7 @@
// USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "node_buffer.h"
+#include "allocated_buffer-inl.h"
#include "node.h"
#include "node_errors.h"
#include "node_internals.h"
@@ -350,7 +351,10 @@ MaybeLocal<Object> New(Environment* env, size_t length) {
AllocatedBuffer ret(env);
if (length > 0) {
- ret = env->AllocateManaged(length, false);
+ ret = AllocatedBuffer::AllocateManaged(
+ env,
+ length,
+ AllocatedBuffer::ALLOCATE_MANAGED_UNCHECKED);
if (ret.data() == nullptr) {
THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
return Local<Object>();
@@ -387,7 +391,10 @@ MaybeLocal<Object> Copy(Environment* env, const char* data, size_t length) {
AllocatedBuffer ret(env);
if (length > 0) {
CHECK_NOT_NULL(data);
- ret = env->AllocateManaged(length, false);
+ ret = AllocatedBuffer::AllocateManaged(
+ env,
+ length,
+ AllocatedBuffer::ALLOCATE_MANAGED_UNCHECKED);
if (ret.data() == nullptr) {
THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
return Local<Object>();
@@ -1107,7 +1114,7 @@ static void EncodeUtf8String(const FunctionCallbackInfo<Value>& args) {
Local<String> str = args[0].As<String>();
size_t length = str->Utf8Length(isolate);
- AllocatedBuffer buf = env->AllocateManaged(length);
+ AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, length);
str->WriteUtf8(isolate,
buf.data(),
-1, // We are certain that `data` is sufficiently large
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 22d8f663398..fe9ac2d0cbf 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -28,6 +28,7 @@
#include "node_errors.h"
#include "node_mutex.h"
#include "node_process.h"
+#include "allocated_buffer-inl.h"
#include "tls_wrap.h" // TLSWrap
#include "async_wrap-inl.h"
@@ -1918,7 +1919,7 @@ void SSLWrap<Base>::GetFinished(const FunctionCallbackInfo<Value>& args) {
if (len == 0)
return;
- AllocatedBuffer buf = env->AllocateManaged(len);
+ AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, len);
CHECK_EQ(len, SSL_get_finished(w->ssl_.get(), buf.data(), len));
args.GetReturnValue().Set(buf.ToBuffer().ToLocalChecked());
}
@@ -1941,7 +1942,7 @@ void SSLWrap<Base>::GetPeerFinished(const FunctionCallbackInfo<Value>& args) {
if (len == 0)
return;
- AllocatedBuffer buf = env->AllocateManaged(len);
+ AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, len);
CHECK_EQ(len, SSL_get_peer_finished(w->ssl_.get(), buf.data(), len));
args.GetReturnValue().Set(buf.ToBuffer().ToLocalChecked());
}
@@ -1962,7 +1963,7 @@ void SSLWrap<Base>::GetSession(const FunctionCallbackInfo<Value>& args) {
if (slen <= 0)
return; // Invalid or malformed session.
- AllocatedBuffer sbuf = env->AllocateManaged(slen);
+ AllocatedBuffer sbuf = AllocatedBuffer::AllocateManaged(env, slen);
unsigned char* p = reinterpret_cast<unsigned char*>(sbuf.data());
CHECK_LT(0, i2d_SSL_SESSION(sess, &p));
args.GetReturnValue().Set(sbuf.ToBuffer().ToLocalChecked());
@@ -2272,7 +2273,7 @@ void SSLWrap<Base>::ExportKeyingMaterial(
uint32_t olen = args[0].As<Uint32>()->Value();
node::Utf8Value label(env->isolate(), args[1]);
- AllocatedBuffer out = env->AllocateManaged(olen);
+ AllocatedBuffer out = AllocatedBuffer::AllocateManaged(env, olen);
ByteSource context;
bool use_context = !args[2]->IsUndefined();
@@ -3950,7 +3951,7 @@ CipherBase::UpdateResult CipherBase::Update(const char* data,
return kErrorState;
}
- *out = env()->AllocateManaged(buf_len);
+ *out = AllocatedBuffer::AllocateManaged(env(), buf_len);
int r = EVP_CipherUpdate(ctx_.get(),
reinterpret_cast<unsigned char*>(out->data()),
&buf_len,
@@ -4014,7 +4015,8 @@ bool CipherBase::Final(AllocatedBuffer* out) {
const int mode = EVP_CIPHER_CTX_mode(ctx_.get());
- *out = env()->AllocateManaged(
+ *out = AllocatedBuffer::AllocateManaged(
+ env(),
static_cast<size_t>(EVP_CIPHER_CTX_block_size(ctx_.get())));
if (kind_ == kDecipher && IsSupportedAuthenticatedMode(ctx_.get())) {
@@ -4535,7 +4537,7 @@ static AllocatedBuffer ConvertSignatureToP1363(Environment* env,
if (!asn1_sig)
return AllocatedBuffer();
- AllocatedBuffer buf = env->AllocateManaged(2 * n);
+ AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, 2 * n);
unsigned char* data = reinterpret_cast<unsigned char*>(buf.data());
const BIGNUM* r = ECDSA_SIG_get0_r(asn1_sig.get());
@@ -4594,7 +4596,7 @@ static AllocatedBuffer Node_SignFinal(Environment* env,
int signed_sig_len = EVP_PKEY_size(pkey.get());
CHECK_GE(signed_sig_len, 0);
size_t sig_len = static_cast<size_t>(signed_sig_len);
- AllocatedBuffer sig = env->AllocateManaged(sig_len);
+ AllocatedBuffer sig = AllocatedBuffer::AllocateManaged(env, sig_len);
EVPKeyCtxPointer pkctx(EVP_PKEY_CTX_new(pkey.get(), nullptr));
if (pkctx &&
@@ -4755,7 +4757,7 @@ void SignOneShot(const FunctionCallbackInfo<Value>& args) {
if (!EVP_DigestSign(mdctx.get(), nullptr, &sig_len, input, data.length()))
return CheckThrow(env, SignBase::Error::kSignPrivateKey);
- AllocatedBuffer signature = env->AllocateManaged(sig_len);
+ AllocatedBuffer signature = AllocatedBuffer::AllocateManaged(env, sig_len);
if (!EVP_DigestSign(mdctx.get(),
reinterpret_cast<unsigned char*>(signature.data()),
&sig_len,
@@ -5012,7 +5014,7 @@ bool PublicKeyCipher::Cipher(Environment* env,
if (EVP_PKEY_cipher(ctx.get(), nullptr, &out_len, data, len) <= 0)
return false;
- *out = env->AllocateManaged(out_len);
+ *out = AllocatedBuffer::AllocateManaged(env, out_len);
if (EVP_PKEY_cipher(ctx.get(),
reinterpret_cast<unsigned char*>(out->data()),
@@ -5264,7 +5266,7 @@ void DiffieHellman::GenerateKeys(const FunctionCallbackInfo<Value>& args) {
DH_get0_key(diffieHellman->dh_.get(), &pub_key, nullptr);
const int size = BN_num_bytes(pub_key);
CHECK_GE(size, 0);
- AllocatedBuffer data = env->AllocateManaged(size);
+ AllocatedBuffer data = AllocatedBuffer::AllocateManaged(env, size);
CHECK_EQ(size,
BN_bn2binpad(
pub_key, reinterpret_cast<unsigned char*>(data.data()), size));
@@ -5285,7 +5287,7 @@ void DiffieHellman::GetField(const FunctionCallbackInfo<Value>& args,
const int size = BN_num_bytes(num);
CHECK_GE(size, 0);
- AllocatedBuffer data = env->AllocateManaged(size);
+ AllocatedBuffer data = AllocatedBuffer::AllocateManaged(env, size);
CHECK_EQ(
size,
BN_bn2binpad(num, reinterpret_cast<unsigned char*>(data.data()), size));
@@ -5355,7 +5357,8 @@ void DiffieHellman::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
ArrayBufferViewContents<unsigned char> key_buf(args[0].As<ArrayBufferView>());
BignumPointer key(BN_bin2bn(key_buf.data(), key_buf.length(), nullptr));
- AllocatedBuffer ret = env->AllocateManaged(DH_size(diffieHellman->dh_.get()));
+ AllocatedBuffer ret =
+ AllocatedBuffer::AllocateManaged(env, DH_size(diffieHellman->dh_.get()));
int size = DH_compute_key(reinterpret_cast<unsigned char*>(ret.data()),
key.get(),
@@ -5561,7 +5564,7 @@ void ECDH::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
// NOTE: field_size is in bits
int field_size = EC_GROUP_get_degree(ecdh->group_);
size_t out_len = (field_size + 7) / 8;
- AllocatedBuffer out = env->AllocateManaged(out_len);
+ AllocatedBuffer out = AllocatedBuffer::AllocateManaged(env, out_len);
int r = ECDH_compute_key(
out.data(), out_len, pub.get(), ecdh->key_.get(), nullptr);
@@ -5610,7 +5613,7 @@ void ECDH::GetPrivateKey(const FunctionCallbackInfo<Value>& args) {
return env->ThrowError("Failed to get ECDH private key");
const int size = BN_num_bytes(b);
- AllocatedBuffer out = env->AllocateManaged(size);
+ AllocatedBuffer out = AllocatedBuffer::AllocateManaged(env, size);
CHECK_EQ(size, BN_bn2binpad(b,
reinterpret_cast<unsigned char*>(out.data()),
size));
@@ -6595,7 +6598,7 @@ AllocatedBuffer ExportPublicKey(Environment* env,
BIO_get_mem_ptr(bio.get(), &ptr);
*size = ptr->length;
- AllocatedBuffer buf = env->AllocateManaged(*size);
+ AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, *size);
memcpy(buf.data(), ptr->data, *size);
return buf;
@@ -6704,7 +6707,7 @@ AllocatedBuffer StatelessDiffieHellman(Environment* env, ManagedEVPPKey our_key,
EVP_PKEY_derive(ctx.get(), nullptr, &out_size) <= 0)
return AllocatedBuffer();
- AllocatedBuffer result = env->AllocateManaged(out_size);
+ AllocatedBuffer result = AllocatedBuffer::AllocateManaged(env, out_size);
CHECK_NOT_NULL(result.data());
unsigned char* data = reinterpret_cast<unsigned char*>(result.data());
diff --git a/src/node_crypto.h b/src/node_crypto.h
index 772a34a7da7..1eea1239f19 100644
--- a/src/node_crypto.h
+++ b/src/node_crypto.h
@@ -27,6 +27,7 @@
// ClientHelloParser
#include "node_crypto_clienthello.h"
+#include "allocated_buffer.h"
#include "env.h"
#include "base_object.h"
#include "util.h"
diff --git a/src/node_crypto_bio.cc b/src/node_crypto_bio.cc
index 55f5e8a5a37..8c58e31f86b 100644
--- a/src/node_crypto_bio.cc
+++ b/src/node_crypto_bio.cc
@@ -21,6 +21,7 @@
#include "base_object-inl.h"
#include "memory_tracker-inl.h"
+#include "allocated_buffer-inl.h" // Inlined functions needed by node_crypto.h.
#include "node_crypto_bio.h"
#include "openssl/bio.h"
#include "util-inl.h"
diff --git a/src/node_crypto_common.cc b/src/node_crypto_common.cc
index 3b35ee1ff7b..d88074dfe83 100644
--- a/src/node_crypto_common.cc
+++ b/src/node_crypto_common.cc
@@ -1,3 +1,4 @@
+#include "allocated_buffer-inl.h"
#include "base_object-inl.h"
#include "env-inl.h"
#include "node_buffer.h"
@@ -492,7 +493,7 @@ MaybeLocal<Object> GetLastIssuedCert(
MaybeLocal<Object> GetRawDERCertificate(Environment* env, X509* cert) {
int size = i2d_X509(cert, nullptr);
- AllocatedBuffer buffer = env->AllocateManaged(size);
+ AllocatedBuffer buffer = AllocatedBuffer::AllocateManaged(env, size);
unsigned char* serialized =
reinterpret_cast<unsigned char*>(buffer.data());
i2d_X509(cert, &serialized);
@@ -669,7 +670,7 @@ MaybeLocal<Object> GetPubKey(Environment* env, const RSAPointer& rsa) {
int size = i2d_RSA_PUBKEY(rsa.get(), nullptr);
CHECK_GE(size, 0);
- AllocatedBuffer buffer = env->AllocateManaged(size);
+ AllocatedBuffer buffer = AllocatedBuffer::AllocateManaged(env, size);
unsigned char* serialized =
reinterpret_cast<unsigned char*>(buffer.data());
i2d_RSA_PUBKEY(rsa.get(), &serialized);
@@ -891,7 +892,7 @@ MaybeLocal<Object> ECPointToBuffer(Environment* env,
if (error != nullptr) *error = "Failed to get public key length";
return MaybeLocal<Object>();
}
- AllocatedBuffer buf = env->AllocateManaged(len);
+ AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, len);
len = EC_POINT_point2oct(group,
point,
form,
diff --git a/src/node_http2.cc b/src/node_http2.cc
index 067e73b043b..72901083a42 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -1,4 +1,5 @@
#include "aliased_buffer.h"
+#include "allocated_buffer-inl.h"
#include "aliased_struct-inl.h"
#include "debug_utils-inl.h"
#include "memory_tracker-inl.h"
@@ -259,7 +260,7 @@ Local<Value> Http2Settings::Pack(
const nghttp2_settings_entry* entries) {
EscapableHandleScope scope(env->isolate());
const size_t size = count * 6;
- AllocatedBuffer buffer = env->AllocateManaged(size);
+ AllocatedBuffer buffer = AllocatedBuffer::AllocateManaged(env, size);
ssize_t ret =
nghttp2_pack_settings_payload(
reinterpret_cast<uint8_t*>(buffer.data()),
@@ -359,8 +360,10 @@ Origins::Origins(
return;
}
- buf_ = env->AllocateManaged((alignof(nghttp2_origin_entry) - 1) +
- count_ * sizeof(nghttp2_origin_entry) +
+ buf_ = AllocatedBuffer::AllocateManaged(
+ env,
+ (alignof(nghttp2_origin_entry) - 1) +
+ count_ * sizeof(nghttp2_origin_entry) +
origin_string_len);
// Make sure the start address is aligned appropriately for an nghttp2_nv*.
@@ -1725,7 +1728,7 @@ Http2Stream* Http2Session::SubmitRequest(
}
uv_buf_t Http2Session::OnStreamAlloc(size_t suggested_size) {
- return env()->AllocateManaged(suggested_size).release();
+ return AllocatedBuffer::AllocateManaged(env(), suggested_size).release();
}
// Callback used to receive inbound data from the i/o stream
@@ -1757,7 +1760,8 @@ void Http2Session::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
// happen, we concatenate the data we received with the already-stored
// pending input data, slicing off the already processed part.
size_t pending_len = stream_buf_.len - stream_buf_offset_;
- AllocatedBuffer new_buf = env()->AllocateManaged(pending_len + nread);
+ AllocatedBuffer new_buf =
+ AllocatedBuffer::AllocateManaged(env(), pending_len + nread);
memcpy(new_buf.data(), stream_buf_.base + stream_buf_offset_, pending_len);
memcpy(new_buf.data() + pending_len, buf.data(), nread);
diff --git a/src/node_http2.h b/src/node_http2.h
index 6b11535f84e..4ef9e9fbab0 100644
--- a/src/node_http2.h
+++ b/src/node_http2.h
@@ -7,6 +7,7 @@
#include <cstdint>
#include "nghttp2/nghttp2.h"
+#include "allocated_buffer.h"
#include "aliased_struct.h"
#include "node_http2_state.h"
#include "node_http_common.h"
diff --git a/src/stream_base-inl.h b/src/stream_base-inl.h
index 149f542d841..bd7224e9c02 100644
--- a/src/stream_base-inl.h
+++ b/src/stream_base-inl.h
@@ -3,6 +3,7 @@
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#include "allocated_buffer-inl.h"
#include "async_wrap-inl.h"
#include "base_object-inl.h"
#include "node.h"
diff --git a/src/stream_base.cc b/src/stream_base.cc
index d8a191dc2e5..b35df39afe9 100644
--- a/src/stream_base.cc
+++ b/src/stream_base.cc
@@ -1,6 +1,7 @@
#include "stream_base.h" // NOLINT(build/include_inline)
#include "stream_base-inl.h"
#include "stream_wrap.h"
+#include "allocated_buffer-inl.h"
#include "node.h"
#include "node_buffer.h"
@@ -132,7 +133,7 @@ int StreamBase::Writev(const FunctionCallbackInfo<Value>& args) {
AllocatedBuffer storage;
if (storage_size > 0)
- storage = env->AllocateManaged(storage_size);
+ storage = AllocatedBuffer::AllocateManaged(env, storage_size);
offset = 0;
if (!all_buffers) {
@@ -276,12 +277,12 @@ int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
if (try_write) {
// Copy partial data
- data = env->AllocateManaged(buf.len);
+ data = AllocatedBuffer::AllocateManaged(env, buf.len);
memcpy(data.data(), buf.base, buf.len);
data_size = buf.len;
} else {
// Write it
- data = env->AllocateManaged(storage_size);
+ data = AllocatedBuffer::AllocateManaged(env, storage_size);
data_size = StringBytes::Write(env->isolate(),
data.data(),
storage_size,
@@ -486,7 +487,7 @@ void StreamResource::ClearError() {
uv_buf_t EmitToJSStreamListener::OnStreamAlloc(size_t suggested_size) {
CHECK_NOT_NULL(stream_);
Environment* env = static_cast<StreamBase*>(stream_)->stream_env();
- return env->AllocateManaged(suggested_size).release();
+ return AllocatedBuffer::AllocateManaged(env, suggested_size).release();
}
void EmitToJSStreamListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
diff --git a/src/stream_base.h b/src/stream_base.h
index 176271e05a8..7c6bcba81ed 100644
--- a/src/stream_base.h
+++ b/src/stream_base.h
@@ -4,6 +4,7 @@
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#include "env.h"
+#include "allocated_buffer.h"
#include "async_wrap.h"
#include "node.h"
#include "util.h"
diff --git a/src/stream_pipe.cc b/src/stream_pipe.cc
index 1bed4514eb8..1422f9e0ea5 100644
--- a/src/stream_pipe.cc
+++ b/src/stream_pipe.cc
@@ -1,4 +1,5 @@
#include "stream_pipe.h"
+#include "allocated_buffer-inl.h"
#include "stream_base-inl.h"
#include "node_buffer.h"
#include "util-inl.h"
@@ -118,7 +119,7 @@ uv_buf_t StreamPipe::ReadableListener::OnStreamAlloc(size_t suggested_size) {
StreamPipe* pipe = ContainerOf(&StreamPipe::readable_listener_, this);
size_t size = std::min(suggested_size, pipe->wanted_data_);
CHECK_GT(size, 0);
- return pipe->env()->AllocateManaged(size).release();
+ return AllocatedBuffer::AllocateManaged(pipe->env(), size).release();
}
void StreamPipe::ReadableListener::OnStreamRead(ssize_t nread,
diff --git a/src/stream_pipe.h b/src/stream_pipe.h
index e22abab0115..36179c95f74 100644
--- a/src/stream_pipe.h
+++ b/src/stream_pipe.h
@@ -4,6 +4,7 @@
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#include "stream_base.h"
+#include "allocated_buffer.h"
namespace node {
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index 8fa1bd2eea0..792d3ea79ce 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -20,6 +20,7 @@
// USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "tls_wrap.h"
+#include "allocated_buffer-inl.h"
#include "async_wrap-inl.h"
#include "debug_utils-inl.h"
#include "memory_tracker-inl.h"
@@ -766,7 +767,7 @@ int TLSWrap::DoWrite(WriteWrap* w,
// and copying it when it could just be used.
if (nonempty_count != 1) {
- data = env()->AllocateManaged(length);
+ data = AllocatedBuffer::AllocateManaged(env(), length);
size_t offset = 0;
for (i = 0; i < count; i++) {
memcpy(data.data() + offset, bufs[i].base, bufs[i].len);
@@ -782,7 +783,7 @@ int TLSWrap::DoWrite(WriteWrap* w,
written = SSL_write(ssl_.get(), buf->base, buf->len);
if (written == -1) {
- data = env()->AllocateManaged(length);
+ data = AllocatedBuffer::AllocateManaged(env(), length);
memcpy(data.data(), buf->base, buf->len);
}
}
diff --git a/src/tls_wrap.h b/src/tls_wrap.h
index 7bb33b4a3cb..7b8e50de9d4 100644
--- a/src/tls_wrap.h
+++ b/src/tls_wrap.h
@@ -26,6 +26,7 @@
#include "node_crypto.h" // SSLWrap
+#include "allocated_buffer.h"
#include "async_wrap.h"
#include "stream_wrap.h"
#include "v8.h"
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 9013bc9fe33..eb02db0a2a4 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -20,6 +20,7 @@
// USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "udp_wrap.h"
+#include "allocated_buffer-inl.h"
#include "env-inl.h"
#include "node_buffer.h"
#include "node_sockaddr-inl.h"
@@ -688,7 +689,7 @@ void UDPWrap::OnAlloc(uv_handle_t* handle,
}
uv_buf_t UDPWrap::OnAlloc(size_t suggested_size) {
- return env()->AllocateManaged(suggested_size).release();
+ return AllocatedBuffer::AllocateManaged(env(), suggested_size).release();
}
void UDPWrap::OnRecv(uv_udp_t* handle,
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-03 15:05:49 +0300