1 #include "node_util.h"
2 #include "base_object-inl.h"
3 #include "node_errors.h"
4 #include "node_external_reference.h"
5 #include "util-inl.h"
6
7 namespace node {
8 namespace util {
9
10 using v8::ALL_PROPERTIES;
11 using v8::Array;
12 using v8::ArrayBufferView;
13 using v8::BigInt;
14 using v8::Boolean;
15 using v8::Context;
16 using v8::External;
17 using v8::FunctionCallbackInfo;
18 using v8::FunctionTemplate;
19 using v8::HandleScope;
20 using v8::IndexFilter;
21 using v8::Integer;
22 using v8::Isolate;
23 using v8::KeyCollectionMode;
24 using v8::Local;
25 using v8::Object;
26 using v8::ONLY_CONFIGURABLE;
27 using v8::ONLY_ENUMERABLE;
28 using v8::ONLY_WRITABLE;
29 using v8::Promise;
30 using v8::PropertyFilter;
31 using v8::Proxy;
32 using v8::SKIP_STRINGS;
33 using v8::SKIP_SYMBOLS;
34 using v8::StackFrame;
35 using v8::StackTrace;
36 using v8::String;
37 using v8::Uint32;
38 using v8::Value;
39
40 // Used in ToUSVString().
41 constexpr char16_t kUnicodeReplacementCharacter = 0xFFFD;
42
43 // If a UTF-16 character is a low/trailing surrogate.
44 CHAR_TEST(16, IsUnicodeTrail, (ch & 0xFC00) == 0xDC00)
45
46 // If a UTF-16 character is a surrogate.
47 CHAR_TEST(16, IsUnicodeSurrogate, (ch & 0xF800) == 0xD800)
48
49 // If a UTF-16 surrogate is a low/trailing one.
50 CHAR_TEST(16, IsUnicodeSurrogateTrail, (ch & 0x400) != 0)
51
GetOwnNonIndexProperties(const FunctionCallbackInfo<Value> & args)52 static void GetOwnNonIndexProperties(
53 const FunctionCallbackInfo<Value>& args) {
54 Environment* env = Environment::GetCurrent(args);
55 Local<Context> context = env->context();
56
57 CHECK(args[0]->IsObject());
58 CHECK(args[1]->IsUint32());
59
60 Local<Object> object = args[0].As<Object>();
61
62 Local<Array> properties;
63
64 PropertyFilter filter =
65 static_cast<PropertyFilter>(args[1].As<Uint32>()->Value());
66
67 if (!object->GetPropertyNames(
68 context, KeyCollectionMode::kOwnOnly,
69 filter,
70 IndexFilter::kSkipIndices)
71 .ToLocal(&properties)) {
72 return;
73 }
74 args.GetReturnValue().Set(properties);
75 }
76
GetConstructorName(const FunctionCallbackInfo<Value> & args)77 static void GetConstructorName(
78 const FunctionCallbackInfo<Value>& args) {
79 CHECK(args[0]->IsObject());
80
81 Local<Object> object = args[0].As<Object>();
82 Local<String> name = object->GetConstructorName();
83
84 args.GetReturnValue().Set(name);
85 }
86
GetExternalValue(const FunctionCallbackInfo<Value> & args)87 static void GetExternalValue(
88 const FunctionCallbackInfo<Value>& args) {
89 CHECK(args[0]->IsExternal());
90 Isolate* isolate = args.GetIsolate();
91 Local<External> external = args[0].As<External>();
92
93 void* ptr = external->Value();
94 uint64_t value = reinterpret_cast<uint64_t>(ptr);
95 Local<BigInt> ret = BigInt::NewFromUnsigned(isolate, value);
96 args.GetReturnValue().Set(ret);
97 }
98
GetPromiseDetails(const FunctionCallbackInfo<Value> & args)99 static void GetPromiseDetails(const FunctionCallbackInfo<Value>& args) {
100 // Return undefined if it's not a Promise.
101 if (!args[0]->IsPromise())
102 return;
103
104 auto isolate = args.GetIsolate();
105
106 Local<Promise> promise = args[0].As<Promise>();
107
108 int state = promise->State();
109 Local<Value> values[2] = { Integer::New(isolate, state) };
110 size_t number_of_values = 1;
111 if (state != Promise::PromiseState::kPending)
112 values[number_of_values++] = promise->Result();
113 Local<Array> ret = Array::New(isolate, values, number_of_values);
114 args.GetReturnValue().Set(ret);
115 }
116
GetProxyDetails(const FunctionCallbackInfo<Value> & args)117 static void GetProxyDetails(const FunctionCallbackInfo<Value>& args) {
118 // Return undefined if it's not a proxy.
119 if (!args[0]->IsProxy())
120 return;
121
122 Local<Proxy> proxy = args[0].As<Proxy>();
123
124 // TODO(BridgeAR): Remove the length check as soon as we prohibit access to
125 // the util binding layer. It's accessed in the wild and `esm` would break in
126 // case the check is removed.
127 if (args.Length() == 1 || args[1]->IsTrue()) {
128 Local<Value> ret[] = {
129 proxy->GetTarget(),
130 proxy->GetHandler()
131 };
132
133 args.GetReturnValue().Set(
134 Array::New(args.GetIsolate(), ret, arraysize(ret)));
135 } else {
136 Local<Value> ret = proxy->GetTarget();
137
138 args.GetReturnValue().Set(ret);
139 }
140 }
141
GetCallerLocation(const FunctionCallbackInfo<Value> & args)142 static void GetCallerLocation(const FunctionCallbackInfo<Value>& args) {
143 Isolate* isolate = args.GetIsolate();
144 Local<StackTrace> trace = StackTrace::CurrentStackTrace(isolate, 2);
145
146 // This function is frame zero. The caller is frame one. If there aren't two
147 // stack frames, return undefined.
148 if (trace->GetFrameCount() != 2) {
149 return;
150 }
151
152 Local<StackFrame> frame = trace->GetFrame(isolate, 1);
153 Local<Value> ret[] = {Integer::New(isolate, frame->GetLineNumber()),
154 Integer::New(isolate, frame->GetColumn()),
155 frame->GetScriptNameOrSourceURL()};
156
157 args.GetReturnValue().Set(Array::New(args.GetIsolate(), ret, arraysize(ret)));
158 }
159
IsArrayBufferDetached(const FunctionCallbackInfo<Value> & args)160 static void IsArrayBufferDetached(const FunctionCallbackInfo<Value>& args) {
161 if (args[0]->IsArrayBuffer()) {
162 auto buffer = args[0].As<v8::ArrayBuffer>();
163 args.GetReturnValue().Set(buffer->WasDetached());
164 return;
165 }
166 args.GetReturnValue().Set(false);
167 }
168
PreviewEntries(const FunctionCallbackInfo<Value> & args)169 static void PreviewEntries(const FunctionCallbackInfo<Value>& args) {
170 if (!args[0]->IsObject())
171 return;
172
173 Environment* env = Environment::GetCurrent(args);
174 bool is_key_value;
175 Local<Array> entries;
176 if (!args[0].As<Object>()->PreviewEntries(&is_key_value).ToLocal(&entries))
177 return;
178 // Fast path for WeakMap and WeakSet.
179 if (args.Length() == 1)
180 return args.GetReturnValue().Set(entries);
181
182 Local<Value> ret[] = {
183 entries,
184 Boolean::New(env->isolate(), is_key_value)
185 };
186 return args.GetReturnValue().Set(
187 Array::New(env->isolate(), ret, arraysize(ret)));
188 }
189
Sleep(const FunctionCallbackInfo<Value> & args)190 static void Sleep(const FunctionCallbackInfo<Value>& args) {
191 CHECK(args[0]->IsUint32());
192 uint32_t msec = args[0].As<Uint32>()->Value();
193 uv_sleep(msec);
194 }
195
ArrayBufferViewHasBuffer(const FunctionCallbackInfo<Value> & args)196 void ArrayBufferViewHasBuffer(const FunctionCallbackInfo<Value>& args) {
197 CHECK(args[0]->IsArrayBufferView());
198 args.GetReturnValue().Set(args[0].As<ArrayBufferView>()->HasBuffer());
199 }
200
WeakReference(Realm * realm,Local<Object> object,Local<Object> target)201 WeakReference::WeakReference(Realm* realm,
202 Local<Object> object,
203 Local<Object> target)
204 : WeakReference(realm, object, target, 0) {}
205
WeakReference(Realm * realm,Local<Object> object,Local<Object> target,uint64_t reference_count)206 WeakReference::WeakReference(Realm* realm,
207 Local<Object> object,
208 Local<Object> target,
209 uint64_t reference_count)
210 : SnapshotableObject(realm, object, type_int),
211 reference_count_(reference_count) {
212 MakeWeak();
213 if (!target.IsEmpty()) {
214 target_.Reset(realm->isolate(), target);
215 if (reference_count_ == 0) {
216 target_.SetWeak();
217 }
218 }
219 }
220
PrepareForSerialization(Local<Context> context,v8::SnapshotCreator * creator)221 bool WeakReference::PrepareForSerialization(Local<Context> context,
222 v8::SnapshotCreator* creator) {
223 if (target_.IsEmpty()) {
224 target_index_ = 0;
225 return true;
226 }
227
228 // Users can still hold strong references to target in addition to the
229 // reference that we manage here, and they could expect that the referenced
230 // object remains the same as long as that external strong reference
231 // is alive. Since we have no way to know if there is any other reference
232 // keeping the target alive, the best we can do to maintain consistency is to
233 // simply save a reference to the target in the snapshot (effectively making
234 // it strong) during serialization, and restore it during deserialization.
235 // If there's no known counted reference from our side, we'll make the
236 // reference here weak upon deserialization so that it can be GC'ed if users
237 // do not hold additional references to it.
238 Local<Object> target = target_.Get(context->GetIsolate());
239 target_index_ = creator->AddData(context, target);
240 DCHECK_NE(target_index_, 0);
241 target_.Reset();
242 return true;
243 }
244
Serialize(int index)245 InternalFieldInfoBase* WeakReference::Serialize(int index) {
246 DCHECK_EQ(index, BaseObject::kEmbedderType);
247 InternalFieldInfo* info =
248 InternalFieldInfoBase::New<InternalFieldInfo>(type());
249 info->target = target_index_;
250 info->reference_count = reference_count_;
251 return info;
252 }
253
Deserialize(Local<Context> context,Local<Object> holder,int index,InternalFieldInfoBase * info)254 void WeakReference::Deserialize(Local<Context> context,
255 Local<Object> holder,
256 int index,
257 InternalFieldInfoBase* info) {
258 DCHECK_EQ(index, BaseObject::kEmbedderType);
259 HandleScope scope(context->GetIsolate());
260
261 InternalFieldInfo* weak_info = reinterpret_cast<InternalFieldInfo*>(info);
262 Local<Object> target;
263 if (weak_info->target != 0) {
264 target = context->GetDataFromSnapshotOnce<Object>(weak_info->target)
265 .ToLocalChecked();
266 }
267 new WeakReference(
268 Realm::GetCurrent(context), holder, target, weak_info->reference_count);
269 }
270
New(const FunctionCallbackInfo<Value> & args)271 void WeakReference::New(const FunctionCallbackInfo<Value>& args) {
272 Realm* realm = Realm::GetCurrent(args);
273 CHECK(args.IsConstructCall());
274 CHECK(args[0]->IsObject());
275 new WeakReference(realm, args.This(), args[0].As<Object>());
276 }
277
Get(const FunctionCallbackInfo<Value> & args)278 void WeakReference::Get(const FunctionCallbackInfo<Value>& args) {
279 WeakReference* weak_ref = Unwrap<WeakReference>(args.Holder());
280 Isolate* isolate = args.GetIsolate();
281 if (!weak_ref->target_.IsEmpty())
282 args.GetReturnValue().Set(weak_ref->target_.Get(isolate));
283 }
284
IncRef(const FunctionCallbackInfo<Value> & args)285 void WeakReference::IncRef(const FunctionCallbackInfo<Value>& args) {
286 WeakReference* weak_ref = Unwrap<WeakReference>(args.Holder());
287 weak_ref->reference_count_++;
288 if (weak_ref->target_.IsEmpty()) return;
289 if (weak_ref->reference_count_ == 1) weak_ref->target_.ClearWeak();
290 args.GetReturnValue().Set(
291 v8::Number::New(args.GetIsolate(), weak_ref->reference_count_));
292 }
293
DecRef(const FunctionCallbackInfo<Value> & args)294 void WeakReference::DecRef(const FunctionCallbackInfo<Value>& args) {
295 WeakReference* weak_ref = Unwrap<WeakReference>(args.Holder());
296 CHECK_GE(weak_ref->reference_count_, 1);
297 weak_ref->reference_count_--;
298 if (weak_ref->target_.IsEmpty()) return;
299 if (weak_ref->reference_count_ == 0) weak_ref->target_.SetWeak();
300 args.GetReturnValue().Set(
301 v8::Number::New(args.GetIsolate(), weak_ref->reference_count_));
302 }
303
GuessHandleType(const FunctionCallbackInfo<Value> & args)304 static void GuessHandleType(const FunctionCallbackInfo<Value>& args) {
305 Environment* env = Environment::GetCurrent(args);
306 int fd;
307 if (!args[0]->Int32Value(env->context()).To(&fd)) return;
308 CHECK_GE(fd, 0);
309
310 uv_handle_type t = uv_guess_handle(fd);
311 const char* type = nullptr;
312
313 switch (t) {
314 case UV_TCP:
315 type = "TCP";
316 break;
317 case UV_TTY:
318 type = "TTY";
319 break;
320 case UV_UDP:
321 type = "UDP";
322 break;
323 case UV_FILE:
324 type = "FILE";
325 break;
326 case UV_NAMED_PIPE:
327 type = "PIPE";
328 break;
329 case UV_UNKNOWN_HANDLE:
330 type = "UNKNOWN";
331 break;
332 default:
333 ABORT();
334 }
335
336 args.GetReturnValue().Set(OneByteString(env->isolate(), type));
337 }
338
ToUSVString(const FunctionCallbackInfo<Value> & args)339 static void ToUSVString(const FunctionCallbackInfo<Value>& args) {
340 Environment* env = Environment::GetCurrent(args);
341 CHECK_GE(args.Length(), 2);
342 CHECK(args[0]->IsString());
343 CHECK(args[1]->IsNumber());
344
345 TwoByteValue value(env->isolate(), args[0]);
346
347 int64_t start = args[1]->IntegerValue(env->context()).FromJust();
348 CHECK_GE(start, 0);
349
350 for (size_t i = start; i < value.length(); i++) {
351 char16_t c = value[i];
352 if (!IsUnicodeSurrogate(c)) {
353 continue;
354 } else if (IsUnicodeSurrogateTrail(c) || i == value.length() - 1) {
355 value[i] = kUnicodeReplacementCharacter;
356 } else {
357 char16_t d = value[i + 1];
358 if (IsUnicodeTrail(d)) {
359 i++;
360 } else {
361 value[i] = kUnicodeReplacementCharacter;
362 }
363 }
364 }
365
366 args.GetReturnValue().Set(
367 String::NewFromTwoByte(env->isolate(),
368 *value,
369 v8::NewStringType::kNormal,
370 value.length()).ToLocalChecked());
371 }
372
RegisterExternalReferences(ExternalReferenceRegistry * registry)373 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
374 registry->Register(GetPromiseDetails);
375 registry->Register(GetProxyDetails);
376 registry->Register(GetCallerLocation);
377 registry->Register(IsArrayBufferDetached);
378 registry->Register(PreviewEntries);
379 registry->Register(GetOwnNonIndexProperties);
380 registry->Register(GetConstructorName);
381 registry->Register(GetExternalValue);
382 registry->Register(Sleep);
383 registry->Register(ArrayBufferViewHasBuffer);
384 registry->Register(WeakReference::New);
385 registry->Register(WeakReference::Get);
386 registry->Register(WeakReference::IncRef);
387 registry->Register(WeakReference::DecRef);
388 registry->Register(GuessHandleType);
389 registry->Register(ToUSVString);
390 }
391
Initialize(Local<Object> target,Local<Value> unused,Local<Context> context,void * priv)392 void Initialize(Local<Object> target,
393 Local<Value> unused,
394 Local<Context> context,
395 void* priv) {
396 Environment* env = Environment::GetCurrent(context);
397 Isolate* isolate = env->isolate();
398
399 {
400 Local<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
401 #define V(PropertyName, _) \
402 tmpl->Set(FIXED_ONE_BYTE_STRING(env->isolate(), #PropertyName), \
403 env->PropertyName());
404
405 PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)
406 #undef V
407
408 target
409 ->Set(context,
410 FIXED_ONE_BYTE_STRING(isolate, "privateSymbols"),
411 tmpl->NewInstance(context).ToLocalChecked())
412 .Check();
413 }
414
415 {
416 Local<Object> constants = Object::New(isolate);
417 #define V(name) \
418 constants \
419 ->Set(context, \
420 FIXED_ONE_BYTE_STRING(isolate, #name), \
421 Integer::New(isolate, Promise::PromiseState::name)) \
422 .Check();
423
424 V(kPending);
425 V(kFulfilled);
426 V(kRejected);
427 #undef V
428
429 #define V(name) \
430 constants \
431 ->Set(context, \
432 FIXED_ONE_BYTE_STRING(isolate, #name), \
433 Integer::New(isolate, PropertyFilter::name)) \
434 .Check();
435
436 V(ALL_PROPERTIES);
437 V(ONLY_WRITABLE);
438 V(ONLY_ENUMERABLE);
439 V(ONLY_CONFIGURABLE);
440 V(SKIP_STRINGS);
441 V(SKIP_SYMBOLS);
442 #undef V
443
444 target->Set(context, env->constants_string(), constants).Check();
445 }
446
447 SetMethodNoSideEffect(
448 context, target, "getPromiseDetails", GetPromiseDetails);
449 SetMethodNoSideEffect(context, target, "getProxyDetails", GetProxyDetails);
450 SetMethodNoSideEffect(
451 context, target, "getCallerLocation", GetCallerLocation);
452 SetMethodNoSideEffect(
453 context, target, "isArrayBufferDetached", IsArrayBufferDetached);
454 SetMethodNoSideEffect(context, target, "previewEntries", PreviewEntries);
455 SetMethodNoSideEffect(
456 context, target, "getOwnNonIndexProperties", GetOwnNonIndexProperties);
457 SetMethodNoSideEffect(
458 context, target, "getConstructorName", GetConstructorName);
459 SetMethodNoSideEffect(context, target, "getExternalValue", GetExternalValue);
460 SetMethod(context, target, "sleep", Sleep);
461
462 SetMethod(
463 context, target, "arrayBufferViewHasBuffer", ArrayBufferViewHasBuffer);
464
465 Local<String> should_abort_on_uncaught_toggle =
466 FIXED_ONE_BYTE_STRING(env->isolate(), "shouldAbortOnUncaughtToggle");
467 CHECK(target
468 ->Set(context,
469 should_abort_on_uncaught_toggle,
470 env->should_abort_on_uncaught_toggle().GetJSArray())
471 .FromJust());
472
473 Local<FunctionTemplate> weak_ref =
474 NewFunctionTemplate(isolate, WeakReference::New);
475 weak_ref->InstanceTemplate()->SetInternalFieldCount(
476 WeakReference::kInternalFieldCount);
477 weak_ref->Inherit(BaseObject::GetConstructorTemplate(env));
478 SetProtoMethod(isolate, weak_ref, "get", WeakReference::Get);
479 SetProtoMethod(isolate, weak_ref, "incRef", WeakReference::IncRef);
480 SetProtoMethod(isolate, weak_ref, "decRef", WeakReference::DecRef);
481 SetConstructorFunction(context, target, "WeakReference", weak_ref);
482
483 SetMethod(context, target, "guessHandleType", GuessHandleType);
484
485 SetMethodNoSideEffect(context, target, "toUSVString", ToUSVString);
486 }
487
488 } // namespace util
489 } // namespace node
490
491 NODE_BINDING_CONTEXT_AWARE_INTERNAL(util, node::util::Initialize)
492 NODE_BINDING_EXTERNAL_REFERENCE(util, node::util::RegisterExternalReferences)
493