1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "monitor.h"
17 
18 #include <cstddef>
19 #include <utility>
20 
21 #include <napi/native_api.h>
22 #include <napi/native_common.h>
23 #include <securec.h>
24 #include <uv.h>
25 
26 #include "module_template.h"
27 #include "napi_utils.h"
28 #include "netstack_log.h"
29 #include "tls_socket.h"
30 
31 namespace OHOS {
32 namespace NetStack {
33 namespace TlsSocket {
34 namespace {
35 constexpr int PARAM_OPTION = 1;
36 constexpr int PARAM_OPTION_CALLBACK = 2;
37 constexpr std::string_view EVENT_MESSAGE = "message";
38 constexpr std::string_view EVENT_CONNECT = "connect";
39 constexpr std::string_view EVENT_CLOSE = "close";
40 constexpr std::string_view EVENT_ERROR = "error";
41 constexpr std::initializer_list<std::string_view> EVENTS = {EVENT_MESSAGE, EVENT_CONNECT, EVENT_CLOSE, EVENT_ERROR};
42 
43 constexpr const char *PROPERTY_ADDRESS = "address";
44 constexpr const char *PROPERTY_FAMILY = "family";
45 constexpr const char *PROPERTY_PORT = "port";
46 constexpr const char *PROPERTY_SIZE = "size";
47 constexpr const char *ON_MESSAGE = "message";
48 constexpr const char *ON_REMOTE_INFO = "remoteInfo";
49 
ParserNullBranch(const std::string & errMessage,uv_work_t * & work,UvWorkWrapper * & workWrapper)50 void ParserNullBranch(const std::string &errMessage, uv_work_t *&work, UvWorkWrapper *&workWrapper)
51 {
52     NETSTACK_LOGE("%{public}s", errMessage.c_str());
53     if (workWrapper != nullptr) {
54         delete workWrapper;
55         workWrapper = nullptr;
56     }
57 
58     if (work != nullptr) {
59         delete work;
60         work = nullptr;
61     }
62 }
63 
SetPropertyForWorkWrapper(UvWorkWrapper * workWrapper,Monitor::MessageRecvParma * messageRecvParma,napi_value arrayBuffer,napi_value remoteInfo,napi_value obj)64 void SetPropertyForWorkWrapper(UvWorkWrapper *workWrapper, Monitor::MessageRecvParma *messageRecvParma,
65                                napi_value arrayBuffer, napi_value remoteInfo, napi_value obj)
66 {
67     napi_value message = nullptr;
68     napi_create_typedarray(workWrapper->env, napi_uint8_array, messageRecvParma->data_.size(), arrayBuffer, 0,
69                            &message);
70     napi_value address = NapiUtils::CreateStringUtf8(workWrapper->env, messageRecvParma->remoteInfo_.GetAddress());
71     napi_value family = NapiUtils::CreateStringUtf8(workWrapper->env, messageRecvParma->remoteInfo_.GetFamily());
72     napi_value port = NapiUtils::CreateInt32(workWrapper->env, messageRecvParma->remoteInfo_.GetPort());
73     napi_value size = NapiUtils::CreateInt32(workWrapper->env, messageRecvParma->remoteInfo_.GetSize());
74     NapiUtils::SetNamedProperty(workWrapper->env, remoteInfo, PROPERTY_ADDRESS, address);
75     NapiUtils::SetNamedProperty(workWrapper->env, remoteInfo, PROPERTY_FAMILY, family);
76     NapiUtils::SetNamedProperty(workWrapper->env, remoteInfo, PROPERTY_PORT, port);
77     NapiUtils::SetNamedProperty(workWrapper->env, remoteInfo, PROPERTY_SIZE, size);
78     NapiUtils::SetNamedProperty(workWrapper->env, obj, ON_MESSAGE, message);
79     NapiUtils::SetNamedProperty(workWrapper->env, obj, ON_REMOTE_INFO, remoteInfo);
80 }
81 
EventMessageCallback(uv_work_t * work,int status)82 void EventMessageCallback(uv_work_t *work, int status)
83 {
84     (void)status;
85     if (work == nullptr) {
86         NETSTACK_LOGE("work is nullptr");
87         return;
88     }
89     auto workWrapper = static_cast<UvWorkWrapper *>(work->data);
90     auto eventManager = reinterpret_cast<EventManager *>(workWrapper->data);
91     auto messageRecvParam = reinterpret_cast<Monitor::MessageRecvParma *>(eventManager->GetQueueData());
92     if (!messageRecvParam) {
93         NETSTACK_LOGE("messageRecvParam is nullptr");
94         return;
95     }
96 
97     napi_env env = workWrapper->env;
98     auto closeScope = [env](napi_handle_scope scope) { NapiUtils::CloseScope(env, scope); };
99     std::unique_ptr<napi_handle_scope__, decltype(closeScope)> scope(NapiUtils::OpenScope(env), closeScope);
100 
101     napi_value obj = NapiUtils::CreateObject(workWrapper->env);
102     napi_value remoteInfo = NapiUtils::CreateObject(workWrapper->env);
103     void *data = nullptr;
104     napi_value arrayBuffer = NapiUtils::CreateArrayBuffer(workWrapper->env, messageRecvParam->data_.size(), &data);
105     if (data != nullptr && NapiUtils::ValueIsArrayBuffer(env, arrayBuffer) &&
106         memcpy_s(data, messageRecvParam->data_.size(), messageRecvParam->data_.c_str(),
107                  messageRecvParam->data_.size()) != EOK) {
108         delete messageRecvParam;
109         ParserNullBranch("", work, workWrapper);
110         return;
111     }
112     SetPropertyForWorkWrapper(workWrapper, messageRecvParam, arrayBuffer, remoteInfo, obj);
113 
114     if (workWrapper->manager == nullptr || !EventManager::IsManagerValid(workWrapper->manager)) {
115         delete messageRecvParam;
116         ParserNullBranch("manager is invalid", work, workWrapper);
117         return;
118     }
119     workWrapper->manager->Emit(workWrapper->type, std::make_pair(NapiUtils::GetUndefined(workWrapper->env), obj));
120     delete messageRecvParam;
121     ParserNullBranch("event message callback success", work, workWrapper);
122 }
123 
EventConnectCloseCallback(uv_work_t * work,int status)124 void EventConnectCloseCallback(uv_work_t *work, int status)
125 {
126     (void)status;
127     if (work == nullptr) {
128         NETSTACK_LOGE("work is nullptr");
129         return;
130     }
131     auto workWrapper = static_cast<UvWorkWrapper *>(work->data);
132     if (workWrapper == nullptr) {
133         NETSTACK_LOGE("workWrapper is nullptr");
134         delete work;
135         return;
136     }
137     if (workWrapper->manager == nullptr) {
138         NETSTACK_LOGE("manager is nullptr");
139         delete workWrapper;
140         delete work;
141         return;
142     }
143     napi_handle_scope scope = NapiUtils::OpenScope(workWrapper->env);
144     std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(workWrapper->env),
145                                              NapiUtils::GetUndefined(workWrapper->env)};
146     workWrapper->manager->Emit(workWrapper->type, arg);
147     NapiUtils::CloseScope(workWrapper->env, scope);
148     delete workWrapper;
149     delete work;
150 }
151 
EventErrorCallback(uv_work_t * work,int status)152 void EventErrorCallback(uv_work_t *work, int status)
153 {
154     (void)status;
155     if (work == nullptr) {
156         NETSTACK_LOGE("work is nullptr");
157         return;
158     }
159     auto workWrapper = static_cast<UvWorkWrapper *>(work->data);
160     if (workWrapper == nullptr) {
161         NETSTACK_LOGE("workWrapper is nullptr");
162         delete work;
163         return;
164     }
165     std::shared_ptr<Monitor::ErrorRecvParma> errorRecvParma(static_cast<Monitor::ErrorRecvParma *>(workWrapper->data));
166     if (errorRecvParma == nullptr) {
167         NETSTACK_LOGE("monitor is nullptr");
168         delete workWrapper;
169         delete work;
170         return;
171     }
172     if (workWrapper->manager == nullptr) {
173         NETSTACK_LOGE("manager is nullptr");
174         delete workWrapper;
175         delete work;
176         return;
177     }
178     napi_handle_scope scope = NapiUtils::OpenScope(workWrapper->env);
179     napi_value obj = NapiUtils::CreateObject(workWrapper->env);
180     napi_value errorNumber = NapiUtils::CreateInt32(workWrapper->env, errorRecvParma->errorNumber_);
181     napi_value errorString = NapiUtils::CreateStringUtf8(workWrapper->env, errorRecvParma->errorString_);
182     NapiUtils::SetNamedProperty(workWrapper->env, obj, "errorNumber", errorNumber);
183     NapiUtils::SetNamedProperty(workWrapper->env, obj, "errorString", errorString);
184     std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(workWrapper->env), obj};
185     workWrapper->manager->Emit(workWrapper->type, arg);
186     NapiUtils::CloseScope(workWrapper->env, scope);
187     delete workWrapper;
188     delete work;
189 }
190 } // namespace
191 
Monitor()192 Monitor::Monitor() {}
193 
~Monitor()194 Monitor::~Monitor() {}
195 
ParserEventForOn(const std::string event,TlsSocket::TLSSocket * tlsSocket,EventManager * manager)196 void Monitor::ParserEventForOn(const std::string event, TlsSocket::TLSSocket *tlsSocket, EventManager *manager)
197 {
198     if (event == EVENT_MESSAGE) {
199         tlsSocket->OnMessage([this, manager](auto data, auto remoteInfo) {
200             MessageRecvParma *messageRecvParma = new MessageRecvParma();
201             messageRecvParma->data_ = data;
202             messageRecvParma->remoteInfo_ = remoteInfo;
203             if (EventManager::IsManagerValid(manager)) {
204                 manager->SetQueueData(reinterpret_cast<void *>(messageRecvParma));
205                 manager->EmitByUv(std::string(EVENT_MESSAGE), reinterpret_cast<void *>(manager), EventMessageCallback);
206             }
207         });
208     }
209     if (event == EVENT_CLOSE) {
210         tlsSocket->OnClose([this, manager]() {
211             if (EventManager::IsManagerValid(manager)) {
212                 manager->EmitByUv(std::string(EVENT_CLOSE), nullptr, EventConnectCloseCallback);
213             }
214         });
215     }
216     if (event == EVENT_CONNECT) {
217         tlsSocket->OnConnect([this, manager]() {
218             if (EventManager::IsManagerValid(manager)) {
219                 manager->EmitByUv(std::string(EVENT_CONNECT), nullptr, EventConnectCloseCallback);
220             }
221         });
222     }
223     if (event == EVENT_ERROR) {
224         tlsSocket->OnError([this, manager](auto errorNumber, auto errorString) {
225             ErrorRecvParma *errorRecvParma = new ErrorRecvParma();
226             errorRecvParma->errorNumber_ = errorNumber;
227             errorRecvParma->errorString_ = errorString;
228             if (EventManager::IsManagerValid(manager)) {
229                 manager->EmitByUv(std::string(EVENT_ERROR), static_cast<void *>(errorRecvParma), EventErrorCallback);
230             }
231         });
232     }
233 }
234 
On(napi_env env,napi_callback_info info)235 napi_value Monitor::On(napi_env env, napi_callback_info info)
236 {
237     napi_value thisVal = nullptr;
238     size_t paramsCount = MAX_PARAM_NUM;
239     napi_value params[MAX_PARAM_NUM] = {nullptr};
240     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, &thisVal, nullptr));
241     if (paramsCount == PARAM_OPTION) {
242         return NapiUtils::GetUndefined(env);
243     }
244     if (paramsCount != PARAM_OPTION_CALLBACK) {
245         if (NapiUtils::GetValueType(env, params[0]) != napi_string) {
246             napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
247         }
248         if (NapiUtils::GetValueType(env, params[1]) != napi_function) {
249             return NapiUtils::GetUndefined(env);
250         }
251     }
252     EventManager *manager = nullptr;
253     napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager));
254     if (manager == nullptr) {
255         NETSTACK_LOGE("manager is nullptr");
256         return NapiUtils::GetUndefined(env);
257     }
258     auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
259     if (tlsSocket == nullptr) {
260         NETSTACK_LOGE("tlsSocket is null");
261         return NapiUtils::GetUndefined(env);
262     }
263 
264     const std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
265     if (std::find(EVENTS.begin(), EVENTS.end(), event) == EVENTS.end()) {
266         NETSTACK_LOGE("Incorrect listening event %{public}s", event.c_str());
267         return NapiUtils::GetUndefined(env);
268     }
269     manager->AddListener(env, event, params[1], false, false);
270     ParserEventForOn(event, tlsSocket, manager);
271     return NapiUtils::GetUndefined(env);
272 }
273 
ParserEventForOff(const std::string event,TLSSocket * tlsSocket)274 void Monitor::ParserEventForOff(const std::string event, TLSSocket *tlsSocket)
275 {
276     if (event == EVENT_MESSAGE) {
277         tlsSocket->OffMessage();
278     }
279     if (event == EVENT_CLOSE) {
280         tlsSocket->OffClose();
281     }
282     if (event == EVENT_CONNECT) {
283         tlsSocket->OffConnect();
284     }
285     if (event == EVENT_ERROR) {
286         tlsSocket->OffError();
287     }
288 }
289 
Off(napi_env env,napi_callback_info info)290 napi_value Monitor::Off(napi_env env, napi_callback_info info)
291 {
292     napi_value thisVal = nullptr;
293     size_t paramsCount = MAX_PARAM_NUM;
294     napi_value params[MAX_PARAM_NUM] = {nullptr};
295     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, &thisVal, nullptr));
296     if (paramsCount == PARAM_OPTION) {
297         return NapiUtils::GetUndefined(env);
298     }
299 
300     if (paramsCount != PARAM_OPTION_CALLBACK) {
301         if (NapiUtils::GetValueType(env, params[0]) != napi_string) {
302             napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
303         }
304         if (NapiUtils::GetValueType(env, params[1]) != napi_function) {
305             return NapiUtils::GetUndefined(env);
306         }
307     }
308     EventManager *manager = nullptr;
309     napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager));
310     if (manager == nullptr) {
311         NETSTACK_LOGE("manager is nullptr");
312         return NapiUtils::GetUndefined(env);
313     }
314     auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
315     if (tlsSocket == nullptr) {
316         NETSTACK_LOGE("tlsSocket is null");
317         return NapiUtils::GetUndefined(env);
318     }
319 
320     const std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
321     manager->DeleteListener(event);
322     ParserEventForOff(event, tlsSocket);
323     return NapiUtils::GetUndefined(env);
324 }
325 } // namespace TlsSocket
326 } // namespace NetStack
327 } // namespace OHOS
328