Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	js_udp_wrap.cc	Lines:	1	105	1.0 %
Date:	2022-12-31 04:22:30	Branches:	0	84	0.0 %


#include "udp_wrap.h"
#include "async_wrap-inl.h"
#include "node_errors.h"
#include "node_sockaddr-inl.h"

#include <algorithm>

// TODO(RaisinTen): Replace all uses with empty `v8::Maybe`s.
#define JS_EXCEPTION_PENDING UV_EPROTO

namespace node {

using errors::TryCatchScope;
using v8::Array;
using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;

// JSUDPWrap is a testing utility used by test/common/udppair.js
// to simulate UDP traffic deterministically in Node.js tests.
class JSUDPWrap final : public UDPWrapBase, public AsyncWrap {
 public:
  JSUDPWrap(Environment* env, Local<Object> obj);

  int RecvStart() override;
  int RecvStop() override;
  ssize_t Send(uv_buf_t* bufs,
               size_t nbufs,
               const sockaddr* addr) override;
  SocketAddress GetPeerName() override;
  SocketAddress GetSockName() override;
  AsyncWrap* GetAsyncWrap() override { return this; }

  static void New(const FunctionCallbackInfo<Value>& args);
  static void EmitReceived(const FunctionCallbackInfo<Value>& args);
  static void OnSendDone(const FunctionCallbackInfo<Value>& args);
  static void OnAfterBind(const FunctionCallbackInfo<Value>& args);

  static void Initialize(Local<Object> target,
                         Local<Value> unused,
                         Local<Context> context,
                         void* priv);
  SET_NO_MEMORY_INFO()
  SET_MEMORY_INFO_NAME(JSUDPWrap)
  SET_SELF_SIZE(JSUDPWrap)
};

JSUDPWrap::JSUDPWrap(Environment* env, Local<Object> obj)
  : AsyncWrap(env, obj, PROVIDER_JSUDPWRAP) {
  MakeWeak();

  obj->SetAlignedPointerInInternalField(
      kUDPWrapBaseField, static_cast<UDPWrapBase*>(this));
}

int JSUDPWrap::RecvStart() {
  HandleScope scope(env()->isolate());
  Context::Scope context_scope(env()->context());
  TryCatchScope try_catch(env());
  Local<Value> value;
  int32_t value_int = JS_EXCEPTION_PENDING;
  if (!MakeCallback(env()->onreadstart_string(), 0, nullptr).ToLocal(&value) ||
      !value->Int32Value(env()->context()).To(&value_int)) {
    if (try_catch.HasCaught() && !try_catch.HasTerminated())
      errors::TriggerUncaughtException(env()->isolate(), try_catch);
  }
  return value_int;
}

int JSUDPWrap::RecvStop() {
  HandleScope scope(env()->isolate());
  Context::Scope context_scope(env()->context());
  TryCatchScope try_catch(env());
  Local<Value> value;
  int32_t value_int = JS_EXCEPTION_PENDING;
  if (!MakeCallback(env()->onreadstop_string(), 0, nullptr).ToLocal(&value) ||
      !value->Int32Value(env()->context()).To(&value_int)) {
    if (try_catch.HasCaught() && !try_catch.HasTerminated())
      errors::TriggerUncaughtException(env()->isolate(), try_catch);
  }
  return value_int;
}

ssize_t JSUDPWrap::Send(uv_buf_t* bufs,
                        size_t nbufs,
                        const sockaddr* addr) {
  HandleScope scope(env()->isolate());
  Context::Scope context_scope(env()->context());
  TryCatchScope try_catch(env());
  Local<Value> value;
  int64_t value_int = JS_EXCEPTION_PENDING;
  size_t total_len = 0;

  MaybeStackBuffer<Local<Value>, 16> buffers(nbufs);
  for (size_t i = 0; i < nbufs; i++) {
    buffers[i] = Buffer::Copy(env(), bufs[i].base, bufs[i].len)
        .ToLocalChecked();
    total_len += bufs[i].len;
  }

  Local<Object> address;
  if (!AddressToJS(env(), addr).ToLocal(&address)) return value_int;

  Local<Value> args[] = {
    listener()->CreateSendWrap(total_len)->object(),
    Array::New(env()->isolate(), buffers.out(), nbufs),
    address,
  };

  if (!MakeCallback(env()->onwrite_string(), arraysize(args), args)
          .ToLocal(&value) ||
      !value->IntegerValue(env()->context()).To(&value_int)) {
    if (try_catch.HasCaught() && !try_catch.HasTerminated())
      errors::TriggerUncaughtException(env()->isolate(), try_catch);
  }
  return value_int;
}

SocketAddress JSUDPWrap::GetPeerName() {
  SocketAddress ret;
  CHECK(SocketAddress::New(AF_INET, "127.0.0.1", 1337, &ret));
  return ret;
}

SocketAddress JSUDPWrap::GetSockName() {
  SocketAddress ret;
  CHECK(SocketAddress::New(AF_INET, "127.0.0.1", 1337, &ret));
  return ret;
}

void JSUDPWrap::New(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  CHECK(args.IsConstructCall());
  new JSUDPWrap(env, args.Holder());
}

void JSUDPWrap::EmitReceived(const FunctionCallbackInfo<Value>& args) {
  JSUDPWrap* wrap;
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
  Environment* env = wrap->env();

  ArrayBufferViewContents<char> buffer(args[0]);
  const char* data = buffer.data();
  int len = buffer.length();

  CHECK(args[1]->IsInt32());   // family
  CHECK(args[2]->IsString());  // address
  CHECK(args[3]->IsInt32());   // port
  CHECK(args[4]->IsInt32());   // flags
  int family = args[1].As<Int32>()->Value() == 4 ? AF_INET : AF_INET6;
  Utf8Value address(env->isolate(), args[2]);
  int port = args[3].As<Int32>()->Value();
  int flags = args[3].As<Int32>()->Value();

  sockaddr_storage addr;
  CHECK_EQ(sockaddr_for_family(family, *address, port, &addr), 0);

  // Repeatedly ask the stream's owner for memory, copy the data that we
  // just read from JS into those buffers and emit them as reads.
  while (len != 0) {
    uv_buf_t buf = wrap->listener()->OnAlloc(len);
    ssize_t avail = std::min<size_t>(buf.len, len);
    memcpy(buf.base, data, avail);
    data += avail;
    len -= static_cast<int>(avail);
    wrap->listener()->OnRecv(
        avail, buf, reinterpret_cast<sockaddr*>(&addr), flags);
  }
}

void JSUDPWrap::OnSendDone(const FunctionCallbackInfo<Value>& args) {
  JSUDPWrap* wrap;
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());

