From ba3f7ff94d95da65a69755000a22c00856165770 Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Fri, 14 Feb 2020 14:25:32 +0200
Subject: [PATCH 01/17] doc: update stream.pipeline() signature

The  `...transforms` parameter is optional.

Refs: https://github.com/nodejs/node/blob/0875837417/lib/internal/streams/pipeline.js#L130-L132
Refs: https://github.com/nodejs/node/blob/e559842188/doc/api/stream.md#streams-compatibility-with-async-generators-and-async-iterators

PR-URL: https://github.com/nodejs/node/pull/31789
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Yongsheng Zhang <zyszys98@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/stream.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 09713f20746180..762f1565721c4e 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -1555,7 +1555,7 @@ const cleanup = finished(rs, (err) => {
 });
 ```
 
-### `stream.pipeline(source, ...transforms, destination, callback)`
+### `stream.pipeline(source[, ...transforms], destination, callback)`
 <!-- YAML
 added: v10.0.0
 changes:

From 0fc45f80b59db586c46d8b0fca265446a46ed121 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= <tniessen@tnie.de>
Date: Sun, 23 Feb 2020 10:58:36 -0400
Subject: [PATCH 02/17] crypto: simplify exportKeyingMaterial

PR-URL: https://github.com/nodejs/node/pull/31922
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: David Carlier <devnexen@gmail.com>
---
 src/node_crypto.cc | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index ea719d3c5c9c05..08982cfcfa1b29 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -2807,14 +2807,10 @@ void SSLWrap<Base>::ExportKeyingMaterial(
 
   AllocatedBuffer out = env->AllocateManaged(olen);
 
-  ByteSource key;
-
-  int useContext = 0;
-  if (!args[2]->IsNull() && Buffer::HasInstance(args[2])) {
-    key = ByteSource::FromBuffer(args[2]);
-
-    useContext = 1;
-  }
+  ByteSource context;
+  bool use_context = !args[2]->IsUndefined();
+  if (use_context)
+    context = ByteSource::FromBuffer(args[2]);
 
   if (SSL_export_keying_material(w->ssl_.get(),
                                  reinterpret_cast<unsigned char*>(out.data()),
@@ -2822,9 +2818,9 @@ void SSLWrap<Base>::ExportKeyingMaterial(
                                  *label,
                                  label.length(),
                                  reinterpret_cast<const unsigned char*>(
-                                   key.get()),
-                                 key.size(),
-                                 useContext) != 1) {
+                                     context.get()),
+                                 context.size(),
+                                 use_context) != 1) {
     return ThrowCryptoError(env, ERR_get_error(), "SSL_export_keying_material");
   }
 

From 4d5318c16467623770bb77f7ecac720cb93b0326 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 25 Feb 2020 14:37:33 -0800
Subject: [PATCH 03/17] src: improve handling of internal field counting

Change suggested by bnoordhuis.

Improve handing of internal field counting by using enums.
Helps protect against future possible breakage if field
indexes are ever changed or added to.

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/31960
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/async_wrap.cc        | 22 ++++++++++++----------
 src/base_object-inl.h    | 14 +++++++++-----
 src/base_object.h        |  2 ++
 src/cares_wrap.cc        |  3 ++-
 src/fs_event_wrap.cc     |  3 ++-
 src/heap_utils.cc        |  2 +-
 src/inspector_js_api.cc  |  3 ++-
 src/js_stream.cc         |  2 +-
 src/module_wrap.cc       |  3 ++-
 src/node_contextify.cc   | 14 +++++++++-----
 src/node_contextify.h    |  1 +
 src/node_crypto.cc       | 26 +++++++++++++++++---------
 src/node_dir.cc          |  2 +-
 src/node_dir.h           |  2 --
 src/node_file.cc         | 12 +++++++-----
 src/node_http2.cc        |  9 +++++----
 src/node_http_parser.cc  |  2 +-
 src/node_i18n.cc         |  2 +-
 src/node_messaging.cc    |  3 ++-
 src/node_perf.cc         |  3 ++-
 src/node_serdes.cc       |  6 ++++--
 src/node_stat_watcher.cc |  3 ++-
 src/node_trace_events.cc |  3 ++-
 src/node_util.cc         |  3 ++-
 src/node_wasi.cc         |  2 +-
 src/node_watchdog.cc     |  3 ++-
 src/node_worker.cc       |  6 ++++--
 src/node_zlib.cc         |  3 ++-
 src/pipe_wrap.cc         |  2 +-
 src/process_wrap.cc      |  3 ++-
 src/signal_wrap.cc       |  3 ++-
 src/stream_base-inl.h    | 22 ++++++++++++++--------
 src/stream_base.cc       | 10 +++++++---
 src/stream_base.h        | 22 +++++++++++++++++-----
 src/stream_pipe.cc       |  3 ++-
 src/stream_wrap.cc       |  8 ++++----
 src/tcp_wrap.cc          |  3 +--
 src/tls_wrap.cc          |  3 +--
 src/tty_wrap.cc          |  3 +--
 src/udp_wrap.cc          |  2 +-
 40 files changed, 151 insertions(+), 92 deletions(-)

diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index 315d4177c8ca48..892e33c624bb88 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -176,6 +176,10 @@ void AsyncWrap::EmitAfter(Environment* env, double async_id) {
 
 class PromiseWrap : public AsyncWrap {
  public:
+  enum InternalFields {
+    kIsChainedPromiseField = AsyncWrap::kInternalFieldCount,
+    kInternalFieldCount
+  };
   PromiseWrap(Environment* env, Local<Object> object, bool silent)
       : AsyncWrap(env, object, PROVIDER_PROMISE, kInvalidAsyncId, silent) {
     MakeWeak();
@@ -185,9 +189,6 @@ class PromiseWrap : public AsyncWrap {
   SET_MEMORY_INFO_NAME(PromiseWrap)
   SET_SELF_SIZE(PromiseWrap)
 
-  static constexpr int kIsChainedPromiseField = 1;
-  static constexpr int kInternalFieldCount = 2;
-
   static PromiseWrap* New(Environment* env,
                           Local<Promise> promise,
                           PromiseWrap* parent_wrap,
@@ -214,15 +215,16 @@ PromiseWrap* PromiseWrap::New(Environment* env,
 void PromiseWrap::getIsChainedPromise(Local<String> property,
                                       const PropertyCallbackInfo<Value>& info) {
   info.GetReturnValue().Set(
-    info.Holder()->GetInternalField(kIsChainedPromiseField));
+      info.Holder()->GetInternalField(PromiseWrap::kIsChainedPromiseField));
 }
 
 static PromiseWrap* extractPromiseWrap(Local<Promise> promise) {
-  Local<Value> resource_object_value = promise->GetInternalField(0);
-  if (resource_object_value->IsObject()) {
-    return Unwrap<PromiseWrap>(resource_object_value.As<Object>());
-  }
-  return nullptr;
+  // This check is imperfect. If the internal field is set, it should
+  // be an object. If it's not, we just ignore it. Ideally v8 would
+  // have had GetInternalField returning a MaybeLocal but this works
+  // for now.
+  Local<Value> obj = promise->GetInternalField(0);
+  return obj->IsObject() ? Unwrap<PromiseWrap>(obj.As<Object>()) : nullptr;
 }
 
 static void PromiseHook(PromiseHookType type, Local<Promise> promise,
@@ -560,7 +562,7 @@ void AsyncWrap::Initialize(Local<Object> target,
     function_template->SetClassName(class_name);
     function_template->Inherit(AsyncWrap::GetConstructorTemplate(env));
     auto instance_template = function_template->InstanceTemplate();
-    instance_template->SetInternalFieldCount(1);
+    instance_template->SetInternalFieldCount(AsyncWrap::kInternalFieldCount);
     auto function =
         function_template->GetFunction(env->context()).ToLocalChecked();
     target->Set(env->context(), class_name, function).Check();
diff --git a/src/base_object-inl.h b/src/base_object-inl.h
index 8b2b30021a8520..c9b4e1491fc947 100644
--- a/src/base_object-inl.h
+++ b/src/base_object-inl.h
@@ -43,7 +43,9 @@ BaseObject::BaseObject(Environment* env, v8::Local<v8::Object> object)
     : persistent_handle_(env->isolate(), object), env_(env) {
   CHECK_EQ(false, object.IsEmpty());
   CHECK_GT(object->InternalFieldCount(), 0);
-  object->SetAlignedPointerInInternalField(0, static_cast<void*>(this));
+  object->SetAlignedPointerInInternalField(
+      BaseObject::kSlot,
+      static_cast<void*>(this));
   env->AddCleanupHook(DeleteMe, static_cast<void*>(this));
   env->modify_base_object_count(1);
 }
@@ -67,7 +69,7 @@ BaseObject::~BaseObject() {
 
   {
     v8::HandleScope handle_scope(env()->isolate());
-    object()->SetAlignedPointerInInternalField(0, nullptr);
+    object()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);
   }
 }
 
@@ -100,7 +102,8 @@ Environment* BaseObject::env() const {
 
 BaseObject* BaseObject::FromJSObject(v8::Local<v8::Object> obj) {
   CHECK_GT(obj->InternalFieldCount(), 0);
-  return static_cast<BaseObject*>(obj->GetAlignedPointerFromInternalField(0));
+  return static_cast<BaseObject*>(
+      obj->GetAlignedPointerFromInternalField(BaseObject::kSlot));
 }
 
 
@@ -148,11 +151,12 @@ BaseObject::MakeLazilyInitializedJSTemplate(Environment* env) {
   auto constructor = [](const v8::FunctionCallbackInfo<v8::Value>& args) {
     DCHECK(args.IsConstructCall());
     DCHECK_GT(args.This()->InternalFieldCount(), 0);
-    args.This()->SetAlignedPointerInInternalField(0, nullptr);
+    args.This()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);
   };
 
   v8::Local<v8::FunctionTemplate> t = env->NewFunctionTemplate(constructor);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      BaseObject::kInternalFieldCount);
   return t;
 }
 
diff --git a/src/base_object.h b/src/base_object.h
index e7ef029995f1cf..2c67445c31fbb6 100644
--- a/src/base_object.h
+++ b/src/base_object.h
@@ -36,6 +36,8 @@ class BaseObjectPtrImpl;
 
 class BaseObject : public MemoryRetainer {
  public:
+  enum InternalFields { kSlot, kInternalFieldCount };
+
   // Associates this object with `object`. It uses the 0th internal field for
   // that, and in particular aborts if there is no such field.
   inline BaseObject(Environment* env, v8::Local<v8::Object> object);
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index 8eeaeddf8300d8..8abf662caa3142 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -2223,7 +2223,8 @@ void Initialize(Local<Object> target,
 
   Local<FunctionTemplate> channel_wrap =
       env->NewFunctionTemplate(ChannelWrap::New);
-  channel_wrap->InstanceTemplate()->SetInternalFieldCount(1);
+  channel_wrap->InstanceTemplate()->SetInternalFieldCount(
+      ChannelWrap::kInternalFieldCount);
   channel_wrap->Inherit(AsyncWrap::GetConstructorTemplate(env));
 
   env->SetProtoMethod(channel_wrap, "queryAny", Query<QueryAnyWrap>);
diff --git a/src/fs_event_wrap.cc b/src/fs_event_wrap.cc
index d38556b1bf8011..858455bff2d42d 100644
--- a/src/fs_event_wrap.cc
+++ b/src/fs_event_wrap.cc
@@ -97,7 +97,8 @@ void FSEventWrap::Initialize(Local<Object> target,
 
   auto fsevent_string = FIXED_ONE_BYTE_STRING(env->isolate(), "FSEvent");
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      FSEventWrap::kInternalFieldCount);
   t->SetClassName(fsevent_string);
 
   t->Inherit(AsyncWrap::GetConstructorTemplate(env));
diff --git a/src/heap_utils.cc b/src/heap_utils.cc
index 68cd532c230830..c21ff8c80062a8 100644
--- a/src/heap_utils.cc
+++ b/src/heap_utils.cc
@@ -341,7 +341,7 @@ BaseObjectPtr<AsyncWrap> CreateHeapSnapshotStream(
     Local<FunctionTemplate> os = FunctionTemplate::New(env->isolate());
     os->Inherit(AsyncWrap::GetConstructorTemplate(env));
     Local<ObjectTemplate> ost = os->InstanceTemplate();
-    ost->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+    ost->SetInternalFieldCount(StreamBase::kInternalFieldCount);
     os->SetClassName(
         FIXED_ONE_BYTE_STRING(env->isolate(), "HeapSnapshotStream"));
     StreamBase::AddMethods(env, os);
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
index 703c9ff598fdf2..ed3b36ad5ca80e 100644
--- a/src/inspector_js_api.cc
+++ b/src/inspector_js_api.cc
@@ -105,7 +105,8 @@ class JSBindingsConnection : public AsyncWrap {
     Local<String> class_name = ConnectionType::GetClassName(env);
     Local<FunctionTemplate> tmpl =
         env->NewFunctionTemplate(JSBindingsConnection::New);
-    tmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        JSBindingsConnection::kInternalFieldCount);
     tmpl->SetClassName(class_name);
     tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
     env->SetProtoMethod(tmpl, "dispatch", JSBindingsConnection::Dispatch);
diff --git a/src/js_stream.cc b/src/js_stream.cc
index 64941b1c4e4fb7..e4da0ce747e3a0 100644
--- a/src/js_stream.cc
+++ b/src/js_stream.cc
@@ -204,7 +204,7 @@ void JSStream::Initialize(Local<Object> target,
       FIXED_ONE_BYTE_STRING(env->isolate(), "JSStream");
   t->SetClassName(jsStreamString);
   t->InstanceTemplate()
-    ->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+    ->SetInternalFieldCount(StreamBase::kInternalFieldCount);
   t->Inherit(AsyncWrap::GetConstructorTemplate(env));
 
   env->SetProtoMethod(t, "finishWrite", Finish<WriteWrap>);
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index 5d758bac620b54..2b1708088bf449 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -1636,7 +1636,8 @@ void ModuleWrap::Initialize(Local<Object> target,
 
   Local<FunctionTemplate> tpl = env->NewFunctionTemplate(New);
   tpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"));
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+  tpl->InstanceTemplate()->SetInternalFieldCount(
+      ModuleWrap::kInternalFieldCount);
 
   env->SetProtoMethod(tpl, "link", Link);
   env->SetProtoMethod(tpl, "instantiate", Instantiate);
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index 6de27188be6c7f..e6e2d123c04278 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -145,7 +145,7 @@ MaybeLocal<Object> ContextifyContext::CreateDataWrapper(Environment* env) {
     return MaybeLocal<Object>();
   }
 
-  wrapper->SetAlignedPointerInInternalField(0, this);
+  wrapper->SetAlignedPointerInInternalField(ContextifyContext::kSlot, this);
   return wrapper;
 }
 
@@ -232,7 +232,8 @@ MaybeLocal<Context> ContextifyContext::CreateV8Context(
 void ContextifyContext::Init(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> function_template =
       FunctionTemplate::New(env->isolate());
-  function_template->InstanceTemplate()->SetInternalFieldCount(1);
+  function_template->InstanceTemplate()->SetInternalFieldCount(
+      ContextifyContext::kInternalFieldCount);
   env->set_script_data_constructor_function(
       function_template->GetFunction(env->context()).ToLocalChecked());
 
@@ -331,7 +332,8 @@ template <typename T>
 ContextifyContext* ContextifyContext::Get(const PropertyCallbackInfo<T>& args) {
   Local<Value> data = args.Data();
   return static_cast<ContextifyContext*>(
-      data.As<Object>()->GetAlignedPointerFromInternalField(0));
+      data.As<Object>()->GetAlignedPointerFromInternalField(
+          ContextifyContext::kSlot));
 }
 
 // static
@@ -628,7 +630,8 @@ void ContextifyScript::Init(Environment* env, Local<Object> target) {
       FIXED_ONE_BYTE_STRING(env->isolate(), "ContextifyScript");
 
   Local<FunctionTemplate> script_tmpl = env->NewFunctionTemplate(New);
-  script_tmpl->InstanceTemplate()->SetInternalFieldCount(1);
+  script_tmpl->InstanceTemplate()->SetInternalFieldCount(
+      ContextifyScript::kInternalFieldCount);
   script_tmpl->SetClassName(class_name);
   env->SetProtoMethod(script_tmpl, "createCachedData", CreateCachedData);
   env->SetProtoMethod(script_tmpl, "runInContext", RunInContext);
@@ -1251,7 +1254,8 @@ void Initialize(Local<Object> target,
   {
     Local<FunctionTemplate> tpl = FunctionTemplate::New(env->isolate());
     tpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "CompiledFnEntry"));
-    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+    tpl->InstanceTemplate()->SetInternalFieldCount(
+        CompiledFnEntry::kInternalFieldCount);
 
     env->set_compiled_fn_entry_template(tpl->InstanceTemplate());
   }
diff --git a/src/node_contextify.h b/src/node_contextify.h
index cf1e8475075fcb..f04ea86f41abac 100644
--- a/src/node_contextify.h
+++ b/src/node_contextify.h
@@ -19,6 +19,7 @@ struct ContextOptions {
 
 class ContextifyContext {
  public:
+  enum InternalFields { kSlot, kInternalFieldCount };
   ContextifyContext(Environment* env,
                     v8::Local<v8::Object> sandbox_obj,
                     const ContextOptions& options);
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 08982cfcfa1b29..0b48821cf6c8af 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -464,7 +464,8 @@ static T* MallocOpenSSL(size_t count) {
 
 void SecureContext::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      SecureContext::kInternalFieldCount);
   Local<String> secureContextString =
       FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext");
   t->SetClassName(secureContextString);
@@ -3803,7 +3804,8 @@ EVP_PKEY* ManagedEVPPKey::get() const {
 
 Local<Function> KeyObject::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      KeyObject::kInternalFieldCount);
 
   env->SetProtoMethod(t, "init", Init);
   env->SetProtoMethodNoSideEffect(t, "getSymmetricKeySize",
@@ -4036,7 +4038,8 @@ CipherBase::CipherBase(Environment* env,
 void CipherBase::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
 
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      CipherBase::kInternalFieldCount);
 
   env->SetProtoMethod(t, "init", Init);
   env->SetProtoMethod(t, "initiv", InitIv);
@@ -4663,7 +4666,8 @@ Hmac::Hmac(Environment* env, v8::Local<v8::Object> wrap)
 void Hmac::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
 
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      Hmac::kInternalFieldCount);
 
   env->SetProtoMethod(t, "init", HmacInit);
   env->SetProtoMethod(t, "update", HmacUpdate);
@@ -4789,7 +4793,8 @@ Hash::Hash(Environment* env, v8::Local<v8::Object> wrap)
 void Hash::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
 
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      Hash::kInternalFieldCount);
 
   env->SetProtoMethod(t, "update", HashUpdate);
   env->SetProtoMethod(t, "digest", HashDigest);
@@ -5061,7 +5066,8 @@ Sign::Sign(Environment* env, v8::Local<v8::Object> wrap) : SignBase(env, wrap) {
 void Sign::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
 
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      SignBase::kInternalFieldCount);
 
   env->SetProtoMethod(t, "init", SignInit);
   env->SetProtoMethod(t, "update", SignUpdate);
@@ -5385,7 +5391,8 @@ Verify::Verify(Environment* env, v8::Local<v8::Object> wrap) :
 void Verify::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
 
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      SignBase::kInternalFieldCount);
 
   env->SetProtoMethod(t, "init", VerifyInit);
   env->SetProtoMethod(t, "update", VerifyUpdate);
@@ -5697,7 +5704,8 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
     const PropertyAttribute attributes =
         static_cast<PropertyAttribute>(ReadOnly | DontDelete);
 
-    t->InstanceTemplate()->SetInternalFieldCount(1);
+    t->InstanceTemplate()->SetInternalFieldCount(
+        DiffieHellman::kInternalFieldCount);
 
     env->SetProtoMethod(t, "generateKeys", GenerateKeys);
     env->SetProtoMethod(t, "computeSecret", ComputeSecret);
@@ -6036,7 +6044,7 @@ void ECDH::Initialize(Environment* env, Local<Object> target) {
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
 
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(ECDH::kInternalFieldCount);
 
   env->SetProtoMethod(t, "generateKeys", GenerateKeys);
   env->SetProtoMethod(t, "computeSecret", ComputeSecret);
diff --git a/src/node_dir.cc b/src/node_dir.cc
index ec53d8216bcba0..9923f042779f2e 100644
--- a/src/node_dir.cc
+++ b/src/node_dir.cc
@@ -358,7 +358,7 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(dir, "read", DirHandle::Read);
   env->SetProtoMethod(dir, "close", DirHandle::Close);
   Local<ObjectTemplate> dirt = dir->InstanceTemplate();
-  dirt->SetInternalFieldCount(DirHandle::kDirHandleFieldCount);
+  dirt->SetInternalFieldCount(DirHandle::kInternalFieldCount);
   Local<String> handleString =
        FIXED_ONE_BYTE_STRING(isolate, "DirHandle");
   dir->SetClassName(handleString);
diff --git a/src/node_dir.h b/src/node_dir.h
index b55245d5b89a2e..5fcc36326b7ba2 100644
--- a/src/node_dir.h
+++ b/src/node_dir.h
@@ -12,8 +12,6 @@ namespace fs_dir {
 // Needed to propagate `uv_dir_t`.
 class DirHandle : public AsyncWrap {
  public:
-  static constexpr int kDirHandleFieldCount = 1;
-
   static DirHandle* New(Environment* env, uv_dir_t* dir);
   ~DirHandle() override;
 
diff --git a/src/node_file.cc b/src/node_file.cc
index 360f20e5f6c36a..314e237a781fdb 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -2198,7 +2198,8 @@ void Initialize(Local<Object> target,
 
   // Create FunctionTemplate for FSReqCallback
   Local<FunctionTemplate> fst = env->NewFunctionTemplate(NewFSReqCallback);
-  fst->InstanceTemplate()->SetInternalFieldCount(1);
+  fst->InstanceTemplate()->SetInternalFieldCount(
+      FSReqBase::kInternalFieldCount);
   fst->Inherit(AsyncWrap::GetConstructorTemplate(env));
   Local<String> wrapString =
       FIXED_ONE_BYTE_STRING(isolate, "FSReqCallback");
@@ -2211,7 +2212,8 @@ void Initialize(Local<Object> target,
   // Create FunctionTemplate for FileHandleReadWrap. There’s no need
   // to do anything in the constructor, so we only store the instance template.
   Local<FunctionTemplate> fh_rw = FunctionTemplate::New(isolate);
-  fh_rw->InstanceTemplate()->SetInternalFieldCount(1);
+  fh_rw->InstanceTemplate()->SetInternalFieldCount(
+      FSReqBase::kInternalFieldCount);
   fh_rw->Inherit(AsyncWrap::GetConstructorTemplate(env));
   Local<String> fhWrapString =
       FIXED_ONE_BYTE_STRING(isolate, "FileHandleReqWrap");
@@ -2226,7 +2228,7 @@ void Initialize(Local<Object> target,
       FIXED_ONE_BYTE_STRING(isolate, "FSReqPromise");
   fpt->SetClassName(promiseString);
   Local<ObjectTemplate> fpo = fpt->InstanceTemplate();
-  fpo->SetInternalFieldCount(1);
+  fpo->SetInternalFieldCount(FSReqBase::kInternalFieldCount);
   env->set_fsreqpromise_constructor_template(fpo);
 
   // Create FunctionTemplate for FileHandle
@@ -2235,7 +2237,7 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(fd, "close", FileHandle::Close);
   env->SetProtoMethod(fd, "releaseFD", FileHandle::ReleaseFD);
   Local<ObjectTemplate> fdt = fd->InstanceTemplate();
-  fdt->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+  fdt->SetInternalFieldCount(StreamBase::kInternalFieldCount);
   Local<String> handleString =
        FIXED_ONE_BYTE_STRING(isolate, "FileHandle");
   fd->SetClassName(handleString);
@@ -2252,7 +2254,7 @@ void Initialize(Local<Object> target,
                         "FileHandleCloseReq"));
   fdclose->Inherit(AsyncWrap::GetConstructorTemplate(env));
   Local<ObjectTemplate> fdcloset = fdclose->InstanceTemplate();
-  fdcloset->SetInternalFieldCount(1);
+  fdcloset->SetInternalFieldCount(FSReqBase::kInternalFieldCount);
   env->set_fdclose_constructor_template(fdcloset);
 
   Local<Symbol> use_promises_symbol =
diff --git a/src/node_http2.cc b/src/node_http2.cc
index f6224393bab9e7..3de43f5f3af2cb 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -3024,14 +3024,14 @@ void Initialize(Local<Object> target,
   ping->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Ping"));
   ping->Inherit(AsyncWrap::GetConstructorTemplate(env));
   Local<ObjectTemplate> pingt = ping->InstanceTemplate();
-  pingt->SetInternalFieldCount(1);
+  pingt->SetInternalFieldCount(Http2Session::Http2Ping::kInternalFieldCount);
   env->set_http2ping_constructor_template(pingt);
 
   Local<FunctionTemplate> setting = FunctionTemplate::New(env->isolate());
   setting->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Setting"));
   setting->Inherit(AsyncWrap::GetConstructorTemplate(env));
   Local<ObjectTemplate> settingt = setting->InstanceTemplate();
-  settingt->SetInternalFieldCount(1);
+  settingt->SetInternalFieldCount(AsyncWrap::kInternalFieldCount);
   env->set_http2settings_constructor_template(settingt);
 
   Local<FunctionTemplate> stream = FunctionTemplate::New(env->isolate());
@@ -3048,7 +3048,7 @@ void Initialize(Local<Object> target,
   stream->Inherit(AsyncWrap::GetConstructorTemplate(env));
   StreamBase::AddMethods(env, stream);
   Local<ObjectTemplate> streamt = stream->InstanceTemplate();
-  streamt->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+  streamt->SetInternalFieldCount(StreamBase::kInternalFieldCount);
   env->set_http2stream_constructor_template(streamt);
   target->Set(context,
               FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Stream"),
@@ -3057,7 +3057,8 @@ void Initialize(Local<Object> target,
   Local<FunctionTemplate> session =
       env->NewFunctionTemplate(Http2Session::New);
   session->SetClassName(http2SessionClassName);
-  session->InstanceTemplate()->SetInternalFieldCount(1);
+  session->InstanceTemplate()->SetInternalFieldCount(
+      Http2Session::kInternalFieldCount);
   session->Inherit(AsyncWrap::GetConstructorTemplate(env));
   env->SetProtoMethod(session, "origin", Http2Session::Origin);
   env->SetProtoMethod(session, "altsvc", Http2Session::AltSvc);
diff --git a/src/node_http_parser.cc b/src/node_http_parser.cc
index 40ece82b625746..75d7e89a91c34f 100644
--- a/src/node_http_parser.cc
+++ b/src/node_http_parser.cc
@@ -873,7 +873,7 @@ void InitializeHttpParser(Local<Object> target,
                           void* priv) {
   Environment* env = Environment::GetCurrent(context);
   Local<FunctionTemplate> t = env->NewFunctionTemplate(Parser::New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(Parser::kInternalFieldCount);
   t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "HTTPParser"));
 
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "REQUEST"),
diff --git a/src/node_i18n.cc b/src/node_i18n.cc
index 46c6ef39f861ec..a32ddf2066be5f 100644
--- a/src/node_i18n.cc
+++ b/src/node_i18n.cc
@@ -172,7 +172,7 @@ class ConverterObject : public BaseObject, Converter {
     HandleScope scope(env->isolate());
 
     Local<ObjectTemplate> t = ObjectTemplate::New(env->isolate());
-    t->SetInternalFieldCount(1);
+    t->SetInternalFieldCount(ConverterObject::kInternalFieldCount);
     Local<Object> obj;
     if (!t->NewInstance(env->context()).ToLocal(&obj)) return;
 
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 608f62e7f0ac1b..657b409627c838 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -934,7 +934,8 @@ Local<FunctionTemplate> GetMessagePortConstructorTemplate(Environment* env) {
   {
     Local<FunctionTemplate> m = env->NewFunctionTemplate(MessagePort::New);
     m->SetClassName(env->message_port_constructor_string());
-    m->InstanceTemplate()->SetInternalFieldCount(1);
+    m->InstanceTemplate()->SetInternalFieldCount(
+        MessagePort::kInternalFieldCount);
     m->Inherit(HandleWrap::GetConstructorTemplate(env));
 
     env->SetProtoMethod(m, "postMessage", MessagePort::PostMessage);
diff --git a/src/node_perf.cc b/src/node_perf.cc
index 68b015f33eda49..21766d3b89aa3b 100644
--- a/src/node_perf.cc
+++ b/src/node_perf.cc
@@ -640,7 +640,8 @@ void Initialize(Local<Object> target,
   Local<FunctionTemplate> eldh =
       env->NewFunctionTemplate(ELDHistogramNew);
   eldh->SetClassName(eldh_classname);
-  eldh->InstanceTemplate()->SetInternalFieldCount(1);
+  eldh->InstanceTemplate()->SetInternalFieldCount(
+      ELDHistogram::kInternalFieldCount);
   env->SetProtoMethod(eldh, "exceeds", ELDHistogramExceeds);
   env->SetProtoMethod(eldh, "min", ELDHistogramMin);
   env->SetProtoMethod(eldh, "max", ELDHistogramMax);
diff --git a/src/node_serdes.cc b/src/node_serdes.cc
index a2d185c4167a75..bcdcd19b261e88 100644
--- a/src/node_serdes.cc
+++ b/src/node_serdes.cc
@@ -451,7 +451,8 @@ void Initialize(Local<Object> target,
   Local<FunctionTemplate> ser =
       env->NewFunctionTemplate(SerializerContext::New);
 
-  ser->InstanceTemplate()->SetInternalFieldCount(1);
+  ser->InstanceTemplate()->SetInternalFieldCount(
+      SerializerContext::kInternalFieldCount);
 
   env->SetProtoMethod(ser, "writeHeader", SerializerContext::WriteHeader);
   env->SetProtoMethod(ser, "writeValue", SerializerContext::WriteValue);
@@ -477,7 +478,8 @@ void Initialize(Local<Object> target,
   Local<FunctionTemplate> des =
       env->NewFunctionTemplate(DeserializerContext::New);
 
-  des->InstanceTemplate()->SetInternalFieldCount(1);
+  des->InstanceTemplate()->SetInternalFieldCount(
+      DeserializerContext::kInternalFieldCount);
 
   env->SetProtoMethod(des, "readHeader", DeserializerContext::ReadHeader);
   env->SetProtoMethod(des, "readValue", DeserializerContext::ReadValue);
diff --git a/src/node_stat_watcher.cc b/src/node_stat_watcher.cc
index 0d67eceed54931..05c540bbff17cc 100644
--- a/src/node_stat_watcher.cc
+++ b/src/node_stat_watcher.cc
@@ -47,7 +47,8 @@ void StatWatcher::Initialize(Environment* env, Local<Object> target) {
   HandleScope scope(env->isolate());
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(StatWatcher::New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      StatWatcher::kInternalFieldCount);
   Local<String> statWatcherString =
       FIXED_ONE_BYTE_STRING(env->isolate(), "StatWatcher");
   t->SetClassName(statWatcherString);
diff --git a/src/node_trace_events.cc b/src/node_trace_events.cc
index f5852076b4ec68..9adee9e458ccc0 100644
--- a/src/node_trace_events.cc
+++ b/src/node_trace_events.cc
@@ -129,7 +129,8 @@ void NodeCategorySet::Initialize(Local<Object> target,
 
   Local<FunctionTemplate> category_set =
       env->NewFunctionTemplate(NodeCategorySet::New);
-  category_set->InstanceTemplate()->SetInternalFieldCount(1);
+  category_set->InstanceTemplate()->SetInternalFieldCount(
+      NodeCategorySet::kInternalFieldCount);
   env->SetProtoMethod(category_set, "enable", NodeCategorySet::Enable);
   env->SetProtoMethod(category_set, "disable", NodeCategorySet::Disable);
 
diff --git a/src/node_util.cc b/src/node_util.cc
index e0ef7d421ff24a..db9b8ec8d65f51 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -323,7 +323,8 @@ void Initialize(Local<Object> target,
       FIXED_ONE_BYTE_STRING(env->isolate(), "WeakReference");
   Local<FunctionTemplate> weak_ref =
       env->NewFunctionTemplate(WeakReference::New);
-  weak_ref->InstanceTemplate()->SetInternalFieldCount(1);
+  weak_ref->InstanceTemplate()->SetInternalFieldCount(
+      WeakReference::kInternalFieldCount);
   weak_ref->SetClassName(weak_ref_string);
   env->SetProtoMethod(weak_ref, "get", WeakReference::Get);
   env->SetProtoMethod(weak_ref, "incRef", WeakReference::IncRef);
diff --git a/src/node_wasi.cc b/src/node_wasi.cc
index 20872c58d60fb7..ed8f6c4fa4cb67 100644
--- a/src/node_wasi.cc
+++ b/src/node_wasi.cc
@@ -1810,7 +1810,7 @@ static void Initialize(Local<Object> target,
 
   Local<FunctionTemplate> tmpl = env->NewFunctionTemplate(WASI::New);
   auto wasi_wrap_string = FIXED_ONE_BYTE_STRING(env->isolate(), "WASI");
-  tmpl->InstanceTemplate()->SetInternalFieldCount(1);
+  tmpl->InstanceTemplate()->SetInternalFieldCount(WASI::kInternalFieldCount);
   tmpl->SetClassName(wasi_wrap_string);
 
   env->SetProtoMethod(tmpl, "args_get", WASI::ArgsGet);
diff --git a/src/node_watchdog.cc b/src/node_watchdog.cc
index 4cc75c3160473a..29f0bc18c0d7b0 100644
--- a/src/node_watchdog.cc
+++ b/src/node_watchdog.cc
@@ -121,7 +121,8 @@ SignalPropagation SigintWatchdog::HandleSigint() {
 
 void TraceSigintWatchdog::Init(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
-  constructor->InstanceTemplate()->SetInternalFieldCount(1);
+  constructor->InstanceTemplate()->SetInternalFieldCount(
+      TraceSigintWatchdog::kInternalFieldCount);
   Local<v8::String> js_sigint_watch_dog =
       FIXED_ONE_BYTE_STRING(env->isolate(), "TraceSigintWatchdog");
   constructor->SetClassName(js_sigint_watch_dog);
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 04ae234c3b4cb6..8f3a8e88e4a61d 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -775,7 +775,8 @@ void InitWorker(Local<Object> target,
   {
     Local<FunctionTemplate> w = env->NewFunctionTemplate(Worker::New);
 
-    w->InstanceTemplate()->SetInternalFieldCount(1);
+    w->InstanceTemplate()->SetInternalFieldCount(
+        Worker::kInternalFieldCount);
     w->Inherit(AsyncWrap::GetConstructorTemplate(env));
 
     env->SetProtoMethod(w, "startThread", Worker::StartThread);
@@ -796,7 +797,8 @@ void InitWorker(Local<Object> target,
   {
     Local<FunctionTemplate> wst = FunctionTemplate::New(env->isolate());
 
-    wst->InstanceTemplate()->SetInternalFieldCount(1);
+    wst->InstanceTemplate()->SetInternalFieldCount(
+        WorkerHeapSnapshotTaker::kInternalFieldCount);
     wst->Inherit(AsyncWrap::GetConstructorTemplate(env));
 
     Local<String> wst_string =
diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index 1b7fd788b959f9..eacd710143a1b2 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -1216,7 +1216,8 @@ struct MakeClass {
   static void Make(Environment* env, Local<Object> target, const char* name) {
     Local<FunctionTemplate> z = env->NewFunctionTemplate(Stream::New);
 
-    z->InstanceTemplate()->SetInternalFieldCount(1);
+    z->InstanceTemplate()->SetInternalFieldCount(
+        Stream::kInternalFieldCount);
     z->Inherit(AsyncWrap::GetConstructorTemplate(env));
 
     env->SetProtoMethod(z, "write", Stream::template Write<true>);
diff --git a/src/pipe_wrap.cc b/src/pipe_wrap.cc
index c2be4320387549..c4a5b7cd62e1b4 100644
--- a/src/pipe_wrap.cc
+++ b/src/pipe_wrap.cc
@@ -74,7 +74,7 @@ void PipeWrap::Initialize(Local<Object> target,
   Local<String> pipeString = FIXED_ONE_BYTE_STRING(env->isolate(), "Pipe");
   t->SetClassName(pipeString);
   t->InstanceTemplate()
-    ->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+    ->SetInternalFieldCount(StreamBase::kInternalFieldCount);
 
   t->Inherit(LibuvStreamWrap::GetConstructorTemplate(env));
 
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index a75f271d1c77b8..1e7de56c6d1581 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -52,7 +52,8 @@ class ProcessWrap : public HandleWrap {
                          void* priv) {
     Environment* env = Environment::GetCurrent(context);
     Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
-    constructor->InstanceTemplate()->SetInternalFieldCount(1);
+    constructor->InstanceTemplate()->SetInternalFieldCount(
+        ProcessWrap::kInternalFieldCount);
     Local<String> processString =
         FIXED_ONE_BYTE_STRING(env->isolate(), "Process");
     constructor->SetClassName(processString);
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index bc2d9f1e355efd..2be7ac9834100b 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -53,7 +53,8 @@ class SignalWrap : public HandleWrap {
                          void* priv) {
     Environment* env = Environment::GetCurrent(context);
     Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
-    constructor->InstanceTemplate()->SetInternalFieldCount(1);
+    constructor->InstanceTemplate()->SetInternalFieldCount(
+        SignalWrap::kInternalFieldCount);
     Local<String> signalString =
         FIXED_ONE_BYTE_STRING(env->isolate(), "Signal");
     constructor->SetClassName(signalString);
diff --git a/src/stream_base-inl.h b/src/stream_base-inl.h
index f89eb3a5287939..27a9a01c7c2170 100644
--- a/src/stream_base-inl.h
+++ b/src/stream_base-inl.h
@@ -23,18 +23,22 @@ using v8::String;
 using v8::Value;
 
 inline void StreamReq::AttachToObject(v8::Local<v8::Object> req_wrap_obj) {
-  CHECK_EQ(req_wrap_obj->GetAlignedPointerFromInternalField(kStreamReqField),
+  CHECK_EQ(req_wrap_obj->GetAlignedPointerFromInternalField(
+               StreamReq::kStreamReqField),
            nullptr);
-  req_wrap_obj->SetAlignedPointerInInternalField(kStreamReqField, this);
+  req_wrap_obj->SetAlignedPointerInInternalField(
+      StreamReq::kStreamReqField, this);
 }
 
 inline StreamReq* StreamReq::FromObject(v8::Local<v8::Object> req_wrap_obj) {
   return static_cast<StreamReq*>(
-      req_wrap_obj->GetAlignedPointerFromInternalField(kStreamReqField));
+      req_wrap_obj->GetAlignedPointerFromInternalField(
+          StreamReq::kStreamReqField));
 }
 
 inline void StreamReq::Dispose() {
-  object()->SetAlignedPointerInInternalField(kStreamReqField, nullptr);
+  object()->SetAlignedPointerInInternalField(
+      StreamReq::kStreamReqField, nullptr);
   delete this;
 }
 
@@ -261,15 +265,17 @@ inline WriteWrap* StreamBase::CreateWriteWrap(
 }
 
 inline void StreamBase::AttachToObject(v8::Local<v8::Object> obj) {
-  obj->SetAlignedPointerInInternalField(kStreamBaseField, this);
+  obj->SetAlignedPointerInInternalField(
+      StreamBase::kStreamBaseField, this);
 }
 
 inline StreamBase* StreamBase::FromObject(v8::Local<v8::Object> obj) {
-  if (obj->GetAlignedPointerFromInternalField(0) == nullptr)
+  if (obj->GetAlignedPointerFromInternalField(StreamBase::kSlot) == nullptr)
     return nullptr;
 
   return static_cast<StreamBase*>(
-      obj->GetAlignedPointerFromInternalField(kStreamBaseField));
+      obj->GetAlignedPointerFromInternalField(
+          StreamBase::kStreamBaseField));
 }
 
 
@@ -304,7 +310,7 @@ inline void StreamReq::Done(int status, const char* error_str) {
 inline void StreamReq::ResetObject(v8::Local<v8::Object> obj) {
   DCHECK_GT(obj->InternalFieldCount(), StreamReq::kStreamReqField);
 
-  obj->SetAlignedPointerInInternalField(0, nullptr);  // BaseObject field.
+  obj->SetAlignedPointerInInternalField(StreamReq::kSlot, nullptr);
   obj->SetAlignedPointerInInternalField(StreamReq::kStreamReqField, nullptr);
 }
 
diff --git a/src/stream_base.cc b/src/stream_base.cc
index eaccfc995c745f..28a3bf65fc0178 100644
--- a/src/stream_base.cc
+++ b/src/stream_base.cc
@@ -340,7 +340,8 @@ MaybeLocal<Value> StreamBase::CallJSOnreadMethod(ssize_t nread,
 
   AsyncWrap* wrap = GetAsyncWrap();
   CHECK_NOT_NULL(wrap);
-  Local<Value> onread = wrap->object()->GetInternalField(kOnReadFunctionField);
+  Local<Value> onread = wrap->object()->GetInternalField(
+      StreamBase::kOnReadFunctionField);
   CHECK(onread->IsFunction());
   return wrap->MakeCallback(onread.As<Function>(), arraysize(argv), argv);
 }
@@ -409,8 +410,11 @@ void StreamBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
                               True(env->isolate()));
   t->PrototypeTemplate()->SetAccessor(
       FIXED_ONE_BYTE_STRING(env->isolate(), "onread"),
-      BaseObject::InternalFieldGet<kOnReadFunctionField>,
-      BaseObject::InternalFieldSet<kOnReadFunctionField, &Value::IsFunction>);
+      BaseObject::InternalFieldGet<
+          StreamBase::kOnReadFunctionField>,
+      BaseObject::InternalFieldSet<
+          StreamBase::kOnReadFunctionField,
+          &Value::IsFunction>);
 }
 
 void StreamBase::GetFD(const FunctionCallbackInfo<Value>& args) {
diff --git a/src/stream_base.h b/src/stream_base.h
index 3df9e99f6e438e..15b83ec91f6387 100644
--- a/src/stream_base.h
+++ b/src/stream_base.h
@@ -29,7 +29,14 @@ using JSMethodFunction = void(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 class StreamReq {
  public:
-  static constexpr int kStreamReqField = 1;
+  // The kSlot internal field here mirrors BaseObject::InternalFields::kSlot
+  // here because instances derived from StreamReq will also derive from
+  // BaseObject, and the slots are used for the identical purpose.
+  enum InternalFields {
+    kSlot = BaseObject::kSlot,
+    kStreamReqField = BaseObject::kInternalFieldCount,
+    kInternalFieldCount
+  };
 
   explicit StreamReq(StreamBase* stream,
                      v8::Local<v8::Object> req_wrap_obj) : stream_(stream) {
@@ -275,10 +282,15 @@ class StreamResource {
 
 class StreamBase : public StreamResource {
  public:
-  // 0 is reserved for the BaseObject pointer.
-  static constexpr int kStreamBaseField = 1;
-  static constexpr int kOnReadFunctionField = 2;
-  static constexpr int kStreamBaseFieldCount = 3;
+  // The kSlot field here mirrors that of BaseObject::InternalFields::kSlot
+  // because instances deriving from StreamBase generally also derived from
+  // BaseObject (it's possible for it not to, however).
+  enum InternalFields {
+    kSlot = BaseObject::kSlot,
+    kStreamBaseField = BaseObject::kInternalFieldCount,
+    kOnReadFunctionField,
+    kInternalFieldCount
+  };
 
   static void AddMethods(Environment* env,
                          v8::Local<v8::FunctionTemplate> target);
diff --git a/src/stream_pipe.cc b/src/stream_pipe.cc
index 5f7514b1b84790..40b094ab5930a5 100644
--- a/src/stream_pipe.cc
+++ b/src/stream_pipe.cc
@@ -298,7 +298,8 @@ void InitializeStreamPipe(Local<Object> target,
   env->SetProtoMethod(pipe, "pendingWrites", StreamPipe::PendingWrites);
   pipe->Inherit(AsyncWrap::GetConstructorTemplate(env));
   pipe->SetClassName(stream_pipe_string);
-  pipe->InstanceTemplate()->SetInternalFieldCount(1);
+  pipe->InstanceTemplate()->SetInternalFieldCount(
+      StreamPipe::kInternalFieldCount);
   target
       ->Set(context, stream_pipe_string,
             pipe->GetFunction(context).ToLocalChecked())
diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc
index 21b775401e4571..7548516e477a36 100644
--- a/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@ -64,8 +64,7 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
   };
   Local<FunctionTemplate> sw =
       FunctionTemplate::New(env->isolate(), is_construct_call_callback);
-  sw->InstanceTemplate()->SetInternalFieldCount(
-      StreamReq::kStreamReqField + 1 + 3);
+  sw->InstanceTemplate()->SetInternalFieldCount(StreamReq::kInternalFieldCount);
   Local<String> wrapString =
       FIXED_ONE_BYTE_STRING(env->isolate(), "ShutdownWrap");
   sw->SetClassName(wrapString);
@@ -94,7 +93,8 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
 
   Local<FunctionTemplate> ww =
       FunctionTemplate::New(env->isolate(), is_construct_call_callback);
-  ww->InstanceTemplate()->SetInternalFieldCount(StreamReq::kStreamReqField + 1);
+  ww->InstanceTemplate()->SetInternalFieldCount(
+      StreamReq::kInternalFieldCount);
   Local<String> writeWrapString =
       FIXED_ONE_BYTE_STRING(env->isolate(), "WriteWrap");
   ww->SetClassName(writeWrapString);
@@ -136,7 +136,7 @@ Local<FunctionTemplate> LibuvStreamWrap::GetConstructorTemplate(
         FIXED_ONE_BYTE_STRING(env->isolate(), "LibuvStreamWrap"));
     tmpl->Inherit(HandleWrap::GetConstructorTemplate(env));
     tmpl->InstanceTemplate()->SetInternalFieldCount(
-        StreamBase::kStreamBaseFieldCount);
+        StreamBase::kInternalFieldCount);
     Local<FunctionTemplate> get_write_queue_size =
         FunctionTemplate::New(env->isolate(),
                               GetWriteQueueSize,
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index 89c4e215bbe6ae..1aca3a5e6aeeee 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -77,8 +77,7 @@ void TCPWrap::Initialize(Local<Object> target,
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
   Local<String> tcpString = FIXED_ONE_BYTE_STRING(env->isolate(), "TCP");
   t->SetClassName(tcpString);
-  t->InstanceTemplate()
-    ->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+  t->InstanceTemplate()->SetInternalFieldCount(StreamBase::kInternalFieldCount);
 
   // Init properties
   t->InstanceTemplate()->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "reading"),
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index 2f8da61f647f44..39dcf532a9fb7a 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -1269,8 +1269,7 @@ void TLSWrap::Initialize(Local<Object> target,
   Local<String> tlsWrapString =
       FIXED_ONE_BYTE_STRING(env->isolate(), "TLSWrap");
   t->SetClassName(tlsWrapString);
-  t->InstanceTemplate()
-    ->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+  t->InstanceTemplate()->SetInternalFieldCount(StreamBase::kInternalFieldCount);
 
   Local<FunctionTemplate> get_write_queue_size =
       FunctionTemplate::New(env->isolate(),
diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc
index 7dface926e4349..8536fae3ed7383 100644
--- a/src/tty_wrap.cc
+++ b/src/tty_wrap.cc
@@ -51,8 +51,7 @@ void TTYWrap::Initialize(Local<Object> target,
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
   t->SetClassName(ttyString);
-  t->InstanceTemplate()
-    ->SetInternalFieldCount(StreamBase::kStreamBaseFieldCount);
+  t->InstanceTemplate()->SetInternalFieldCount(StreamBase::kInternalFieldCount);
   t->Inherit(LibuvStreamWrap::GetConstructorTemplate(env));
 
   env->SetProtoMethodNoSideEffect(t, "getWindowSize", TTYWrap::GetWindowSize);
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 4a66ce0a1f1018..fa5cf8da479644 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -91,7 +91,7 @@ void UDPWrap::Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->InstanceTemplate()->SetInternalFieldCount(UDPWrap::kInternalFieldCount);
   Local<String> udpString =
       FIXED_ONE_BYTE_STRING(env->isolate(), "UDP");
   t->SetClassName(udpString);

From 6b44df24153aa9a6694c24a2fae2f30e0eff3129 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 27 Feb 2020 13:14:38 -0800
Subject: [PATCH 04/17] perf,src: add HistogramBase and internal/histogram.js

Separating this out from the QUIC PR to allow it to be separately
reviewed. The QUIC implementation makes use of the hdr_histogram
for dynamic performance monitoring. This introduces a BaseObject
class that allows the internal histograms to be accessed on the
JavaScript side and adds a generic Histogram class that will be
used by both QUIC and perf_hooks (for the event loop delay
monitoring).

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/31988
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/histogram.js |  94 +++++++++++++++++++++++++
 lib/perf_hooks.js         |  49 ++-----------
 node.gyp                  |   2 +
 src/env.h                 |   1 +
 src/histogram-inl.h       |  70 ++++++++++++-------
 src/histogram.cc          | 141 ++++++++++++++++++++++++++++++++++++++
 src/histogram.h           |  70 +++++++++++++++++--
 src/node_perf.h           |   2 +-
 8 files changed, 355 insertions(+), 74 deletions(-)
 create mode 100644 lib/internal/histogram.js
 create mode 100644 src/histogram.cc

diff --git a/lib/internal/histogram.js b/lib/internal/histogram.js
new file mode 100644
index 00000000000000..6deb8314a41bbb
--- /dev/null
+++ b/lib/internal/histogram.js
@@ -0,0 +1,94 @@
+'use strict';
+
+const {
+  customInspectSymbol: kInspect,
+} = require('internal/util');
+
+const { format } = require('util');
+const { Map, Symbol } = primordials;
+
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_ARG_VALUE,
+} = require('internal/errors').codes;
+
+const kDestroy = Symbol('kDestroy');
+const kHandle = Symbol('kHandle');
+
+// Histograms are created internally by Node.js and used to
+// record various metrics. This Histogram class provides a
+// generally read-only view of the internal histogram.
+class Histogram {
+  #handle = undefined;
+  #map = new Map();
+
+  constructor(internal) {
+    this.#handle = internal;
+  }
+
+  [kInspect]() {
+    const obj = {
+      min: this.min,
+      max: this.max,
+      mean: this.mean,
+      exceeds: this.exceeds,
+      stddev: this.stddev,
+      percentiles: this.percentiles,
+    };
+    return `Histogram ${format(obj)}`;
+  }
+
+  get min() {
+    return this.#handle ? this.#handle.min() : undefined;
+  }
+
+  get max() {
+    return this.#handle ? this.#handle.max() : undefined;
+  }
+
+  get mean() {
+    return this.#handle ? this.#handle.mean() : undefined;
+  }
+
+  get exceeds() {
+    return this.#handle ? this.#handle.exceeds() : undefined;
+  }
+
+  get stddev() {
+    return this.#handle ? this.#handle.stddev() : undefined;
+  }
+
+  percentile(percentile) {
+    if (typeof percentile !== 'number')
+      throw new ERR_INVALID_ARG_TYPE('percentile', 'number', percentile);
+
+    if (percentile <= 0 || percentile > 100)
+      throw new ERR_INVALID_ARG_VALUE.RangeError('percentile', percentile);
+
+    return this.#handle ? this.#handle.percentile(percentile) : undefined;
+  }
+
+  get percentiles() {
+    this.#map.clear();
+    if (this.#handle)
+      this.#handle.percentiles(this.#map);
+    return this.#map;
+  }
+
+  reset() {
+    if (this.#handle)
+      this.#handle.reset();
+  }
+
+  [kDestroy]() {
+    this.#handle = undefined;
+  }
+
+  get [kHandle]() { return this.#handle; }
+}
+
+module.exports = {
+  Histogram,
+  kDestroy,
+  kHandle,
+};
diff --git a/lib/perf_hooks.js b/lib/perf_hooks.js
index 267b4577ffee3d..a141705728227b 100644
--- a/lib/perf_hooks.js
+++ b/lib/perf_hooks.js
@@ -3,7 +3,6 @@
 const {
   ArrayIsArray,
   Boolean,
-  Map,
   NumberIsSafeInteger,
   ObjectDefineProperties,
   ObjectDefineProperty,
@@ -52,16 +51,18 @@ const kInspect = require('internal/util').customInspectSymbol;
 
 const {
   ERR_INVALID_CALLBACK,
-  ERR_INVALID_ARG_VALUE,
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_OPT_VALUE,
   ERR_VALID_PERFORMANCE_ENTRY_TYPE,
   ERR_INVALID_PERFORMANCE_MARK
 } = require('internal/errors').codes;
 
+const {
+  Histogram,
+  kHandle,
+} = require('internal/histogram');
+
 const { setImmediate } = require('timers');
-const kHandle = Symbol('handle');
-const kMap = Symbol('map');
 const kCallback = Symbol('callback');
 const kTypes = Symbol('types');
 const kEntries = Symbol('entries');
@@ -557,47 +558,9 @@ function sortedInsert(list, entry) {
   list.splice(location, 0, entry);
 }
 
-class ELDHistogram {
-  constructor(handle) {
-    this[kHandle] = handle;
-    this[kMap] = new Map();
-  }
-
-  reset() { this[kHandle].reset(); }
+class ELDHistogram extends Histogram {
   enable() { return this[kHandle].enable(); }
   disable() { return this[kHandle].disable(); }
-
-  get exceeds() { return this[kHandle].exceeds(); }
-  get min() { return this[kHandle].min(); }
-  get max() { return this[kHandle].max(); }
-  get mean() { return this[kHandle].mean(); }
-  get stddev() { return this[kHandle].stddev(); }
-  percentile(percentile) {
-    if (typeof percentile !== 'number') {
-      throw new ERR_INVALID_ARG_TYPE('percentile', 'number', percentile);
-    }
-    if (percentile <= 0 || percentile > 100) {
-      throw new ERR_INVALID_ARG_VALUE.RangeError('percentile',
-                                                 percentile);
-    }
-    return this[kHandle].percentile(percentile);
-  }
-  get percentiles() {
-    this[kMap].clear();
-    this[kHandle].percentiles(this[kMap]);
-    return this[kMap];
-  }
-
-  [kInspect]() {
-    return {
-      min: this.min,
-      max: this.max,
-      mean: this.mean,
-      stddev: this.stddev,
-      percentiles: this.percentiles,
-      exceeds: this.exceeds
-    };
-  }
 }
 
 function monitorEventLoopDelay(options = {}) {
diff --git a/node.gyp b/node.gyp
index 29dd0ed0c7a16e..5410e59fe78e42 100644
--- a/node.gyp
+++ b/node.gyp
@@ -140,6 +140,7 @@
       'lib/internal/fs/watchers.js',
       'lib/internal/http.js',
       'lib/internal/heap_utils.js',
+      'lib/internal/histogram.js',
       'lib/internal/idna.js',
       'lib/internal/inspector_async_hook.js',
       'lib/internal/js_stream_socket.js',
@@ -533,6 +534,7 @@
         'src/fs_event_wrap.cc',
         'src/handle_wrap.cc',
         'src/heap_utils.cc',
+        'src/histogram.cc',
         'src/js_native_api.h',
         'src/js_native_api_types.h',
         'src/js_native_api_v8.cc',
diff --git a/src/env.h b/src/env.h
index 260f816bcca621..a19a455c6dd183 100644
--- a/src/env.h
+++ b/src/env.h
@@ -406,6 +406,7 @@ constexpr size_t kFsStatsBufferLength =
   V(filehandlereadwrap_template, v8::ObjectTemplate)                           \
   V(fsreqpromise_constructor_template, v8::ObjectTemplate)                     \
   V(handle_wrap_ctor_template, v8::FunctionTemplate)                           \
+  V(histogram_instance_template, v8::ObjectTemplate)                           \
   V(http2settings_constructor_template, v8::ObjectTemplate)                    \
   V(http2stream_constructor_template, v8::ObjectTemplate)                      \
   V(http2ping_constructor_template, v8::ObjectTemplate)                        \
diff --git a/src/histogram-inl.h b/src/histogram-inl.h
index 3135041f7387a9..58911dae8f2dae 100644
--- a/src/histogram-inl.h
+++ b/src/histogram-inl.h
@@ -4,58 +4,78 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "histogram.h"
+#include "base_object-inl.h"
 #include "node_internals.h"
 
 namespace node {
 
-inline Histogram::Histogram(int64_t lowest, int64_t highest, int figures) {
-  CHECK_EQ(0, hdr_init(lowest, highest, figures, &histogram_));
+void Histogram::Reset() {
+  hdr_reset(histogram_.get());
 }
 
-inline Histogram::~Histogram() {
-  hdr_close(histogram_);
+bool Histogram::Record(int64_t value) {
+  return hdr_record_value(histogram_.get(), value);
 }
 
-inline void Histogram::Reset() {
-  hdr_reset(histogram_);
+int64_t Histogram::Min() {
+  return hdr_min(histogram_.get());
 }
 
-inline bool Histogram::Record(int64_t value) {
-  return hdr_record_value(histogram_, value);
+int64_t Histogram::Max() {
+  return hdr_max(histogram_.get());
 }
 
-inline int64_t Histogram::Min() {
-  return hdr_min(histogram_);
+double Histogram::Mean() {
+  return hdr_mean(histogram_.get());
 }
 
-inline int64_t Histogram::Max() {
-  return hdr_max(histogram_);
+double Histogram::Stddev() {
+  return hdr_stddev(histogram_.get());
 }
 
-inline double Histogram::Mean() {
-  return hdr_mean(histogram_);
-}
-
-inline double Histogram::Stddev() {
-  return hdr_stddev(histogram_);
-}
-
-inline double Histogram::Percentile(double percentile) {
+double Histogram::Percentile(double percentile) {
   CHECK_GT(percentile, 0);
   CHECK_LE(percentile, 100);
-  return hdr_value_at_percentile(histogram_, percentile);
+  return static_cast<double>(
+      hdr_value_at_percentile(histogram_.get(), percentile));
 }
 
-inline void Histogram::Percentiles(std::function<void(double, double)> fn) {
+template <typename Iterator>
+void Histogram::Percentiles(Iterator&& fn) {
   hdr_iter iter;
-  hdr_iter_percentile_init(&iter, histogram_, 1);
+  hdr_iter_percentile_init(&iter, histogram_.get(), 1);
   while (hdr_iter_next(&iter)) {
     double key = iter.specifics.percentiles.percentile;
-    double value = iter.value;
+    double value = static_cast<double>(iter.value);
     fn(key, value);
   }
 }
 
+bool HistogramBase::RecordDelta() {
+  uint64_t time = uv_hrtime();
+  bool ret = true;
+  if (prev_ > 0) {
+    int64_t delta = time - prev_;
+    if (delta > 0) {
+      ret = Record(delta);
+      TraceDelta(delta);
+      if (!ret) {
+        if (exceeds_ < 0xFFFFFFFF)
+          exceeds_++;
+        TraceExceeds(delta);
+      }
+    }
+  }
+  prev_ = time;
+  return ret;
+}
+
+void HistogramBase::ResetState() {
+  Reset();
+  exceeds_ = 0;
+  prev_ = 0;
+}
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/histogram.cc b/src/histogram.cc
new file mode 100644
index 00000000000000..8d1eb77b1bc88e
--- /dev/null
+++ b/src/histogram.cc
@@ -0,0 +1,141 @@
+#include "histogram.h"  // NOLINT(build/include_inline)
+#include "histogram-inl.h"
+#include "memory_tracker-inl.h"
+
+namespace node {
+
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Local;
+using v8::Map;
+using v8::Number;
+using v8::ObjectTemplate;
+using v8::String;
+using v8::Value;
+
+Histogram::Histogram(int64_t lowest, int64_t highest, int figures) {
+  hdr_histogram* histogram;
+  CHECK_EQ(0, hdr_init(lowest, highest, figures, &histogram));
+  histogram_.reset(histogram);
+}
+
+HistogramBase::HistogramBase(
+    Environment* env,
+    v8::Local<v8::Object> wrap,
+    int64_t lowest,
+    int64_t highest,
+    int figures)
+    : BaseObject(env, wrap),
+      Histogram(lowest, highest, figures) {
+  MakeWeak();
+}
+
+void HistogramBase::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("histogram", GetMemorySize());
+}
+
+void HistogramBase::GetMin(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>(histogram->Min());
+  args.GetReturnValue().Set(value);
+}
+
+void HistogramBase::GetMax(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>(histogram->Max());
+  args.GetReturnValue().Set(value);
+}
+
+void HistogramBase::GetMean(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  args.GetReturnValue().Set(histogram->Mean());
+}
+
+void HistogramBase::GetExceeds(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>(histogram->Exceeds());
+  args.GetReturnValue().Set(value);
+}
+
+void HistogramBase::GetStddev(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  args.GetReturnValue().Set(histogram->Stddev());
+}
+
+void HistogramBase::GetPercentile(
+    const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  CHECK(args[0]->IsNumber());
+  double percentile = args[0].As<Number>()->Value();
+  args.GetReturnValue().Set(histogram->Percentile(percentile));
+}
+
+void HistogramBase::GetPercentiles(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  CHECK(args[0]->IsMap());
+  Local<Map> map = args[0].As<Map>();
+  histogram->Percentiles([map, env](double key, double value) {
+    map->Set(
+        env->context(),
+        Number::New(env->isolate(), key),
+        Number::New(env->isolate(), value)).IsEmpty();
+  });
+}
+
+void HistogramBase::DoReset(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  histogram->ResetState();
+}
+
+BaseObjectPtr<HistogramBase> HistogramBase::New(
+    Environment* env,
+    int64_t lowest,
+    int64_t highest,
+    int figures) {
+  CHECK_LE(lowest, highest);
+  CHECK_GT(figures, 0);
+  v8::Local<v8::Object> obj;
+  auto tmpl = env->histogram_instance_template();
+  if (!tmpl->NewInstance(env->context()).ToLocal(&obj))
+    return {};
+
+  return MakeDetachedBaseObject<HistogramBase>(
+      env, obj, lowest, highest, figures);
+}
+
+void HistogramBase::Initialize(Environment* env) {
+  // Guard against multiple initializations
+  if (!env->histogram_instance_template().IsEmpty())
+    return;
+
+  Local<FunctionTemplate> histogram = FunctionTemplate::New(env->isolate());
+  Local<String> classname = FIXED_ONE_BYTE_STRING(env->isolate(), "Histogram");
+  histogram->SetClassName(classname);
+
+  Local<ObjectTemplate> histogramt =
+    histogram->InstanceTemplate();
+
+  histogramt->SetInternalFieldCount(1);
+  env->SetProtoMethod(histogram, "exceeds", HistogramBase::GetExceeds);
+  env->SetProtoMethod(histogram, "min", HistogramBase::GetMin);
+  env->SetProtoMethod(histogram, "max", HistogramBase::GetMax);
+  env->SetProtoMethod(histogram, "mean", HistogramBase::GetMean);
+  env->SetProtoMethod(histogram, "stddev", HistogramBase::GetStddev);
+  env->SetProtoMethod(histogram, "percentile", HistogramBase::GetPercentile);
+  env->SetProtoMethod(histogram, "percentiles", HistogramBase::GetPercentiles);
+  env->SetProtoMethod(histogram, "reset", HistogramBase::DoReset);
+
+  env->set_histogram_instance_template(histogramt);
+}
+
+}  // namespace node
diff --git a/src/histogram.h b/src/histogram.h
index eb94af5da2a997..e92c31c4724ac6 100644
--- a/src/histogram.h
+++ b/src/histogram.h
@@ -4,15 +4,24 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "hdr_histogram.h"
+#include "base_object.h"
+#include "util.h"
+
 #include <functional>
+#include <limits>
 #include <map>
 
 namespace node {
 
+constexpr int kDefaultHistogramFigures = 3;
+
 class Histogram {
  public:
-  inline Histogram(int64_t lowest, int64_t highest, int figures = 3);
-  inline virtual ~Histogram();
+  Histogram(
+      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+  virtual ~Histogram() = default;
 
   inline bool Record(int64_t value);
   inline void Reset();
@@ -21,14 +30,65 @@ class Histogram {
   inline double Mean();
   inline double Stddev();
   inline double Percentile(double percentile);
-  inline void Percentiles(std::function<void(double, double)> fn);
+
+  // Iterator is a function type that takes two doubles as argument, one for
+  // percentile and one for the value at that percentile.
+  template <typename Iterator>
+  inline void Percentiles(Iterator&& fn);
 
   size_t GetMemorySize() const {
-    return hdr_get_memory_size(histogram_);
+    return hdr_get_memory_size(histogram_.get());
   }
 
  private:
-  hdr_histogram* histogram_;
+  using HistogramPointer = DeleteFnPtr<hdr_histogram, hdr_close>;
+  HistogramPointer histogram_;
+};
+
+class HistogramBase : public BaseObject, public Histogram {
+ public:
+  virtual ~HistogramBase() = default;
+
+  virtual void TraceDelta(int64_t delta) {}
+  virtual void TraceExceeds(int64_t delta) {}
+
+  inline bool RecordDelta();
+  inline void ResetState();
+
+  int64_t Exceeds() const { return exceeds_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HistogramBase)
+  SET_SELF_SIZE(HistogramBase)
+
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Initialize(Environment* env);
+
+  static BaseObjectPtr<HistogramBase> New(
+      Environment* env,
+      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+
+ private:
+  int64_t exceeds_ = 0;
+  uint64_t prev_ = 0;
 };
 
 }  // namespace node
diff --git a/src/node_perf.h b/src/node_perf.h
index 4f5ca93f223289..ac65533a772e36 100644
--- a/src/node_perf.h
+++ b/src/node_perf.h
@@ -161,7 +161,7 @@ class ELDHistogram : public HandleWrap, public Histogram {
     exceeds_ = 0;
     prev_ = 0;
   }
-  int64_t Exceeds() { return exceeds_; }
+  int64_t Exceeds() const { return exceeds_; }
 
   void MemoryInfo(MemoryTracker* tracker) const override {
     tracker->TrackFieldWithSize("histogram", GetMemorySize());

From be9081755816d2fb66d51dafc554c1407e7860a2 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Sat, 29 Feb 2020 09:48:44 -0800
Subject: [PATCH 05/17] test: remove common.port from
 test-tls-securepair-client

OpenSSL s_server accepts port 0 as an indicator to use an open port
provided by the operating system. Use that instead of common.PORT in the
test.

Remove 500ms delay added in 8e461673c44cb550a7aadc20f0af6453810f1b18.
Hopefully the race condition in OpenSSL s_server has been fixed and/or
the change to port 0 means that the server is listening by the time
the ACCEPT text is printed and the setTimeout() is no longer necessary.

PR-URL: https://github.com/nodejs/node/pull/32024
Reviewed-By: Ben Coe <bencoe@gmail.com>
Reviewed-By: Sam Roberts <vieuxtech@gmail.com>
---
 test/sequential/test-tls-securepair-client.js | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/test/sequential/test-tls-securepair-client.js b/test/sequential/test-tls-securepair-client.js
index c450410baf907c..d5e2b7b7d2b08d 100644
--- a/test/sequential/test-tls-securepair-client.js
+++ b/test/sequential/test-tls-securepair-client.js
@@ -62,7 +62,7 @@ function test(keyPath, certPath, check, next) {
   const cert = fixtures.readSync(certPath).toString();
 
   const server = spawn(common.opensslCli, ['s_server',
-                                           '-accept', common.PORT,
+                                           '-accept', 0,
                                            '-cert', fixtures.path(certPath),
                                            '-key', fixtures.path(keyPath)]);
   server.stdout.pipe(process.stdout);
@@ -78,10 +78,11 @@ function test(keyPath, certPath, check, next) {
     console.log(state);
     switch (state) {
       case 'WAIT-ACCEPT':
-        if (/ACCEPT/.test(serverStdoutBuffer)) {
-          // Give s_server half a second to start up.
-          setTimeout(startClient, 500);
+        const matches = serverStdoutBuffer.match(/ACCEPT .*?:(\d+)/);
+        if (matches) {
+          const port = matches[1];
           state = 'WAIT-HELLO';
+          startClient(port);
         }
         break;
 
@@ -117,7 +118,7 @@ function test(keyPath, certPath, check, next) {
   });
 
 
-  function startClient() {
+  function startClient(port) {
     const s = new net.Stream();
 
     const sslcontext = tls.createSecureContext({ key, cert });
@@ -131,7 +132,7 @@ function test(keyPath, certPath, check, next) {
     pair.encrypted.pipe(s);
     s.pipe(pair.encrypted);
 
-    s.connect(common.PORT);
+    s.connect(port);
 
     s.on('connect', function() {
       console.log('client connected');

From 3c8daa3aa04dd06389722f180ba4e35fc61b8806 Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Tue, 18 Feb 2020 15:33:31 +0100
Subject: [PATCH 06/17] events: convert errorMonitor to a normal property
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Convert property errorMonitor to a normal property as non-writable
caused unwanted side effects.

Refs: https://github.com/nodejs/node/pull/30932#discussion_r379679982

PR-URL: https://github.com/nodejs/node/pull/31848
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matheus Marchini <mat@mmarchini.me>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 lib/events.js | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/lib/events.js b/lib/events.js
index 76b376e789115f..4a8311af059295 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -90,12 +90,7 @@ ObjectDefineProperty(EventEmitter, 'captureRejections', {
   enumerable: true
 });
 
-ObjectDefineProperty(EventEmitter, 'errorMonitor', {
-  value: kErrorMonitor,
-  writable: false,
-  configurable: true,
-  enumerable: true
-});
+EventEmitter.errorMonitor = kErrorMonitor;
 
 // The default for captureRejections is false
 ObjectDefineProperty(EventEmitter.prototype, kCapture, {

From 1539928ed915f54f5c2c1a1cafdb29d3b898f897 Mon Sep 17 00:00:00 2001
From: Andrey Pechkurov <apechkurov@gmail.com>
Date: Wed, 26 Feb 2020 09:38:48 +0300
Subject: [PATCH 07/17] test: add GC test for disabled AsyncLocalStorage

PR-URL: https://github.com/nodejs/node/pull/31995
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Vladimir de Turckheim <vlad2t@hotmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 .../test-async-local-storage-gcable.js        | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 test/async-hooks/test-async-local-storage-gcable.js

diff --git a/test/async-hooks/test-async-local-storage-gcable.js b/test/async-hooks/test-async-local-storage-gcable.js
new file mode 100644
index 00000000000000..37b04b38d14588
--- /dev/null
+++ b/test/async-hooks/test-async-local-storage-gcable.js
@@ -0,0 +1,20 @@
+'use strict';
+// Flags: --expose_gc
+
+// This test ensures that AsyncLocalStorage gets gced once it was disabled
+// and no strong references remain in userland.
+
+const common = require('../common');
+const { AsyncLocalStorage } = require('async_hooks');
+const onGC = require('../common/ongc');
+
+let asyncLocalStorage = new AsyncLocalStorage();
+
+asyncLocalStorage.runSyncAndReturn({}, () => {
+  asyncLocalStorage.disable();
+
+  onGC(asyncLocalStorage, { ongc: common.mustCall() });
+});
+
+asyncLocalStorage = null;
+global.gc();

From 755da035ceff4fd3f347efba1d731fce0038f968 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 28 Feb 2020 17:13:08 -0800
Subject: [PATCH 08/17] src: add node_crypto_common and refactor

Two things in one on this commit:

(a) For the QUIC implementation, we need to separate out various bits
    from node_crypto.cc to allow them to be reused. That's where this
    commit starts.

(b) Quite a bit of the node_crypto.cc code was just messy in terms of
    it's organization and lack of error handling and use of Local vs.
    MaybeLocal. This cleans that up a bit and hopefully makes certain
    parts a bit more manageable also.

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/32016
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Sam Roberts <vieuxtech@gmail.com>
---
 node.gyp                  |    2 +
 src/env.h                 |    2 +
 src/node_crypto.cc        |  637 +--------------------
 src/node_crypto.h         |   13 +
 src/node_crypto_common.cc | 1110 +++++++++++++++++++++++++++++++++++++
 src/node_crypto_common.h  |  139 +++++
 src/string_bytes.cc       |   12 +-
 src/string_bytes.h        |    9 +
 8 files changed, 1313 insertions(+), 611 deletions(-)
 create mode 100644 src/node_crypto_common.cc
 create mode 100644 src/node_crypto_common.h

diff --git a/node.gyp b/node.gyp
index 5410e59fe78e42..b0757da045d1f9 100644
--- a/node.gyp
+++ b/node.gyp
@@ -822,9 +822,11 @@
         [ 'node_use_openssl=="true"', {
           'sources': [
             'src/node_crypto.cc',
+            'src/node_crypto_common.cc',
             'src/node_crypto_bio.cc',
             'src/node_crypto_clienthello.cc',
             'src/node_crypto.h',
+            'src/node_crypto_common.h',
             'src/node_crypto_bio.h',
             'src/node_crypto_clienthello.h',
             'src/node_crypto_clienthello-inl.h',
diff --git a/src/env.h b/src/env.h
index a19a455c6dd183..3c6aeb0f4ce6eb 100644
--- a/src/env.h
+++ b/src/env.h
@@ -206,6 +206,7 @@ constexpr size_t kFsStatsBufferLength =
   V(dest_string, "dest")                                                       \
   V(destroyed_string, "destroyed")                                             \
   V(detached_string, "detached")                                               \
+  V(dh_string, "DH")                                                           \
   V(dns_a_string, "A")                                                         \
   V(dns_aaaa_string, "AAAA")                                                   \
   V(dns_cname_string, "CNAME")                                                 \
@@ -219,6 +220,7 @@ constexpr size_t kFsStatsBufferLength =
   V(done_string, "done")                                                       \
   V(dot_string, ".")                                                           \
   V(duration_string, "duration")                                               \
+  V(ecdh_string, "ECDH")                                                       \
   V(emit_warning_string, "emitWarning")                                        \
   V(empty_object_string, "{}")                                                 \
   V(encoding_string, "encoding")                                               \
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 0b48821cf6c8af..fdaf91acdc0a1c 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -22,6 +22,7 @@
 #include "node_crypto.h"
 #include "node_buffer.h"
 #include "node_crypto_bio.h"
+#include "node_crypto_common.h"
 #include "node_crypto_clienthello-inl.h"
 #include "node_crypto_groups.h"
 #include "node_errors.h"
@@ -59,11 +60,6 @@
 #include <utility>
 #include <vector>
 
-static const int X509_NAME_FLAGS = ASN1_STRFLGS_ESC_CTRL
-                                 | ASN1_STRFLGS_UTF8_CONVERT
-                                 | XN_FLAG_SEP_MULTILINE
-                                 | XN_FLAG_FN_SN;
-
 namespace node {
 namespace crypto {
 
@@ -75,7 +71,6 @@ using v8::Boolean;
 using v8::ConstructorBehavior;
 using v8::Context;
 using v8::DontDelete;
-using v8::EscapableHandleScope;
 using v8::Exception;
 using v8::External;
 using v8::False;
@@ -110,24 +105,6 @@ using v8::Value;
 # define IS_OCB_MODE(mode) ((mode) == EVP_CIPH_OCB_MODE)
 #endif
 
-struct StackOfX509Deleter {
-  void operator()(STACK_OF(X509)* p) const { sk_X509_pop_free(p, X509_free); }
-};
-using StackOfX509 = std::unique_ptr<STACK_OF(X509), StackOfX509Deleter>;
-
-struct StackOfXASN1Deleter {
-  void operator()(STACK_OF(ASN1_OBJECT)* p) const {
-    sk_ASN1_OBJECT_pop_free(p, ASN1_OBJECT_free);
-  }
-};
-using StackOfASN1 = std::unique_ptr<STACK_OF(ASN1_OBJECT), StackOfXASN1Deleter>;
-
-// OPENSSL_free is a macro, so we need a wrapper function.
-struct OpenSSLBufferDeleter {
-  void operator()(char* pointer) const { OPENSSL_free(pointer); }
-};
-using OpenSSLBuffer = std::unique_ptr<char[], OpenSSLBufferDeleter>;
-
 static const char* const root_certs[] = {
 #include "node_root_certs.h"  // NOLINT(build/include_order)
 };
@@ -386,7 +363,7 @@ void ThrowCryptoError(Environment* env,
                       unsigned long err,  // NOLINT(runtime/int)
                       // Default, only used if there is no SSL `err` which can
                       // be used to create a long-style message string.
-                      const char* message = nullptr) {
+                      const char* message) {
   char message_buffer[128] = {0};
   if (err != 0 || message == nullptr) {
     ERR_error_string_n(err, message_buffer, sizeof(message_buffer));
@@ -453,15 +430,6 @@ bool EntropySource(unsigned char* buffer, size_t length) {
   return RAND_bytes(buffer, length) != -1;
 }
 
-
-template <typename T>
-static T* MallocOpenSSL(size_t count) {
-  void* mem = OPENSSL_malloc(MultiplyWithOverflowCheck(count, sizeof(T)));
-  CHECK_IMPLIES(mem == nullptr, count == 0);
-  return static_cast<T*>(mem);
-}
-
-
 void SecureContext::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
   t->InstanceTemplate()->SetInternalFieldCount(
@@ -831,16 +799,6 @@ void SecureContext::SetEngineKey(const FunctionCallbackInfo<Value>& args) {
 }
 #endif  // !OPENSSL_NO_ENGINE
 
-int SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert, X509** issuer) {
-  X509_STORE* store = SSL_CTX_get_cert_store(ctx);
-  DeleteFnPtr<X509_STORE_CTX, X509_STORE_CTX_free> store_ctx(
-      X509_STORE_CTX_new());
-  return store_ctx.get() != nullptr &&
-         X509_STORE_CTX_init(store_ctx.get(), store, nullptr, nullptr) == 1 &&
-         X509_STORE_CTX_get1_issuer(issuer, store_ctx.get(), cert) == 1;
-}
-
-
 int SSL_CTX_use_certificate_chain(SSL_CTX* ctx,
                                   X509Pointer&& x,
                                   STACK_OF(X509)* extra_certs,
@@ -1893,381 +1851,6 @@ void SSLWrap<Base>::OnClientHello(void* arg,
   w->MakeCallback(env->onclienthello_string(), arraysize(argv), argv);
 }
 
-
-static bool SafeX509ExtPrint(BIO* out, X509_EXTENSION* ext) {
-  const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
-
-  if (method != X509V3_EXT_get_nid(NID_subject_alt_name))
-    return false;
-
-  GENERAL_NAMES* names = static_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(ext));
-  if (names == nullptr)
-    return false;
-
-  for (int i = 0; i < sk_GENERAL_NAME_num(names); i++) {
-    GENERAL_NAME* gen = sk_GENERAL_NAME_value(names, i);
-
-    if (i != 0)
-      BIO_write(out, ", ", 2);
-
-    if (gen->type == GEN_DNS) {
-      ASN1_IA5STRING* name = gen->d.dNSName;
-
-      BIO_write(out, "DNS:", 4);
-      BIO_write(out, name->data, name->length);
-    } else {
-      STACK_OF(CONF_VALUE)* nval = i2v_GENERAL_NAME(
-          const_cast<X509V3_EXT_METHOD*>(method), gen, nullptr);
-      if (nval == nullptr)
-        return false;
-      X509V3_EXT_val_prn(out, nval, 0, 0);
-      sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
-    }
-  }
-  sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
-
-  return true;
-}
-
-
-static void AddFingerprintDigest(const unsigned char* md,
-                                 unsigned int md_size,
-                                 char (*fingerprint)[3 * EVP_MAX_MD_SIZE + 1]) {
-  unsigned int i;
-  const char hex[] = "0123456789ABCDEF";
-
-  for (i = 0; i < md_size; i++) {
-    (*fingerprint)[3*i] = hex[(md[i] & 0xf0) >> 4];
-    (*fingerprint)[(3*i)+1] = hex[(md[i] & 0x0f)];
-    (*fingerprint)[(3*i)+2] = ':';
-  }
-
-  if (md_size > 0) {
-    (*fingerprint)[(3*(md_size-1))+2] = '\0';
-  } else {
-    (*fingerprint)[0] = '\0';
-  }
-}
-
-
-static MaybeLocal<Object> ECPointToBuffer(Environment* env,
-                                          const EC_GROUP* group,
-                                          const EC_POINT* point,
-                                          point_conversion_form_t form,
-                                          const char** error) {
-  size_t len = EC_POINT_point2oct(group, point, form, nullptr, 0, nullptr);
-  if (len == 0) {
-    if (error != nullptr) *error = "Failed to get public key length";
-    return MaybeLocal<Object>();
-  }
-  AllocatedBuffer buf = env->AllocateManaged(len);
-  len = EC_POINT_point2oct(group,
-                           point,
-                           form,
-                           reinterpret_cast<unsigned char*>(buf.data()),
-                           buf.size(),
-                           nullptr);
-  if (len == 0) {
-    if (error != nullptr) *error = "Failed to get public key";
-    return MaybeLocal<Object>();
-  }
-  return buf.ToBuffer();
-}
-
-
-static Local<Object> X509ToObject(Environment* env, X509* cert) {
-  EscapableHandleScope scope(env->isolate());
-  Local<Context> context = env->context();
-  Local<Object> info = Object::New(env->isolate());
-
-  BIOPointer bio(BIO_new(BIO_s_mem()));
-  BUF_MEM* mem;
-  if (X509_NAME_print_ex(bio.get(),
-                         X509_get_subject_name(cert),
-                         0,
-                         X509_NAME_FLAGS) > 0) {
-    BIO_get_mem_ptr(bio.get(), &mem);
-    info->Set(context, env->subject_string(),
-              String::NewFromUtf8(env->isolate(), mem->data,
-                                  NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).Check();
-  }
-  USE(BIO_reset(bio.get()));
-
-  X509_NAME* issuer_name = X509_get_issuer_name(cert);
-  if (X509_NAME_print_ex(bio.get(), issuer_name, 0, X509_NAME_FLAGS) > 0) {
-    BIO_get_mem_ptr(bio.get(), &mem);
-    info->Set(context, env->issuer_string(),
-              String::NewFromUtf8(env->isolate(), mem->data,
-                                  NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).Check();
-  }
-  USE(BIO_reset(bio.get()));
-
-  int nids[] = { NID_subject_alt_name, NID_info_access };
-  Local<String> keys[] = { env->subjectaltname_string(),
-                           env->infoaccess_string() };
-  CHECK_EQ(arraysize(nids), arraysize(keys));
-  for (size_t i = 0; i < arraysize(nids); i++) {
-    int index = X509_get_ext_by_NID(cert, nids[i], -1);
-    if (index < 0)
-      continue;
-
-    X509_EXTENSION* ext = X509_get_ext(cert, index);
-    CHECK_NOT_NULL(ext);
-
-    if (!SafeX509ExtPrint(bio.get(), ext) &&
-        X509V3_EXT_print(bio.get(), ext, 0, 0) != 1) {
-      info->Set(context, keys[i], Null(env->isolate())).Check();
-      USE(BIO_reset(bio.get()));
-      continue;
-    }
-
-    BIO_get_mem_ptr(bio.get(), &mem);
-    info->Set(context, keys[i],
-              String::NewFromUtf8(env->isolate(), mem->data,
-                                  NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).Check();
-
-    USE(BIO_reset(bio.get()));
-  }
-
-  EVPKeyPointer pkey(X509_get_pubkey(cert));
-  RSAPointer rsa;
-  ECPointer ec;
-  if (pkey) {
-    switch (EVP_PKEY_id(pkey.get())) {
-      case EVP_PKEY_RSA:
-        rsa.reset(EVP_PKEY_get1_RSA(pkey.get()));
-        break;
-      case EVP_PKEY_EC:
-        ec.reset(EVP_PKEY_get1_EC_KEY(pkey.get()));
-        break;
-    }
-  }
-
-  if (rsa) {
-    const BIGNUM* n;
-    const BIGNUM* e;
-    RSA_get0_key(rsa.get(), &n, &e, nullptr);
-    BN_print(bio.get(), n);
-    BIO_get_mem_ptr(bio.get(), &mem);
-    info->Set(context, env->modulus_string(),
-              String::NewFromUtf8(env->isolate(), mem->data,
-                                  NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).Check();
-    USE(BIO_reset(bio.get()));
-
-    int bits = BN_num_bits(n);
-    info->Set(context, env->bits_string(),
-              Integer::New(env->isolate(), bits)).Check();
-
-    uint64_t exponent_word = static_cast<uint64_t>(BN_get_word(e));
-    uint32_t lo = static_cast<uint32_t>(exponent_word);
-    uint32_t hi = static_cast<uint32_t>(exponent_word >> 32);
-    if (hi == 0) {
-      BIO_printf(bio.get(), "0x%x", lo);
-    } else {
-      BIO_printf(bio.get(), "0x%x%08x", hi, lo);
-    }
-    BIO_get_mem_ptr(bio.get(), &mem);
-    info->Set(context, env->exponent_string(),
-              String::NewFromUtf8(env->isolate(), mem->data,
-                                  NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).Check();
-    USE(BIO_reset(bio.get()));
-
-    int size = i2d_RSA_PUBKEY(rsa.get(), nullptr);
-    CHECK_GE(size, 0);
-    Local<Object> pubbuff = Buffer::New(env, size).ToLocalChecked();
-    unsigned char* pubserialized =
-        reinterpret_cast<unsigned char*>(Buffer::Data(pubbuff));
-    i2d_RSA_PUBKEY(rsa.get(), &pubserialized);
-    info->Set(env->context(), env->pubkey_string(), pubbuff).Check();
-  } else if (ec) {
-    const EC_GROUP* group = EC_KEY_get0_group(ec.get());
-    if (group != nullptr) {
-      int bits = EC_GROUP_order_bits(group);
-      if (bits > 0) {
-        info->Set(context, env->bits_string(),
-                  Integer::New(env->isolate(), bits)).Check();
-      }
-    }
-
-    const EC_POINT* pubkey = EC_KEY_get0_public_key(ec.get());
-    Local<Object> buf;
-    if (pubkey != nullptr &&
-        ECPointToBuffer(
-            env, group, pubkey, EC_KEY_get_conv_form(ec.get()), nullptr)
-            .ToLocal(&buf)) {
-      info->Set(context, env->pubkey_string(), buf).Check();
-    }
-
-    const int nid = EC_GROUP_get_curve_name(group);
-    if (nid != 0) {
-      // Curve is well-known, get its OID and NIST nick-name (if it has one).
-
-      if (const char* sn = OBJ_nid2sn(nid)) {
-        info->Set(context, env->asn1curve_string(),
-                  OneByteString(env->isolate(), sn)).Check();
-      }
-
-      if (const char* nist = EC_curve_nid2nist(nid)) {
-        info->Set(context, env->nistcurve_string(),
-                  OneByteString(env->isolate(), nist)).Check();
-      }
-    } else {
-      // Unnamed curves can be described by their mathematical properties,
-      // but aren't used much (at all?) with X.509/TLS. Support later if needed.
-    }
-  }
-
-  pkey.reset();
-  rsa.reset();
-  ec.reset();
-
-  ASN1_TIME_print(bio.get(), X509_get0_notBefore(cert));
-  BIO_get_mem_ptr(bio.get(), &mem);
-  info->Set(context, env->valid_from_string(),
-            String::NewFromUtf8(env->isolate(), mem->data,
-                                NewStringType::kNormal,
-                                mem->length).ToLocalChecked()).Check();
-  USE(BIO_reset(bio.get()));
-
-  ASN1_TIME_print(bio.get(), X509_get0_notAfter(cert));
-  BIO_get_mem_ptr(bio.get(), &mem);
-  info->Set(context, env->valid_to_string(),
-            String::NewFromUtf8(env->isolate(), mem->data,
-                                NewStringType::kNormal,
-                                mem->length).ToLocalChecked()).Check();
-  bio.reset();
-
-  unsigned char md[EVP_MAX_MD_SIZE];
-  unsigned int md_size;
-  char fingerprint[EVP_MAX_MD_SIZE * 3 + 1];
-  if (X509_digest(cert, EVP_sha1(), md, &md_size)) {
-      AddFingerprintDigest(md, md_size, &fingerprint);
-      info->Set(context, env->fingerprint_string(),
-                OneByteString(env->isolate(), fingerprint)).Check();
-  }
-  if (X509_digest(cert, EVP_sha256(), md, &md_size)) {
-      AddFingerprintDigest(md, md_size, &fingerprint);
-      info->Set(context, env->fingerprint256_string(),
-                OneByteString(env->isolate(), fingerprint)).Check();
-  }
-
-  StackOfASN1 eku(static_cast<STACK_OF(ASN1_OBJECT)*>(
-      X509_get_ext_d2i(cert, NID_ext_key_usage, nullptr, nullptr)));
-  if (eku) {
-    const int count = sk_ASN1_OBJECT_num(eku.get());
-    MaybeStackBuffer<Local<Value>, 16> ext_key_usage(count);
-    char buf[256];
-
-    int j = 0;
-    for (int i = 0; i < count; i++) {
-      if (OBJ_obj2txt(buf,
-                      sizeof(buf),
-                      sk_ASN1_OBJECT_value(eku.get(), i), 1) >= 0) {
-        ext_key_usage[j++] = OneByteString(env->isolate(), buf);
-      }
-    }
-
-    eku.reset();
-    info->Set(context, env->ext_key_usage_string(),
-              Array::New(env->isolate(), ext_key_usage.out(), count)).Check();
-  }
-
-  if (ASN1_INTEGER* serial_number = X509_get_serialNumber(cert)) {
-    BignumPointer bn(ASN1_INTEGER_to_BN(serial_number, nullptr));
-    if (bn) {
-      OpenSSLBuffer buf(BN_bn2hex(bn.get()));
-      if (buf) {
-        info->Set(context, env->serial_number_string(),
-                  OneByteString(env->isolate(), buf.get())).Check();
-      }
-    }
-  }
-
-  // Raw DER certificate
-  int size = i2d_X509(cert, nullptr);
-  Local<Object> buff = Buffer::New(env, size).ToLocalChecked();
-  unsigned char* serialized = reinterpret_cast<unsigned char*>(
-      Buffer::Data(buff));
-  i2d_X509(cert, &serialized);
-  info->Set(context, env->raw_string(), buff).Check();
-
-  return scope.Escape(info);
-}
-
-
-static Local<Object> AddIssuerChainToObject(X509Pointer* cert,
-                                            Local<Object> object,
-                                            StackOfX509&& peer_certs,
-                                            Environment* const env) {
-  Local<Context> context = env->isolate()->GetCurrentContext();
-  cert->reset(sk_X509_delete(peer_certs.get(), 0));
-  for (;;) {
-    int i;
-    for (i = 0; i < sk_X509_num(peer_certs.get()); i++) {
-      X509* ca = sk_X509_value(peer_certs.get(), i);
-      if (X509_check_issued(ca, cert->get()) != X509_V_OK)
-        continue;
-
-      Local<Object> ca_info = X509ToObject(env, ca);
-      object->Set(context, env->issuercert_string(), ca_info).Check();
-      object = ca_info;
-
-      // NOTE: Intentionally freeing cert that is not used anymore.
-      // Delete cert and continue aggregating issuers.
-      cert->reset(sk_X509_delete(peer_certs.get(), i));
-      break;
-    }
-
-    // Issuer not found, break out of the loop.
-    if (i == sk_X509_num(peer_certs.get()))
-      break;
-  }
-  return object;
-}
-
-
-static StackOfX509 CloneSSLCerts(X509Pointer&& cert,
-                                 const STACK_OF(X509)* const ssl_certs) {
-  StackOfX509 peer_certs(sk_X509_new(nullptr));
-  if (cert)
-    sk_X509_push(peer_certs.get(), cert.release());
-  for (int i = 0; i < sk_X509_num(ssl_certs); i++) {
-    X509Pointer cert(X509_dup(sk_X509_value(ssl_certs, i)));
-    if (!cert || !sk_X509_push(peer_certs.get(), cert.get()))
-      return StackOfX509();
-    // `cert` is now managed by the stack.
-    cert.release();
-  }
-  return peer_certs;
-}
-
-
-static Local<Object> GetLastIssuedCert(X509Pointer* cert,
-                                       const SSLPointer& ssl,
-                                       Local<Object> issuer_chain,
-                                       Environment* const env) {
-  Local<Context> context = env->isolate()->GetCurrentContext();
-  while (X509_check_issued(cert->get(), cert->get()) != X509_V_OK) {
-    X509* ca;
-    if (SSL_CTX_get_issuer(SSL_get_SSL_CTX(ssl.get()), cert->get(), &ca) <= 0)
-      break;
-
-    Local<Object> ca_info = X509ToObject(env, ca);
-    issuer_chain->Set(context, env->issuercert_string(), ca_info).Check();
-    issuer_chain = ca_info;
-
-    // Delete previous cert and continue aggregating issuers.
-    cert->reset(ca);
-  }
-  return issuer_chain;
-}
-
-
 template <class Base>
 void SSLWrap<Base>::GetPeerCertificate(
     const FunctionCallbackInfo<Value>& args) {
@@ -2275,44 +1858,11 @@ void SSLWrap<Base>::GetPeerCertificate(
   ASSIGN_OR_RETURN_UNWRAP(&w, args.Holder());
   Environment* env = w->ssl_env();
 
-  ClearErrorOnReturn clear_error_on_return;
+  bool abbreviated = args.Length() < 1 || !args[0]->IsTrue();
 
-  Local<Object> result;
-  // Used to build the issuer certificate chain.
-  Local<Object> issuer_chain;
-
-  // NOTE: This is because of the odd OpenSSL behavior. On client `cert_chain`
-  // contains the `peer_certificate`, but on server it doesn't.
-  X509Pointer cert(
-      w->is_server() ? SSL_get_peer_certificate(w->ssl_.get()) : nullptr);
-  STACK_OF(X509)* ssl_certs = SSL_get_peer_cert_chain(w->ssl_.get());
-  if (!cert && (ssl_certs == nullptr || sk_X509_num(ssl_certs) == 0))
-    goto done;
-
-  // Short result requested.
-  if (args.Length() < 1 || !args[0]->IsTrue()) {
-    result = X509ToObject(env, cert ? cert.get() : sk_X509_value(ssl_certs, 0));
-    goto done;
-  }
-
-  if (auto peer_certs = CloneSSLCerts(std::move(cert), ssl_certs)) {
-    // First and main certificate.
-    X509Pointer cert(sk_X509_value(peer_certs.get(), 0));
-    CHECK(cert);
-    result = X509ToObject(env, cert.release());
-
-    issuer_chain =
-        AddIssuerChainToObject(&cert, result, std::move(peer_certs), env);
-    issuer_chain = GetLastIssuedCert(&cert, w->ssl_, issuer_chain, env);
-    // Last certificate should be self-signed.
-    if (X509_check_issued(cert.get(), cert.get()) == X509_V_OK)
-      issuer_chain->Set(env->context(),
-                        env->issuercert_string(),
-                        issuer_chain).Check();
-  }
-
- done:
-  args.GetReturnValue().Set(result);
+  Local<Value> ret;
+  if (GetPeerCert(env, w->ssl_, abbreviated, w->is_server()).ToLocal(&ret))
+    args.GetReturnValue().Set(ret);
 }
 
 
@@ -2323,16 +1873,9 @@ void SSLWrap<Base>::GetCertificate(
   ASSIGN_OR_RETURN_UNWRAP(&w, args.Holder());
   Environment* env = w->ssl_env();
 
-  ClearErrorOnReturn clear_error_on_return;
-
-  Local<Object> result;
-
-  X509* cert = SSL_get_certificate(w->ssl_.get());
-
-  if (cert != nullptr)
-    result = X509ToObject(env, cert);
-
-  args.GetReturnValue().Set(result);
+  Local<Value> ret;
+  if (GetCert(env, w->ssl_).ToLocal(&ret))
+    args.GetReturnValue().Set(ret);
 }
 
 
@@ -2411,22 +1954,16 @@ void SSLWrap<Base>::SetSession(const FunctionCallbackInfo<Value>& args) {
   Base* w;
   ASSIGN_OR_RETURN_UNWRAP(&w, args.Holder());
 
-  if (args.Length() < 1) {
+  if (args.Length() < 1)
     return THROW_ERR_MISSING_ARGS(env, "Session argument is mandatory");
-  }
 
   THROW_AND_RETURN_IF_NOT_BUFFER(env, args[0], "Session");
-  ArrayBufferViewContents<unsigned char> sbuf(args[0].As<ArrayBufferView>());
-
-  const unsigned char* p = sbuf.data();
-  SSLSessionPointer sess(d2i_SSL_SESSION(nullptr, &p, sbuf.length()));
 
+  SSLSessionPointer sess = GetTLSSession(args[0]);
   if (sess == nullptr)
     return;
 
-  int r = SSL_set_session(w->ssl_.get(), sess.get());
-
-  if (!r)
+  if (!SetTLSSession(w->ssl_, sess))
     return env->ThrowError("SSL_set_session error");
 }
 
@@ -2542,7 +2079,6 @@ void SSLWrap<Base>::GetEphemeralKeyInfo(
   Base* w;
   ASSIGN_OR_RETURN_UNWRAP(&w, args.Holder());
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
 
   CHECK(w->ssl_);
 
@@ -2550,51 +2086,12 @@ void SSLWrap<Base>::GetEphemeralKeyInfo(
   if (w->is_server())
     return args.GetReturnValue().SetNull();
 
-  Local<Object> info = Object::New(env->isolate());
+  Local<Object> ret;
+  if (GetEphemeralKey(env, w->ssl_).ToLocal(&ret))
+    args.GetReturnValue().Set(ret);
 
-  EVP_PKEY* raw_key;
-  if (SSL_get_server_tmp_key(w->ssl_.get(), &raw_key)) {
-    EVPKeyPointer key(raw_key);
-    int kid = EVP_PKEY_id(key.get());
-    switch (kid) {
-      case EVP_PKEY_DH:
-        info->Set(context, env->type_string(),
-                  FIXED_ONE_BYTE_STRING(env->isolate(), "DH")).Check();
-        info->Set(context, env->size_string(),
-                  Integer::New(env->isolate(), EVP_PKEY_bits(key.get())))
-            .Check();
-        break;
-      case EVP_PKEY_EC:
-      case EVP_PKEY_X25519:
-      case EVP_PKEY_X448:
-        {
-          const char* curve_name;
-          if (kid == EVP_PKEY_EC) {
-            EC_KEY* ec = EVP_PKEY_get1_EC_KEY(key.get());
-            int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
-            curve_name = OBJ_nid2sn(nid);
-            EC_KEY_free(ec);
-          } else {
-            curve_name = OBJ_nid2sn(kid);
-          }
-          info->Set(context, env->type_string(),
-                    FIXED_ONE_BYTE_STRING(env->isolate(), "ECDH")).Check();
-          info->Set(context, env->name_string(),
-                    OneByteString(args.GetIsolate(),
-                                  curve_name)).Check();
-          info->Set(context, env->size_string(),
-                    Integer::New(env->isolate(),
-                                 EVP_PKEY_bits(key.get()))).Check();
-        }
-        break;
-      default:
-        break;
-    }
-  }
   // TODO(@sam-github) semver-major: else return ThrowCryptoError(env,
   // ERR_get_error())
-
-  return args.GetReturnValue().Set(info);
 }
 
 
@@ -2624,58 +2121,14 @@ void SSLWrap<Base>::VerifyError(const FunctionCallbackInfo<Value>& args) {
   // peer certificate is questionable but it's compatible with what was
   // here before.
   long x509_verify_error =  // NOLINT(runtime/int)
-      X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;
-  if (X509* peer_cert = SSL_get_peer_certificate(w->ssl_.get())) {
-    X509_free(peer_cert);
-    x509_verify_error = SSL_get_verify_result(w->ssl_.get());
-  } else {
-    const SSL_CIPHER* curr_cipher = SSL_get_current_cipher(w->ssl_.get());
-    const SSL_SESSION* sess = SSL_get_session(w->ssl_.get());
-    // Allow no-cert for PSK authentication in TLS1.2 and lower.
-    // In TLS1.3 check that session was reused because TLS1.3 PSK
-    // looks like session resumption. Is there a better way?
-    if (SSL_CIPHER_get_auth_nid(curr_cipher) == NID_auth_psk ||
-        (SSL_SESSION_get_protocol_version(sess) == TLS1_3_VERSION &&
-         SSL_session_reused(w->ssl_.get())))
-      return args.GetReturnValue().SetNull();
-  }
+      VerifyPeerCertificate(w->ssl_, X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT);
 
   if (x509_verify_error == X509_V_OK)
     return args.GetReturnValue().SetNull();
 
   const char* reason = X509_verify_cert_error_string(x509_verify_error);
   const char* code = reason;
-#define CASE_X509_ERR(CODE) case X509_V_ERR_##CODE: code = #CODE; break;
-  switch (x509_verify_error) {
-    CASE_X509_ERR(UNABLE_TO_GET_ISSUER_CERT)
-    CASE_X509_ERR(UNABLE_TO_GET_CRL)
-    CASE_X509_ERR(UNABLE_TO_DECRYPT_CERT_SIGNATURE)
-    CASE_X509_ERR(UNABLE_TO_DECRYPT_CRL_SIGNATURE)
-    CASE_X509_ERR(UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY)
-    CASE_X509_ERR(CERT_SIGNATURE_FAILURE)
-    CASE_X509_ERR(CRL_SIGNATURE_FAILURE)
-    CASE_X509_ERR(CERT_NOT_YET_VALID)
-    CASE_X509_ERR(CERT_HAS_EXPIRED)
-    CASE_X509_ERR(CRL_NOT_YET_VALID)
-    CASE_X509_ERR(CRL_HAS_EXPIRED)
-    CASE_X509_ERR(ERROR_IN_CERT_NOT_BEFORE_FIELD)
-    CASE_X509_ERR(ERROR_IN_CERT_NOT_AFTER_FIELD)
-    CASE_X509_ERR(ERROR_IN_CRL_LAST_UPDATE_FIELD)
-    CASE_X509_ERR(ERROR_IN_CRL_NEXT_UPDATE_FIELD)
-    CASE_X509_ERR(OUT_OF_MEM)
-    CASE_X509_ERR(DEPTH_ZERO_SELF_SIGNED_CERT)
-    CASE_X509_ERR(SELF_SIGNED_CERT_IN_CHAIN)
-    CASE_X509_ERR(UNABLE_TO_GET_ISSUER_CERT_LOCALLY)
-    CASE_X509_ERR(UNABLE_TO_VERIFY_LEAF_SIGNATURE)
-    CASE_X509_ERR(CERT_CHAIN_TOO_LONG)
-    CASE_X509_ERR(CERT_REVOKED)
-    CASE_X509_ERR(INVALID_CA)
-    CASE_X509_ERR(PATH_LENGTH_EXCEEDED)
-    CASE_X509_ERR(INVALID_PURPOSE)
-    CASE_X509_ERR(CERT_UNTRUSTED)
-    CASE_X509_ERR(CERT_REJECTED)
-  }
-#undef CASE_X509_ERR
+  code = X509ErrorCode(x509_verify_error);
 
   Isolate* isolate = args.GetIsolate();
   Local<String> reason_string = OneByteString(isolate, reason);
@@ -2693,23 +2146,14 @@ void SSLWrap<Base>::GetCipher(const FunctionCallbackInfo<Value>& args) {
   Base* w;
   ASSIGN_OR_RETURN_UNWRAP(&w, args.Holder());
   Environment* env = w->ssl_env();
-  Local<Context> context = env->context();
 
   const SSL_CIPHER* c = SSL_get_current_cipher(w->ssl_.get());
   if (c == nullptr)
     return;
 
-  Local<Object> info = Object::New(env->isolate());
-  const char* cipher_name = SSL_CIPHER_get_name(c);
-  info->Set(context, env->name_string(),
-            OneByteString(args.GetIsolate(), cipher_name)).Check();
-  const char* cipher_standard_name = SSL_CIPHER_standard_name(c);
-  info->Set(context, env->standard_name_string(),
-            OneByteString(args.GetIsolate(), cipher_standard_name)).Check();
-  const char* cipher_version = SSL_CIPHER_get_version(c);
-  info->Set(context, env->version_string(),
-            OneByteString(args.GetIsolate(), cipher_version)).Check();
-  args.GetReturnValue().Set(info);
+  Local<Object> ret;
+  if (GetCipherInfo(env, w->ssl_).ToLocal(&ret))
+    args.GetReturnValue().Set(ret);
 }
 
 
@@ -2904,10 +2348,7 @@ void SSLWrap<Base>::SetALPNProtocols(const FunctionCallbackInfo<Value>& args) {
     return env->ThrowTypeError("Must give a Buffer as first argument");
 
   if (w->is_client()) {
-    ArrayBufferViewContents<unsigned char> alpn_protos(args[0]);
-    int r = SSL_set_alpn_protos(
-        w->ssl_.get(), alpn_protos.data(), alpn_protos.length());
-    CHECK_EQ(r, 0);
+    CHECK(SetALPN(w->ssl_, args[0]));
   } else {
     CHECK(
         w->object()->SetPrivate(
@@ -2930,18 +2371,10 @@ int SSLWrap<Base>::TLSExtStatusCallback(SSL* s, void* arg) {
 
   if (w->is_client()) {
     // Incoming response
-    const unsigned char* resp;
-    int len = SSL_get_tlsext_status_ocsp_resp(s, &resp);
     Local<Value> arg;
-    if (resp == nullptr) {
-      arg = Null(env->isolate());
-    } else {
-      arg =
-          Buffer::Copy(env, reinterpret_cast<const char*>(resp), len)
-          .ToLocalChecked();
-    }
-
-    w->MakeCallback(env->onocspresponse_string(), 1, &arg);
+    MaybeLocal<Value> ret = GetSSLOCSPResponse(env, s, Null(env->isolate()));
+    if (ret.ToLocal(&arg))
+      w->MakeCallback(env->onocspresponse_string(), 1, &arg);
 
     // No async acceptance is possible, so always return 1 to accept the
     // response.  The listener for 'OCSPResponse' event has no control over
@@ -3000,7 +2433,7 @@ int SSLWrap<Base>::SSLCertCallback(SSL* s, void* arg) {
 
   Local<Object> info = Object::New(env->isolate());
 
-  const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
+  const char* servername = GetServerName(s);
   if (servername == nullptr) {
     info->Set(context,
               env->servername_string(),
@@ -3049,23 +2482,7 @@ void SSLWrap<Base>::CertCbDone(const FunctionCallbackInfo<Value>& args) {
     // Store the SNI context for later use.
     w->sni_context_ = BaseObjectPtr<SecureContext>(sc);
 
-    int rv;
-
-    // NOTE: reference count is not increased by this API methods
-    X509* x509 = SSL_CTX_get0_certificate(sc->ctx_.get());
-    EVP_PKEY* pkey = SSL_CTX_get0_privatekey(sc->ctx_.get());
-    STACK_OF(X509)* chain;
-
-    rv = SSL_CTX_get0_chain_certs(sc->ctx_.get(), &chain);
-    if (rv)
-      rv = SSL_use_certificate(w->ssl_.get(), x509);
-    if (rv)
-      rv = SSL_use_PrivateKey(w->ssl_.get(), pkey);
-    if (rv && chain != nullptr)
-      rv = SSL_set1_chain(w->ssl_.get(), chain);
-    if (rv)
-      rv = w->SetCACerts(sc);
-    if (!rv) {
+    if (UseSNIContext(w->ssl_, sc) && !w->SetCACerts(sc)) {
       // Not clear why sometimes we throw error, and sometimes we call
       // onerror(). Both cause .destroy(), but onerror does a bit more.
       unsigned long err = ERR_get_error();  // NOLINT(runtime/int)
@@ -4255,7 +3672,7 @@ void CipherBase::InitIv(const FunctionCallbackInfo<Value>& args) {
                  reinterpret_cast<const unsigned char*>(key.get()),
                  key.size(),
                  iv_buf.data(),
-                 iv_len,
+                 static_cast<int>(iv_len),
                  auth_tag_len);
 }
 
diff --git a/src/node_crypto.h b/src/node_crypto.h
index 655605290b092f..772a34a7da7699 100644
--- a/src/node_crypto.h
+++ b/src/node_crypto.h
@@ -90,6 +90,8 @@ class SecureContext final : public BaseObject {
 
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 
+  SSL_CTX* operator*() const { return ctx_.get(); }
+
   // TODO(joyeecheung): track the memory used by OpenSSL types
   SET_NO_MEMORY_INFO()
   SET_MEMORY_INFO_NAME(SecureContext)
@@ -779,6 +781,17 @@ void SetEngine(const v8::FunctionCallbackInfo<v8::Value>& args);
 #endif  // !OPENSSL_NO_ENGINE
 void InitCrypto(v8::Local<v8::Object> target);
 
+void ThrowCryptoError(Environment* env,
+                      unsigned long err,  // NOLINT(runtime/int)
+                      const char* message = nullptr);
+
+template <typename T>
+inline T* MallocOpenSSL(size_t count) {
+  void* mem = OPENSSL_malloc(MultiplyWithOverflowCheck(count, sizeof(T)));
+  CHECK_IMPLIES(mem == nullptr, count == 0);
+  return static_cast<T*>(mem);
+}
+
 }  // namespace crypto
 }  // namespace node
 
diff --git a/src/node_crypto_common.cc b/src/node_crypto_common.cc
new file mode 100644
index 00000000000000..197bc5cd5913a4
--- /dev/null
+++ b/src/node_crypto_common.cc
@@ -0,0 +1,1110 @@
+#include "env-inl.h"
+#include "node_buffer.h"
+#include "node_crypto.h"
+#include "node_crypto_common.h"
+#include "node.h"
+#include "node_internals.h"
+#include "node_url.h"
+#include "string_bytes.h"
+#include "v8.h"
+
+#include <openssl/ec.h>
+#include <openssl/ecdh.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/x509v3.h>
+#include <openssl/hmac.h>
+#include <openssl/rand.h>
+#include <openssl/pkcs12.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace node {
+
+using v8::Array;
+using v8::ArrayBufferView;
+using v8::Context;
+using v8::EscapableHandleScope;
+using v8::Integer;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::NewStringType;
+using v8::Null;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+namespace crypto {
+
+static constexpr int X509_NAME_FLAGS =
+    ASN1_STRFLGS_ESC_CTRL |
+    ASN1_STRFLGS_UTF8_CONVERT |
+    XN_FLAG_SEP_MULTILINE |
+    XN_FLAG_FN_SN;
+
+int SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert, X509** issuer) {
+  X509_STORE* store = SSL_CTX_get_cert_store(ctx);
+  DeleteFnPtr<X509_STORE_CTX, X509_STORE_CTX_free> store_ctx(
+      X509_STORE_CTX_new());
+  return store_ctx.get() != nullptr &&
+         X509_STORE_CTX_init(store_ctx.get(), store, nullptr, nullptr) == 1 &&
+         X509_STORE_CTX_get1_issuer(issuer, store_ctx.get(), cert) == 1;
+}
+
+void LogSecret(
+    const SSLPointer& ssl,
+    const char* name,
+    const unsigned char* secret,
+    size_t secretlen) {
+  auto keylog_cb = SSL_CTX_get_keylog_callback(SSL_get_SSL_CTX(ssl.get()));
+  unsigned char crandom[32];
+
+  if (keylog_cb == nullptr ||
+      SSL_get_client_random(ssl.get(), crandom, 32) != 32) {
+    return;
+  }
+
+  std::string line = name;
+  line += " " + StringBytes::hex_encode(
+      reinterpret_cast<const char*>(crandom), 32);
+  line += " " + StringBytes::hex_encode(
+      reinterpret_cast<const char*>(secret), secretlen);
+  keylog_cb(ssl.get(), line.c_str());
+}
+
+bool SetALPN(const SSLPointer& ssl, const std::string& alpn) {
+  return SSL_set_alpn_protos(
+      ssl.get(),
+      reinterpret_cast<const uint8_t*>(alpn.c_str()),
+      alpn.length()) == 0;
+}
+
+bool SetALPN(const SSLPointer& ssl, Local<Value> alpn) {
+  if (!alpn->IsArrayBufferView())
+    return false;
+  ArrayBufferViewContents<unsigned char> protos(alpn.As<ArrayBufferView>());
+  return SSL_set_alpn_protos(ssl.get(), protos.data(), protos.length()) == 0;
+}
+
+MaybeLocal<Value> GetSSLOCSPResponse(
+    Environment* env,
+    SSL* ssl,
+    Local<Value> default_value) {
+  const unsigned char* resp;
+  int len = SSL_get_tlsext_status_ocsp_resp(ssl, &resp);
+  if (resp == nullptr)
+    return default_value;
+
+  Local<Value> ret;
+  MaybeLocal<Object> maybe_buffer =
+      Buffer::Copy(env, reinterpret_cast<const char*>(resp), len);
+
+  if (!maybe_buffer.ToLocal(&ret))
+    return MaybeLocal<Value>();
+
+  return ret;
+}
+
+bool SetTLSSession(
+    const SSLPointer& ssl,
+    const unsigned char* buf,
+    size_t length) {
+  SSLSessionPointer s(d2i_SSL_SESSION(nullptr, &buf, length));
+  return s == nullptr ? false : SetTLSSession(ssl, s);
+}
+
+bool SetTLSSession(
+    const SSLPointer& ssl,
+    const SSLSessionPointer& session) {
+  return session != nullptr && SSL_set_session(ssl.get(), session.get()) == 1;
+}
+
+SSLSessionPointer GetTLSSession(Local<Value> val) {
+  if (!val->IsArrayBufferView())
+    return SSLSessionPointer();
+  ArrayBufferViewContents<unsigned char> sbuf(val.As<ArrayBufferView>());
+  return GetTLSSession(sbuf.data(), sbuf.length());
+}
+
+SSLSessionPointer GetTLSSession(const unsigned char* buf, size_t length) {
+  return SSLSessionPointer(d2i_SSL_SESSION(nullptr, &buf, length));
+}
+
+std::unordered_multimap<std::string, std::string>
+GetCertificateAltNames(X509* cert) {
+  std::unordered_multimap<std::string, std::string> map;
+  BIOPointer bio(BIO_new(BIO_s_mem()));
+  BUF_MEM* mem;
+  int idx = X509_get_ext_by_NID(cert, NID_subject_alt_name, -1);
+  if (idx < 0)  // There is no subject alt name
+    return map;
+
+  X509_EXTENSION* ext = X509_get_ext(cert, idx);
+  CHECK_NOT_NULL(ext);
+  const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
+  CHECK_EQ(method, X509V3_EXT_get_nid(NID_subject_alt_name));
+
+  GENERAL_NAMES* names = static_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(ext));
+  if (names == nullptr)  // There are no names
+    return map;
+
+  for (int i = 0; i < sk_GENERAL_NAME_num(names); i++) {
+    USE(BIO_reset(bio.get()));
+    GENERAL_NAME* gen = sk_GENERAL_NAME_value(names, i);
+    if (gen->type == GEN_DNS) {
+      ASN1_IA5STRING* name = gen->d.dNSName;
+      BIO_write(bio.get(), name->data, name->length);
+      BIO_get_mem_ptr(bio.get(), &mem);
+      map.emplace("dns", std::string(mem->data, mem->length));
+    } else {
+      STACK_OF(CONF_VALUE)* nval = i2v_GENERAL_NAME(
+          const_cast<X509V3_EXT_METHOD*>(method), gen, nullptr);
+      if (nval == nullptr)
+        continue;
+      X509V3_EXT_val_prn(bio.get(), nval, 0, 0);
+      sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
+      BIO_get_mem_ptr(bio.get(), &mem);
+      std::string value(mem->data, mem->length);
+      if (value.compare(0, 11, "IP Address:") == 0) {
+        map.emplace("ip", value.substr(11));
+      } else if (value.compare(0, 4, "URI:") == 0) {
+        url::URL url(value.substr(4));
+        if (url.flags() & url::URL_FLAGS_CANNOT_BE_BASE ||
+            url.flags() & url::URL_FLAGS_FAILED) {
+          continue;  // Skip this one
+        }
+        map.emplace("uri", url.host());
+      }
+    }
+  }
+  sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
+  return map;
+}
+
+std::string GetCertificateCN(X509* cert) {
+  X509_NAME* subject = X509_get_subject_name(cert);
+  if (subject != nullptr) {
+    int nid = OBJ_txt2nid("CN");
+    int idx = X509_NAME_get_index_by_NID(subject, nid, -1);
+    if (idx != -1) {
+      X509_NAME_ENTRY* cn = X509_NAME_get_entry(subject, idx);
+      if (cn != nullptr) {
+        ASN1_STRING* cn_str = X509_NAME_ENTRY_get_data(cn);
+        if (cn_str != nullptr) {
+          return std::string(reinterpret_cast<const char*>(
+              ASN1_STRING_get0_data(cn_str)));
+        }
+      }
+    }
+  }
+  return std::string();
+}
+
+long VerifyPeerCertificate(  // NOLINT(runtime/int)
+    const SSLPointer& ssl,
+    long def) {  // NOLINT(runtime/int)
+  long err = def;  // NOLINT(runtime/int)
+  if (X509* peer_cert = SSL_get_peer_certificate(ssl.get())) {
+    X509_free(peer_cert);
+    err = SSL_get_verify_result(ssl.get());
+  } else {
+    const SSL_CIPHER* curr_cipher = SSL_get_current_cipher(ssl.get());
+    const SSL_SESSION* sess = SSL_get_session(ssl.get());
+    // Allow no-cert for PSK authentication in TLS1.2 and lower.
+    // In TLS1.3 check that session was reused because TLS1.3 PSK
+    // looks like session resumption.
+    if (SSL_CIPHER_get_auth_nid(curr_cipher) == NID_auth_psk ||
+        (SSL_SESSION_get_protocol_version(sess) == TLS1_3_VERSION &&
+         SSL_session_reused(ssl.get()))) {
+      return X509_V_OK;
+    }
+  }
+  return err;
+}
+
+int UseSNIContext(const SSLPointer& ssl, SecureContext* context) {
+  SSL_CTX* ctx = context->ctx_.get();
+  X509* x509 = SSL_CTX_get0_certificate(ctx);
+  EVP_PKEY* pkey = SSL_CTX_get0_privatekey(ctx);
+  STACK_OF(X509)* chain;
+
+  int err = SSL_CTX_get0_chain_certs(ctx, &chain);
+  if (err == 1) err = SSL_use_certificate(ssl.get(), x509);
+  if (err == 1) err = SSL_use_PrivateKey(ssl.get(), pkey);
+  if (err == 1 && chain != nullptr) err = SSL_set1_chain(ssl.get(), chain);
+  return err;
+}
+
+const char* GetClientHelloALPN(const SSLPointer& ssl) {
+  const unsigned char* buf;
+  size_t len;
+  size_t rem;
+
+  if (!SSL_client_hello_get0_ext(
+          ssl.get(),
+          TLSEXT_TYPE_application_layer_protocol_negotiation,
+          &buf,
+          &rem) ||
+      rem < 2) {
+    return nullptr;
+  }
+
+  len = (buf[0] << 8) | buf[1];
+  if (len + 2 != rem) return nullptr;
+  return reinterpret_cast<const char*>(buf + 3);
+}
+
+const char* GetClientHelloServerName(const SSLPointer& ssl) {
+  const unsigned char* buf;
+  size_t len;
+  size_t rem;
+
+  if (!SSL_client_hello_get0_ext(
+          ssl.get(),
+          TLSEXT_TYPE_server_name,
+          &buf,
+          &rem) || rem <= 2) {
+    return nullptr;
+  }
+
+  len = (*buf << 8) | *(buf + 1);
+  if (len + 2 != rem)
+    return nullptr;
+  rem = len;
+
+  if (rem == 0 || *(buf + 2) != TLSEXT_NAMETYPE_host_name) return nullptr;
+  rem--;
+  if (rem <= 2)
+    return nullptr;
+  len = (*(buf + 3) << 8) | *(buf + 4);
+  if (len + 2 > rem)
+    return nullptr;
+  return reinterpret_cast<const char*>(buf + 5);
+}
+
+const char* GetServerName(SSL* ssl) {
+  return SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
+}
+
+bool SetGroups(SecureContext* sc, const char* groups) {
+  return SSL_CTX_set1_groups_list(**sc, groups) == 1;
+}
+
+const char* X509ErrorCode(long err) {  // NOLINT(runtime/int)
+  const char* code = "UNSPECIFIED";
+#define CASE_X509_ERR(CODE) case X509_V_ERR_##CODE: code = #CODE; break;
+  switch (err) {
+    CASE_X509_ERR(UNABLE_TO_GET_ISSUER_CERT)
+    CASE_X509_ERR(UNABLE_TO_GET_CRL)
+    CASE_X509_ERR(UNABLE_TO_DECRYPT_CERT_SIGNATURE)
+    CASE_X509_ERR(UNABLE_TO_DECRYPT_CRL_SIGNATURE)
+    CASE_X509_ERR(UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY)
+    CASE_X509_ERR(CERT_SIGNATURE_FAILURE)
+    CASE_X509_ERR(CRL_SIGNATURE_FAILURE)
+    CASE_X509_ERR(CERT_NOT_YET_VALID)
+    CASE_X509_ERR(CERT_HAS_EXPIRED)
+    CASE_X509_ERR(CRL_NOT_YET_VALID)
+    CASE_X509_ERR(CRL_HAS_EXPIRED)
+    CASE_X509_ERR(ERROR_IN_CERT_NOT_BEFORE_FIELD)
+    CASE_X509_ERR(ERROR_IN_CERT_NOT_AFTER_FIELD)
+    CASE_X509_ERR(ERROR_IN_CRL_LAST_UPDATE_FIELD)
+    CASE_X509_ERR(ERROR_IN_CRL_NEXT_UPDATE_FIELD)
+    CASE_X509_ERR(OUT_OF_MEM)
+    CASE_X509_ERR(DEPTH_ZERO_SELF_SIGNED_CERT)
+    CASE_X509_ERR(SELF_SIGNED_CERT_IN_CHAIN)
+    CASE_X509_ERR(UNABLE_TO_GET_ISSUER_CERT_LOCALLY)
+    CASE_X509_ERR(UNABLE_TO_VERIFY_LEAF_SIGNATURE)
+    CASE_X509_ERR(CERT_CHAIN_TOO_LONG)
+    CASE_X509_ERR(CERT_REVOKED)
+    CASE_X509_ERR(INVALID_CA)
+    CASE_X509_ERR(PATH_LENGTH_EXCEEDED)
+    CASE_X509_ERR(INVALID_PURPOSE)
+    CASE_X509_ERR(CERT_UNTRUSTED)
+    CASE_X509_ERR(CERT_REJECTED)
+    CASE_X509_ERR(HOSTNAME_MISMATCH)
+  }
+#undef CASE_X509_ERR
+  return code;
+}
+
+MaybeLocal<Value> GetValidationErrorReason(Environment* env, int err) {
+  const char* reason = X509_verify_cert_error_string(err);
+  return OneByteString(env->isolate(), reason);
+}
+
+MaybeLocal<Value> GetValidationErrorCode(Environment* env, int err) {
+  return OneByteString(env->isolate(), X509ErrorCode(err));
+}
+
+MaybeLocal<Value> GetCert(Environment* env, const SSLPointer& ssl) {
+  ClearErrorOnReturn clear_error_on_return;
+  X509* cert = SSL_get_certificate(ssl.get());
+  if (cert == nullptr)
+    return Undefined(env->isolate());
+
+  Local<Value> ret;
+  MaybeLocal<Object> maybe_cert = X509ToObject(env, cert);
+  return maybe_cert.ToLocal(&ret) ? ret : MaybeLocal<Value>();
+}
+
+namespace {
+template <typename T>
+bool Set(
+    Local<Context> context,
+    Local<Object> target,
+    Local<Value> name,
+    MaybeLocal<T> maybe_value) {
+  Local<Value> value;
+  if (!maybe_value.ToLocal(&value))
+    return false;
+
+  // Undefined is ignored, but still considered successful
+  if (value->IsUndefined())
+    return true;
+
+  return !target->Set(context, name, value).IsNothing();
+}
+
+Local<Value> ToV8Value(Environment* env, const BIOPointer& bio) {
+  BUF_MEM* mem;
+  BIO_get_mem_ptr(bio.get(), &mem);
+  MaybeLocal<String> ret =
+      String::NewFromUtf8(
+          env->isolate(),
+          mem->data,
+          NewStringType::kNormal,
+          mem->length);
+  USE(BIO_reset(bio.get()));
+  return ret.FromMaybe(Local<Value>());
+}
+
+MaybeLocal<Value> GetCipherName(
+    Environment* env,
+    const SSL_CIPHER* cipher) {
+  if (cipher == nullptr)
+    return Undefined(env->isolate());
+
+  return OneByteString(env->isolate(), SSL_CIPHER_get_name(cipher));
+}
+
+MaybeLocal<Value> GetCipherStandardName(
+    Environment* env,
+    const SSL_CIPHER* cipher) {
+  if (cipher == nullptr)
+    return Undefined(env->isolate());
+
+  return OneByteString(env->isolate(), SSL_CIPHER_standard_name(cipher));
+}
+
+MaybeLocal<Value> GetCipherVersion(
+    Environment* env,
+    const SSL_CIPHER* cipher) {
+  if (cipher == nullptr)
+    return Undefined(env->isolate());
+
+  return OneByteString(env->isolate(), SSL_CIPHER_get_version(cipher));
+}
+
+StackOfX509 CloneSSLCerts(X509Pointer&& cert,
+                          const STACK_OF(X509)* const ssl_certs) {
+  StackOfX509 peer_certs(sk_X509_new(nullptr));
+  if (cert)
+    sk_X509_push(peer_certs.get(), cert.release());
+  for (int i = 0; i < sk_X509_num(ssl_certs); i++) {
+    X509Pointer cert(X509_dup(sk_X509_value(ssl_certs, i)));
+    if (!cert || !sk_X509_push(peer_certs.get(), cert.get()))
+      return StackOfX509();
+    // `cert` is now managed by the stack.
+    cert.release();
+  }
+  return peer_certs;
+}
+
+MaybeLocal<Object> AddIssuerChainToObject(
+    X509Pointer* cert,
+    Local<Object> object,
+    StackOfX509&& peer_certs,
+    Environment* const env) {
+  Local<Context> context = env->isolate()->GetCurrentContext();
+  cert->reset(sk_X509_delete(peer_certs.get(), 0));
+  for (;;) {
+    int i;
+    for (i = 0; i < sk_X509_num(peer_certs.get()); i++) {
+      X509* ca = sk_X509_value(peer_certs.get(), i);
+      if (X509_check_issued(ca, cert->get()) != X509_V_OK)
+        continue;
+
+      Local<Object> ca_info;
+      MaybeLocal<Object> maybe_ca_info = X509ToObject(env, ca);
+      if (!maybe_ca_info.ToLocal(&ca_info))
+        return MaybeLocal<Object>();
+
+      if (!Set<Object>(context, object, env->issuercert_string(), ca_info))
+        return MaybeLocal<Object>();
+      object = ca_info;
+
+      // NOTE: Intentionally freeing cert that is not used anymore.
+      // Delete cert and continue aggregating issuers.
+      cert->reset(sk_X509_delete(peer_certs.get(), i));
+      break;
+    }
+
+    // Issuer not found, break out of the loop.
+    if (i == sk_X509_num(peer_certs.get()))
+      break;
+  }
+  return MaybeLocal<Object>(object);
+}
+
+MaybeLocal<Object> GetLastIssuedCert(
+    X509Pointer* cert,
+    const SSLPointer& ssl,
+    Local<Object> issuer_chain,
+    Environment* const env) {
+  Local<Context> context = env->isolate()->GetCurrentContext();
+  while (X509_check_issued(cert->get(), cert->get()) != X509_V_OK) {
+    X509* ca;
+    if (SSL_CTX_get_issuer(SSL_get_SSL_CTX(ssl.get()), cert->get(), &ca) <= 0)
+      break;
+
+    Local<Object> ca_info;
+    MaybeLocal<Object> maybe_ca_info = X509ToObject(env, ca);
+    if (!maybe_ca_info.ToLocal(&ca_info))
+      return MaybeLocal<Object>();
+
+    if (!Set<Object>(context, issuer_chain, env->issuercert_string(), ca_info))
+      return MaybeLocal<Object>();
+    issuer_chain = ca_info;
+
+    // Delete previous cert and continue aggregating issuers.
+    cert->reset(ca);
+  }
+  return MaybeLocal<Object>(issuer_chain);
+}
+
+MaybeLocal<Object> GetRawDERCertificate(Environment* env, X509* cert) {
+  int size = i2d_X509(cert, nullptr);
+
+  AllocatedBuffer buffer = env->AllocateManaged(size);
+  unsigned char* serialized =
+      reinterpret_cast<unsigned char*>(buffer.data());
+  i2d_X509(cert, &serialized);
+  return buffer.ToBuffer();
+}
+
+MaybeLocal<Value> GetSerialNumber(Environment* env, X509* cert) {
+  if (ASN1_INTEGER* serial_number = X509_get_serialNumber(cert)) {
+    BignumPointer bn(ASN1_INTEGER_to_BN(serial_number, nullptr));
+    if (bn) {
+      OpenSSLBuffer buf(BN_bn2hex(bn.get()));
+      if (buf)
+        return OneByteString(env->isolate(), buf.get());
+    }
+  }
+
+  return Undefined(env->isolate());
+}
+
+MaybeLocal<Value> GetKeyUsage(Environment* env, X509* cert) {
+  StackOfASN1 eku(static_cast<STACK_OF(ASN1_OBJECT)*>(
+      X509_get_ext_d2i(cert, NID_ext_key_usage, nullptr, nullptr)));
+  if (eku) {
+    const int count = sk_ASN1_OBJECT_num(eku.get());
+    MaybeStackBuffer<Local<Value>, 16> ext_key_usage(count);
+    char buf[256];
+
+    int j = 0;
+    for (int i = 0; i < count; i++) {
+      if (OBJ_obj2txt(buf,
+                      sizeof(buf),
+                      sk_ASN1_OBJECT_value(eku.get(), i), 1) >= 0) {
+        ext_key_usage[j++] = OneByteString(env->isolate(), buf);
+      }
+    }
+
+    return Array::New(env->isolate(), ext_key_usage.out(), count);
+  }
+
+  return Undefined(env->isolate());
+}
+
+void AddFingerprintDigest(
+    const unsigned char* md,
+    unsigned int md_size,
+    char (*fingerprint)[3 * EVP_MAX_MD_SIZE + 1]) {
+  unsigned int i;
+  const char hex[] = "0123456789ABCDEF";
+
+  for (i = 0; i < md_size; i++) {
+    (*fingerprint)[3*i] = hex[(md[i] & 0xf0) >> 4];
+    (*fingerprint)[(3*i)+1] = hex[(md[i] & 0x0f)];
+    (*fingerprint)[(3*i)+2] = ':';
+  }
+
+  if (md_size > 0) {
+    (*fingerprint)[(3*(md_size-1))+2] = '\0';
+  } else {
+    (*fingerprint)[0] = '\0';
+  }
+}
+
+bool SafeX509ExtPrint(const BIOPointer& out, X509_EXTENSION* ext) {
+  const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
+
+  if (method != X509V3_EXT_get_nid(NID_subject_alt_name))
+    return false;
+
+  GENERAL_NAMES* names = static_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(ext));
+  if (names == nullptr)
+    return false;
+
+  for (int i = 0; i < sk_GENERAL_NAME_num(names); i++) {
+    GENERAL_NAME* gen = sk_GENERAL_NAME_value(names, i);
+
+    if (i != 0)
+      BIO_write(out.get(), ", ", 2);
+
+    if (gen->type == GEN_DNS) {
+      ASN1_IA5STRING* name = gen->d.dNSName;
+
+      BIO_write(out.get(), "DNS:", 4);
+      BIO_write(out.get(), name->data, name->length);
+    } else {
+      STACK_OF(CONF_VALUE)* nval = i2v_GENERAL_NAME(
+          const_cast<X509V3_EXT_METHOD*>(method), gen, nullptr);
+      if (nval == nullptr)
+        return false;
+      X509V3_EXT_val_prn(out.get(), nval, 0, 0);
+      sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
+    }
+  }
+  sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
+
+  return true;
+}
+
+MaybeLocal<Value> GetFingerprintDigest(
+    Environment* env,
+    const EVP_MD* method,
+    X509* cert) {
+  unsigned char md[EVP_MAX_MD_SIZE];
+  unsigned int md_size;
+  char fingerprint[EVP_MAX_MD_SIZE * 3 + 1];
+
+  if (X509_digest(cert, method, md, &md_size)) {
+    AddFingerprintDigest(md, md_size, &fingerprint);
+    return OneByteString(env->isolate(), fingerprint);
+  }
+  return Undefined(env->isolate());
+}
+
+MaybeLocal<Value> GetValidTo(
+    Environment* env,
+    X509* cert,
+    const BIOPointer& bio) {
+  ASN1_TIME_print(bio.get(), X509_get0_notAfter(cert));
+  return ToV8Value(env, bio);
+}
+
+MaybeLocal<Value> GetValidFrom(
+    Environment* env,
+    X509* cert,
+    const BIOPointer& bio) {
+  ASN1_TIME_print(bio.get(), X509_get0_notBefore(cert));
+  return ToV8Value(env, bio);
+}
+
+MaybeLocal<Value> GetCurveASN1Name(Environment* env, const int nid) {
+  const char* nist = OBJ_nid2sn(nid);
+  return nist != nullptr ?
+      MaybeLocal<Value>(OneByteString(env->isolate(), nist)) :
+      MaybeLocal<Value>(Undefined(env->isolate()));
+}
+
+MaybeLocal<Value> GetCurveNistName(Environment* env, const int nid) {
+  const char* nist = EC_curve_nid2nist(nid);
+  return nist != nullptr ?
+      MaybeLocal<Value>(OneByteString(env->isolate(), nist)) :
+      MaybeLocal<Value>(Undefined(env->isolate()));
+}
+
+MaybeLocal<Value> GetECPubKey(
+    Environment* env,
+    const EC_GROUP* group,
+    const ECPointer& ec) {
+  const EC_POINT* pubkey = EC_KEY_get0_public_key(ec.get());
+  if (pubkey == nullptr)
+    return Undefined(env->isolate());
+
+  return ECPointToBuffer(
+      env,
+      group,
+      pubkey,
+      EC_KEY_get_conv_form(ec.get()),
+      nullptr).FromMaybe(Local<Object>());
+}
+
+MaybeLocal<Value> GetECGroup(
+    Environment* env,
+    const EC_GROUP* group,
+    const ECPointer& ec) {
+  if (group == nullptr)
+    return Undefined(env->isolate());
+
+  int bits = EC_GROUP_order_bits(group);
+  if (bits <= 0)
+    return Undefined(env->isolate());
+
+  return Integer::New(env->isolate(), bits);
+}
+
+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);
+  unsigned char* serialized =
+      reinterpret_cast<unsigned char*>(buffer.data());
+  i2d_RSA_PUBKEY(rsa.get(), &serialized);
+  return buffer.ToBuffer();
+}
+
+MaybeLocal<Value> GetExponentString(
+    Environment* env,
+    const BIOPointer& bio,
+    const BIGNUM* e) {
+  uint64_t exponent_word = static_cast<uint64_t>(BN_get_word(e));
+  uint32_t lo = static_cast<uint32_t>(exponent_word);
+  uint32_t hi = static_cast<uint32_t>(exponent_word >> 32);
+  if (hi == 0)
+    BIO_printf(bio.get(), "0x%x", lo);
+  else
+    BIO_printf(bio.get(), "0x%x%08x", hi, lo);
+
+  return ToV8Value(env, bio);
+}
+
+Local<Value> GetBits(Environment* env, const BIGNUM* n) {
+  return Integer::New(env->isolate(), BN_num_bits(n));
+}
+
+MaybeLocal<Value> GetModulusString(
+    Environment* env,
+    const BIOPointer& bio,
+    const BIGNUM* n) {
+  BN_print(bio.get(), n);
+  return ToV8Value(env, bio);
+}
+
+template <int nid>
+MaybeLocal<Value> GetInfoString(
+    Environment* env,
+    const BIOPointer& bio,
+    X509* cert) {
+  int index = X509_get_ext_by_NID(cert, nid, -1);
+  if (index < 0)
+    return Undefined(env->isolate());
+
+  X509_EXTENSION* ext = X509_get_ext(cert, index);
+  CHECK_NOT_NULL(ext);
+
+  if (!SafeX509ExtPrint(bio, ext) &&
+      X509V3_EXT_print(bio.get(), ext, 0, 0) != 1) {
+    USE(BIO_reset(bio.get()));
+    return Null(env->isolate());
+  }
+
+  return ToV8Value(env, bio);
+}
+
+MaybeLocal<Value> GetIssuerString(
+    Environment* env,
+    const BIOPointer& bio,
+    X509* cert) {
+  X509_NAME* issuer_name = X509_get_issuer_name(cert);
+  if (X509_NAME_print_ex(bio.get(), issuer_name, 0, X509_NAME_FLAGS) <= 0) {
+    USE(BIO_reset(bio.get()));
+    return Undefined(env->isolate());
+  }
+
+  return ToV8Value(env, bio);
+}
+
+MaybeLocal<Value> GetSubject(
+    Environment* env,
+    const BIOPointer& bio,
+    X509* cert) {
+  if (X509_NAME_print_ex(
+          bio.get(),
+          X509_get_subject_name(cert),
+          0,
+          X509_NAME_FLAGS) <= 0) {
+    USE(BIO_reset(bio.get()));
+    return Undefined(env->isolate());
+  }
+
+  return ToV8Value(env, bio);
+}
+}  // namespace
+
+MaybeLocal<Value> GetCipherName(Environment* env, const SSLPointer& ssl) {
+  return GetCipherName(env, SSL_get_current_cipher(ssl.get()));
+}
+
+MaybeLocal<Value> GetCipherStandardName(
+    Environment* env,
+    const SSLPointer& ssl) {
+  return GetCipherStandardName(env, SSL_get_current_cipher(ssl.get()));
+}
+
+MaybeLocal<Value> GetCipherVersion(Environment* env, const SSLPointer& ssl) {
+  return GetCipherVersion(env, SSL_get_current_cipher(ssl.get()));
+}
+
+MaybeLocal<Array> GetClientHelloCiphers(
+    Environment* env,
+    const SSLPointer& ssl) {
+  EscapableHandleScope scope(env->isolate());
+  const unsigned char* buf;
+  size_t len = SSL_client_hello_get0_ciphers(ssl.get(), &buf);
+  size_t count = len / 2;
+  MaybeStackBuffer<Local<Value>, 16> ciphers(count);
+  int j = 0;
+  for (size_t n = 0; n < len; n += 2) {
+    const SSL_CIPHER* cipher = SSL_CIPHER_find(ssl.get(), buf);
+    buf += 2;
+    Local<Object> obj = Object::New(env->isolate());
+    if (!Set(env->context(),
+             obj,
+             env->name_string(),
+             GetCipherName(env, cipher)) ||
+        !Set(env->context(),
+             obj,
+             env->standard_name_string(),
+             GetCipherStandardName(env, cipher)) ||
+        !Set(env->context(),
+             obj,
+             env->version_string(),
+             GetCipherVersion(env, cipher))) {
+      return MaybeLocal<Array>();
+    }
+    ciphers[j++] = obj;
+  }
+  Local<Array> ret = Array::New(env->isolate(), ciphers.out(), count);
+  return scope.Escape(ret);
+}
+
+
+MaybeLocal<Object> GetCipherInfo(Environment* env, const SSLPointer& ssl) {
+  EscapableHandleScope scope(env->isolate());
+  Local<Object> info = Object::New(env->isolate());
+
+  if (!Set<Value>(env->context(),
+                  info,
+                  env->name_string(),
+                  GetCipherName(env, ssl)) ||
+      !Set<Value>(env->context(),
+                  info,
+                  env->standard_name_string(),
+                  GetCipherStandardName(env, ssl)) ||
+      !Set<Value>(env->context(),
+                  info,
+                  env->version_string(),
+                  GetCipherVersion(env, ssl))) {
+    return MaybeLocal<Object>();
+  }
+
+  return scope.Escape(info);
+}
+
+MaybeLocal<Object> GetEphemeralKey(Environment* env, const SSLPointer& ssl) {
+  CHECK_EQ(SSL_is_server(ssl.get()), 0);
+  EVP_PKEY* raw_key;
+
+  EscapableHandleScope scope(env->isolate());
+  Local<Object> info = Object::New(env->isolate());
+  if (!SSL_get_server_tmp_key(ssl.get(), &raw_key))
+    return scope.Escape(info);
+
+  Local<Context> context = env->context();
+  crypto::EVPKeyPointer key(raw_key);
+
+  int kid = EVP_PKEY_id(key.get());
+  int bits = EVP_PKEY_bits(key.get());
+  switch (kid) {
+    case EVP_PKEY_DH:
+      if (!Set<String>(context, info, env->type_string(), env->dh_string()) ||
+          !Set<Integer>(context,
+               info,
+               env->size_string(),
+               Integer::New(env->isolate(), bits))) {
+        return MaybeLocal<Object>();
+      }
+      break;
+    case EVP_PKEY_EC:
+    case EVP_PKEY_X25519:
+    case EVP_PKEY_X448:
+      {
+        const char* curve_name;
+        if (kid == EVP_PKEY_EC) {
+          ECKeyPointer ec(EVP_PKEY_get1_EC_KEY(key.get()));
+          int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec.get()));
+          curve_name = OBJ_nid2sn(nid);
+        } else {
+          curve_name = OBJ_nid2sn(kid);
+        }
+        if (!Set<String>(context,
+                         info,
+                         env->type_string(),
+                         env->ecdh_string()) ||
+            !Set<String>(context,
+                info,
+                env->name_string(),
+                OneByteString(env->isolate(), curve_name)) ||
+            !Set<Integer>(context,
+                 info,
+                 env->size_string(),
+                 Integer::New(env->isolate(), bits))) {
+          return MaybeLocal<Object>();
+        }
+      }
+      break;
+  }
+
+  return scope.Escape(info);
+}
+
+MaybeLocal<Object> ECPointToBuffer(Environment* env,
+                                   const EC_GROUP* group,
+                                   const EC_POINT* point,
+                                   point_conversion_form_t form,
+                                   const char** error) {
+  size_t len = EC_POINT_point2oct(group, point, form, nullptr, 0, nullptr);
+  if (len == 0) {
+    if (error != nullptr) *error = "Failed to get public key length";
+    return MaybeLocal<Object>();
+  }
+  AllocatedBuffer buf = env->AllocateManaged(len);
+  len = EC_POINT_point2oct(group,
+                           point,
+                           form,
+                           reinterpret_cast<unsigned char*>(buf.data()),
+                           buf.size(),
+                           nullptr);
+  if (len == 0) {
+    if (error != nullptr) *error = "Failed to get public key";
+    return MaybeLocal<Object>();
+  }
+  return buf.ToBuffer();
+}
+
+MaybeLocal<Value> GetPeerCert(
+    Environment* env,
+    const SSLPointer& ssl,
+    bool abbreviated,
+    bool is_server) {
+  ClearErrorOnReturn clear_error_on_return;
+  Local<Object> result;
+  MaybeLocal<Object> maybe_cert;
+
+  // NOTE: This is because of the odd OpenSSL behavior. On client `cert_chain`
+  // contains the `peer_certificate`, but on server it doesn't.
+  X509Pointer cert(is_server ? SSL_get_peer_certificate(ssl.get()) : nullptr);
+  STACK_OF(X509)* ssl_certs = SSL_get_peer_cert_chain(ssl.get());
+  if (!cert && (ssl_certs == nullptr || sk_X509_num(ssl_certs) == 0))
+    return Undefined(env->isolate());
+
+  // Short result requested.
+  if (abbreviated) {
+    maybe_cert =
+        X509ToObject(env, cert ? cert.get() : sk_X509_value(ssl_certs, 0));
+    return maybe_cert.ToLocal(&result) ? result : MaybeLocal<Value>();
+  }
+
+  StackOfX509 peer_certs = CloneSSLCerts(std::move(cert), ssl_certs);
+  if (peer_certs == nullptr)
+    return Undefined(env->isolate());
+
+  // First and main certificate.
+  X509Pointer first_cert(sk_X509_value(peer_certs.get(), 0));
+  CHECK(first_cert);
+  maybe_cert = X509ToObject(env, first_cert.release()).ToLocalChecked();
+  if (!maybe_cert.ToLocal(&result))
+    return MaybeLocal<Value>();
+
+  Local<Object> issuer_chain;
+  MaybeLocal<Object> maybe_issuer_chain;
+
+  maybe_issuer_chain =
+      AddIssuerChainToObject(
+          &cert,
+          result,
+          std::move(peer_certs),
+          env);
+  if (!maybe_issuer_chain.ToLocal(&issuer_chain))
+    return MaybeLocal<Value>();
+
+  maybe_issuer_chain =
+      GetLastIssuedCert(
+          &cert,
+          ssl,
+          issuer_chain,
+          env);
+
+  issuer_chain.Clear();
+  if (!maybe_issuer_chain.ToLocal(&issuer_chain))
+    return MaybeLocal<Value>();
+
+  // Last certificate should be self-signed.
+  if (X509_check_issued(cert.get(), cert.get()) == X509_V_OK &&
+      !Set<Object>(env->context(),
+           issuer_chain,
+           env->issuercert_string(),
+           issuer_chain)) {
+    return MaybeLocal<Value>();
+  }
+
+  return result;
+}
+
+MaybeLocal<Object> X509ToObject(Environment* env, X509* cert) {
+  EscapableHandleScope scope(env->isolate());
+  Local<Context> context = env->context();
+  Local<Object> info = Object::New(env->isolate());
+
+  BIOPointer bio(BIO_new(BIO_s_mem()));
+
+  if (!Set<Value>(context,
+                  info,
+                  env->subject_string(),
+                  GetSubject(env, bio, cert)) ||
+      !Set<Value>(context,
+                  info,
+                  env->issuer_string(),
+                  GetIssuerString(env, bio, cert)) ||
+      !Set<Value>(context,
+                  info,
+                  env->subjectaltname_string(),
+                  GetInfoString<NID_subject_alt_name>(env, bio, cert)) ||
+      !Set<Value>(context,
+                  info,
+                  env->infoaccess_string(),
+                  GetInfoString<NID_info_access>(env, bio, cert))) {
+    return MaybeLocal<Object>();
+  }
+
+  EVPKeyPointer pkey(X509_get_pubkey(cert));
+  RSAPointer rsa;
+  ECPointer ec;
+  if (pkey) {
+    switch (EVP_PKEY_id(pkey.get())) {
+      case EVP_PKEY_RSA:
+        rsa.reset(EVP_PKEY_get1_RSA(pkey.get()));
+        break;
+      case EVP_PKEY_EC:
+        ec.reset(EVP_PKEY_get1_EC_KEY(pkey.get()));
+        break;
+    }
+  }
+
+  if (rsa) {
+    const BIGNUM* n;
+    const BIGNUM* e;
+    RSA_get0_key(rsa.get(), &n, &e, nullptr);
+    if (!Set<Value>(context,
+                    info,
+                    env->modulus_string(),
+                    GetModulusString(env, bio, n)) ||
+        !Set<Value>(context, info, env->bits_string(), GetBits(env, n)) ||
+        !Set<Value>(context,
+                    info,
+                    env->exponent_string(),
+                    GetExponentString(env, bio, e)) ||
+        !Set<Object>(context,
+                     info,
+                     env->pubkey_string(),
+                     GetPubKey(env, rsa))) {
+      return MaybeLocal<Object>();
+    }
+  } else if (ec) {
+    const EC_GROUP* group = EC_KEY_get0_group(ec.get());
+
+    if (!Set<Value>(context,
+                    info,
+                    env->bits_string(),
+                    GetECGroup(env, group, ec)) ||
+        !Set<Value>(context,
+                    info,
+                    env->pubkey_string(),
+                    GetECPubKey(env, group, ec))) {
+      return MaybeLocal<Object>();
+    }
+
+    const int nid = EC_GROUP_get_curve_name(group);
+    if (nid != 0) {
+      // Curve is well-known, get its OID and NIST nick-name (if it has one).
+
+      if (!Set<Value>(context,
+                      info,
+                      env->asn1curve_string(),
+                      GetCurveASN1Name(env, nid)) ||
+          !Set<Value>(context,
+                      info,
+                      env->nistcurve_string(),
+                      GetCurveNistName(env, nid))) {
+        return MaybeLocal<Object>();
+      }
+    } else {
+      // Unnamed curves can be described by their mathematical properties,
+      // but aren't used much (at all?) with X.509/TLS. Support later if needed.
+    }
+  }
+
+  // pkey, rsa, and ec pointers are no longer needed.
+  pkey.reset();
+  rsa.reset();
+  ec.reset();
+
+  if (!Set<Value>(context,
+                  info,
+                  env->valid_from_string(),
+                  GetValidFrom(env, cert, bio)) ||
+      !Set<Value>(context,
+                  info,
+                  env->valid_to_string(),
+                  GetValidTo(env, cert, bio))) {
+    return MaybeLocal<Object>();
+  }
+
+  // bio is no longer needed
+  bio.reset();
+
+  if (!Set<Value>(context,
+                  info,
+                  env->fingerprint_string(),
+                  GetFingerprintDigest(env, EVP_sha1(), cert)) ||
+      !Set<Value>(context,
+                  info,
+                  env->fingerprint256_string(),
+                  GetFingerprintDigest(env, EVP_sha256(), cert)) ||
+      !Set<Value>(context,
+                  info,
+                  env->ext_key_usage_string(),
+                  GetKeyUsage(env, cert)) ||
+      !Set<Value>(context,
+                  info,
+                  env->serial_number_string(),
+                  GetSerialNumber(env, cert)) ||
+      !Set<Object>(context,
+                   info,
+                   env->raw_string(),
+                   GetRawDERCertificate(env, cert))) {
+    return MaybeLocal<Object>();
+  }
+
+  return scope.Escape(info);
+}
+
+}  // namespace crypto
+}  // namespace node
diff --git a/src/node_crypto_common.h b/src/node_crypto_common.h
new file mode 100644
index 00000000000000..e42e249ef2ba2e
--- /dev/null
+++ b/src/node_crypto_common.h
@@ -0,0 +1,139 @@
+#ifndef SRC_NODE_CRYPTO_COMMON_H_
+#define SRC_NODE_CRYPTO_COMMON_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "env.h"
+#include "node_crypto.h"
+#include "v8.h"
+#include <openssl/ssl.h>
+#include <openssl/x509v3.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace node {
+namespace crypto {
+
+// OPENSSL_free is a macro, so we need a wrapper function.
+struct OpenSSLBufferDeleter {
+  void operator()(char* pointer) const { OPENSSL_free(pointer); }
+};
+using OpenSSLBuffer = std::unique_ptr<char[], OpenSSLBufferDeleter>;
+
+struct StackOfX509Deleter {
+  void operator()(STACK_OF(X509)* p) const { sk_X509_pop_free(p, X509_free); }
+};
+using StackOfX509 = std::unique_ptr<STACK_OF(X509), StackOfX509Deleter>;
+
+struct StackOfXASN1Deleter {
+  void operator()(STACK_OF(ASN1_OBJECT)* p) const {
+    sk_ASN1_OBJECT_pop_free(p, ASN1_OBJECT_free);
+  }
+};
+using StackOfASN1 = std::unique_ptr<STACK_OF(ASN1_OBJECT), StackOfXASN1Deleter>;
+
+int SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert, X509** issuer);
+
+void LogSecret(
+    const SSLPointer& ssl,
+    const char* name,
+    const unsigned char* secret,
+    size_t secretlen);
+
+bool SetALPN(const SSLPointer& ssl, const std::string& alpn);
+
+bool SetALPN(const SSLPointer& ssl, v8::Local<v8::Value> alpn);
+
+v8::MaybeLocal<v8::Value> GetSSLOCSPResponse(
+    Environment* env,
+    SSL* ssl,
+    v8::Local<v8::Value> default_value);
+
+bool SetTLSSession(
+    const SSLPointer& ssl,
+    const unsigned char* buf,
+    size_t length);
+
+bool SetTLSSession(
+    const SSLPointer& ssl,
+    const SSLSessionPointer& session);
+
+SSLSessionPointer GetTLSSession(v8::Local<v8::Value> val);
+
+SSLSessionPointer GetTLSSession(const unsigned char* buf, size_t length);
+
+std::unordered_multimap<std::string, std::string>
+GetCertificateAltNames(X509* cert);
+
+std::string GetCertificateCN(X509* cert);
+
+long VerifyPeerCertificate(  // NOLINT(runtime/int)
+    const SSLPointer& ssl,
+    long def = X509_V_ERR_UNSPECIFIED);  // NOLINT(runtime/int)
+
+int UseSNIContext(const SSLPointer& ssl, SecureContext* context);
+
+const char* GetClientHelloALPN(const SSLPointer& ssl);
+
+const char* GetClientHelloServerName(const SSLPointer& ssl);
+
+const char* GetServerName(SSL* ssl);
+
+v8::MaybeLocal<v8::Array> GetClientHelloCiphers(
+    Environment* env,
+    const SSLPointer& ssl);
+
+bool SetGroups(SecureContext* sc, const char* groups);
+
+const char* X509ErrorCode(long err);  // NOLINT(runtime/int)
+
+v8::MaybeLocal<v8::Value> GetValidationErrorReason(Environment* env, int err);
+
+v8::MaybeLocal<v8::Value> GetValidationErrorCode(Environment* env, int err);
+
+v8::MaybeLocal<v8::Value> GetCert(Environment* env, const SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Value> GetCipherName(
+    Environment* env,
+    const SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Value> GetCipherStandardName(
+    Environment* env,
+    const SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Value> GetCipherVersion(
+    Environment* env,
+    const SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Object> GetCipherInfo(
+    Environment* env,
+    const SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Object> GetEphemeralKey(
+    Environment* env,
+    const SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Value> GetPeerCert(
+    Environment* env,
+    const SSLPointer& ssl,
+    bool abbreviated = false,
+    bool is_server = false);
+
+v8::MaybeLocal<v8::Object> ECPointToBuffer(
+    Environment* env,
+    const EC_GROUP* group,
+    const EC_POINT* point,
+    point_conversion_form_t form,
+    const char** error);
+
+v8::MaybeLocal<v8::Object> X509ToObject(
+    Environment* env,
+    X509* cert);
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CRYPTO_COMMON_H_
diff --git a/src/string_bytes.cc b/src/string_bytes.cc
index f8d7243e5d6c36..7ee87a8ebe8e30 100644
--- a/src/string_bytes.cc
+++ b/src/string_bytes.cc
@@ -587,7 +587,11 @@ static void force_ascii(const char* src, char* dst, size_t len) {
 }
 
 
-static size_t hex_encode(const char* src, size_t slen, char* dst, size_t dlen) {
+size_t StringBytes::hex_encode(
+    const char* src,
+    size_t slen,
+    char* dst,
+    size_t dlen) {
   // We know how much we'll write, just make sure that there's space.
   CHECK(dlen >= slen * 2 &&
       "not enough space provided for hex encode");
@@ -603,6 +607,12 @@ static size_t hex_encode(const char* src, size_t slen, char* dst, size_t dlen) {
   return dlen;
 }
 
+std::string StringBytes::hex_encode(const char* src, size_t slen) {
+  size_t dlen = slen * 2;
+  std::string dst(dlen, '\0');
+  hex_encode(src, slen, &dst[0], dlen);
+  return dst;
+}
 
 #define CHECK_BUFLEN_IN_RANGE(len)                                    \
   do {                                                                \
diff --git a/src/string_bytes.h b/src/string_bytes.h
index 5ef05fc48cd50d..69bb828e018cb0 100644
--- a/src/string_bytes.h
+++ b/src/string_bytes.h
@@ -29,6 +29,8 @@
 #include "v8.h"
 #include "env-inl.h"
 
+#include <string>
+
 namespace node {
 
 class StringBytes {
@@ -97,6 +99,13 @@ class StringBytes {
                                           enum encoding encoding,
                                           v8::Local<v8::Value>* error);
 
+  static size_t hex_encode(const char* src,
+                           size_t slen,
+                           char* dst,
+                           size_t dlen);
+
+  static std::string hex_encode(const char* src, size_t slen);
+
  private:
   static size_t WriteUCS2(v8::Isolate* isolate,
                           char* buf,

From 70f046010cfd04763960df8cda4dc523c5ac405e Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 26 Feb 2020 16:21:41 -0800
Subject: [PATCH 09/17] src: start the .text section with an asm symbol

We create an object file in assembly which introduces the symbol
`__node_text_start` into the .text section and place the resulting
object file as the first file the linker encounters. We do this to
ensure that we can recognize the boundaries of the .text section when
attempting to establish the address range to map to large pages.

Additionally, we rename the section containing the remapping code from
`.lpstub` to `lpstub` so as to take advantage of the linker's feature
whereby it inserts the symbol `__start_lpstub` when the section's name
can be rendered as a valid C variable. We need this symbol in order to
avoid self-mapping the remapping code to large pages, because doing so
would cause the process to crash.

PR-URL: https://github.com/nodejs/node/pull/31981
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: David Carlier <devnexen@gmail.com>
Signed-off-by: Gabriel Schulhof <gabriel.schulhof@intel.com>
---
 node.gyp                           | 20 ++++++++++++++++++++
 src/large_pages/node_large_page.cc | 28 ++++++++++++++--------------
 src/large_pages/node_text_start.S  |  5 +++++
 3 files changed, 39 insertions(+), 14 deletions(-)
 create mode 100644 src/large_pages/node_text_start.S

diff --git a/node.gyp b/node.gyp
index b0757da045d1f9..260ce439a40fcb 100644
--- a/node.gyp
+++ b/node.gyp
@@ -313,6 +313,19 @@
   },
 
   'targets': [
+    {
+      'target_name': 'node_text_start',
+      'type': 'none',
+      'conditions': [
+        [ 'OS=="linux" and '
+          'target_arch=="x64"', {
+          'type': 'static_library',
+          'sources': [
+            'src/large_pages/node_text_start.S'
+          ]
+        }],
+      ]
+    },
     {
       'target_name': '<(node_core_target_name)',
       'type': 'executable',
@@ -498,6 +511,13 @@
             'src/node_snapshot_stub.cc'
           ],
         }],
+        [ 'OS=="linux" and '
+          'target_arch=="x64"', {
+          'dependencies': [ 'node_text_start' ],
+          'ldflags+': [
+            '<(PRODUCT_DIR)/obj.target/node_text_start/src/large_pages/node_text_start.o'
+          ]
+        }],
       ],
     }, # node_core_target_name
     {
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index a72cb65bb65674..31d85c1734a63c 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -71,7 +71,11 @@
 
 #if defined(__linux__)
 extern "C" {
-extern char __executable_start;
+// This symbol must be declared weak because this file becomes part of all
+// Node.js targets (like node_mksnapshot, node_mkcodecache, and cctest) and
+// those files do not supply the symbol.
+extern char __attribute__((weak)) __node_text_start;
+extern char __start_lpstub;
 }  // extern "C"
 #endif  // defined(__linux__)
 
@@ -121,6 +125,8 @@ struct text_region FindNodeTextRegion() {
   std::string dev;
   char dash;
   uintptr_t start, end, offset, inode;
+  uintptr_t node_text_start = reinterpret_cast<uintptr_t>(&__node_text_start);
+  uintptr_t lpstub_start = reinterpret_cast<uintptr_t>(&__start_lpstub);
 
   ifs.open("/proc/self/maps");
   if (!ifs) {
@@ -144,21 +150,15 @@ struct text_region FindNodeTextRegion() {
     std::string pathname;
     iss >> pathname;
 
-    if (start != reinterpret_cast<uintptr_t>(&__executable_start))
+    if (permission != "r-xp")
       continue;
 
-    // The next line is our .text section.
-    if (!std::getline(ifs, map_line))
-      break;
-
-    iss = std::istringstream(map_line);
-    iss >> std::hex >> start;
-    iss >> dash;
-    iss >> std::hex >> end;
-    iss >> permission;
+    if (node_text_start < start || node_text_start >= end)
+      continue;
 
-    if (permission != "r-xp")
-      break;
+    start = node_text_start;
+    if (lpstub_start > start && lpstub_start <= end)
+      end = lpstub_start;
 
     char* from = reinterpret_cast<char*>(hugepage_align_up(start));
     char* to = reinterpret_cast<char*>(hugepage_align_down(end));
@@ -318,7 +318,7 @@ static bool IsSuperPagesEnabled() {
 // d. If successful copy the code there and unmap the original region
 int
 #if !defined(__APPLE__)
-__attribute__((__section__(".lpstub")))
+__attribute__((__section__("lpstub")))
 #else
 __attribute__((__section__("__TEXT,__lpstub")))
 #endif
diff --git a/src/large_pages/node_text_start.S b/src/large_pages/node_text_start.S
new file mode 100644
index 00000000000000..1609b254f0495a
--- /dev/null
+++ b/src/large_pages/node_text_start.S
@@ -0,0 +1,5 @@
+.text
+.align 0x2000
+.global __node_text_start
+.hidden __node_text_start
+__node_text_start:

From 478450d6b320c9c904bff12d871a62fd7e8bab33 Mon Sep 17 00:00:00 2001
From: gengjiawen <technicalcute@gmail.com>
Date: Fri, 21 Feb 2020 22:31:15 +0800
Subject: [PATCH 10/17] build: add asan check in Github action

PR-URL: https://github.com/nodejs/node/pull/31902
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
---
 .github/workflows/ASAN.yml | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 .github/workflows/ASAN.yml

diff --git a/.github/workflows/ASAN.yml b/.github/workflows/ASAN.yml
new file mode 100644
index 00000000000000..77b8fd530adb52
--- /dev/null
+++ b/.github/workflows/ASAN.yml
@@ -0,0 +1,20 @@
+name: node ASAN
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+      runs-on: ubuntu-latest
+      container: gengjiawen/node-build:2020-02-14
+      steps:
+        - uses: actions/checkout@v2
+        - name: Build
+          run: |
+              npx envinfo
+              ./configure --debug --enable-asan --ninja && ninja -C out/Debug
+        - name: Test
+          env:
+            ASAN_OPTIONS: halt_on_error=0
+          continue-on-error: true
+          run: |
+            python3 tools/test.py -J --mode=debug

From 4dc59b91a71099f054e9ece5fb05657b1b916af6 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Wed, 9 Oct 2019 18:56:21 +0200
Subject: [PATCH 11/17] dgram: make UDPWrap more reusable

Allow using the handle more directly for I/O in other parts of
the codebase.

Originally landed in the QUIC repo

Original review metadata:

```
  PR-URL: https://github.com/nodejs/quic/pull/165
  Reviewed-By: James M Snell <jasnell@gmail.com>
  Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
