1 // Copyright Joyent, Inc. and other Node contributors.
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a
4 // copy of this software and associated documentation files (the
5 // "Software"), to deal in the Software without restriction, including
6 // without limitation the rights to use, copy, modify, merge, publish,
7 // distribute, sublicense, and/or sell copies of the Software, and to permit
8 // persons to whom the Software is furnished to do so, subject to the
9 // following conditions:
10 //
11 // The above copyright notice and this permission notice shall be included
12 // in all copies or substantial portions of the Software.
13 //
14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20 // USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22 #include "handle_wrap.h"
23 #include "async_wrap-inl.h"
24 #include "env-inl.h"
25 #include "node_external_reference.h"
26 #include "util-inl.h"
27
28 namespace node {
29
30 using v8::Context;
31 using v8::FunctionCallbackInfo;
32 using v8::FunctionTemplate;
33 using v8::HandleScope;
34 using v8::Isolate;
35 using v8::Local;
36 using v8::Object;
37 using v8::Value;
38
39
Ref(const FunctionCallbackInfo<Value> & args)40 void HandleWrap::Ref(const FunctionCallbackInfo<Value>& args) {
41 HandleWrap* wrap;
42 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
43
44 if (IsAlive(wrap))
45 uv_ref(wrap->GetHandle());
46 }
47
48
Unref(const FunctionCallbackInfo<Value> & args)49 void HandleWrap::Unref(const FunctionCallbackInfo<Value>& args) {
50 HandleWrap* wrap;
51 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
52
53 if (IsAlive(wrap))
54 uv_unref(wrap->GetHandle());
55 }
56
57
HasRef(const FunctionCallbackInfo<Value> & args)58 void HandleWrap::HasRef(const FunctionCallbackInfo<Value>& args) {
59 HandleWrap* wrap;
60 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
61 args.GetReturnValue().Set(HasRef(wrap));
62 }
63
64
Close(const FunctionCallbackInfo<Value> & args)65 void HandleWrap::Close(const FunctionCallbackInfo<Value>& args) {
66 HandleWrap* wrap;
67 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
68
69 wrap->Close(args[0]);
70 }
71
Close(Local<Value> close_callback)72 void HandleWrap::Close(Local<Value> close_callback) {
73 if (state_ != kInitialized)
74 return;
75
76 uv_close(handle_, OnClose);
77 state_ = kClosing;
78
79 if (!close_callback.IsEmpty() && close_callback->IsFunction() &&
80 !persistent().IsEmpty()) {
81 object()->Set(env()->context(),
82 env()->handle_onclose_symbol(),
83 close_callback).Check();
84 }
85 }
86
87
OnGCCollect()88 void HandleWrap::OnGCCollect() {
89 // When all references to a HandleWrap are lost and the object is supposed to
90 // be destroyed, we first call Close() to clean up the underlying libuv
91 // handle. The OnClose callback then acquires and destroys another reference
92 // to that object, and when that reference is lost, we perform the default
93 // action (i.e. destroying `this`).
94 if (state_ != kClosed) {
95 Close();
96 } else {
97 BaseObject::OnGCCollect();
98 }
99 }
100
101
IsNotIndicativeOfMemoryLeakAtExit() const102 bool HandleWrap::IsNotIndicativeOfMemoryLeakAtExit() const {
103 return IsWeakOrDetached() ||
104 !HandleWrap::HasRef(this) ||
105 !uv_is_active(GetHandle());
106 }
107
108
MarkAsInitialized()109 void HandleWrap::MarkAsInitialized() {
110 env()->handle_wrap_queue()->PushBack(this);
111 state_ = kInitialized;
112 }
113
114
MarkAsUninitialized()115 void HandleWrap::MarkAsUninitialized() {
116 handle_wrap_queue_.Remove();
117 state_ = kClosed;
118 }
119
120
HandleWrap(Environment * env,Local<Object> object,uv_handle_t * handle,AsyncWrap::ProviderType provider)121 HandleWrap::HandleWrap(Environment* env,
122 Local<Object> object,
123 uv_handle_t* handle,
124 AsyncWrap::ProviderType provider)
125 : AsyncWrap(env, object, provider),
126 state_(kInitialized),
127 handle_(handle) {
128 handle_->data = this;
129 HandleScope scope(env->isolate());
130 CHECK(env->has_run_bootstrapping_code());
131 env->handle_wrap_queue()->PushBack(this);
132 }
133
134
OnClose(uv_handle_t * handle)135 void HandleWrap::OnClose(uv_handle_t* handle) {
136 CHECK_NOT_NULL(handle->data);
137 BaseObjectPtr<HandleWrap> wrap { static_cast<HandleWrap*>(handle->data) };
138 wrap->Detach();
139
140 Environment* env = wrap->env();
141 HandleScope scope(env->isolate());
142 Context::Scope context_scope(env->context());
143
144 CHECK_EQ(wrap->state_, kClosing);
145
146 wrap->state_ = kClosed;
147
148 wrap->OnClose();
149 wrap->handle_wrap_queue_.Remove();
150
151 if (!wrap->persistent().IsEmpty() &&
152 wrap->object()->Has(env->context(), env->handle_onclose_symbol())
153 .FromMaybe(false)) {
154 wrap->MakeCallback(env->handle_onclose_symbol(), 0, nullptr);
155 }
156 }
157
GetConstructorTemplate(Environment * env)158 Local<FunctionTemplate> HandleWrap::GetConstructorTemplate(Environment* env) {
159 Local<FunctionTemplate> tmpl = env->handle_wrap_ctor_template();
160 if (tmpl.IsEmpty()) {
161 Isolate* isolate = env->isolate();
162 tmpl = NewFunctionTemplate(isolate, nullptr);
163 tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "HandleWrap"));
164 tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
165 SetProtoMethod(isolate, tmpl, "close", HandleWrap::Close);
166 SetProtoMethodNoSideEffect(isolate, tmpl, "hasRef", HandleWrap::HasRef);
167 SetProtoMethod(isolate, tmpl, "ref", HandleWrap::Ref);
168 SetProtoMethod(isolate, tmpl, "unref", HandleWrap::Unref);
169 env->set_handle_wrap_ctor_template(tmpl);
170 }
171 return tmpl;
172 }
173
RegisterExternalReferences(ExternalReferenceRegistry * registry)174 void HandleWrap::RegisterExternalReferences(
175 ExternalReferenceRegistry* registry) {
176 registry->Register(HandleWrap::Close);
177 registry->Register(HandleWrap::HasRef);
178 registry->Register(HandleWrap::Ref);
179 registry->Register(HandleWrap::Unref);
180 }
181
182 } // namespace node
183
184 NODE_BINDING_EXTERNAL_REFERENCE(handle_wrap,
185 node::HandleWrap::RegisterExternalReferences)
186