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 "cm_napi_common.h"
17
18 #include "securec.h"
19
20 #include "cm_log.h"
21 #include "cm_type.h"
22
23 namespace CMNapi {
24 namespace {
25 constexpr int CM_MAX_DATA_LEN = 0x6400000; // The maximum length is 100M
26 } // namespace
27
ParseUint32(napi_env env,napi_value object,uint32_t & store)28 napi_value ParseUint32(napi_env env, napi_value object, uint32_t &store)
29 {
30 napi_valuetype valueType;
31 napi_typeof(env, object, &valueType);
32 if (valueType != napi_number) {
33 CM_LOG_E("param type is not number");
34 return nullptr;
35 }
36 uint32_t temp = 0;
37 napi_get_value_uint32(env, object, &temp);
38 store = temp;
39 return GetInt32(env, 0);
40 }
41
ParseBoolean(napi_env env,napi_value object,bool & status)42 napi_value ParseBoolean(napi_env env, napi_value object, bool &status)
43 {
44 napi_valuetype valueType;
45 napi_typeof(env, object, &valueType);
46 if (valueType != napi_boolean) {
47 CM_LOG_E("param type is not bool");
48 return nullptr;
49 }
50 bool temp = false;
51 napi_get_value_bool(env, object, &temp);
52 status = temp;
53 return GetInt32(env, 0);
54 }
55
ParseString(napi_env env,napi_value object,CmBlob * & certUri)56 napi_value ParseString(napi_env env, napi_value object, CmBlob *&certUri)
57 {
58 napi_valuetype valueType = napi_undefined;
59 NAPI_CALL(env, napi_typeof(env, object, &valueType));
60 if (valueType != napi_string) {
61 CM_LOG_E("the type of param is not string");
62 return nullptr;
63 }
64 size_t length = 0;
65 napi_status status = napi_get_value_string_utf8(env, object, nullptr, 0, &length);
66 if (status != napi_ok) {
67 GET_AND_THROW_LAST_ERROR((env));
68 CM_LOG_E("could not get string length");
69 return nullptr;
70 }
71
72 if (length > CM_MAX_DATA_LEN) {
73 CM_LOG_E("input key alias length too large");
74 return nullptr;
75 }
76
77 char *data = static_cast<char *>(CmMalloc(length + 1));
78 if (data == nullptr) {
79 napi_throw_error(env, nullptr, "could not alloc memory");
80 CM_LOG_E("could not alloc memory");
81 return nullptr;
82 }
83 (void)memset_s(data, length + 1, 0, length + 1);
84
85 size_t result = 0;
86 status = napi_get_value_string_utf8(env, object, data, length + 1, &result);
87 if (status != napi_ok) {
88 CmFree(data);
89 GET_AND_THROW_LAST_ERROR((env));
90 CM_LOG_E("could not get string");
91 return nullptr;
92 }
93
94 certUri = static_cast<CmBlob *>(CmMalloc(sizeof(CmBlob)));
95 if (certUri == nullptr) {
96 CmFree(data);
97 napi_throw_error(env, nullptr, "could not alloc memory");
98 CM_LOG_E("could not alloc memory");
99 return nullptr;
100 }
101 certUri->data = reinterpret_cast<uint8_t *>(data);
102 certUri->size = static_cast<uint32_t>((length + 1) & UINT32_MAX);
103
104 return GetInt32(env, 0);
105 }
106
GetUint8Array(napi_env env,napi_value object,CmBlob & arrayBlob)107 napi_value GetUint8Array(napi_env env, napi_value object, CmBlob &arrayBlob)
108 {
109 napi_typedarray_type arrayType;
110 napi_value arrayBuffer = nullptr;
111 size_t length = 0;
112 size_t offset = 0;
113 void *rawData = nullptr;
114
115 napi_status status = napi_get_typedarray_info(
116 env, object, &arrayType, &length, static_cast<void **>(&rawData), &arrayBuffer, &offset);
117 if (status != napi_ok) {
118 CM_LOG_E("the type of param is not uint8_array");
119 return nullptr;
120 }
121 if (length > CM_MAX_DATA_LEN) {
122 CM_LOG_E("Data is too large, length = %x", length);
123 return nullptr;
124 }
125 if (length == 0) {
126 CM_LOG_D("The memory length created is only 1 Byte");
127 // The memory length created is only 1 Byte
128 arrayBlob.data = static_cast<uint8_t *>(CmMalloc(1));
129 } else {
130 arrayBlob.data = static_cast<uint8_t *>(CmMalloc(length));
131 }
132 if (arrayBlob.data == nullptr) {
133 CM_LOG_E("Malloc failed");
134 return nullptr;
135 }
136 (void)memset_s(arrayBlob.data, length, 0, length);
137 if (memcpy_s(arrayBlob.data, length, rawData, length) != EOK) {
138 CM_LOG_E("memcpy_s fail, length = %x", length);
139 return nullptr;
140 }
141 arrayBlob.size = static_cast<uint32_t>(length);
142
143 return GetInt32(env, 0);
144 }
145
GetCallback(napi_env env,napi_value object)146 napi_ref GetCallback(napi_env env, napi_value object)
147 {
148 napi_valuetype valueType = napi_undefined;
149 napi_status status = napi_typeof(env, object, &valueType);
150 if (status != napi_ok) {
151 CM_LOG_E("could not get object type");
152 return nullptr;
153 }
154
155 if (valueType != napi_function) {
156 CM_LOG_E("invalid type");
157 return nullptr;
158 }
159
160 napi_ref ref = nullptr;
161 status = napi_create_reference(env, object, 1, &ref);
162 if (status != napi_ok) {
163 CM_LOG_E("could not create reference");
164 return nullptr;
165 }
166 return ref;
167 }
168
GetCallback(napi_env env,napi_value object,napi_ref & callback)169 int32_t GetCallback(napi_env env, napi_value object, napi_ref &callback)
170 {
171 napi_valuetype valueType = napi_undefined;
172 napi_status status = napi_typeof(env, object, &valueType);
173 if (status != napi_ok) {
174 CM_LOG_E("could not get object type");
175 return CM_FAILURE;
176 }
177
178 if (valueType == napi_null || valueType == napi_undefined) {
179 CM_LOG_D("callback is null or undefined, treat as promise");
180 return CM_SUCCESS;
181 }
182
183 if (valueType != napi_function) {
184 CM_LOG_E("invalid type, not function");
185 return CM_FAILURE;
186 }
187
188 napi_ref ref = nullptr;
189 status = napi_create_reference(env, object, 1, &ref);
190 if (status != napi_ok) {
191 CM_LOG_E("could not create reference");
192 return CM_FAILURE;
193 }
194 callback = ref;
195 return CM_SUCCESS;
196 }
197
GenerateAarrayBuffer(napi_env env,uint8_t * data,uint32_t size)198 static napi_value GenerateAarrayBuffer(napi_env env, uint8_t *data, uint32_t size)
199 {
200 uint8_t *buffer = static_cast<uint8_t *>(CmMalloc(size));
201 if (buffer == nullptr) {
202 return nullptr;
203 }
204 (void)memcpy_s(buffer, size, data, size);
205
206 napi_value outBuffer = nullptr;
207 napi_status status = napi_create_external_arraybuffer(
208 env, buffer, size, [](napi_env env, void *data, void *hint) { CmFree(data); }, nullptr, &outBuffer);
209 if (status == napi_ok) {
210 // free by finalize callback
211 buffer = nullptr;
212 } else {
213 CmFree(buffer);
214 GET_AND_THROW_LAST_ERROR((env));
215 }
216
217 return outBuffer;
218 }
219
GenerateCertAbstractArray(napi_env env,const struct CertAbstract * certAbstract,const uint32_t certCount)220 napi_value GenerateCertAbstractArray(napi_env env, const struct CertAbstract *certAbstract, const uint32_t certCount)
221 {
222 if (certCount == 0 || certAbstract == nullptr) {
223 return nullptr;
224 }
225 napi_value array = nullptr;
226 NAPI_CALL(env, napi_create_array(env, &array));
227 for (uint32_t i = 0; i < certCount; i++) {
228 napi_value uri = nullptr;
229 napi_value certAlias = nullptr;
230 napi_value subjectName = nullptr;
231 napi_value status = nullptr;
232
233 napi_create_string_latin1(env, static_cast<const char *>(certAbstract[i].uri), NAPI_AUTO_LENGTH, &uri);
234 napi_create_string_latin1(env, static_cast<const char *>(certAbstract[i].certAlias),
235 NAPI_AUTO_LENGTH, &certAlias);
236 napi_create_string_latin1(env, static_cast<const char *>(certAbstract[i].subjectName),
237 NAPI_AUTO_LENGTH, &subjectName);
238 napi_get_boolean(env, certAbstract[i].status, &status);
239
240 napi_value element = nullptr;
241 napi_create_object(env, &element);
242 napi_set_named_property (env, element, CM_CERT_PROPERTY_URI.c_str(), uri);
243 napi_set_named_property (env, element, CM_CERT_PROPERTY_CERTALIAS.c_str(), certAlias);
244 napi_set_named_property (env, element, CM_CERT_PROPERTY_STATUS.c_str(), status);
245 napi_set_named_property (env, element, CM_CERT_PROPERTY_STATE.c_str(), status);
246 napi_set_named_property (env, element, CM_CERT_PROPERTY_SUBJECTNAME.c_str(), subjectName);
247
248 napi_set_element(env, array, i, element);
249 }
250 return array;
251 }
252
GenerateCredentialAbstractArray(napi_env env,const struct CredentialAbstract * credentialAbstract,const uint32_t credentialCount)253 napi_value GenerateCredentialAbstractArray(napi_env env,
254 const struct CredentialAbstract *credentialAbstract, const uint32_t credentialCount)
255 {
256 if (credentialCount == 0 || credentialAbstract == nullptr) {
257 return nullptr;
258 }
259 napi_value array = nullptr;
260 NAPI_CALL(env, napi_create_array(env, &array));
261 for (uint32_t i = 0; i < credentialCount; i++) {
262 napi_value type = nullptr;
263 napi_value alias = nullptr;
264 napi_value keyUri = nullptr;
265 napi_create_string_latin1(env, static_cast<const char *>(credentialAbstract[i].type),
266 NAPI_AUTO_LENGTH, &type);
267 napi_create_string_latin1(env, static_cast<const char *>(credentialAbstract[i].alias),
268 NAPI_AUTO_LENGTH, &alias);
269 napi_create_string_latin1(env, static_cast<const char *>(credentialAbstract[i].keyUri),
270 NAPI_AUTO_LENGTH, &keyUri);
271
272 napi_value element = nullptr;
273 napi_create_object(env, &element);
274 napi_set_named_property (env, element, CM_CERT_PROPERTY_TYPE.c_str(), type);
275 napi_set_named_property (env, element, CM_CERT_PROPERTY_CREDENTIAL_ALIAS.c_str(), alias);
276 napi_set_named_property (env, element, CM_CERT_PROPERTY_KEY_URI.c_str(), keyUri);
277
278 napi_set_element(env, array, i, element);
279 }
280 return array;
281 }
282
GenerateCertInfo(napi_env env,const struct CertInfo * certInfo)283 napi_value GenerateCertInfo(napi_env env, const struct CertInfo *certInfo)
284 {
285 if (certInfo == nullptr) {
286 return nullptr;
287 }
288 napi_value result = nullptr;
289 NAPI_CALL(env, napi_create_object(env, &result));
290
291 struct CertInfoValue cInfVal = { nullptr };
292 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->uri),
293 NAPI_AUTO_LENGTH, &cInfVal.uri));
294 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->certAlias),
295 NAPI_AUTO_LENGTH, &cInfVal.certAlias));
296 NAPI_CALL(env, napi_get_boolean(env, certInfo->status, &cInfVal.status));
297 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->issuerName),
298 NAPI_AUTO_LENGTH, &cInfVal.issuerName));
299 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->subjectName),
300 NAPI_AUTO_LENGTH, &cInfVal.subjectName));
301 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->serial),
302 NAPI_AUTO_LENGTH, &cInfVal.serial));
303 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->notBefore),
304 NAPI_AUTO_LENGTH, &cInfVal.notBefore));
305 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->notAfter),
306 NAPI_AUTO_LENGTH, &cInfVal.notAfter));
307 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(certInfo->fingerprintSha256),
308 NAPI_AUTO_LENGTH, &cInfVal.fingerprintSha256));
309
310 napi_value certBuffer = GenerateAarrayBuffer(env, certInfo->certInfo.data, certInfo->certInfo.size);
311 if (certBuffer != nullptr) {
312 NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, certInfo->certInfo.size,
313 certBuffer, 0, &cInfVal.certInfoBlob));
314 }
315
316 napi_value elem = nullptr;
317 NAPI_CALL(env, napi_create_object(env, &elem));
318 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_URI.c_str(), cInfVal.uri));
319 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_CERTALIAS.c_str(), cInfVal.certAlias));
320 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_STATUS.c_str(), cInfVal.status));
321 NAPI_CALL(env, napi_set_named_property (env, elem, CM_CERT_PROPERTY_STATE.c_str(), cInfVal.status));
322
323 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_ISSUERNAME.c_str(), cInfVal.issuerName));
324 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_SUBJECTNAME.c_str(), cInfVal.subjectName));
325 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_SERIAL.c_str(), cInfVal.serial));
326 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_BEFORE.c_str(), cInfVal.notBefore));
327 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_AFTER.c_str(), cInfVal.notAfter));
328 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_FINGERSHA256.c_str(),
329 cInfVal.fingerprintSha256));
330 NAPI_CALL(env, napi_set_named_property(env, elem, CM_CERT_PROPERTY_CERT_DATA.c_str(), cInfVal.certInfoBlob));
331
332 return elem;
333 }
334
TranformErrorCode(int32_t errorCode)335 int32_t TranformErrorCode(int32_t errorCode)
336 {
337 if (errorCode == CMR_ERROR_INVALID_CERT_FORMAT || errorCode == CMR_ERROR_INSUFFICIENT_DATA) {
338 return INVALID_CERT_FORMAT;
339 }
340 if (errorCode == CMR_ERROR_NOT_FOUND || errorCode == CMR_ERROR_NOT_EXIST) {
341 return NOT_FOUND;
342 }
343 if (errorCode == CMR_ERROR_PERMISSION_DENIED) {
344 return HAS_NO_PERMISSION;
345 }
346 if (errorCode == CMR_ERROR_NOT_SYSTEMP_APP) {
347 return NOT_SYSTEM_APP;
348 }
349 if (errorCode == CMR_ERROR_INVALID_ARGUMENT) {
350 return PARAM_ERROR;
351 }
352 return INNER_FAILURE;
353 }
354
GenerateBusinessError(napi_env env,int32_t errorCode,const char * errorMsg)355 napi_value GenerateBusinessError(napi_env env, int32_t errorCode, const char *errorMsg)
356 {
357 napi_value businessError = nullptr;
358 NAPI_CALL(env, napi_create_object(env, &businessError));
359
360 napi_value code = nullptr;
361 int32_t outCode = TranformErrorCode(errorCode);
362 NAPI_CALL(env, napi_create_int32(env, outCode, &code));
363 NAPI_CALL(env, napi_set_named_property(env, businessError, BUSINESS_ERROR_PROPERTY_CODE.c_str(), code));
364 napi_value message = nullptr;
365 NAPI_CALL(env, napi_create_string_utf8(env, errorMsg, NAPI_AUTO_LENGTH, &message));
366 NAPI_CALL(env, napi_set_named_property(env, businessError, BUSINESS_ERROR_PROPERTY_MESSAGE.c_str(), message));
367 return businessError;
368 }
369
ThrowParamsError(napi_env env,int32_t errorCode,std::string errMsg)370 void ThrowParamsError(napi_env env, int32_t errorCode, std::string errMsg)
371 {
372 napi_value paramsError = nullptr;
373 napi_value code = nullptr;
374 napi_value message = nullptr;
375 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, errorCode, &code));
376 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, errMsg.c_str(), NAPI_AUTO_LENGTH, &message));
377 NAPI_CALL_RETURN_VOID(env, napi_create_error(env, nullptr, message, ¶msError));
378 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, paramsError, BUSINESS_ERROR_PROPERTY_CODE.c_str(), code));
379 NAPI_CALL_RETURN_VOID(env, napi_throw(env, paramsError));
380 }
381
GenerateAppCertInfo(napi_env env,const struct Credential * credential)382 napi_value GenerateAppCertInfo(napi_env env, const struct Credential *credential)
383 {
384 if (credential == nullptr) {
385 return nullptr;
386 }
387 napi_value result = nullptr;
388 NAPI_CALL(env, napi_create_object(env, &result));
389 napi_value type = nullptr;
390 napi_value alias = nullptr;
391 napi_value keyUri = nullptr;
392 napi_value certNum = nullptr;
393 napi_value keyNum = nullptr;
394 napi_value credData = nullptr;
395 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(credential->type),
396 NAPI_AUTO_LENGTH, &type));
397 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(credential->alias),
398 NAPI_AUTO_LENGTH, &alias));
399 NAPI_CALL(env, napi_create_string_latin1(env, static_cast<const char *>(credential->keyUri),
400 NAPI_AUTO_LENGTH, &keyUri));
401
402 NAPI_CALL(env, napi_create_int32(env, credential->certNum, &certNum));
403 NAPI_CALL(env, napi_create_int32(env, credential->keyNum, &keyNum));
404
405 napi_value crendentialBuffer = GenerateAarrayBuffer(env, credential->credData.data, credential->credData.size);
406 if (crendentialBuffer != nullptr) {
407 NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, credential->credData.size,
408 crendentialBuffer, 0, &credData));
409 }
410
411 napi_value element = nullptr;
412 NAPI_CALL(env, napi_create_object(env, &element));
413 NAPI_CALL(env, napi_set_named_property(env, element, CM_CERT_PROPERTY_TYPE.c_str(), type));
414 NAPI_CALL(env, napi_set_named_property(env, element, CM_CERT_PROPERTY_CREDENTIAL_ALIAS.c_str(), alias));
415 NAPI_CALL(env, napi_set_named_property(env, element, CM_CERT_PROPERTY_KEY_URI.c_str(), keyUri));
416 NAPI_CALL(env, napi_set_named_property(env, element, CM_CERT_PROPERTY_CERT_NUM.c_str(), certNum));
417 NAPI_CALL(env, napi_set_named_property(env, element, CM_CERT_PROPERTY_KEY_NUM.c_str(), keyNum));
418
419 NAPI_CALL(env, napi_set_named_property(env, element, CM_CERT_PROPERTY_CREDENTIAL_DATA.c_str(), credData));
420 NAPI_CALL(env, napi_set_named_property(env, element, CM_CERT_PROPERTY_CREDENTIAL_DATA_NEW.c_str(), credData));
421 return element;
422 }
423
GeneratePromise(napi_env env,napi_deferred deferred,int32_t resultCode,napi_value * result,int32_t arrLength)424 void GeneratePromise(napi_env env, napi_deferred deferred, int32_t resultCode,
425 napi_value *result, int32_t arrLength)
426 {
427 if (arrLength < RESULT_NUMBER) {
428 return;
429 }
430 if (resultCode == CM_SUCCESS) {
431 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result[1]));
432 } else {
433 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, deferred, result[0]));
434 }
435 }
436
GenerateCallback(napi_env env,napi_ref callback,napi_value * result,int32_t arrLength,int32_t ret)437 void GenerateCallback(napi_env env, napi_ref callback, napi_value *result, int32_t arrLength, int32_t ret)
438 {
439 napi_value func = nullptr;
440 napi_value returnVal = nullptr;
441 if (arrLength < RESULT_NUMBER) {
442 return;
443 }
444 napi_value businessError = (ret == CM_SUCCESS) ? nullptr : result[0];
445 napi_value params[RESULT_NUMBER] = { businessError, result[1] };
446 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callback, &func));
447
448 napi_value recv = nullptr;
449 napi_get_undefined(env, &recv);
450 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, recv, func, RESULT_NUMBER, params, &returnVal));
451 }
452
GenerateNapiPromise(napi_env env,napi_ref callback,napi_deferred * deferred,napi_value * promise)453 void GenerateNapiPromise(napi_env env, napi_ref callback, napi_deferred *deferred, napi_value *promise)
454 {
455 if (callback == nullptr) {
456 NAPI_CALL_RETURN_VOID(env, napi_create_promise(env, deferred, promise));
457 } else {
458 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, promise));
459 }
460 }
461
DeleteNapiContext(napi_env env,napi_async_work & asyncWork,napi_ref & callback)462 void DeleteNapiContext(napi_env env, napi_async_work &asyncWork, napi_ref &callback)
463 {
464 if (asyncWork != nullptr) {
465 napi_delete_async_work(env, asyncWork);
466 asyncWork = nullptr;
467 }
468
469 if (callback != nullptr) {
470 napi_delete_reference(env, callback);
471 callback = nullptr;
472 }
473 }
474
FreeCmContext(CmContext * & context)475 void FreeCmContext(CmContext *&context)
476 {
477 if (context == nullptr) {
478 return;
479 }
480
481 context->userId = 0;
482 context->uid = 0;
483
484 CmFree(context);
485 context = nullptr;
486 }
487
FreeCertList(CertList * & certList)488 void FreeCertList(CertList *&certList)
489 {
490 if (certList == nullptr || certList->certAbstract == nullptr) {
491 return;
492 }
493
494 FreeCertAbstract(certList->certAbstract);
495 certList->certAbstract = nullptr;
496
497 CmFree(certList);
498 certList = nullptr;
499 }
500
FreeCredentialList(CredentialList * & credentialList)501 void FreeCredentialList(CredentialList *&credentialList)
502 {
503 if (credentialList == nullptr || credentialList->credentialAbstract == nullptr) {
504 return;
505 }
506
507 FreeCredentialAbstract(credentialList->credentialAbstract);
508 credentialList->credentialAbstract = nullptr;
509
510 CmFree(credentialList);
511 credentialList = nullptr;
512 }
513
FreeCertInfo(CertInfo * & certInfo)514 void FreeCertInfo(CertInfo *&certInfo)
515 {
516 if (certInfo == nullptr) {
517 return;
518 }
519
520 certInfo->status = false;
521
522 if (certInfo->certInfo.data != nullptr) {
523 CmFree(certInfo->certInfo.data);
524 }
525
526 CmFree(certInfo);
527 certInfo = nullptr;
528 }
529
FreeCredential(Credential * & credential)530 void FreeCredential(Credential *&credential)
531 {
532 if (credential == nullptr) {
533 return;
534 }
535
536 if (credential->credData.data != nullptr) {
537 CmFree(credential->credData.data);
538 }
539
540 CmFree(credential);
541 credential = nullptr;
542 }
543 } // namespace CertManagerNapi
544