```

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/31871
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
---
 lib/dgram.js    |   4 +-
 src/udp_wrap.cc | 205 +++++++++++++++++++++++++++++++++++-------------
 src/udp_wrap.h  | 116 +++++++++++++++++++++++++--
 3 files changed, 265 insertions(+), 60 deletions(-)

diff --git a/lib/dgram.js b/lib/dgram.js
index 26d1e1d11a0e76..dba1bc024272eb 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -232,7 +232,9 @@ Socket.prototype.bind = function(port_, address_ /* , callback */) {
     this.on('listening', onListening);
   }
 
-  if (port instanceof UDP) {
+  if (port !== null &&
+      typeof port === 'object' &&
+      typeof port.recvStart === 'function') {
     replaceHandle(this, port);
     startListening(this);
     return this;
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index fa5cf8da479644..702449daae90a8 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -69,18 +69,57 @@ SendWrap::SendWrap(Environment* env,
 }
 
 
-inline bool SendWrap::have_callback() const {
+bool SendWrap::have_callback() const {
   return have_callback_;
 }
 
+UDPListener::~UDPListener() {
+  if (wrap_ != nullptr)
+    wrap_->set_listener(nullptr);
+}
+
+UDPWrapBase::~UDPWrapBase() {
+  set_listener(nullptr);
+}
+
+UDPListener* UDPWrapBase::listener() const {
+  CHECK_NOT_NULL(listener_);
+  return listener_;
+}
+
+void UDPWrapBase::set_listener(UDPListener* listener) {
+  if (listener_ != nullptr)
+    listener_->wrap_ = nullptr;
+  listener_ = listener;
+  if (listener_ != nullptr) {
+    CHECK_NULL(listener_->wrap_);
+    listener_->wrap_ = this;
+  }
+}
+
+UDPWrapBase* UDPWrapBase::FromObject(Local<Object> obj) {
+  CHECK_GT(obj->InternalFieldCount(), UDPWrapBase::kUDPWrapBaseField);
+  return static_cast<UDPWrapBase*>(
+      obj->GetAlignedPointerFromInternalField(UDPWrapBase::kUDPWrapBaseField));
+}
+
+void UDPWrapBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
+  env->SetProtoMethod(t, "recvStart", RecvStart);
+  env->SetProtoMethod(t, "recvStop", RecvStop);
+}
 
 UDPWrap::UDPWrap(Environment* env, Local<Object> object)
     : HandleWrap(env,
                  object,
                  reinterpret_cast<uv_handle_t*>(&handle_),
                  AsyncWrap::PROVIDER_UDPWRAP) {
+  object->SetAlignedPointerInInternalField(
+      UDPWrapBase::kUDPWrapBaseField, static_cast<UDPWrapBase*>(this));
+
   int r = uv_udp_init(env->event_loop(), &handle_);
   CHECK_EQ(r, 0);  // can't fail anyway
+
+  set_listener(this);
 }
 
 
@@ -91,7 +130,8 @@ void UDPWrap::Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  t->InstanceTemplate()->SetInternalFieldCount(UDPWrap::kInternalFieldCount);
+  t->InstanceTemplate()->SetInternalFieldCount(
+      UDPWrapBase::kInternalFieldCount);
   Local<String> udpString =
       FIXED_ONE_BYTE_STRING(env->isolate(), "UDP");
   t->SetClassName(udpString);
@@ -112,6 +152,7 @@ void UDPWrap::Initialize(Local<Object> target,
                                               Local<FunctionTemplate>(),
                                               attributes);
 
+  UDPWrapBase::AddMethods(env, t);
   env->SetProtoMethod(t, "open", Open);
   env->SetProtoMethod(t, "bind", Bind);
   env->SetProtoMethod(t, "connect", Connect);
@@ -120,8 +161,6 @@ void UDPWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "connect6", Connect6);
   env->SetProtoMethod(t, "send6", Send6);
   env->SetProtoMethod(t, "disconnect", Disconnect);
-  env->SetProtoMethod(t, "recvStart", RecvStart);
-  env->SetProtoMethod(t, "recvStop", RecvStop);
   env->SetProtoMethod(t, "getpeername",
                       GetSockOrPeerName<UDPWrap, uv_udp_getpeername>);
   env->SetProtoMethod(t, "getsockname",
@@ -220,6 +259,9 @@ void UDPWrap::DoBind(const FunctionCallbackInfo<Value>& args, int family) {
                       flags);
   }
 
+  if (err == 0)
+    wrap->listener()->OnAfterBind();
+
   args.GetReturnValue().Set(err);
 }
 
@@ -464,14 +506,10 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
     CHECK(args[3]->IsBoolean());
   }
 
-  Local<Object> req_wrap_obj = args[0].As<Object>();
   Local<Array> chunks = args[1].As<Array>();
   // it is faster to fetch the length of the
   // array in js-land
   size_t count = args[2].As<Uint32>()->Value();
-  const bool have_callback = sendto ? args[5]->IsTrue() : args[3]->IsTrue();
-
-  size_t msg_size = 0;
 
   MaybeStackBuffer<uv_buf_t, 16> bufs(count);
 
@@ -482,7 +520,6 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
     size_t length = Buffer::Length(chunk);
 
     bufs[i] = uv_buf_init(Buffer::Data(chunk), length);
-    msg_size += length;
   }
 
   int err = 0;
@@ -492,14 +529,36 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
     const unsigned short port = args[3].As<Uint32>()->Value();
     node::Utf8Value address(env->isolate(), args[4]);
     err = sockaddr_for_family(family, address.out(), port, &addr_storage);
-    if (err == 0) {
+    if (err == 0)
       addr = reinterpret_cast<sockaddr*>(&addr_storage);
-    }
   }
 
-  uv_buf_t* bufs_ptr = *bufs;
-  if (err == 0 && !UNLIKELY(env->options()->test_udp_no_try_send)) {
-    err = uv_udp_try_send(&wrap->handle_, bufs_ptr, count, addr);
+  if (err == 0) {
+    wrap->current_send_req_wrap_ = args[0].As<Object>();
+    wrap->current_send_has_callback_ =
+        sendto ? args[5]->IsTrue() : args[3]->IsTrue();
+
+    err = wrap->Send(*bufs, count, addr);
+
+    wrap->current_send_req_wrap_.Clear();
+    wrap->current_send_has_callback_ = false;
+  }
+
+  args.GetReturnValue().Set(err);
+}
+
+ssize_t UDPWrap::Send(uv_buf_t* bufs_ptr,
+                      size_t count,
+                      const sockaddr* addr) {
+  if (IsHandleClosing()) return UV_EBADF;
+
+  size_t msg_size = 0;
+  for (size_t i = 0; i < count; i++)
+    msg_size += bufs_ptr[i].len;
+
+  int err = 0;
+  if (!UNLIKELY(env()->options()->test_udp_no_try_send)) {
+    err = uv_udp_try_send(&handle_, bufs_ptr, count, addr);
     if (err == UV_ENOSYS || err == UV_EAGAIN) {
       err = 0;
     } else if (err >= 0) {
@@ -517,28 +576,41 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
         CHECK_EQ(static_cast<size_t>(err), msg_size);
         // + 1 so that the JS side can distinguish 0-length async sends from
         // 0-length sync sends.
-        args.GetReturnValue().Set(static_cast<uint32_t>(msg_size) + 1);
-        return;
+        return msg_size + 1;
       }
     }
   }
 
   if (err == 0) {
-    AsyncHooks::DefaultTriggerAsyncIdScope trigger_scope(wrap);
-    SendWrap* req_wrap = new SendWrap(env, req_wrap_obj, have_callback);
-    req_wrap->msg_size = msg_size;
-
-    err = req_wrap->Dispatch(uv_udp_send,
-                             &wrap->handle_,
-                             bufs_ptr,
-                             count,
-                             addr,
-                             OnSend);
+    AsyncHooks::DefaultTriggerAsyncIdScope trigger_scope(this);
+    ReqWrap<uv_udp_send_t>* req_wrap = listener()->CreateSendWrap(msg_size);
+    if (req_wrap == nullptr) return UV_ENOSYS;
+
+    err = req_wrap->Dispatch(
+        uv_udp_send,
+        &handle_,
+        bufs_ptr,
+        count,
+        addr,
+        uv_udp_send_cb{[](uv_udp_send_t* req, int status) {
+          UDPWrap* self = ContainerOf(&UDPWrap::handle_, req->handle);
+          self->listener()->OnSendDone(
+              ReqWrap<uv_udp_send_t>::from_req(req), status);
+        }});
     if (err)
       delete req_wrap;
   }
 
-  args.GetReturnValue().Set(err);
+  return err;
+}
+
+
+ReqWrap<uv_udp_send_t>* UDPWrap::CreateSendWrap(size_t msg_size) {
+  SendWrap* req_wrap = new SendWrap(env(),
+                                    current_send_req_wrap_,
+                                    current_send_has_callback_);
+  req_wrap->msg_size = msg_size;
+  return req_wrap;
 }
 
 
@@ -552,31 +624,46 @@ void UDPWrap::Send6(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void UDPWrap::RecvStart(const FunctionCallbackInfo<Value>& args) {
-  UDPWrap* wrap;
-  ASSIGN_OR_RETURN_UNWRAP(&wrap,
-                          args.Holder(),
-                          args.GetReturnValue().Set(UV_EBADF));
-  int err = uv_udp_recv_start(&wrap->handle_, OnAlloc, OnRecv);
+AsyncWrap* UDPWrap::GetAsyncWrap() {
+  return this;
+}
+
+int UDPWrap::GetPeerName(sockaddr* name, int* namelen) {
+  return uv_udp_getpeername(&handle_, name, namelen);
+}
+
+int UDPWrap::GetSockName(sockaddr* name, int* namelen) {
+  return uv_udp_getsockname(&handle_, name, namelen);
+}
+
+void UDPWrapBase::RecvStart(const FunctionCallbackInfo<Value>& args) {
+  UDPWrapBase* wrap = UDPWrapBase::FromObject(args.Holder());
+  args.GetReturnValue().Set(wrap == nullptr ? UV_EBADF : wrap->RecvStart());
+}
+
+int UDPWrap::RecvStart() {
+  if (IsHandleClosing()) return UV_EBADF;
+  int err = uv_udp_recv_start(&handle_, OnAlloc, OnRecv);
   // UV_EALREADY means that the socket is already bound but that's okay
   if (err == UV_EALREADY)
     err = 0;
-  args.GetReturnValue().Set(err);
+  return err;
 }
 
 
-void UDPWrap::RecvStop(const FunctionCallbackInfo<Value>& args) {
-  UDPWrap* wrap;
-  ASSIGN_OR_RETURN_UNWRAP(&wrap,
-                          args.Holder(),
-                          args.GetReturnValue().Set(UV_EBADF));
-  int r = uv_udp_recv_stop(&wrap->handle_);
-  args.GetReturnValue().Set(r);
+void UDPWrapBase::RecvStop(const FunctionCallbackInfo<Value>& args) {
+  UDPWrapBase* wrap = UDPWrapBase::FromObject(args.Holder());
+  args.GetReturnValue().Set(wrap == nullptr ? UV_EBADF : wrap->RecvStop());
+}
+
+int UDPWrap::RecvStop() {
+  if (IsHandleClosing()) return UV_EBADF;
+  return uv_udp_recv_stop(&handle_);
 }
 
 
-void UDPWrap::OnSend(uv_udp_send_t* req, int status) {
-  std::unique_ptr<SendWrap> req_wrap{static_cast<SendWrap*>(req->data)};
+void UDPWrap::OnSendDone(ReqWrap<uv_udp_send_t>* req, int status) {
+  std::unique_ptr<SendWrap> req_wrap{static_cast<SendWrap*>(req)};
   if (req_wrap->have_callback()) {
     Environment* env = req_wrap->env();
     HandleScope handle_scope(env->isolate());
@@ -593,19 +680,30 @@ void UDPWrap::OnSend(uv_udp_send_t* req, int status) {
 void UDPWrap::OnAlloc(uv_handle_t* handle,
                       size_t suggested_size,
                       uv_buf_t* buf) {
-  UDPWrap* wrap = static_cast<UDPWrap*>(handle->data);
-  *buf = wrap->env()->AllocateManaged(suggested_size).release();
+  UDPWrap* wrap = ContainerOf(&UDPWrap::handle_,
+                              reinterpret_cast<uv_udp_t*>(handle));
+  *buf = wrap->listener()->OnAlloc(suggested_size);
+}
+
+uv_buf_t UDPWrap::OnAlloc(size_t suggested_size) {
+  return env()->AllocateManaged(suggested_size).release();
 }
 
 void UDPWrap::OnRecv(uv_udp_t* handle,
                      ssize_t nread,
-                     const uv_buf_t* buf_,
-                     const struct sockaddr* addr,
+                     const uv_buf_t* buf,
+                     const sockaddr* addr,
                      unsigned int flags) {
-  UDPWrap* wrap = static_cast<UDPWrap*>(handle->data);
-  Environment* env = wrap->env();
+  UDPWrap* wrap = ContainerOf(&UDPWrap::handle_, handle);
+  wrap->listener()->OnRecv(nread, *buf, addr, flags);
+}
 
-  AllocatedBuffer buf(env, *buf_);
+void UDPWrap::OnRecv(ssize_t nread,
+                     const uv_buf_t& buf_,
+                     const sockaddr* addr,
+                     unsigned int flags) {
+  Environment* env = this->env();
+  AllocatedBuffer buf(env, buf_);
   if (nread == 0 && addr == nullptr) {
     return;
   }
@@ -613,23 +711,22 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(env->context());
 
-  Local<Object> wrap_obj = wrap->object();
   Local<Value> argv[] = {
     Integer::New(env->isolate(), nread),
-    wrap_obj,
+    object(),
     Undefined(env->isolate()),
     Undefined(env->isolate())
   };
 
   if (nread < 0) {
-    wrap->MakeCallback(env->onmessage_string(), arraysize(argv), argv);
+    MakeCallback(env->onmessage_string(), arraysize(argv), argv);
     return;
   }
 
   buf.Resize(nread);
   argv[2] = buf.ToBuffer().ToLocalChecked();
   argv[3] = AddressToJS(env, addr);
-  wrap->MakeCallback(env->onmessage_string(), arraysize(argv), argv);
+  MakeCallback(env->onmessage_string(), arraysize(argv), argv);
 }
 
 MaybeLocal<Object> UDPWrap::Instantiate(Environment* env,
diff --git a/src/udp_wrap.h b/src/udp_wrap.h
index 2026dd1dee1eb1..7afd9784b0ac9e 100644
--- a/src/udp_wrap.h
+++ b/src/udp_wrap.h
@@ -25,14 +25,101 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "handle_wrap.h"
+#include "req_wrap.h"
 #include "uv.h"
 #include "v8.h"
 
 namespace node {
 
-class Environment;
+class UDPWrapBase;
 
-class UDPWrap: public HandleWrap {
+// A listener that can be attached to an `UDPWrapBase` object and generally
+// manages its I/O activity. This is similar to `StreamListener`.
+class UDPListener {
+ public:
+  virtual ~UDPListener();
+
+  // Called right before data is received from the socket. Must return a
+  // buffer suitable for reading data into, that is then passed to OnRecv.
+  virtual uv_buf_t OnAlloc(size_t suggested_size) = 0;
+
+  // Called right after data is received from the socket, and includes
+  // information about the source address. If `nread` is negative, an error
+  // has occurred, and it represents a libuv error code.
+  virtual void OnRecv(ssize_t nread,
+                      const uv_buf_t& buf,
+                      const sockaddr* addr,
+                      unsigned int flags) = 0;
+
+  // Called when an asynchronous request for writing data is created.
+  // The `msg_size` value contains the total size of the data to be sent,
+  // but may be ignored by the implementation of this Method.
+  // The return value is later passed to OnSendDone.
+  virtual ReqWrap<uv_udp_send_t>* CreateSendWrap(size_t msg_size) = 0;
+
+  // Called when an asynchronous request for writing data has finished.
+  // If status is negative, an error has occurred, and it represents a libuv
+  // error code.
+  virtual void OnSendDone(ReqWrap<uv_udp_send_t>* wrap, int status) = 0;
+
+  // Optional callback that is called after the socket has been bound.
+  virtual void OnAfterBind() {}
+
+  inline UDPWrapBase* udp() const { return wrap_; }
+
+ protected:
+  UDPWrapBase* wrap_ = nullptr;
+
+  friend class UDPWrapBase;
+};
+
+class UDPWrapBase {
+ public:
+  // While UDPWrapBase itself does not extend from HandleWrap, classes
+  // derived from it will (like UDPWrap)
+  enum InternalFields {
+    kUDPWrapBaseField = HandleWrap::kInternalFieldCount,
+    kInternalFieldCount
+  };
+  virtual ~UDPWrapBase();
+
+  // Start emitting OnAlloc() + OnRecv() events on the listener.
+  virtual int RecvStart() = 0;
+
+  // Stop emitting OnAlloc() + OnRecv() events on the listener.
+  virtual int RecvStop() = 0;
+
+  // Send a chunk of data over this socket. This may call CreateSendWrap()
+  // on the listener if an async transmission is necessary.
+  virtual ssize_t Send(uv_buf_t* bufs,
+                       size_t nbufs,
+                       const sockaddr* addr) = 0;
+
+  // Stores the sockaddr for the peer in `name`.
+  virtual int GetPeerName(sockaddr* name, int* namelen) = 0;
+
+  // Stores the sockaddr for the local socket in `name`.
+  virtual int GetSockName(sockaddr* name, int* namelen) = 0;
+
+  // Returns an AsyncWrap object with the same lifetime as this object.
+  virtual AsyncWrap* GetAsyncWrap() = 0;
+
+  void set_listener(UDPListener* listener);
+  UDPListener* listener() const;
+
+  static UDPWrapBase* FromObject(v8::Local<v8::Object> obj);
+
+  static void RecvStart(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RecvStop(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddMethods(Environment* env, v8::Local<v8::FunctionTemplate> t);
+
+ private:
+  UDPListener* listener_ = nullptr;
+};
+
+class UDPWrap final : public HandleWrap,
+                      public UDPWrapBase,
+                      public UDPListener {
  public:
   enum SocketType {
     SOCKET
@@ -51,8 +138,6 @@ class UDPWrap: public HandleWrap {
   static void Connect6(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Send6(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Disconnect(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RecvStart(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RecvStop(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AddMembership(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DropMembership(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AddSourceSpecificMembership(
@@ -68,6 +153,25 @@ class UDPWrap: public HandleWrap {
   static void SetTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void BufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
 
+  // UDPListener implementation
+  uv_buf_t OnAlloc(size_t suggested_size) override;
+  void OnRecv(ssize_t nread,
+              const uv_buf_t& buf,
+              const sockaddr* addr,
+              unsigned int flags) override;
+  ReqWrap<uv_udp_send_t>* CreateSendWrap(size_t msg_size) override;
+  void OnSendDone(ReqWrap<uv_udp_send_t>* wrap, int status) override;
+
+  // UDPWrapBase implementation
+  int RecvStart() override;
+  int RecvStop() override;
+  ssize_t Send(uv_buf_t* bufs,
+               size_t nbufs,
+               const sockaddr* addr) override;
+  int GetPeerName(sockaddr* name, int* namelen) override;
+  int GetSockName(sockaddr* name, int* namelen) override;
+  AsyncWrap* GetAsyncWrap() override;
+
   static v8::MaybeLocal<v8::Object> Instantiate(Environment* env,
                                                 AsyncWrap* parent,
                                                 SocketType type);
@@ -99,7 +203,6 @@ class UDPWrap: public HandleWrap {
   static void OnAlloc(uv_handle_t* handle,
                       size_t suggested_size,
                       uv_buf_t* buf);
-  static void OnSend(uv_udp_send_t* req, int status);
   static void OnRecv(uv_udp_t* handle,
                      ssize_t nread,
                      const uv_buf_t* buf,
@@ -107,6 +210,9 @@ class UDPWrap: public HandleWrap {
                      unsigned int flags);
 
   uv_udp_t handle_;
+
+  bool current_send_has_callback_;
+  v8::Local<v8::Object> current_send_req_wrap_;
 };
 
 }  // namespace node

From 9c1ac50fc586a3daa7c9b7da695057649c75a8b6 Mon Sep 17 00:00:00 2001
From: Richard Lau <riclau@uk.ibm.com>
Date: Tue, 3 Mar 2020 15:02:02 -0500
Subject: [PATCH 12/17] build: fix building with ninja

The ninja build places objects in a different directory.

Co-authored-by: Gabriel Schulhof <gabriel.schulhof@intel.com>
Signed-off-by: Richard Lau <riclau@uk.ibm.com>

PR-URL: https://github.com/nodejs/node/pull/32071
Reviewed-By: Matheus Marchini <mat@mmarchini.me>
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: Sam Roberts <vieuxtech@gmail.com>
Reviewed-By: Shelley Vohr <codebytere@gmail.com>
Reviewed-By: Myles Borins <myles.borins@gmail.com>
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
---
 node.gyp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/node.gyp b/node.gyp
index 260ce439a40fcb..9c4057aa417a02 100644
--- a/node.gyp
+++ b/node.gyp
@@ -250,6 +250,11 @@
     'node_mksnapshot_exec': '<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)node_mksnapshot<(EXECUTABLE_SUFFIX)',
     'mkcodecache_exec': '<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)mkcodecache<(EXECUTABLE_SUFFIX)',
     'conditions': [
+      ['GENERATOR == "ninja"', {
+        'node_text_start_object_path': 'src/large_pages/node_text_start.node_text_start.o'
+      }, {
+        'node_text_start_object_path': 'node_text_start/src/large_pages/node_text_start.o'
+      }],
       [ 'node_shared=="true"', {
         'node_target_type%': 'shared_library',
         'conditions': [
@@ -515,7 +520,7 @@
           'target_arch=="x64"', {
           'dependencies': [ 'node_text_start' ],
           'ldflags+': [
-            '<(PRODUCT_DIR)/obj.target/node_text_start/src/large_pages/node_text_start.o'
+            '<(obj_dir)/<(node_text_start_object_path)'
           ]
         }],
       ],

From 2518213a1b8b14b17d7980b2bd30753ca11d7066 Mon Sep 17 00:00:00 2001
From: ConorDavenport <cnrdavenport@gmail.com>
Date: Fri, 14 Feb 2020 12:54:11 +0000
Subject: [PATCH 13/17] doc: improve doc/markdown file organization coherence

* Updated cpp style guide file name and location and fixed links to
  this file.

* Updated collaborator guide file name and location and fixed links
  to this file.

* Updated documentation style guide file name and location and updated
  links referencing the file.

* Moved files to appropriate location and updated naming style for
  some of them.

Fixes: https://github.com/nodejs/node/issues/31741

PR-URL: https://github.com/nodejs/node/pull/31792
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Sam Roberts <vieuxtech@gmail.com>
---
 CONTRIBUTING.md                                           | 4 ++--
 GOVERNANCE.md                                             | 6 +++---
 Makefile                                                  | 4 ++--
 README.md                                                 | 2 +-
 benchmark/README.md                                       | 8 ++++----
 COLLABORATOR_GUIDE.md => doc/guides/collaborator-guide.md | 0
 doc/guides/contributing/{coc.md => code-of-conduct.md}    | 0
 doc/guides/contributing/pull-requests.md                  | 6 +++---
 CPP_STYLE_GUIDE.md => doc/guides/cpp-style-guide.md       | 0
 doc/{STYLE_GUIDE.md => guides/doc-style-guide.md}         | 0
 doc/guides/{internal/readme.md => internal-api.md}        | 0
 .../{updating-root-certs.md => maintaining-root-certs.md} | 2 +-
 doc/{ => guides}/offboarding.md                           | 0
 doc/{ => guides}/onboarding-extras.md                     | 0
 doc/{ => guides}/releases.md                              | 0
 ...ity_release_process.md => security-release-process.md} | 0
 .../guides}/writing-and-running-benchmarks.md             | 0
 doc/onboarding.md => onboarding.md                        | 0
 src/README.md                                             | 2 +-
 19 files changed, 17 insertions(+), 17 deletions(-)
 rename COLLABORATOR_GUIDE.md => doc/guides/collaborator-guide.md (100%)
 rename doc/guides/contributing/{coc.md => code-of-conduct.md} (100%)
 rename CPP_STYLE_GUIDE.md => doc/guides/cpp-style-guide.md (100%)
 rename doc/{STYLE_GUIDE.md => guides/doc-style-guide.md} (100%)
 rename doc/guides/{internal/readme.md => internal-api.md} (100%)
 rename doc/guides/{updating-root-certs.md => maintaining-root-certs.md} (99%)
 rename doc/{ => guides}/offboarding.md (100%)
 rename doc/{ => guides}/onboarding-extras.md (100%)
 rename doc/{ => guides}/releases.md (100%)
 rename doc/guides/{security_release_process.md => security-release-process.md} (100%)
 rename {benchmark => doc/guides}/writing-and-running-benchmarks.md (100%)
 rename doc/onboarding.md => onboarding.md (100%)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b9d1f2cef604b9..29700978fb78bf 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -5,13 +5,13 @@
 * [Pull Requests](#pull-requests)
 * [Developer's Certificate of Origin 1.1](#developers-certificate-of-origin)
 
-## [Code of Conduct](./doc/guides/contributing/coc.md)
+## [Code of Conduct](./doc/guides/contributing/code-of-conduct.md)
 
 The Node.js project has a
 [Code of Conduct](https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md)
 to which all contributors must adhere.
 
-See [details on our policy on Code of Conduct](./doc/guides/contributing/coc.md).
+See [details on our policy on Code of Conduct](./doc/guides/contributing/code-of-conduct.md).
 
 ## [Issues](./doc/guides/contributing/issues.md)
 
diff --git a/GOVERNANCE.md b/GOVERNANCE.md
index d7cb6e321e16cb..5048a700340617 100644
--- a/GOVERNANCE.md
+++ b/GOVERNANCE.md
@@ -7,7 +7,7 @@
 * [Technical Steering Committee](#technical-steering-committee)
   * [TSC Meetings](#tsc-meetings)
 * [Collaborator Nominations](#collaborator-nominations)
-  * [Onboarding](#onboarding)
+  * [Onboarding](#./onboarding)
 * [Consensus Seeking Process](#consensus-seeking-process)
 
 <!-- /TOC -->
@@ -39,7 +39,7 @@ result in Collaborators removing their opposition.
 See:
 
 * [List of Collaborators](./README.md#current-project-team-members)
-* [A guide for Collaborators](./COLLABORATOR_GUIDE.md)
+* [A guide for Collaborators](./doc/guides/collaborator-guide.md)
 
 ### Collaborator Activities
 
@@ -148,7 +148,7 @@ nomination.
 ### Onboarding
 
 After the nomination passes, a TSC member onboards the new Collaborator. See
-[the onboarding guide](./doc/onboarding.md) for details of the onboarding
+[the onboarding guide](./onboarding.md) for details of the onboarding
 process.
 
 ## Consensus Seeking Process
diff --git a/Makefile b/Makefile
index d1705fdc49d118..c716f88e5ff99f 100644
--- a/Makefile
+++ b/Makefile
@@ -924,12 +924,12 @@ endif
 .PHONY: release-only
 release-only: check-xz
 	@if [ "$(DISTTYPE)" = "release" ] && `grep -q REPLACEME doc/api/*.md`; then \
-		echo 'Please update REPLACEME in Added: tags in doc/api/*.md (See doc/releases.md)' ; \
+		echo 'Please update REPLACEME in Added: tags in doc/api/*.md (See doc/guides/releases.md)' ; \
 		exit 1 ; \
 	fi
 	@if [ "$(DISTTYPE)" = "release" ] && \
 		`grep -q DEP...X doc/api/deprecations.md`; then \
-		echo 'Please update DEP...X in doc/api/deprecations.md (See doc/releases.md)' ; \
+		echo 'Please update DEP...X in doc/api/deprecations.md (See doc/guides/releases.md)' ; \
 		exit 1 ; \
 	fi
 	@if [ "$(shell git status --porcelain | egrep -v '^\?\? ')" = "" ]; then \
diff --git a/README.md b/README.md
index 657fc478a37e5b..0576cd5132e6a8 100644
--- a/README.md
+++ b/README.md
@@ -529,7 +529,7 @@ For information about the governance of the Node.js project, see
 * [whitlockjc](https://github.com/whitlockjc) -
 **Jeremy Whitlock** &lt;jwhitlock@apache.org&gt;
 
-Collaborators follow the [COLLABORATOR_GUIDE.md](./COLLABORATOR_GUIDE.md) in
+Collaborators follow the [Collaborator Guide](./doc/guides/collaborator-guide.md) in
 maintaining the Node.js project.
 
 ### Release Keys
diff --git a/benchmark/README.md b/benchmark/README.md
index c5fdad093471b5..cb7c1506eb6235 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -5,7 +5,7 @@ of different Node.js implementations and different ways of
 writing JavaScript run by the built-in JavaScript engine.
 
 For a detailed guide on how to write and run benchmarks in this
-directory, see [the guide on benchmarks](writing-and-running-benchmarks.md).
+directory, see [the guide on benchmarks](../doc/guides/writing-and-running-benchmarks.md).
 
 ## Table of Contents
 
@@ -76,17 +76,17 @@ writing benchmarks.
 
 ### `createBenchmark(fn, configs[, options])`
 
-See [the guide on writing benchmarks](writing-and-running-benchmarks.md#basics-of-a-benchmark).
+See [the guide on writing benchmarks](../doc/guides/contributing/writing-and-running-benchmarks.md#basics-of-a-benchmark).
 
 ### `default_http_benchmarker`
 
 The default benchmarker used to run HTTP benchmarks.
-See [the guide on writing HTTP benchmarks](writing-and-running-benchmarks.md#creating-an-http-benchmark).
+See [the guide on writing HTTP benchmarks](../doc/guides/contributing/writing-and-running-benchmarks.md#creating-an-http-benchmark).
 
 ### `PORT`
 
 The default port used to run HTTP benchmarks.
-See [the guide on writing HTTP benchmarks](writing-and-running-benchmarks.md#creating-an-http-benchmark).
+See [the guide on writing HTTP benchmarks](../doc/guides/contributing/writing-and-running-benchmarks.md#creating-an-http-benchmark).
 
 ### `sendResult(data)`
 
diff --git a/COLLABORATOR_GUIDE.md b/doc/guides/collaborator-guide.md
similarity index 100%
rename from COLLABORATOR_GUIDE.md
rename to doc/guides/collaborator-guide.md
diff --git a/doc/guides/contributing/coc.md b/doc/guides/contributing/code-of-conduct.md
similarity index 100%
rename from doc/guides/contributing/coc.md
rename to doc/guides/contributing/code-of-conduct.md
diff --git a/doc/guides/contributing/pull-requests.md b/doc/guides/contributing/pull-requests.md
index 7f4ab4e83e049b..39b84bc34f17d5 100644
--- a/doc/guides/contributing/pull-requests.md
+++ b/doc/guides/contributing/pull-requests.md
@@ -115,13 +115,13 @@ If you are modifying code, please be sure to run `make lint` from time to
 time to ensure that the changes follow the Node.js code style guide.
 
 Any documentation you write (including code comments and API documentation)
-should follow the [Style Guide](../../STYLE_GUIDE.md). Code samples included
-in the API docs will also be checked when running `make lint` (or
+should follow the [Style Guide](../doc-style-guide.md). Code samples
+included in the API docs will also be checked when running `make lint` (or
 `vcbuild.bat lint` on Windows). If you are adding to or deprecating an API,
 use `REPLACEME` for the version number in the documentation YAML.
 
 For contributing C++ code, you may want to look at the
-[C++ Style Guide](../../../CPP_STYLE_GUIDE.md), as well as the
+[C++ Style Guide](../../cpp-style-guide.md), as well as the
 [README of `src/`](../../../src/README.md) for an overview over Node.js
 C++ internals.
 
diff --git a/CPP_STYLE_GUIDE.md b/doc/guides/cpp-style-guide.md
similarity index 100%
rename from CPP_STYLE_GUIDE.md
rename to doc/guides/cpp-style-guide.md
diff --git a/doc/STYLE_GUIDE.md b/doc/guides/doc-style-guide.md
similarity index 100%
rename from doc/STYLE_GUIDE.md
rename to doc/guides/doc-style-guide.md
diff --git a/doc/guides/internal/readme.md b/doc/guides/internal-api.md
similarity index 100%
rename from doc/guides/internal/readme.md
rename to doc/guides/internal-api.md
diff --git a/doc/guides/updating-root-certs.md b/doc/guides/maintaining-root-certs.md
similarity index 99%
rename from doc/guides/updating-root-certs.md
rename to doc/guides/maintaining-root-certs.md
index 41c83e5898bd10..d26bdad943a50a 100644
--- a/doc/guides/updating-root-certs.md
+++ b/doc/guides/maintaining-root-certs.md
@@ -1,4 +1,4 @@
-# Updating the Root Certificates
+# Maintaining the Root Certificates
 
 Node.js contains a compiled-in set of root certificates used as trust anchors
 for TLS certificate validation.
diff --git a/doc/offboarding.md b/doc/guides/offboarding.md
similarity index 100%
rename from doc/offboarding.md
rename to doc/guides/offboarding.md
diff --git a/doc/onboarding-extras.md b/doc/guides/onboarding-extras.md
similarity index 100%
rename from doc/onboarding-extras.md
rename to doc/guides/onboarding-extras.md
diff --git a/doc/releases.md b/doc/guides/releases.md
similarity index 100%
rename from doc/releases.md
rename to doc/guides/releases.md
diff --git a/doc/guides/security_release_process.md b/doc/guides/security-release-process.md
similarity index 100%
rename from doc/guides/security_release_process.md
rename to doc/guides/security-release-process.md
diff --git a/benchmark/writing-and-running-benchmarks.md b/doc/guides/writing-and-running-benchmarks.md
similarity index 100%
rename from benchmark/writing-and-running-benchmarks.md
rename to doc/guides/writing-and-running-benchmarks.md
diff --git a/doc/onboarding.md b/onboarding.md
similarity index 100%
rename from doc/onboarding.md
rename to onboarding.md
diff --git a/src/README.md b/src/README.md
index 40790b278acb65..2e59c51c3c37e9 100644
--- a/src/README.md
+++ b/src/README.md
@@ -903,7 +903,7 @@ static void GetUserInfo(const FunctionCallbackInfo<Value>& args) {
 [`v8.h` in Node.js master]: https://github.com/nodejs/node/blob/master/deps/v8/include/v8.h
 [`v8.h` in V8 master]: https://github.com/v8/v8/blob/master/include/v8.h
 [`vm` module]: https://nodejs.org/api/vm.html
-[C++ coding style]: ../CPP_STYLE_GUIDE.md
+[C++ coding style]: ../doc/guides/cpp-style-guide.md
 [Callback scopes]: #callback-scopes
 [JavaScript value handles]: #js-handles
 [N-API]: https://nodejs.org/api/n-api.html

From 4ed720e940899076eb6b7fc0198b4a76266ee615 Mon Sep 17 00:00:00 2001
From: Harshitha KP <harshi46@in.ibm.com>
Date: Thu, 16 Jan 2020 07:25:22 -0500
Subject: [PATCH 14/17] doc: visibility of Worker threads cli options

Fixes: https://github.com/nodejs/node/issues/28518
PR-URL: https://github.com/nodejs/node/pull/31380
Fixes: https://github.com/nodejs/node/issues/28518
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/worker_threads.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index b67d563fa6d10b..e773949b49df52 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -55,6 +55,10 @@ correlation between tasks and their outcomes. See
 ["Using `AsyncResource` for a `Worker` thread pool"][async-resource-worker-pool]
 in the `async_hooks` documentation for an example implementation.
 
+Worker threads inherit non-process-specific options by default. Refer to
+[`Worker constructor options`][] to know how to customize worker thread options,
+specifically `argv` and `execArgv` options.
+
 ## `worker.isMainThread`
 <!-- YAML
 added: v10.5.0
@@ -768,6 +772,7 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [`trace_events`]: tracing.html
 [`v8.getHeapSnapshot()`]: v8.html#v8_v8_getheapsnapshot
 [`vm`]: vm.html
+[`Worker constructor options`]: #worker_threads_new_worker_filename_options
 [`worker.on('message')`]: #worker_threads_event_message_1
 [`worker.postMessage()`]: #worker_threads_worker_postmessage_value_transferlist
 [`worker.SHARE_ENV`]: #worker_threads_worker_share_env

From 723aa41d961855cb0229a66950c2d5ebcd1d2a9b Mon Sep 17 00:00:00 2001
From: Shelley Vohr <shelley.vohr@gmail.com>
Date: Wed, 4 Mar 2020 11:11:37 -0800
Subject: [PATCH 15/17] build: fix zlib tarball generation

PR-URL: https://github.com/nodejs/node/pull/32094
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Myles Borins <myles.borins@gmail.com>
---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index c716f88e5ff99f..4ebb16cdfd0672 100644
--- a/Makefile
+++ b/Makefile
@@ -1032,7 +1032,6 @@ $(TARBALL): release-only $(NODE_EXE) doc
 	$(RM) -r $(TARNAME)/deps/v8/samples
 	$(RM) -r $(TARNAME)/deps/v8/tools/profviz
 	$(RM) -r $(TARNAME)/deps/v8/tools/run-tests.py
-	$(RM) -r $(TARNAME)/deps/zlib/contrib # too big, unused
 	$(RM) -r $(TARNAME)/doc/images # too big
 	$(RM) -r $(TARNAME)/test*.tap
 	$(RM) -r $(TARNAME)/tools/cpplint.py
@@ -1043,6 +1042,7 @@ $(TARBALL): release-only $(NODE_EXE) doc
 	$(RM) -r $(TARNAME)/tools/osx-pkg.pmdoc
 	find $(TARNAME)/deps/v8/test/* -type d ! -regex '.*/test/torque$$' | xargs $(RM) -r
 	find $(TARNAME)/deps/v8/test -type f ! -regex '.*/test/torque/.*' | xargs $(RM)