  CHECK(args[0]->IsObject());
  CHECK(args[1]->IsInt32());
  ReqWrap<uv_udp_send_t>* req_wrap;
  ASSIGN_OR_RETURN_UNWRAP(&req_wrap, args[0].As<Object>());
  int status = args[1].As<Int32>()->Value();

  wrap->listener()->OnSendDone(req_wrap, status);
}

void JSUDPWrap::OnAfterBind(const FunctionCallbackInfo<Value>& args) {
  JSUDPWrap* wrap;
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());

  wrap->listener()->OnAfterBind();
}

void JSUDPWrap::Initialize(Local<Object> target,
                           Local<Value> unused,
                           Local<Context> context,
                           void* priv) {
  Environment* env = Environment::GetCurrent(context);
  Isolate* isolate = env->isolate();

  Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
  t->InstanceTemplate()
    ->SetInternalFieldCount(UDPWrapBase::kUDPWrapBaseField + 1);
  t->Inherit(AsyncWrap::GetConstructorTemplate(env));

  UDPWrapBase::AddMethods(env, t);
  SetProtoMethod(isolate, t, "emitReceived", EmitReceived);
  SetProtoMethod(isolate, t, "onSendDone", OnSendDone);
  SetProtoMethod(isolate, t, "onAfterBind", OnAfterBind);

  SetConstructorFunction(context, target, "JSUDPWrap", t);
}


}  // namespace node

