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