+	find $(TARNAME)/deps/zlib/contrib/* -type d ! -regex '.*/contrib/optimizations$$' | xargs $(RM) -r
 	find $(TARNAME)/ -name ".eslint*" -maxdepth 2 | xargs $(RM)
 	find $(TARNAME)/ -type l | xargs $(RM) # annoying on windows
 	tar -cf $(TARNAME).tar $(TARNAME)

From 6a9cea9ed25bedda9cab3c8cd8ff1bee842a3919 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Tue, 3 Mar 2020 10:29:06 +0000
Subject: [PATCH 16/17] src: pass resource object along with
 InternalMakeCallback

This was an oversight in 9fdb6e6aaf45b2364bac89a.
Fixing this is necessary to make `executionAsyncResource()` work
as expected.

Refs: https://github.com/nodejs/node/pull/30959
Fixes: https://github.com/nodejs/node/issues/32060

PR-URL: https://github.com/nodejs/node/pull/32063
Reviewed-By: Vladimir de Turckheim <vlad2t@hotmail.com>
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/api/callback.cc                           |  5 ++-
 src/async_wrap.cc                             |  2 +-
 src/node_internals.h                          |  1 +
 .../test-async-exec-resource-http-32060.js    | 37 +++++++++++++++++++
 4 files changed, 42 insertions(+), 3 deletions(-)
 create mode 100644 test/async-hooks/test-async-exec-resource-http-32060.js

