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 "tlssocketserver_exec.h"
17 
18 #include <string>
19 #include <vector>
20 
21 #include <napi/native_api.h>
22 #include <securec.h>
23 
24 #include "context_key.h"
25 #include "event_list.h"
26 #include "napi_utils.h"
27 #include "netstack_log.h"
28 #include "socket_error.h"
29 #include "tls_socket_server.h"
30 
31 namespace OHOS {
32 namespace NetStack {
33 namespace TlsSocketServer {
34 namespace {
35 constexpr const char *CERTIFICATA_DATA = "data";
36 constexpr const char *CERTIFICATA_ENCODING_FORMAT = "encodingFormat";
37 constexpr const int SYSTEM_INTERNAL_ERROR_CODE = 2300002;
38 const std::string SYSTEM_INTERNAL_ERROR_MESSAGE = "system internal error";
39 } // namespace
ExecGetCertificate(TlsSocket::GetCertificateContext * context)40 bool TLSSocketServerExec::ExecGetCertificate(TlsSocket::GetCertificateContext *context)
41 {
42     auto manager = context->GetManager();
43     if (manager == nullptr) {
44         NETSTACK_LOGE("manager is nullptr");
45         return false;
46     }
47     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
48     if (tlsSocketServer == nullptr) {
49         NETSTACK_LOGE("ExecGetCertificate tlsSocketServer is null");
50         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
51                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
52         return false;
53     }
54     tlsSocketServer->GetCertificate([&context](int32_t errorNumber, const TlsSocket::X509CertRawData &cert) {
55         context->localCert_ = cert;
56         context->errorNumber_ = errorNumber;
57         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
58             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
59         }
60     });
61     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
62 }
63 
ExecListen(TlsSocket::TLSListenContext * context)64 bool TLSSocketServerExec::ExecListen(TlsSocket::TLSListenContext *context)
65 {
66     auto manager = context->GetManager();
67     if (manager == nullptr) {
68         NETSTACK_LOGE("manager is nullptr");
69         return false;
70     }
71     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
72     if (tlsSocketServer == nullptr) {
73         tlsSocketServer = new TLSSocketServer();
74     }
75     if (manager->GetData() == nullptr) {
76         manager->SetData(tlsSocketServer);
77     }
78     tlsSocketServer->Listen(context->connectOptions_, [&context](int32_t errorNumber) {
79         context->errorNumber_ = errorNumber;
80         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
81             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
82         }
83     });
84     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
85 }
86 
ExecGetCipherSuites(ServerGetCipherSuitesContext * context)87 bool TLSSocketServerExec::ExecGetCipherSuites(ServerGetCipherSuitesContext *context)
88 {
89     auto manager = context->GetManager();
90     if (manager == nullptr) {
91         NETSTACK_LOGE("manager is nullptr");
92         return false;
93     }
94     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
95     if (tlsSocketServer == nullptr) {
96         NETSTACK_LOGE("ExecGetCipherSuites tlsSocketServer is null");
97         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
98                           MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
99         return false;
100     }
101     tlsSocketServer->GetCipherSuite(context->clientId_,
102                                     [&context](int32_t errorNumber, const std::vector<std::string> &suite) {
103                                         context->cipherSuites_ = suite;
104                                         context->errorNumber_ = errorNumber;
105                                         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
106                                             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
107                                         }
108                                     });
109     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
110 }
111 
ExecGetRemoteCertificate(ServerGetRemoteCertificateContext * context)112 bool TLSSocketServerExec::ExecGetRemoteCertificate(ServerGetRemoteCertificateContext *context)
113 {
114     auto manager = context->GetManager();
115     if (manager == nullptr) {
116         NETSTACK_LOGE("manager is nullptr");
117         return false;
118     }
119     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
120     if (tlsSocketServer == nullptr) {
121         NETSTACK_LOGE("ExecGetRemoteCertificate tlsSocketServer is null");
122         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
123                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
124         return false;
125     }
126     tlsSocketServer->GetRemoteCertificate(
127         context->clientId_, [&context](int32_t errorNumber, const TlsSocket::X509CertRawData &cert) {
128             context->remoteCert_ = cert;
129             context->errorNumber_ = errorNumber;
130             if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
131                 context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
132             }
133         });
134     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
135 }
136 
ExecGetProtocol(TlsSocket::GetProtocolContext * context)137 bool TLSSocketServerExec::ExecGetProtocol(TlsSocket::GetProtocolContext *context)
138 {
139     auto manager = context->GetManager();
140     if (manager == nullptr) {
141         NETSTACK_LOGE("manager is nullptr");
142         return false;
143     }
144     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
145     if (tlsSocketServer == nullptr) {
146         NETSTACK_LOGE("ExecGetProtocol tlsSocketServer is null");
147         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
148                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
149         return false;
150     }
151     tlsSocketServer->GetProtocol([&context](int32_t errorNumber, const std::string &protocol) {
152         context->protocol_ = protocol;
153         context->errorNumber_ = errorNumber;
154         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
155             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
156         }
157     });
158     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
159 }
160 
ExecGetSignatureAlgorithms(ServerGetSignatureAlgorithmsContext * context)161 bool TLSSocketServerExec::ExecGetSignatureAlgorithms(ServerGetSignatureAlgorithmsContext *context)
162 {
163     auto manager = context->GetManager();
164     if (manager == nullptr) {
165         NETSTACK_LOGE("manager is nullptr");
166         return false;
167     }
168     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
169     if (tlsSocketServer == nullptr) {
170         NETSTACK_LOGE("ExecGetSignatureAlgorithms tlsSocketServer is null");
171         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
172                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
173         return false;
174     }
175     tlsSocketServer->GetSignatureAlgorithms(
176         context->clientId_, [&context](int32_t errorNumber, const std::vector<std::string> &algorithms) {
177             context->signatureAlgorithms_ = algorithms;
178             context->errorNumber_ = errorNumber;
179             if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
180                 context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
181             }
182         });
183     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
184 }
185 
ExecSend(TLSServerSendContext * context)186 bool TLSSocketServerExec::ExecSend(TLSServerSendContext *context)
187 {
188     auto manager = context->GetManager();
189     if (manager == nullptr) {
190         NETSTACK_LOGE("manager is nullptr");
191         return false;
192     }
193     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
194     if (tlsSocketServer == nullptr) {
195         NETSTACK_LOGE("ExecSend tlsSocketServer is null");
196         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
197                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
198         return false;
199     }
200     TLSServerSendOptions tcpSendOptions;
201     int client_id = context->clientId_;
202     tcpSendOptions.SetSocket(client_id);
203     tcpSendOptions.SetSendData(context->m_sendData);
204     tlsSocketServer->Send(tcpSendOptions, [&context](int32_t errorNumber) {
205         context->errorNumber_ = errorNumber;
206         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
207             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
208         }
209     });
210     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
211 }
212 
ExecClose(TLSServerCloseContext * context)213 bool TLSSocketServerExec::ExecClose(TLSServerCloseContext *context)
214 {
215     auto manager = context->GetManager();
216     if (manager == nullptr) {
217         NETSTACK_LOGE("manager is nullptr");
218         return false;
219     }
220     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
221     if (tlsSocketServer == nullptr) {
222         NETSTACK_LOGE("ExecClose tlsSocketServer is null");
223         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
224                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
225         return false;
226     }
227     tlsSocketServer->Close(context->clientId_, [&context](int32_t errorNumber) {
228         context->errorNumber_ = errorNumber;
229         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
230             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
231         }
232     });
233     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
234 }
235 
ExecStop(TlsSocket::TLSNapiContext * context)236 bool TLSSocketServerExec::ExecStop(TlsSocket::TLSNapiContext *context)
237 {
238     auto manager = context->GetManager();
239     if (manager == nullptr) {
240         NETSTACK_LOGE("manager is nullptr");
241         return false;
242     }
243     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
244     if (tlsSocketServer == nullptr) {
245         NETSTACK_LOGE("ExecClose tlsSocketServer is null");
246         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
247                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
248         return false;
249     }
250     tlsSocketServer->Stop([&context](int32_t errorNumber) {
251         context->errorNumber_ = errorNumber;
252         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
253             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
254         }
255     });
256     delete tlsSocketServer;
257     manager->SetData(nullptr);
258     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
259 }
260 
ExecGetRemoteAddress(ServerTLSGetRemoteAddressContext * context)261 bool TLSSocketServerExec::ExecGetRemoteAddress(ServerTLSGetRemoteAddressContext *context)
262 {
263     auto manager = context->GetManager();
264     if (manager == nullptr) {
265         NETSTACK_LOGE("manager is nullptr");
266         return false;
267     }
268     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
269     if (tlsSocketServer == nullptr) {
270         NETSTACK_LOGE("ExecGetRemoteAddress tlsSocketServer is null");
271         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
272                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
273         return false;
274     }
275     tlsSocketServer->GetRemoteAddress(context->clientId_,
276                                       [&context](int32_t errorNumber, const Socket::NetAddress address) {
277                                           context->address_ = address;
278                                           context->errorNumber_ = errorNumber;
279                                           if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
280                                               context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
281                                           }
282                                       });
283     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
284 }
285 
ExecGetLocalAddress(TLSServerGetLocalAddressContext * context)286 bool TLSSocketServerExec::ExecGetLocalAddress(TLSServerGetLocalAddressContext *context)
287 {
288     if (context == nullptr) {
289         NETSTACK_LOGE("context is nullptr");
290         return false;
291     }
292     auto manager = context->GetManager();
293     if (manager == nullptr) {
294         NETSTACK_LOGE("manager is nullptr");
295         context->SetNeedThrowException(true);
296         context->SetError(SYSTEM_INTERNAL_ERROR_CODE, SYSTEM_INTERNAL_ERROR_MESSAGE);
297         return false;
298     }
299     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
300     if (tlsSocketServer == nullptr) {
301         NETSTACK_LOGE("ExecGetRemoteAddress tlsSocketServer is null");
302         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
303                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
304         return false;
305     }
306     struct sockaddr_storage addr{};
307     socklen_t addrLen = sizeof(addr);
308     if (getsockname(tlsSocketServer->GetListenSocketFd(), (struct sockaddr *)&addr, &addrLen) < 0) {
309         context->SetErrorCode(errno);
310         return false;
311     }
312 
313     char ipStr[INET6_ADDRSTRLEN] = {0};
314     Socket::NetAddress localAddress;
315     if (addr.ss_family == AF_INET) {
316         auto *addr_in = (struct sockaddr_in *)&addr;
317         inet_ntop(AF_INET, &addr_in->sin_addr, ipStr, sizeof(ipStr));
318         localAddress.SetFamilyBySaFamily(AF_INET);
319         localAddress.SetRawAddress(ipStr);
320         localAddress.SetPort(ntohs(addr_in->sin_port));
321         tlsSocketServer->SetLocalAddress(localAddress);
322     } else if (addr.ss_family == AF_INET6) {
323         auto *addr_in6 = (struct sockaddr_in6 *)&addr;
324         inet_ntop(AF_INET6, &addr_in6->sin6_addr, ipStr, sizeof(ipStr));
325         localAddress.SetFamilyBySaFamily(AF_INET6);
326         localAddress.SetRawAddress(ipStr);
327         localAddress.SetPort(ntohs(addr_in6->sin6_port));
328         tlsSocketServer->SetLocalAddress(localAddress);
329     }
330     return true;
331 }
332 
ExecConnectionGetLocalAddress(TLSConnectionGetLocalAddressContext * context)333 bool TLSSocketServerExec::ExecConnectionGetLocalAddress(TLSConnectionGetLocalAddressContext *context)
334 {
335     if (context == nullptr) {
336         NETSTACK_LOGE("context is nullptr");
337         return false;
338     }
339     auto manager = context->GetManager();
340     if (manager == nullptr) {
341         NETSTACK_LOGE("manager is nullptr");
342         context->SetNeedThrowException(true);
343         context->SetError(SYSTEM_INTERNAL_ERROR_CODE, SYSTEM_INTERNAL_ERROR_MESSAGE);
344         return false;
345     }
346     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
347     if (tlsSocketServer == nullptr) {
348         NETSTACK_LOGE("ExecGetRemoteAddress tlsSocketServer is null");
349         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
350                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
351         return false;
352     }
353     tlsSocketServer->GetLocalAddress(context->clientId_,
354                                      [&context](int32_t errorNumber, const Socket::NetAddress address) {
355                                          context->localAddress_ = address;
356                                          context->errorNumber_ = errorNumber;
357                                          if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
358                                              context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
359                                          }
360                                      });
361     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
362 }
363 
ExecGetState(TlsSocket::TLSGetStateContext * context)364 bool TLSSocketServerExec::ExecGetState(TlsSocket::TLSGetStateContext *context)
365 {
366     auto manager = context->GetManager();
367     if (manager == nullptr) {
368         NETSTACK_LOGE("manager is nullptr");
369         context->state_.SetIsClose(true);
370         return true;
371     }
372     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
373     if (tlsSocketServer == nullptr) {
374         NETSTACK_LOGE("ExecGetState tlsSocketServer is null");
375         return true;
376     }
377     tlsSocketServer->GetState([&context](int32_t errorNumber, const Socket::SocketStateBase state) {
378         context->state_ = state;
379         context->errorNumber_ = errorNumber;
380         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
381             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
382         }
383     });
384     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
385 }
386 
ExecSetExtraOptions(TlsSocket::TLSSetExtraOptionsContext * context)387 bool TLSSocketServerExec::ExecSetExtraOptions(TlsSocket::TLSSetExtraOptionsContext *context)
388 {
389     auto manager = context->GetManager();
390     if (manager == nullptr) {
391         NETSTACK_LOGE("manager is nullptr");
392         return false;
393     }
394     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
395     if (tlsSocketServer == nullptr) {
396         NETSTACK_LOGE("ExecSetExtraOptions tlsSocketServer is null");
397         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
398                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
399         return false;
400     }
401     tlsSocketServer->SetExtraOptions(context->options_, [&context](int32_t errorNumber) {
402         context->errorNumber_ = errorNumber;
403         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
404             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
405         }
406     });
407     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
408 }
409 
GetCertificateCallback(TlsSocket::GetCertificateContext * context)410 napi_value TLSSocketServerExec::GetCertificateCallback(TlsSocket::GetCertificateContext *context)
411 {
412     void *data = nullptr;
413     napi_value arrayBuffer = NapiUtils::CreateArrayBuffer(context->GetEnv(), context->localCert_.data.Length(), &data);
414     if (data != nullptr && arrayBuffer != nullptr) {
415         if (memcpy_s(data, context->localCert_.data.Length(),
416                      reinterpret_cast<const uint8_t *>(context->localCert_.data.Data()),
417                      context->localCert_.data.Length()) != EOK) {
418             NETSTACK_LOGE("memcpy_s failed!");
419             return NapiUtils::GetUndefined(context->GetEnv());
420         }
421     }
422     napi_value outData = nullptr;
423     napi_create_typedarray(context->GetEnv(), napi_uint8_array, context->localCert_.data.Length(), arrayBuffer, 0,
424                            &outData);
425     napi_value obj = NapiUtils::CreateObject(context->GetEnv());
426     if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
427         return NapiUtils::GetUndefined(context->GetEnv());
428     }
429     NapiUtils::SetNamedProperty(context->GetEnv(), obj, CERTIFICATA_DATA, outData);
430     NapiUtils::SetInt32Property(context->GetEnv(), obj, CERTIFICATA_ENCODING_FORMAT,
431                                 context->localCert_.encodingFormat);
432     return obj;
433 }
434 
ListenCallback(TlsSocket::TLSListenContext * context)435 napi_value TLSSocketServerExec::ListenCallback(TlsSocket::TLSListenContext *context)
436 {
437     context->Emit(EVENT_LISTENING, std::make_pair(NapiUtils::GetUndefined(context->GetEnv()),
438                                                   NapiUtils::GetUndefined(context->GetEnv())));
439     return NapiUtils::GetUndefined(context->GetEnv());
440 }
441 
GetCipherSuitesCallback(ServerGetCipherSuitesContext * context)442 napi_value TLSSocketServerExec::GetCipherSuitesCallback(ServerGetCipherSuitesContext *context)
443 {
444     napi_value cipherSuites = NapiUtils::CreateArray(context->GetEnv(), 0);
445     int index = 0;
446     for (const auto &cipher : context->cipherSuites_) {
447         napi_value cipherSuite = NapiUtils::CreateStringUtf8(context->GetEnv(), cipher);
448         NapiUtils::SetArrayElement(context->GetEnv(), cipherSuites, index++, cipherSuite);
449     }
450     return cipherSuites;
451 }
452 
GetRemoteCertificateCallback(ServerGetRemoteCertificateContext * context)453 napi_value TLSSocketServerExec::GetRemoteCertificateCallback(ServerGetRemoteCertificateContext *context)
454 {
455     napi_value obj = nullptr;
456     if (context->remoteCert_.data.Length() > 0 && context->remoteCert_.data.Data() != nullptr) {
457         void *data = nullptr;
458         napi_value arrayBuffer =
459             NapiUtils::CreateArrayBuffer(context->GetEnv(), context->remoteCert_.data.Length(), &data);
460         if (data != nullptr && arrayBuffer != nullptr) {
461             if (memcpy_s(data, context->remoteCert_.data.Length(),
462                          reinterpret_cast<const uint8_t *>(context->remoteCert_.data.Data()),
463                          context->remoteCert_.data.Length()) != EOK) {
464                 NETSTACK_LOGE("memcpy_s failed!");
465                 return NapiUtils::GetUndefined(context->GetEnv());
466             }
467         }
468         napi_value outData = nullptr;
469         napi_create_typedarray(context->GetEnv(), napi_uint8_array, context->remoteCert_.data.Length(), arrayBuffer, 0,
470                                &outData);
471         obj = NapiUtils::CreateObject(context->GetEnv());
472         if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
473             return NapiUtils::GetUndefined(context->GetEnv());
474         }
475         NapiUtils::SetNamedProperty(context->GetEnv(), obj, CERTIFICATA_DATA, outData);
476         NapiUtils::SetInt32Property(context->GetEnv(), obj, CERTIFICATA_ENCODING_FORMAT,
477                                     context->remoteCert_.encodingFormat);
478     }
479     return obj;
480 }
481 
GetProtocolCallback(TlsSocket::GetProtocolContext * context)482 napi_value TLSSocketServerExec::GetProtocolCallback(TlsSocket::GetProtocolContext *context)
483 {
484     return NapiUtils::CreateStringUtf8(context->GetEnv(), context->protocol_);
485 }
486 
GetSignatureAlgorithmsCallback(ServerGetSignatureAlgorithmsContext * context)487 napi_value TLSSocketServerExec::GetSignatureAlgorithmsCallback(ServerGetSignatureAlgorithmsContext *context)
488 {
489     napi_value signatureAlgorithms = NapiUtils::CreateArray(context->GetEnv(), 0);
490     int index = 0;
491     for (const auto &algorithm : context->signatureAlgorithms_) {
492         napi_value signatureAlgorithm = NapiUtils::CreateStringUtf8(context->GetEnv(), algorithm);
493         NapiUtils::SetArrayElement(context->GetEnv(), signatureAlgorithms, index++, signatureAlgorithm);
494     }
495     return signatureAlgorithms;
496 }
497 
SendCallback(TLSServerSendContext * context)498 napi_value TLSSocketServerExec::SendCallback(TLSServerSendContext *context)
499 {
500     context->Emit(EVENT_LISTENING, std::make_pair(NapiUtils::GetUndefined(context->GetEnv()),
501                                                   NapiUtils::GetUndefined(context->GetEnv())));
502     return NapiUtils::GetUndefined(context->GetEnv());
503 }
504 
CloseCallback(TLSServerCloseContext * context)505 napi_value TLSSocketServerExec::CloseCallback(TLSServerCloseContext *context)
506 {
507     context->Emit(EVENT_CLOSE, std::make_pair(NapiUtils::GetUndefined(context->GetEnv()),
508                                               NapiUtils::GetUndefined(context->GetEnv())));
509     return NapiUtils::GetUndefined(context->GetEnv());
510 }
511 
StopCallback(TlsSocket::TLSNapiContext * context)512 napi_value TLSSocketServerExec::StopCallback(TlsSocket::TLSNapiContext *context)
513 {
514     return NapiUtils::GetUndefined(context->GetEnv());
515 }
516 
GetStateCallback(TlsSocket::TLSGetStateContext * context)517 napi_value TLSSocketServerExec::GetStateCallback(TlsSocket::TLSGetStateContext *context)
518 {
519     napi_value obj = NapiUtils::CreateObject(context->GetEnv());
520     if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
521         return NapiUtils::GetUndefined(context->GetEnv());
522     }
523     NapiUtils::SetBooleanProperty(context->GetEnv(), obj, KEY_IS_BOUND, context->state_.IsBound());
524     NapiUtils::SetBooleanProperty(context->GetEnv(), obj, KEY_IS_CLOSE, context->state_.IsClose());
525     NapiUtils::SetBooleanProperty(context->GetEnv(), obj, KEY_IS_CONNECTED, context->state_.IsConnected());
526     return obj;
527 }
528 
GetRemoteAddressCallback(ServerTLSGetRemoteAddressContext * context)529 napi_value TLSSocketServerExec::GetRemoteAddressCallback(ServerTLSGetRemoteAddressContext *context)
530 {
531     napi_value obj = NapiUtils::CreateObject(context->GetEnv());
532     if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
533         return NapiUtils::GetUndefined(context->GetEnv());
534     }
535     NapiUtils::SetStringPropertyUtf8(context->GetEnv(), obj, KEY_ADDRESS, context->address_.GetAddress());
536     NapiUtils::SetUint32Property(context->GetEnv(), obj, KEY_FAMILY, context->address_.GetJsValueFamily());
537     NapiUtils::SetUint32Property(context->GetEnv(), obj, KEY_PORT, context->address_.GetPort());
538     return obj;
539 }
540 
GetLocalAddressCallback(TLSServerGetLocalAddressContext * context)541 napi_value TLSSocketServerExec::GetLocalAddressCallback(TLSServerGetLocalAddressContext *context)
542 {
543     napi_value obj = NapiUtils::CreateObject(context->GetEnv());
544     if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
545         return NapiUtils::GetUndefined(context->GetEnv());
546     }
547     auto manager = context->GetManager();
548     if (manager == nullptr) {
549         NETSTACK_LOGE("manager is nullptr");
550         return obj;
551     }
552     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
553     if (tlsSocketServer == nullptr) {
554         NETSTACK_LOGE("get localAddress callback tlsSocketServer is null");
555         return obj;
556     }
557     auto env = context->GetEnv();
558     NapiUtils::SetStringPropertyUtf8(env, obj, KEY_ADDRESS, tlsSocketServer->GetLocalAddress().GetAddress());
559     NapiUtils::SetUint32Property(env, obj, KEY_FAMILY, tlsSocketServer->GetLocalAddress().GetJsValueFamily());
560     NapiUtils::SetUint32Property(env, obj, KEY_PORT, tlsSocketServer->GetLocalAddress().GetPort());
561     return obj;
562 }
563 
GetConnectionLocalAddressCallback(TLSConnectionGetLocalAddressContext * context)564 napi_value TLSSocketServerExec::GetConnectionLocalAddressCallback(TLSConnectionGetLocalAddressContext *context)
565 {
566     napi_value obj = NapiUtils::CreateObject(context->GetEnv());
567     if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
568         return NapiUtils::GetUndefined(context->GetEnv());
569     }
570     auto env = context->GetEnv();
571     NapiUtils::SetStringPropertyUtf8(env, obj, KEY_ADDRESS, context->localAddress_.GetAddress());
572     NapiUtils::SetUint32Property(env, obj, KEY_FAMILY, context->localAddress_.GetJsValueFamily());
573     NapiUtils::SetUint32Property(env, obj, KEY_PORT, context->localAddress_.GetPort());
574     return obj;
575 }
576 
SetExtraOptionsCallback(TlsSocket::TLSSetExtraOptionsContext * context)577 napi_value TLSSocketServerExec::SetExtraOptionsCallback(TlsSocket::TLSSetExtraOptionsContext *context)
578 {
579     return NapiUtils::GetUndefined(context->GetEnv());
580 }
581 
ExecConnectionSend(TLSServerSendContext * context)582 bool TLSSocketServerExec::ExecConnectionSend(TLSServerSendContext *context)
583 {
584     auto manager = context->GetManager();
585     if (manager == nullptr) {
586         NETSTACK_LOGE("manager is nullptr");
587         return false;
588     }
589     auto tlsSocketServer = reinterpret_cast<TLSSocketServer *>(manager->GetData());
590     if (tlsSocketServer == nullptr) {
591         NETSTACK_LOGE("ExecSend tlsSocketServer is null");
592         context->SetError(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND,
593                           TlsSocket::MakeErrorMessage(TlsSocket::TlsSocketError::TLS_ERR_NO_BIND));
594         return false;
595     }
596     TLSServerSendOptions tcpSendOptions;
597     int client_id = context->clientId_;
598 
599     tcpSendOptions.SetSocket(client_id);
600     tcpSendOptions.SetSendData(context->m_sendData);
601     tlsSocketServer->Send(tcpSendOptions, [&context](int32_t errorNumber) {
602         context->errorNumber_ = errorNumber;
603         if (errorNumber != TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS) {
604             context->SetError(errorNumber, TlsSocket::MakeErrorMessage(errorNumber));
605         }
606     });
607     return context->errorNumber_ == TlsSocket::TlsSocketError::TLSSOCKET_SUCCESS;
608 }
609 
ConnectionSendCallback(TLSServerSendContext * context)610 napi_value TLSSocketServerExec::ConnectionSendCallback(TLSServerSendContext *context)
611 {
612     return NapiUtils::GetUndefined(context->GetEnv());
613 }
614 } // namespace TlsSocketServer
615 } // namespace NetStack
616 } // namespace OHOS
617