NODE_BINDING_CONTEXT_AWARE_INTERNAL(js_udp_wrap, node::JSUDPWrap::Initialize)


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "udp_wrap.h"
2			#include "async_wrap-inl.h"
3			#include "node_errors.h"
4			#include "node_sockaddr-inl.h"
5
6			#include <algorithm>
7
8			// TODO(RaisinTen): Replace all uses with empty `v8::Maybe`s.
9			#define JS_EXCEPTION_PENDING UV_EPROTO
10
11			namespace node {
12
13			using errors::TryCatchScope;
14			using v8::Array;
15			using v8::Context;
16			using v8::FunctionCallbackInfo;
17			using v8::FunctionTemplate;
18			using v8::HandleScope;
19			using v8::Int32;
20			using v8::Isolate;
21			using v8::Local;
22			using v8::Object;
23			using v8::Value;
24
25			// JSUDPWrap is a testing utility used by test/common/udppair.js
26			// to simulate UDP traffic deterministically in Node.js tests.
27			class JSUDPWrap final : public UDPWrapBase, public AsyncWrap {
28			public:
29			JSUDPWrap(Environment* env, Local<Object> obj);
30
31			int RecvStart() override;
32			int RecvStop() override;
33			ssize_t Send(uv_buf_t* bufs,
34			size_t nbufs,
35			const sockaddr* addr) override;
36			SocketAddress GetPeerName() override;
37			SocketAddress GetSockName() override;
38			AsyncWrap* GetAsyncWrap() override { return this; }
39
40			static void New(const FunctionCallbackInfo<Value>& args);
41			static void EmitReceived(const FunctionCallbackInfo<Value>& args);
42			static void OnSendDone(const FunctionCallbackInfo<Value>& args);
43			static void OnAfterBind(const FunctionCallbackInfo<Value>& args);
44
45			static void Initialize(Local<Object> target,
46			Local<Value> unused,
47			Local<Context> context,
48			void* priv);
49			SET_NO_MEMORY_INFO()
50			SET_MEMORY_INFO_NAME(JSUDPWrap)
51			SET_SELF_SIZE(JSUDPWrap)
52			};
53
54			JSUDPWrap::JSUDPWrap(Environment* env, Local<Object> obj)
55			: AsyncWrap(env, obj, PROVIDER_JSUDPWRAP) {
56			MakeWeak();
57
58			obj->SetAlignedPointerInInternalField(
59			kUDPWrapBaseField, static_cast<UDPWrapBase*>(this));
60			}
61
62			int JSUDPWrap::RecvStart() {
63			HandleScope scope(env()->isolate());
64			Context::Scope context_scope(env()->context());
65			TryCatchScope try_catch(env());
66			Local<Value> value;
67			int32_t value_int = JS_EXCEPTION_PENDING;
68			if (!MakeCallback(env()->onreadstart_string(), 0, nullptr).ToLocal(&value) \|\|
69			!value->Int32Value(env()->context()).To(&value_int)) {
70			if (try_catch.HasCaught() && !try_catch.HasTerminated())
71			errors::TriggerUncaughtException(env()->isolate(), try_catch);
72			}
73			return value_int;
74			}
75
76			int JSUDPWrap::RecvStop() {
77			HandleScope scope(env()->isolate());
78			Context::Scope context_scope(env()->context());
79			TryCatchScope try_catch(env());
80			Local<Value> value;
81			int32_t value_int = JS_EXCEPTION_PENDING;
82			if (!MakeCallback(env()->onreadstop_string(), 0, nullptr).ToLocal(&value) \|\|
83			!value->Int32Value(env()->context()).To(&value_int)) {
84			if (try_catch.HasCaught() && !try_catch.HasTerminated())
85			errors::TriggerUncaughtException(env()->isolate(), try_catch);
86			}
87			return value_int;
88			}
89
90			ssize_t JSUDPWrap::Send(uv_buf_t* bufs,
91			size_t nbufs,
92			const sockaddr* addr) {
93			HandleScope scope(env()->isolate());
94			Context::Scope context_scope(env()->context());
95			TryCatchScope try_catch(env());
96			Local<Value> value;
97			int64_t value_int = JS_EXCEPTION_PENDING;
98			size_t total_len = 0;
99
100			MaybeStackBuffer<Local<Value>, 16> buffers(nbufs);
101			for (size_t i = 0; i < nbufs; i++) {
102			buffers[i] = Buffer::Copy(env(), bufs[i].base, bufs[i].len)
103			.ToLocalChecked();
104			total_len += bufs[i].len;
105			}
106
107			Local<Object> address;
108			if (!AddressToJS(env(), addr).ToLocal(&address)) return value_int;
109
110			Local<Value> args[] = {
111			listener()->CreateSendWrap(total_len)->object(),
112			Array::New(env()->isolate(), buffers.out(), nbufs),
113			address,
114			};
115
116			if (!MakeCallback(env()->onwrite_string(), arraysize(args), args)
117			.ToLocal(&value) \|\|
118			!value->IntegerValue(env()->context()).To(&value_int)) {
119			if (try_catch.HasCaught() && !try_catch.HasTerminated())
120			errors::TriggerUncaughtException(env()->isolate(), try_catch);
121			}
122			return value_int;
123			}
124
125			SocketAddress JSUDPWrap::GetPeerName() {
126			SocketAddress ret;
127			CHECK(SocketAddress::New(AF_INET, "127.0.0.1", 1337, &ret));
128			return ret;
129			}
130
131			SocketAddress JSUDPWrap::GetSockName() {
132			SocketAddress ret;
133			CHECK(SocketAddress::New(AF_INET, "127.0.0.1", 1337, &ret));
134			return ret;
135			}
136
137			void JSUDPWrap::New(const FunctionCallbackInfo<Value>& args) {
138			Environment* env = Environment::GetCurrent(args);
139			CHECK(args.IsConstructCall());
140			new JSUDPWrap(env, args.Holder());
141			}
142
143			void JSUDPWrap::EmitReceived(const FunctionCallbackInfo<Value>& args) {
144			JSUDPWrap* wrap;
145			ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
146			Environment* env = wrap->env();
147
148			ArrayBufferViewContents<char> buffer(args[0]);
149			const char* data = buffer.data();
150			int len = buffer.length();
151
152			CHECK(args[1]->IsInt32()); // family
153			CHECK(args[2]->IsString()); // address
154			CHECK(args[3]->IsInt32()); // port
155			CHECK(args[4]->IsInt32()); // flags
156			int family = args[1].As<Int32>()->Value() == 4 ? AF_INET : AF_INET6;
157			Utf8Value address(env->isolate(), args[2]);
158			int port = args[3].As<Int32>()->Value();
159			int flags = args[3].As<Int32>()->Value();
160
161			sockaddr_storage addr;
162			CHECK_EQ(sockaddr_for_family(family, *address, port, &addr), 0);
163
164			// Repeatedly ask the stream's owner for memory, copy the data that we
165			// just read from JS into those buffers and emit them as reads.
166			while (len != 0) {
167			uv_buf_t buf = wrap->listener()->OnAlloc(len);
168			ssize_t avail = std::min<size_t>(buf.len, len);
169			memcpy(buf.base, data, avail);
170			data += avail;
171			len -= static_cast<int>(avail);
172			wrap->listener()->OnRecv(
173			avail, buf, reinterpret_cast<sockaddr*>(&addr), flags);
174			}
175			}
176
177			void JSUDPWrap::OnSendDone(const FunctionCallbackInfo<Value>& args) {
178			JSUDPWrap* wrap;
179			ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
180
181			CHECK(args[0]->IsObject());
182			CHECK(args[1]->IsInt32());
183			ReqWrap<uv_udp_send_t>* req_wrap;
184			ASSIGN_OR_RETURN_UNWRAP(&req_wrap, args[0].As<Object>());
185			int status = args[1].As<Int32>()->Value();
186
187			wrap->listener()->OnSendDone(req_wrap, status);
188			}
189
190			void JSUDPWrap::OnAfterBind(const FunctionCallbackInfo<Value>& args) {
191			JSUDPWrap* wrap;
192			ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
193
194			wrap->listener()->OnAfterBind();
195			}
196
197			void JSUDPWrap::Initialize(Local<Object> target,
198			Local<Value> unused,
199			Local<Context> context,
200			void* priv) {
201			Environment* env = Environment::GetCurrent(context);
202			Isolate* isolate = env->isolate();
203
204			Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
205			t->InstanceTemplate()
206			->SetInternalFieldCount(UDPWrapBase::kUDPWrapBaseField + 1);
207			t->Inherit(AsyncWrap::GetConstructorTemplate(env));
208
209			UDPWrapBase::AddMethods(env, t);
210			SetProtoMethod(isolate, t, "emitReceived", EmitReceived);
211			SetProtoMethod(isolate, t, "onSendDone", OnSendDone);
212			SetProtoMethod(isolate, t, "onAfterBind", OnAfterBind);
213
214			SetConstructorFunction(context, target, "JSUDPWrap", t);
215			}
216
217
218			} // namespace node
219
220		5788	NODE_BINDING_CONTEXT_AWARE_INTERNAL(js_udp_wrap, node::JSUDPWrap::Initialize)