diff --git a/src/api/callback.cc b/src/api/callback.cc
index 1fb85c5883f120..f7e7ddedfae377 100644
--- a/src/api/callback.cc
+++ b/src/api/callback.cc
@@ -139,6 +139,7 @@ void InternalCallbackScope::Close() {
 }
 
 MaybeLocal<Value> InternalMakeCallback(Environment* env,
+                                       Local<Object> resource,
                                        Local<Object> recv,
                                        const Local<Function> callback,
                                        int argc,
@@ -150,7 +151,7 @@ MaybeLocal<Value> InternalMakeCallback(Environment* env,
     CHECK(!argv[i].IsEmpty());
 #endif
 
-  InternalCallbackScope scope(env, recv, asyncContext);
+  InternalCallbackScope scope(env, resource, asyncContext);
   if (scope.Failed()) {
     return MaybeLocal<Value>();
   }
@@ -224,7 +225,7 @@ MaybeLocal<Value> MakeCallback(Isolate* isolate,
   CHECK_NOT_NULL(env);
   Context::Scope context_scope(env->context());
   MaybeLocal<Value> ret =
-      InternalMakeCallback(env, recv, callback, argc, argv, asyncContext);
+      InternalMakeCallback(env, recv, recv, callback, argc, argv, asyncContext);
   if (ret.IsEmpty() && env->async_callback_scope_depth() == 0) {
     // This is only for legacy compatibility and we may want to look into
     // removing/adjusting it.
diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index 892e33c624bb88..b35cdca08a6f87 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -749,7 +749,7 @@ MaybeLocal<Value> AsyncWrap::MakeCallback(const Local<Function> cb,
   ProviderType provider = provider_type();
   async_context context { get_async_id(), get_trigger_async_id() };
   MaybeLocal<Value> ret = InternalMakeCallback(
-      env(), object(), cb, argc, argv, context);
+      env(), GetResource(), object(), cb, argc, argv, context);
 
   // This is a static call with cached values because the `this` object may
   // no longer be alive at this point.
diff --git a/src/node_internals.h b/src/node_internals.h
index 91ba2a58a755ae..7dcbf65f8e698a 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -199,6 +199,7 @@ static v8::MaybeLocal<v8::Object> New(Environment* env,
 
 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,
diff --git a/test/async-hooks/test-async-exec-resource-http-32060.js b/test/async-hooks/test-async-exec-resource-http-32060.js
new file mode 100644
index 00000000000000..0ff68aa1070e19
--- /dev/null
+++ b/test/async-hooks/test-async-exec-resource-http-32060.js
@@ -0,0 +1,37 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const {
+  executionAsyncResource,
+  executionAsyncId,
+  createHook,
+} = require('async_hooks');
+const http = require('http');
+
+const hooked = {};
+createHook({
+  init(asyncId, type, triggerAsyncId, resource) {
+    hooked[asyncId] = resource;
+  }
+}).enable();
+
+const server = http.createServer((req, res) => {
+  res.write('hello');
+  setTimeout(() => {
+    res.end(' world!');
+  }, 1000);
+});
+
+server.listen(0, () => {
+  assert.strictEqual(executionAsyncResource(), hooked[executionAsyncId()]);
+  http.get({ port: server.address().port }, (res) => {
+    assert.strictEqual(executionAsyncResource(), hooked[executionAsyncId()]);
+    res.on('data', () => {
+      assert.strictEqual(executionAsyncResource(), hooked[executionAsyncId()]);
+    });
+    res.on('end', () => {
+      assert.strictEqual(executionAsyncResource(), hooked[executionAsyncId()]);
+      server.close();
+    });
+  });
+});

From 59ab6bf351b7ab58f26c5e48844de855bdb3752a Mon Sep 17 00:00:00 2001
From: Myles Borins <mylesborins@google.com>
Date: Wed, 4 Mar 2020 17:04:01 -0500
Subject: [PATCH 17/17] 2020-03-04 Version 13.10.1 (Current)

Notable changes:

In Node.js 13.9.0 deps/zlib was switched to the chromium maintained
implementation. This change had the unforseen consequence of breaking
building from the tarballs we release as we were too aggressively
removing `unneccessary files` from the `deps/zlib` folder. This release
includes a patch that ensures that individuals will once again be able
to build Node.js from source.

PR-URL: https://github.com/nodejs/node/pull/32099
---
 CHANGELOG.md                    |  3 ++-
 doc/changelogs/CHANGELOG_V13.md | 31 +++++++++++++++++++++++++++++++
 src/node_version.h              |  2 +-
 3 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 61fbc6c8f998a0..cd5600535009ec 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,7 +30,8 @@ release.
 </tr>
 <tr>
     <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V13.md#13.10.0">13.10.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V13.md#13.10.1">13.10.1</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V13.md#13.10.0">13.10.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V13.md#13.9.0">13.9.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V13.md#13.8.0">13.8.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V13.md#13.7.0">13.7.0</a><br/>
diff --git a/doc/changelogs/CHANGELOG_V13.md b/doc/changelogs/CHANGELOG_V13.md
index d5e33d41c23672..9eef50a7667385 100644
--- a/doc/changelogs/CHANGELOG_V13.md
+++ b/doc/changelogs/CHANGELOG_V13.md
@@ -9,6 +9,8 @@
 </tr>
 <tr>
 <td>
+<a href="#13.10.1">13.10.1</a><br/>
+<a href="#13.10.0">13.10.0</a><br/>
 <a href="#13.9.0">13.9.0</a><br/>
 <a href="#13.8.0">13.8.0</a><br/>
 <a href="#13.7.0">13.7.0</a><br/>
@@ -39,6 +41,35 @@
   * [io.js](CHANGELOG_IOJS.md)
   * [Archive](CHANGELOG_ARCHIVE.md)
 
+<a id="13.10.1"></a>
+## 2020-03-04, Version 13.10.1 (Current), @MylesBorins
+
+### Notable Changes
+
+In Node.js 13.9.0 deps/zlib was switched to the chromium maintained implementation. This change
+had the unforseen consequence of breaking building from the tarballs we release as we were too
+aggressively removing `unneccessary files` from the `deps/zlib` folder. This release includes
+a patch that ensures that individuals will once again be able to build Node.js from source.
+
+### Commits
+
+* [[`723aa41d96`](https://github.com/nodejs/node/commit/723aa41d96)] - **build**: fix zlib tarball generation (Shelley Vohr) [#32094](https://github.com/nodejs/node/pull/32094)
+* [[`9c1ac50fc5`](https://github.com/nodejs/node/commit/9c1ac50fc5)] - **build**: fix building with ninja (Richard Lau) [#32071](https://github.com/nodejs/node/pull/32071)
+* [[`478450d6b3`](https://github.com/nodejs/node/commit/478450d6b3)] - **build**: add asan check in Github action (gengjiawen) [#31902](https://github.com/nodejs/node/pull/31902)
+* [[`0fc45f80b5`](https://github.com/nodejs/node/commit/0fc45f80b5)] - **crypto**: simplify exportKeyingMaterial (Tobias Nießen) [#31922](https://github.com/nodejs/node/pull/31922)
+* [[`4dc59b91a7`](https://github.com/nodejs/node/commit/4dc59b91a7)] - **dgram**: make UDPWrap more reusable (Anna Henningsen) [#31871](https://github.com/nodejs/node/pull/31871)
+* [[`4ed720e940`](https://github.com/nodejs/node/commit/4ed720e940)] - **doc**: visibility of Worker threads cli options (Harshitha KP) [#31380](https://github.com/nodejs/node/pull/31380)
+* [[`2518213a1b`](https://github.com/nodejs/node/commit/2518213a1b)] - **doc**: improve doc/markdown file organization coherence (ConorDavenport) [#31792](https://github.com/nodejs/node/pull/31792)
+* [[`ba3f7ff94d`](https://github.com/nodejs/node/commit/ba3f7ff94d)] - **doc**: update stream.pipeline() signature (vsemozhetbyt) [#31789](https://github.com/nodejs/node/pull/31789)
+* [[`3c8daa3aa0`](https://github.com/nodejs/node/commit/3c8daa3aa0)] - **events**: convert errorMonitor to a normal property (Gerhard Stoebich) [#31848](https://github.com/nodejs/node/pull/31848)
+* [[`6b44df2415`](https://github.com/nodejs/node/commit/6b44df2415)] - **perf,src**: add HistogramBase and internal/histogram.js (James M Snell) [#31988](https://github.com/nodejs/node/pull/31988)
+* [[`6a9cea9ed2`](https://github.com/nodejs/node/commit/6a9cea9ed2)] - **src**: pass resource object along with InternalMakeCallback (Anna Henningsen) [#32063](https://github.com/nodejs/node/pull/32063)
+* [[`70f046010c`](https://github.com/nodejs/node/commit/70f046010c)] - **src**: start the .text section with an asm symbol (Gabriel Schulhof) [#31981](https://github.com/nodejs/node/pull/31981)
+* [[`755da035ce`](https://github.com/nodejs/node/commit/755da035ce)] - **src**: add node\_crypto\_common and refactor (James M Snell) [#32016](https://github.com/nodejs/node/pull/32016)
+* [[`4d5318c164`](https://github.com/nodejs/node/commit/4d5318c164)] - **src**: improve handling of internal field counting (James M Snell) [#31960](https://github.com/nodejs/node/pull/31960)
+* [[`1539928ed9`](https://github.com/nodejs/node/commit/1539928ed9)] - **test**: add GC test for disabled AsyncLocalStorage (Andrey Pechkurov) [#31995](https://github.com/nodejs/node/pull/31995)
+* [[`be90817558`](https://github.com/nodejs/node/commit/be90817558)] - **test**: remove common.port from test-tls-securepair-client (Rich Trott) [#32024](https://github.com/nodejs/node/pull/32024)
+
 <a id="13.10.0"></a>
 ## 2020-03-04, Version 13.10.0 (Current), @codebytere
 
diff --git a/src/node_version.h b/src/node_version.h
index 5216c03fcaa831..896a4c15045fd3 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -29,7 +29,7 @@
 #define NODE_VERSION_IS_LTS 0
 #define NODE_VERSION_LTS_CODENAME ""
 
-#define NODE_VERSION_IS_RELEASE 0
+#define NODE_VERSION_IS_RELEASE 1
 
 #ifndef NODE_STRINGIFY
 #define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)