1 /*
2  * Copyright (c) 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_server.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 
30 #include "tls_socket_server.h"
31 #include "tlssocketserver_module.h"
32 
33 namespace OHOS {
34 namespace NetStack {
35 namespace TlsSocketServer {
36 namespace {
37 constexpr int PARAM_OPTION = 1;
38 constexpr int PARAM_OPTION_CALLBACK = 2;
39 constexpr std::string_view EVENT_MESSAGE = "message";
40 constexpr std::string_view EVENT_CONNECT = "connect";
41 constexpr std::string_view EVENT_CLOSE = "close";
42 constexpr std::string_view EVENT_ERROR = "error";
43 
44 constexpr const char *PROPERTY_ADDRESS = "address";
45 constexpr const char *PROPERTY_FAMILY = "family";
46 constexpr const char *PROPERTY_PORT = "port";
47 constexpr const char *PROPERTY_SIZE = "size";
48 constexpr const char *ON_MESSAGE = "message";
49 constexpr const char *ON_REMOTE_INFO = "remoteInfo";
50 
NewInstanceWithConstructor(napi_env env,napi_callback_info info,napi_value jsConstructor,int32_t counter,std::shared_ptr<EventManager> eventManager)51 napi_value NewInstanceWithConstructor(napi_env env, napi_callback_info info, napi_value jsConstructor, int32_t counter,
52                                       std::shared_ptr<EventManager> eventManager)
53 {
54     napi_value result = nullptr;
55     NAPI_CALL(env, napi_new_instance(env, jsConstructor, 0, nullptr, &result));
56 
57     std::shared_ptr<EventManager> manager = eventManager;
58 
59     napi_wrap(
60         env, result, reinterpret_cast<void *>(manager.get()),
61         [](napi_env, void *data, void *) {
62             NETSTACK_LOGI("socket handle is finalized");
63             auto manager = static_cast<EventManager *>(data);
64             if (manager != nullptr) {
65                 auto tlsServer = static_cast<TLSSocketServer *>(manager->GetData());
66                 if (tlsServer != nullptr) {
67                     tlsServer->CloseConnectionByEventManager(manager);
68                     tlsServer->DeleteConnectionByEventManager(manager);
69                 }
70                 EventManager::SetInvalid(manager);
71             }
72         },
73         nullptr, nullptr);
74 
75     return result;
76 }
77 
ConstructTLSSocketConnection(napi_env env,napi_callback_info info,int32_t counter,std::shared_ptr<EventManager> eventManager)78 napi_value ConstructTLSSocketConnection(napi_env env, napi_callback_info info, int32_t counter,
79                                         std::shared_ptr<EventManager> eventManager)
80 {
81     napi_value jsConstructor = nullptr;
82     std::initializer_list<napi_property_descriptor> properties = {
83         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_GET_CERTIFICATE,
84                               TLSSocketServerModuleExports::TLSSocketConnection::GetCertificate),
85         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_GET_REMOTE_CERTIFICATE,
86                               TlsSocketServer::TLSSocketServerModuleExports::TLSSocketConnection::GetRemoteCertificate),
87         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_GET_SIGNATURE_ALGORITHMS,
88                               TLSSocketServerModuleExports::TLSSocketConnection::GetSignatureAlgorithms),
89         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_GET_CIPHER_SUITE,
90                               TLSSocketServerModuleExports::TLSSocketConnection::GetCipherSuites),
91         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_SEND,
92                               TLSSocketServerModuleExports::TLSSocketConnection::Send),
93         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_CLOSE,
94                               TLSSocketServerModuleExports::TLSSocketConnection::Close),
95         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_GET_REMOTE_ADDRESS,
96                               TLSSocketServerModuleExports::TLSSocketConnection::GetRemoteAddress),
97         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_GET_LOCAL_ADDRESS,
98                               TLSSocketServerModuleExports::TLSSocketConnection::GetLocalAddress),
99         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_ON,
100                               TLSSocketServerModuleExports::TLSSocketConnection::On),
101         DECLARE_NAPI_FUNCTION(TLSSocketServerModuleExports::TLSSocketConnection::FUNCTION_OFF,
102                               TLSSocketServerModuleExports::TLSSocketConnection::Off),
103     };
104 
105     auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
106         napi_value thisVal = nullptr;
107         NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVal, nullptr));
108 
109         return thisVal;
110     };
111 
112     napi_property_descriptor descriptors[properties.size()];
113     std::copy(properties.begin(), properties.end(), descriptors);
114 
115     NAPI_CALL_BASE(env,
116                    napi_define_class(env, TLSSocketServerModuleExports::INTERFACE_TLS_SOCKET_SERVER_CONNECTION,
117                                      NAPI_AUTO_LENGTH, constructor, nullptr, properties.size(), descriptors,
118                                      &jsConstructor),
119                    NapiUtils::GetUndefined(env));
120 
121     if (jsConstructor != nullptr) {
122         napi_value result = NewInstanceWithConstructor(env, info, jsConstructor, counter, eventManager);
123         NapiUtils::SetInt32Property(env, result, TLSSocketServerModuleExports::TLSSocketConnection::PROPERTY_CLIENT_ID,
124                                     counter);
125         return result;
126     }
127     return NapiUtils::GetUndefined(env);
128 }
129 
MakeMessageObj(napi_env env,std::shared_ptr<MonitorServer::MessageRecvParma> MessagePara)130 napi_value MakeMessageObj(napi_env env, std::shared_ptr<MonitorServer::MessageRecvParma> MessagePara)
131 {
132     void *data = nullptr;
133     napi_value arrayBuffer = NapiUtils::CreateArrayBuffer(env, MessagePara->data.size(), &data);
134     if (data != nullptr && arrayBuffer != nullptr) {
135         if (memcpy_s(data, MessagePara->data.size(), MessagePara->data.c_str(), MessagePara->data.size()) != EOK) {
136             NETSTACK_LOGE("memcpy_s failed!");
137             return nullptr;
138         }
139     } else {
140         return nullptr;
141     }
142 
143     napi_value obj = NapiUtils::CreateObject(env);
144     napi_value remoteInfo = NapiUtils::CreateObject(env);
145 
146     napi_value message = nullptr;
147     napi_create_typedarray(env, napi_uint8_array, MessagePara->data.size(), arrayBuffer, 0, &message);
148     napi_value address = NapiUtils::CreateStringUtf8(env, MessagePara->remoteInfo_.GetAddress());
149     napi_value family = NapiUtils::CreateStringUtf8(env, MessagePara->remoteInfo_.GetFamily());
150     napi_value port = NapiUtils::CreateInt32(env, MessagePara->remoteInfo_.GetPort());
151     napi_value size = NapiUtils::CreateInt32(env, MessagePara->remoteInfo_.GetSize());
152     NapiUtils::SetNamedProperty(env, remoteInfo, PROPERTY_ADDRESS, address);
153     NapiUtils::SetNamedProperty(env, remoteInfo, PROPERTY_FAMILY, family);
154     NapiUtils::SetNamedProperty(env, remoteInfo, PROPERTY_PORT, port);
155     NapiUtils::SetNamedProperty(env, remoteInfo, PROPERTY_SIZE, size);
156     NapiUtils::SetNamedProperty(env, obj, ON_MESSAGE, message);
157     NapiUtils::SetNamedProperty(env, obj, ON_REMOTE_INFO, remoteInfo);
158 
159     return obj;
160 }
161 
EventMessageCallback(uv_work_t * work,int status)162 void EventMessageCallback(uv_work_t *work, int status)
163 {
164     (void)status;
165     if (work == nullptr) {
166         NETSTACK_LOGE("work is nullptr");
167         return;
168     }
169     auto workWrapper = static_cast<UvWorkWrapper *>(work->data);
170     if (workWrapper == nullptr) {
171         NETSTACK_LOGE("workWrapper is nullptr");
172         delete work;
173         return;
174     }
175     std::shared_ptr<MonitorServer::MessageRecvParma> ptrMessageRecvParma(
176         static_cast<MonitorServer::MessageRecvParma *>(workWrapper->data));
177     if (ptrMessageRecvParma == nullptr) {
178         NETSTACK_LOGE("messageRecvParma is nullptr");
179         delete workWrapper;
180         delete work;
181         return;
182     }
183     if (workWrapper->manager == nullptr) {
184         NETSTACK_LOGE("manager is nullptr");
185         delete workWrapper;
186         delete work;
187         return;
188     }
189     napi_handle_scope scope = NapiUtils::OpenScope(workWrapper->env);
190     auto obj = MakeMessageObj(workWrapper->env, ptrMessageRecvParma);
191     if (obj == nullptr) {
192         NapiUtils::CloseScope(workWrapper->env, scope);
193         delete workWrapper;
194         delete work;
195         return;
196     }
197 
198     workWrapper->manager->Emit(workWrapper->type, std::make_pair(NapiUtils::GetUndefined(workWrapper->env), obj));
199     NapiUtils::CloseScope(workWrapper->env, scope);
200 
201     delete workWrapper;
202     delete work;
203 }
204 
EventConnectCallback(uv_work_t * work,int status)205 void EventConnectCallback(uv_work_t *work, int status)
206 {
207     (void)status;
208     if (work == nullptr) {
209         NETSTACK_LOGE("work is nullptr");
210         return;
211     }
212     auto workWrapper = static_cast<UvWorkWrapper *>(work->data);
213     if (workWrapper == nullptr) {
214         NETSTACK_LOGE("workWrapper is nullptr");
215         delete work;
216         return;
217     }
218     std::shared_ptr<MonitorServer::MessageParma> messageParma(
219         static_cast<MonitorServer::MessageParma *>(workWrapper->data));
220     if (messageParma == nullptr) {
221         NETSTACK_LOGE("messageParma is nullptr");
222         delete workWrapper;
223         delete work;
224         return;
225     }
226     auto clientid = messageParma->clientID;
227     auto eventManager = messageParma->eventManager;
228     napi_handle_scope scope = NapiUtils::OpenScope(workWrapper->env);
229     napi_callback_info info = nullptr;
230     napi_value obj = ConstructTLSSocketConnection(workWrapper->env, info, clientid, eventManager);
231     workWrapper->manager->Emit(workWrapper->type, std::make_pair(NapiUtils::GetUndefined(workWrapper->env), obj));
232     NapiUtils::CloseScope(workWrapper->env, scope);
233     delete workWrapper;
234     delete work;
235 }
236 
EventCloseCallback(uv_work_t * work,int status)237 void EventCloseCallback(uv_work_t *work, int status)
238 {
239     (void)status;
240     if (work == nullptr) {
241         NETSTACK_LOGE("work is nullptr");
242         return;
243     }
244     auto workWrapper = static_cast<UvWorkWrapper *>(work->data);
245     if (workWrapper == nullptr) {
246         NETSTACK_LOGE("workWrapper is nullptr");
247         delete work;
248         return;
249     }
250     std::shared_ptr<int> ptrClientID(static_cast<int *>(workWrapper->data));
251     if (ptrClientID == nullptr) {
252         NETSTACK_LOGE("ptrClientID == nullptr");
253         delete workWrapper;
254         delete work;
255         return;
256     }
257     if (workWrapper->manager == nullptr) {
258         NETSTACK_LOGE("manager is nullptr");
259         delete workWrapper;
260         delete work;
261         return;
262     }
263     napi_handle_scope scope = NapiUtils::OpenScope(workWrapper->env);
264     napi_value obj = nullptr;
265     workWrapper->manager->Emit(workWrapper->type, std::make_pair(NapiUtils::GetUndefined(workWrapper->env), obj));
266     NapiUtils::CloseScope(workWrapper->env, scope);
267     delete workWrapper;
268     delete work;
269 }
270 
EventErrorCallback(uv_work_t * work,int status)271 void EventErrorCallback(uv_work_t *work, int status)
272 {
273     (void)status;
274     if (work == nullptr) {
275         NETSTACK_LOGE("work is nullptr");
276         return;
277     }
278     auto workWrapper = static_cast<UvWorkWrapper *>(work->data);
279     if (workWrapper == nullptr) {
280         NETSTACK_LOGE("workWrapper is nullptr");
281         delete work;
282         return;
283     }
284     auto monitor = static_cast<MonitorServer *>(workWrapper->data);
285     if (monitor == nullptr) {
286         NETSTACK_LOGE("monitor is nullptr");
287         delete workWrapper;
288         delete work;
289         return;
290     }
291     if (workWrapper->manager == nullptr) {
292         NETSTACK_LOGE("manager is nullptr");
293         delete workWrapper;
294         delete work;
295         return;
296     }
297     napi_handle_scope scope = NapiUtils::OpenScope(workWrapper->env);
298     napi_value obj = NapiUtils::CreateObject(workWrapper->env);
299     napi_value errorNumber = NapiUtils::CreateInt32(workWrapper->env, monitor->errorNumber_);
300     napi_value errorString = NapiUtils::CreateStringUtf8(workWrapper->env, monitor->errorString_);
301     NapiUtils::SetNamedProperty(workWrapper->env, obj, "errorNumber", errorNumber);
302     NapiUtils::SetNamedProperty(workWrapper->env, obj, "errorString", errorString);
303     std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(workWrapper->env), obj};
304     workWrapper->manager->Emit(workWrapper->type, arg);
305     NapiUtils::CloseScope(workWrapper->env, scope);
306     delete workWrapper;
307     delete work;
308 }
309 } // namespace
310 
MonitorServer()311 MonitorServer::MonitorServer() {}
312 
~MonitorServer()313 MonitorServer::~MonitorServer() {}
314 
On(napi_env env,napi_callback_info info)315 napi_value MonitorServer::On(napi_env env, napi_callback_info info)
316 {
317     napi_value thisVal = nullptr;
318     size_t paramsCount = MAX_PARAM_NUM;
319     napi_value params[MAX_PARAM_NUM] = {nullptr};
320     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, &thisVal, nullptr));
321 
322     if (paramsCount != PARAM_OPTION_CALLBACK || NapiUtils::GetValueType(env, params[0]) != napi_string ||
323         NapiUtils::GetValueType(env, params[1]) != napi_function) {
324         NETSTACK_LOGE("on off once interface para: [string, function]");
325         napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
326         return NapiUtils::GetUndefined(env);
327     }
328     EventManager *manager_ = nullptr;
329     napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager_));
330     if (manager_ == nullptr) {
331         NETSTACK_LOGE("manager is nullptr");
332         return NapiUtils::GetUndefined(env);
333     }
334     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager_->GetData());
335     if (tlsSocketServer == nullptr) {
336         NETSTACK_LOGE("tlsSocketServer is null");
337         return NapiUtils::GetUndefined(env);
338     }
339 
340     const std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
341     auto itor = monitors_.find(event);
342     if (itor != monitors_.end()) {
343         NETSTACK_LOGE("monitor is exits %{public}s", event.c_str());
344         return NapiUtils::GetUndefined(env);
345     }
346     manager_->AddListener(env, event, params[1], false, false);
347     TLSServerRegEvent(event, tlsSocketServer, manager_);
348     return NapiUtils::GetUndefined(env);
349 }
350 
ConnectionOn(napi_env env,napi_callback_info info)351 napi_value MonitorServer::ConnectionOn(napi_env env, napi_callback_info info)
352 {
353     napi_value thisVal = nullptr;
354     size_t paramsCount = MAX_PARAM_NUM;
355     napi_value params[MAX_PARAM_NUM] = {nullptr};
356     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, &thisVal, nullptr));
357 
358     if (false == NapiUtils::HasNamedProperty(env, thisVal,
359                                              TLSSocketServerModuleExports::TLSSocketConnection::PROPERTY_CLIENT_ID)) {
360         NETSTACK_LOGI("not found Property clientId");
361         return NapiUtils::GetUndefined(env);
362     }
363 
364     int clientid = NapiUtils::GetInt32Property(env, thisVal,
365                                                TLSSocketServerModuleExports::TLSSocketConnection::PROPERTY_CLIENT_ID);
366 
367     if (paramsCount != PARAM_OPTION_CALLBACK || NapiUtils::GetValueType(env, params[0]) != napi_string ||
368         NapiUtils::GetValueType(env, params[1]) != napi_function) {
369         NETSTACK_LOGE("on off once interface para: [string, function]");
370         napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
371         return NapiUtils::GetUndefined(env);
372     }
373     EventManager *manager_ = nullptr;
374     napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager_));
375     if (manager_ == nullptr) {
376         NETSTACK_LOGE("manager is nullptr");
377         return NapiUtils::GetUndefined(env);
378     }
379     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager_->GetData());
380     if (tlsSocketServer == nullptr) {
381         NETSTACK_LOGE("tlsSocketServer is null");
382         return NapiUtils::GetUndefined(env);
383     }
384 
385     const std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
386 
387     manager_->AddListener(env, event, params[1], false, false);
388     TLSConnectionRegEvent(event, tlsSocketServer, clientid, manager_);
389     return NapiUtils::GetUndefined(env);
390 }
391 
Off(napi_env env,napi_callback_info info)392 napi_value MonitorServer::Off(napi_env env, napi_callback_info info)
393 {
394     napi_value thisVal = nullptr;
395     size_t paramsCount = MAX_PARAM_NUM;
396     napi_value params[MAX_PARAM_NUM] = {nullptr};
397     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, &thisVal, nullptr));
398 
399     if ((paramsCount != PARAM_OPTION && paramsCount != PARAM_OPTION_CALLBACK) ||
400         NapiUtils::GetValueType(env, params[0]) != napi_string) {
401         NETSTACK_LOGE("on off once interface para: [string, function?]");
402         napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
403         return NapiUtils::GetUndefined(env);
404     }
405 
406     if (paramsCount == PARAM_OPTION_CALLBACK && NapiUtils::GetValueType(env, params[1]) != napi_function) {
407         NETSTACK_LOGE("on off once interface para: [string, function]");
408         napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
409         return NapiUtils::GetUndefined(env);
410     }
411     EventManager *manager_ = nullptr;
412     napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager_));
413     if (manager_ == nullptr) {
414         NETSTACK_LOGE("manager is nullptr");
415         return NapiUtils::GetUndefined(env);
416     }
417     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager_->GetData());
418     if (tlsSocketServer == nullptr) {
419         NETSTACK_LOGE("tlsSocketServer is null");
420         return NapiUtils::GetUndefined(env);
421     }
422 
423     const std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
424     auto itor = monitors_.find(event);
425     if (itor == monitors_.end()) {
426         NETSTACK_LOGE("monitor is off %{public}s", event.c_str());
427         return NapiUtils::GetUndefined(env);
428     }
429     if (manager_ != nullptr) {
430         if (paramsCount == PARAM_OPTION_CALLBACK) {
431             manager_->DeleteListener(event, params[1]);
432         } else {
433             manager_->DeleteListener(event);
434         }
435     }
436 
437     if (event == EVENT_CONNECT) {
438         monitors_.erase(EVENT_CONNECT);
439         tlsSocketServer->OffConnect();
440     }
441     if (event == EVENT_ERROR) {
442         monitors_.erase(EVENT_ERROR);
443         tlsSocketServer->OffError();
444     }
445     return NapiUtils::GetUndefined(env);
446 }
447 
ConnectionOff(napi_env env,napi_callback_info info)448 napi_value MonitorServer::ConnectionOff(napi_env env, napi_callback_info info)
449 {
450     napi_value thisVal = nullptr;
451     size_t paramsCount = MAX_PARAM_NUM;
452     napi_value params[MAX_PARAM_NUM] = {nullptr};
453     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, &thisVal, nullptr));
454 
455     int clientid = NapiUtils::GetInt32Property(env, thisVal,
456                                                TLSSocketServerModuleExports::TLSSocketConnection::PROPERTY_CLIENT_ID);
457 
458     if ((paramsCount != PARAM_OPTION && paramsCount != PARAM_OPTION_CALLBACK) ||
459         NapiUtils::GetValueType(env, params[0]) != napi_string) {
460         NETSTACK_LOGE("on off once interface para: [string, function?]");
461         napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
462         return NapiUtils::GetUndefined(env);
463     }
464 
465     if (paramsCount == PARAM_OPTION_CALLBACK && NapiUtils::GetValueType(env, params[1]) != napi_function) {
466         NETSTACK_LOGE("on off once interface para: [string, function]");
467         napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
468         return NapiUtils::GetUndefined(env);
469     }
470     EventManager *manager_ = nullptr;
471     napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager_));
472     if (manager_ == nullptr) {
473         NETSTACK_LOGE("manager is nullptr");
474         return NapiUtils::GetUndefined(env);
475     }
476     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager_->GetData());
477     if (tlsSocketServer == nullptr) {
478         NETSTACK_LOGE("tlsSocketServer is null");
479         return NapiUtils::GetUndefined(env);
480     }
481 
482     const std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
483     auto itor = monitors_.find(event);
484     if (itor == monitors_.end()) {
485         NETSTACK_LOGE("monitor is off %{public}s", event.c_str());
486         return NapiUtils::GetUndefined(env);
487     }
488     if (manager_ != nullptr) {
489         if (paramsCount == PARAM_OPTION_CALLBACK) {
490             manager_->DeleteListener(event, params[1]);
491         } else {
492             manager_->DeleteListener(event);
493         }
494     }
495     TLSConnectionUnRegEvent(event, tlsSocketServer, clientid);
496     return NapiUtils::GetUndefined(env);
497 }
498 
TLSServerRegEvent(std::string event,TLSSocketServer * tlsSocketServer,EventManager * ServerEventManager)499 void MonitorServer::TLSServerRegEvent(std::string event, TLSSocketServer *tlsSocketServer,
500                                       EventManager *ServerEventManager)
501 {
502     if (event == EVENT_CONNECT) {
503         monitors_.insert(EVENT_CONNECT);
504         tlsSocketServer->OnConnect(
505             [this, ServerEventManager](auto clientFd, std::shared_ptr<EventManager> eventManager) {
506                 auto messageParma = new MonitorServer::MessageParma();
507                 messageParma->clientID = clientFd;
508                 messageParma->eventManager = eventManager;
509                 ServerEventManager->EmitByUv(std::string(EVENT_CONNECT), messageParma, EventConnectCallback);
510             });
511     }
512     if (event == EVENT_ERROR) {
513         monitors_.insert(EVENT_ERROR);
514         tlsSocketServer->OnError([this, ServerEventManager](auto errorNumber, auto errorString) {
515             errorNumber_ = errorNumber;
516             errorString_ = errorString;
517             ServerEventManager->EmitByUv(std::string(EVENT_ERROR), static_cast<void *>(this), EventErrorCallback);
518         });
519     }
520 }
521 
TLSConnectionRegEvent(std::string event,TLSSocketServer * tlsSocketServer,int clientId,EventManager * eventManager)522 void MonitorServer::TLSConnectionRegEvent(std::string event, TLSSocketServer *tlsSocketServer, int clientId,
523                                           EventManager *eventManager)
524 {
525     if (event == EVENT_MESSAGE) {
526         monitors_.insert(EVENT_MESSAGE);
527         auto ptrConnection = tlsSocketServer->GetConnectionByClientID(clientId);
528         if (ptrConnection != nullptr) {
529             ptrConnection->OnMessage([this, eventManager](auto clientFd, auto data, auto remoteInfo) {
530                 auto messageRecvParma = new MessageRecvParma();
531                 messageRecvParma->clientID = clientFd;
532                 messageRecvParma->data = data;
533                 messageRecvParma->remoteInfo_.SetAddress(remoteInfo.GetAddress());
534                 messageRecvParma->remoteInfo_.SetFamilyByStr(remoteInfo.GetFamily());
535                 messageRecvParma->remoteInfo_.SetPort(remoteInfo.GetPort());
536                 messageRecvParma->remoteInfo_.SetSize(remoteInfo.GetSize());
537                 eventManager->EmitByUv(std::string(EVENT_MESSAGE), messageRecvParma, EventMessageCallback);
538             });
539         }
540     }
541     if (event == EVENT_CLOSE) {
542         monitors_.insert(EVENT_CLOSE);
543         auto ptrConnection = tlsSocketServer->GetConnectionByClientID(clientId);
544         if (ptrConnection != nullptr) {
545             ptrConnection->OnClose([this, eventManager](auto clientFd) {
546                 eventManager->EmitByUv(std::string(EVENT_CLOSE), static_cast<void *>(this), EventCloseCallback);
547             });
548         }
549     }
550     if (event == EVENT_ERROR) {
551         monitors_.insert(EVENT_ERROR);
552         auto ptrConnection = tlsSocketServer->GetConnectionByClientID(clientId);
553         if (ptrConnection != nullptr) {
554             ptrConnection->OnError([this, eventManager](auto errorNumber, auto errorString) {
555                 eventManager->EmitByUv(std::string(EVENT_ERROR), static_cast<void *>(this), EventErrorCallback);
556             });
557         }
558     }
559 }
560 
TLSConnectionUnRegEvent(std::string event,TLSSocketServer * tlsSocketServer,int clientId)561 void MonitorServer::TLSConnectionUnRegEvent(std::string event, TLSSocketServer *tlsSocketServer, int clientId)
562 {
563     if (event == EVENT_MESSAGE) {
564         monitors_.erase(EVENT_MESSAGE);
565         auto ptrConnection = tlsSocketServer->GetConnectionByClientID(clientId);
566         if (ptrConnection != nullptr) {
567             ptrConnection->OffMessage();
568         }
569     }
570     if (event == EVENT_CLOSE) {
571         monitors_.erase(EVENT_CLOSE);
572         auto ptrConnection = tlsSocketServer->GetConnectionByClientID(clientId);
573         if (ptrConnection != nullptr) {
574             ptrConnection->OffClose();
575         }
576     }
577     if (event == EVENT_ERROR) {
578         monitors_.erase(EVENT_ERROR);
579         auto ptrConnection = tlsSocketServer->GetConnectionByClientID(clientId);
580         if (ptrConnection != nullptr) {
581             ptrConnection->OffError();
582         }
583     }
584 }
585 } // namespace TlsSocketServer
586 } // namespace NetStack
587 } // namespace OHOS
588