async_wrap: add provider types for net server

Adds `TCPSERVERWRAP` and `PIPESERVERWRAP` as provider types. This
makes it possible to distinguish servers from connections.

PR-URL: https://github.com/nodejs/node/pull/17157
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>

9 files changed, 111 insertions, 20 deletions

diff --git a/src/async_wrap.h b/src/async_wrap.h
index 98451ead3b..ec9e162ca7 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -46,6 +46,7 @@ namespace node {
   V(HTTPPARSER)                                                               \
   V(JSSTREAM)                                                                 \
   V(PIPECONNECTWRAP)                                                          \
+  V(PIPESERVERWRAP)                                                           \
   V(PIPEWRAP)                                                                 \
   V(PROCESSWRAP)                                                              \
   V(PROMISE)                                                                  \
@@ -54,6 +55,7 @@ namespace node {
   V(SIGNALWRAP)                                                               \
   V(STATWATCHER)                                                              \
   V(TCPCONNECTWRAP)                                                           \
+  V(TCPSERVERWRAP)                                                            \
   V(TCPWRAP)                                                                  \
   V(TIMERWRAP)                                                                \
   V(TTYWRAP)                                                                  \
diff --git a/src/connection_wrap.cc b/src/connection_wrap.cc
index b620c387ff..d82e7195d7 100644
--- a/src/connection_wrap.cc
+++ b/src/connection_wrap.cc
@@ -51,7 +51,9 @@ void ConnectionWrap<WrapType, UVType>::OnConnection(uv_stream_t* handle,
   if (status == 0) {
     env->set_init_trigger_async_id(wrap_data->get_async_id());
     // Instantiate the client javascript object and handle.
-    Local<Object> client_obj = WrapType::Instantiate(env, wrap_data);
+    Local<Object> client_obj = WrapType::Instantiate(env,
+                                                     wrap_data,
+                                                     WrapType::SOCKET);
 
     // Unwrap the client javascript object.
     WrapType* wrap;
diff --git a/src/pipe_wrap.cc b/src/pipe_wrap.cc
index 5ed8d30470..76280f0ce7 100644
--- a/src/pipe_wrap.cc
+++ b/src/pipe_wrap.cc
@@ -40,6 +40,7 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
+using v8::Int32;
 using v8::Local;
 using v8::Object;
 using v8::String;
@@ -48,14 +49,17 @@ using v8::Value;
 using AsyncHooks = Environment::AsyncHooks;
 
 
-Local<Object> PipeWrap::Instantiate(Environment* env, AsyncWrap* parent) {
+Local<Object> PipeWrap::Instantiate(Environment* env,
+                                    AsyncWrap* parent,
+                                    PipeWrap::SocketType type) {
   EscapableHandleScope handle_scope(env->isolate());
   AsyncHooks::InitScope init_scope(env, parent->get_async_id());
   CHECK_EQ(false, env->pipe_constructor_template().IsEmpty());
   Local<Function> constructor = env->pipe_constructor_template()->GetFunction();
   CHECK_EQ(false, constructor.IsEmpty());
+  Local<Value> type_value = Int32::New(env->isolate(), type);
   Local<Object> instance =
-      constructor->NewInstance(env->context()).ToLocalChecked();
+      constructor->NewInstance(env->context(), 1, &type_value).ToLocalChecked();
   return handle_scope.Escape(instance);
 }
 
@@ -107,6 +111,15 @@ void PipeWrap::Initialize(Local<Object> target,
       FIXED_ONE_BYTE_STRING(env->isolate(), "PipeConnectWrap");
   cwt->SetClassName(wrapString);
   target->Set(wrapString, cwt->GetFunction());
+
+  // Define constants
+  Local<Object> constants = Object::New(env->isolate());
+  NODE_DEFINE_CONSTANT(constants, SOCKET);
+  NODE_DEFINE_CONSTANT(constants, SERVER);
+  NODE_DEFINE_CONSTANT(constants, IPC);
+  target->Set(context,
+              FIXED_ONE_BYTE_STRING(env->isolate(), "constants"),
+              constants).FromJust();
 }
 
 
@@ -115,17 +128,40 @@ void PipeWrap::New(const FunctionCallbackInfo<Value>& args) {
   // Therefore we assert that we are not trying to call this as a
   // normal function.
   CHECK(args.IsConstructCall());
+  CHECK(args[0]->IsInt32());
   Environment* env = Environment::GetCurrent(args);
-  new PipeWrap(env, args.This(), args[0]->IsTrue());
+
+  int type_value = args[0].As<Int32>()->Value();
+  PipeWrap::SocketType type = static_cast<PipeWrap::SocketType>(type_value);
+
+  bool ipc;
+  ProviderType provider;
+  switch (type) {
+    case SOCKET:
+      provider = PROVIDER_PIPEWRAP;
+      ipc = false;
+      break;
+    case SERVER:
+      provider = PROVIDER_PIPESERVERWRAP;
+      ipc = false;
+      break;
+    case IPC:
+      provider = PROVIDER_PIPEWRAP;
+      ipc = true;
+      break;
+    default:
+      UNREACHABLE();
+  }
+
+  new PipeWrap(env, args.This(), provider, ipc);
 }
 
 
 PipeWrap::PipeWrap(Environment* env,
                    Local<Object> object,
+                   ProviderType provider,
                    bool ipc)
-    : ConnectionWrap(env,
-                     object,
-                     AsyncWrap::PROVIDER_PIPEWRAP) {
+    : ConnectionWrap(env, object, provider) {
   int r = uv_pipe_init(env->event_loop(), &handle_, ipc);
   CHECK_EQ(r, 0);  // How do we proxy this error up to javascript?
                    // Suggestion: uv_pipe_init() returns void.
diff --git a/src/pipe_wrap.h b/src/pipe_wrap.h
index 6f22038b91..5a611c0f94 100644
--- a/src/pipe_wrap.h
+++ b/src/pipe_wrap.h
@@ -32,7 +32,15 @@ namespace node {
 
 class PipeWrap : public ConnectionWrap<PipeWrap, uv_pipe_t> {
  public:
-  static v8::Local<v8::Object> Instantiate(Environment* env, AsyncWrap* parent);
+  enum SocketType {
+    SOCKET,
+    SERVER,
+    IPC
+  };
+
+  static v8::Local<v8::Object> Instantiate(Environment* env,
+                                           AsyncWrap* parent,
+                                           SocketType type);
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context);
@@ -42,6 +50,7 @@ class PipeWrap : public ConnectionWrap<PipeWrap, uv_pipe_t> {
  private:
   PipeWrap(Environment* env,
            v8::Local<v8::Object> object,
+           ProviderType provider,
            bool ipc);
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc
index 13586e1403..a737ed67b0 100644
--- a/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@ -187,7 +187,7 @@ static Local<Object> AcceptHandle(Environment* env, LibuvStreamWrap* parent) {
   Local<Object> wrap_obj;
   UVType* handle;
 
-  wrap_obj = WrapType::Instantiate(env, parent);
+  wrap_obj = WrapType::Instantiate(env, parent, WrapType::SOCKET);
   if (wrap_obj.IsEmpty())
     return Local<Object>();
 
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index af64f89b54..8dd14e2e16 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -42,6 +42,7 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
+using v8::Int32;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
@@ -51,14 +52,17 @@ using v8::Value;
 using AsyncHooks = Environment::AsyncHooks;
 
 
-Local<Object> TCPWrap::Instantiate(Environment* env, AsyncWrap* parent) {
+Local<Object> TCPWrap::Instantiate(Environment* env,
+                                   AsyncWrap* parent,
+                                   TCPWrap::SocketType type) {
   EscapableHandleScope handle_scope(env->isolate());
   AsyncHooks::InitScope init_scope(env, parent->get_async_id());
   CHECK_EQ(env->tcp_constructor_template().IsEmpty(), false);
   Local<Function> constructor = env->tcp_constructor_template()->GetFunction();
   CHECK_EQ(constructor.IsEmpty(), false);
+  Local<Value> type_value = Int32::New(env->isolate(), type);
   Local<Object> instance =
-      constructor->NewInstance(env->context()).ToLocalChecked();
+      constructor->NewInstance(env->context(), 1, &type_value).ToLocalChecked();
   return handle_scope.Escape(instance);
 }
 
@@ -122,6 +126,14 @@ void TCPWrap::Initialize(Local<Object> target,
       FIXED_ONE_BYTE_STRING(env->isolate(), "TCPConnectWrap");
   cwt->SetClassName(wrapString);
   target->Set(wrapString, cwt->GetFunction());
+
+  // Define constants
+  Local<Object> constants = Object::New(env->isolate());
+  NODE_DEFINE_CONSTANT(constants, SOCKET);
+  NODE_DEFINE_CONSTANT(constants, SERVER);
+  target->Set(context,
+              FIXED_ONE_BYTE_STRING(env->isolate(), "constants"),
+              constants).FromJust();
 }
 
 
@@ -130,15 +142,30 @@ void TCPWrap::New(const FunctionCallbackInfo<Value>& args) {
   // Therefore we assert that we are not trying to call this as a
   // normal function.
   CHECK(args.IsConstructCall());
+  CHECK(args[0]->IsInt32());
   Environment* env = Environment::GetCurrent(args);
-  new TCPWrap(env, args.This());
+
+  int type_value = args[0].As<Int32>()->Value();
+  TCPWrap::SocketType type = static_cast<TCPWrap::SocketType>(type_value);
+
+  ProviderType provider;
+  switch (type) {
+    case SOCKET:
+      provider = PROVIDER_TCPWRAP;
+      break;
+    case SERVER:
+      provider = PROVIDER_TCPSERVERWRAP;
+      break;
+    default:
+      UNREACHABLE();
+  }
+
+  new TCPWrap(env, args.This(), provider);
 }
 
 
-TCPWrap::TCPWrap(Environment* env, Local<Object> object)
-    : ConnectionWrap(env,
-                     object,
-                     AsyncWrap::PROVIDER_TCPWRAP) {
+TCPWrap::TCPWrap(Environment* env, Local<Object> object, ProviderType provider)
+    : ConnectionWrap(env, object, provider) {
   int r = uv_tcp_init(env->event_loop(), &handle_);
   CHECK_EQ(r, 0);  // How do we proxy this error up to javascript?
                    // Suggestion: uv_tcp_init() returns void.
diff --git a/src/tcp_wrap.h b/src/tcp_wrap.h
index fa6bac0138..a7f6b19019 100644
--- a/src/tcp_wrap.h
+++ b/src/tcp_wrap.h
@@ -32,7 +32,14 @@ namespace node {
 
 class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
  public:
-  static v8::Local<v8::Object> Instantiate(Environment* env, AsyncWrap* parent);
+  enum SocketType {
+    SOCKET,
+    SERVER
+  };
+
+  static v8::Local<v8::Object> Instantiate(Environment* env,
+                                           AsyncWrap* parent,
+                                           SocketType type);
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context);
@@ -46,7 +53,8 @@ class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
             int (*F)(const typename T::HandleType*, sockaddr*, int*)>
   friend void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>&);
 
-  TCPWrap(Environment* env, v8::Local<v8::Object> object);
+  TCPWrap(Environment* env, v8::Local<v8::Object> object,
+          ProviderType provider);
   ~TCPWrap();
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 504e057682..d8665d6789 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -496,7 +496,9 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
 }
 
 
-Local<Object> UDPWrap::Instantiate(Environment* env, AsyncWrap* parent) {
+Local<Object> UDPWrap::Instantiate(Environment* env,
+                                   AsyncWrap* parent,
+                                   UDPWrap::SocketType type) {
   EscapableHandleScope scope(env->isolate());
   AsyncHooks::InitScope init_scope(env, parent->get_async_id());
   // If this assert fires then Initialize hasn't been called yet.
diff --git a/src/udp_wrap.h b/src/udp_wrap.h
index 254ae76131..7f0cc96d34 100644
--- a/src/udp_wrap.h
+++ b/src/udp_wrap.h
@@ -35,6 +35,9 @@ namespace node {
 
 class UDPWrap: public HandleWrap {
  public:
+  enum SocketType {
+    SOCKET
+  };
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context);
@@ -58,7 +61,9 @@ class UDPWrap: public HandleWrap {
   static void SetTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void BufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Local<v8::Object> Instantiate(Environment* env, AsyncWrap* parent);
+  static v8::Local<v8::Object> Instantiate(Environment* env,
+                                           AsyncWrap* parent,
+                                           SocketType type);
   uv_udp_t* UVHandle();
 
   size_t self_size() const override { return sizeof(*this); }