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 "hks_errcode_adapter.h"
17
18 #include <stddef.h>
19
20 #include "hks_type.h"
21
22 static const char *g_convertErrMsg = "HksConvertErrCode Failed.";
23
24 static struct HksError g_errCodeTable[] = {
25 {
26 .innerErrCode = HKS_SUCCESS,
27 .hksResult = {
28 .errorCode = HKS_SUCCESS,
29 .errorMsg = "Success.",
30 .data = NULL
31 }
32 }, {
33 .innerErrCode = HKS_ERROR_NO_PERMISSION,
34 .hksResult = {
35 .errorCode = HUKS_ERR_CODE_PERMISSION_FAIL,
36 .errorMsg = "Permission check failed. Apply for the required permissions first.",
37 .data = NULL
38 }
39 }, {
40 .innerErrCode = HKS_ERROR_INVALID_ARGUMENT,
41 .hksResult = {
42 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
43 .errorMsg = "Invalid parameters.",
44 .data = NULL
45 }
46 }, {
47 .innerErrCode = HKS_ERROR_INSUFFICIENT_DATA,
48 .hksResult = {
49 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
50 .errorMsg = "Some input parameters are not set.",
51 .data = NULL
52 }
53 }, {
54 .innerErrCode = HKS_ERROR_BUFFER_TOO_SMALL,
55 .hksResult = {
56 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
57 .errorMsg = "Insufficient buffer size.",
58 .data = NULL
59 }
60 }, {
61 .innerErrCode = HKS_ERROR_NULL_POINTER,
62 .hksResult = {
63 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
64 .errorMsg = "The parameter value cannot be null.",
65 .data = NULL
66 }
67 }, {
68 .innerErrCode = HKS_ERROR_INVALID_PUBLIC_KEY,
69 .hksResult = {
70 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
71 .errorMsg = "Invalid public key.",
72 .data = NULL
73 }
74 }, {
75 .innerErrCode = HKS_ERROR_INVALID_KEY_INFO,
76 .hksResult = {
77 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
78 .errorMsg = "Invalid key information.",
79 .data = NULL
80 }
81 }, {
82 .innerErrCode = HKS_ERROR_PARAM_NOT_EXIST,
83 .hksResult = {
84 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
85 .errorMsg = "The parameter does not exist.",
86 .data = NULL
87 }
88 }, {
89 .innerErrCode = HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST,
90 .hksResult = {
91 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
92 .errorMsg = "The root key material already exists.",
93 .data = NULL
94 }
95 }, {
96 .innerErrCode = HKS_ERROR_INVALID_WRAPPED_FORMAT,
97 .hksResult = {
98 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
99 .errorMsg = "The wrapped key data is in invalid format.",
100 .data = NULL
101 }
102 }, {
103 .innerErrCode = HKS_ERROR_CHECK_GET_AUTH_TYP_FAILED,
104 .hksResult = {
105 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
106 .errorMsg = "Failed to obtain the authentication type. It is not set in ParamSet.",
107 .data = NULL
108 }
109 }, {
110 .innerErrCode = HKS_ERROR_CHECK_GET_CHALLENGE_TYPE_FAILED,
111 .hksResult = {
112 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
113 .errorMsg = "Failed to obtain the challenge type. It is not set in ParamSet.",
114 .data = NULL
115 }
116 }, {
117 .innerErrCode = HKS_ERROR_CHECK_GET_ACCESS_TYPE_FAILED,
118 .hksResult = {
119 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
120 .errorMsg = "Failed to obtain the access type. It is not set in ParamSet.",
121 .data = NULL
122 }
123 }, {
124 .innerErrCode = HKS_ERROR_CHECK_GET_AUTH_TOKEN_FAILED,
125 .hksResult = {
126 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
127 .errorMsg = "Failed to obtain the authentication token. It is not set in ParamSet.",
128 .data = NULL
129 }
130 }, {
131 .innerErrCode = HKS_ERROR_INVALID_TIME_OUT,
132 .hksResult = {
133 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
134 .errorMsg = "Invalid timeout parameter.",
135 .data = NULL
136 }
137 }, {
138 .innerErrCode = HKS_ERROR_INVALID_AUTH_TYPE,
139 .hksResult = {
140 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
141 .errorMsg = "Invalid authentication type.",
142 .data = NULL
143 }
144 }, {
145 .innerErrCode = HKS_ERROR_INVALID_CHALLENGE_TYPE,
146 .hksResult = {
147 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
148 .errorMsg = "Invalid challenge type.",
149 .data = NULL
150 }
151 }, {
152 .innerErrCode = HKS_ERROR_INVALID_ACCESS_TYPE,
153 .hksResult = {
154 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
155 .errorMsg = "Invalid access type.",
156 .data = NULL
157 }
158 }, {
159 .innerErrCode = HKS_ERROR_INVALID_AUTH_TOKEN,
160 .hksResult = {
161 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
162 .errorMsg = "Invalid authentication token.",
163 .data = NULL
164 }
165 }, {
166 .innerErrCode = HKS_ERROR_INVALID_SECURE_SIGN_TYPE,
167 .hksResult = {
168 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
169 .errorMsg = "Invalid secure sign type.",
170 .data = NULL
171 }
172 }, {
173 .innerErrCode = HKS_ERROR_API_NOT_SUPPORTED,
174 .hksResult = {
175 .errorCode = HUKS_ERR_CODE_NOT_SUPPORTED_API,
176 .errorMsg = "This API is not supported.",
177 .data = NULL
178 }
179 }, {
180 .innerErrCode = HKS_ERROR_NOT_SUPPORTED,
181 .hksResult = {
182 .errorCode = HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED,
183 .errorMsg = "The feature is not support.",
184 .data = NULL
185 }
186 }, {
187 .innerErrCode = HKS_ERROR_USER_AUTH_TYPE_NOT_SUPPORT,
188 .hksResult = {
189 .errorCode = HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED,
190 .errorMsg = "The user authentication type is not supported.",
191 .data = NULL
192 }
193 }, {
194 .innerErrCode = HKS_ERROR_CHECK_GET_ALG_FAIL,
195 .hksResult = {
196 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
197 .errorMsg = "Failed to obtain the algorithm. It is not set in ParamSet.",
198 .data = NULL
199 }
200 }, {
201 .innerErrCode = HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL,
202 .hksResult = {
203 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
204 .errorMsg = "Failed to obtain the key size. It is not set in ParamSet.",
205 .data = NULL
206 }
207 }, {
208 .innerErrCode = HKS_ERROR_CHECK_GET_PADDING_FAIL,
209 .hksResult = {
210 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
211 .errorMsg = "Failed to obtain the padding algorithm. It is not set in ParamSet.",
212 .data = NULL
213 }
214 }, {
215 .innerErrCode = HKS_ERROR_CHECK_GET_PURPOSE_FAIL,
216 .hksResult = {
217 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
218 .errorMsg = "Failed to obtain the key purpose. It is not set in ParamSet.",
219 .data = NULL
220 }
221 }, {
222 .innerErrCode = HKS_ERROR_CHECK_GET_DIGEST_FAIL,
223 .hksResult = {
224 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
225 .errorMsg = "Failed to obtain the digest algorithm. It is not set in ParamSet.",
226 .data = NULL
227 }
228 }, {
229 .innerErrCode = HKS_ERROR_CHECK_GET_MODE_FAIL,
230 .hksResult = {
231 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
232 .errorMsg = "Failed to obtain the cipher mode. It is not set in ParamSet.",
233 .data = NULL
234 }
235 }, {
236 .innerErrCode = HKS_ERROR_CHECK_GET_NONCE_FAIL,
237 .hksResult = {
238 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
239 .errorMsg = "Failed to obtain the nonce. It is not set in ParamSet.",
240 .data = NULL
241 }
242 }, {
243 .innerErrCode = HKS_ERROR_CHECK_GET_AAD_FAIL,
244 .hksResult = {
245 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
246 .errorMsg = "Failed to obtain the AAD. It is not set in ParamSet.",
247 .data = NULL
248 }
249 }, {
250 .innerErrCode = HKS_ERROR_CHECK_GET_IV_FAIL,
251 .hksResult = {
252 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
253 .errorMsg = "Failed to obtain the IV. It is not set in ParamSet.",
254 .data = NULL
255 }
256 }, {
257 .innerErrCode = HKS_ERROR_CHECK_GET_AE_TAG_FAIL,
258 .hksResult = {
259 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
260 .errorMsg = "Failed to obtain the AEAD. It is not set in ParamSet.",
261 .data = NULL
262 }
263 }, {
264 .innerErrCode = HKS_ERROR_CHECK_GET_SALT_FAIL,
265 .hksResult = {
266 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
267 .errorMsg = "Failed to obtain the salt value. It is not set in ParamSet.",
268 .data = NULL
269 }
270 }, {
271 .innerErrCode = HKS_ERROR_CHECK_GET_ITERATION_FAIL,
272 .hksResult = {
273 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
274 .errorMsg = "Failed to obtain the number of iterations. It is not set in ParamSet.",
275 .data = NULL
276 }
277 }, {
278 .innerErrCode = HKS_ERROR_INVALID_ALGORITHM,
279 .hksResult = {
280 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
281 .errorMsg = "Invalid algorithm.",
282 .data = NULL
283 }
284 }, {
285 .innerErrCode = HKS_ERROR_INVALID_KEY_SIZE,
286 .hksResult = {
287 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
288 .errorMsg = "Invalid key size.",
289 .data = NULL
290 }
291 }, {
292 .innerErrCode = HKS_ERROR_INVALID_PADDING,
293 .hksResult = {
294 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
295 .errorMsg = "Invalid padding algorithm.",
296 .data = NULL
297 }
298 }, {
299 .innerErrCode = HKS_ERROR_INVALID_PURPOSE,
300 .hksResult = {
301 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
302 .errorMsg = "Invalid key purpose.",
303 .data = NULL
304 }
305 }, {
306 .innerErrCode = HKS_ERROR_INVALID_MODE,
307 .hksResult = {
308 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
309 .errorMsg = "Invalid cipher mode.",
310 .data = NULL
311 }
312 }, {
313 .innerErrCode = HKS_ERROR_INVALID_DIGEST,
314 .hksResult = {
315 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
316 .errorMsg = "Invalid digest algorithm.",
317 .data = NULL
318 }
319 }, {
320 .innerErrCode = HKS_ERROR_INVALID_SIGNATURE_SIZE,
321 .hksResult = {
322 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
323 .errorMsg = "Invalid signature size.",
324 .data = NULL
325 }
326 }, {
327 .innerErrCode = HKS_ERROR_INVALID_IV,
328 .hksResult = {
329 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
330 .errorMsg = "Invalid IV.",
331 .data = NULL
332 }
333 }, {
334 .innerErrCode = HKS_ERROR_INVALID_AAD,
335 .hksResult = {
336 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
337 .errorMsg = "Invalid AAD.",
338 .data = NULL
339 }
340 }, {
341 .innerErrCode = HKS_ERROR_INVALID_NONCE,
342 .hksResult = {
343 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
344 .errorMsg = "Invalid nonce.",
345 .data = NULL
346 }
347 }, {
348 .innerErrCode = HKS_ERROR_INVALID_AE_TAG,
349 .hksResult = {
350 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
351 .errorMsg = "Invalid AE.",
352 .data = NULL
353 }
354 }, {
355 .innerErrCode = HKS_ERROR_INVALID_SALT,
356 .hksResult = {
357 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
358 .errorMsg = "Invalid salt value.",
359 .data = NULL
360 }
361 }, {
362 .innerErrCode = HKS_ERROR_INVALID_ITERATION,
363 .hksResult = {
364 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
365 .errorMsg = "Invalid iteration count.",
366 .data = NULL
367 }
368 }, {
369 .innerErrCode = HKS_ERROR_INVALID_USAGE_OF_KEY,
370 .hksResult = {
371 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
372 .errorMsg = "Invalid key purpose.",
373 .data = NULL
374 }
375 }, {
376 .innerErrCode = HKS_ERROR_STORAGE_FAILURE,
377 .hksResult = {
378 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
379 .errorMsg = "Insufficient storage space.",
380 .data = NULL
381 }
382 }, {
383 .innerErrCode = HKS_ERROR_FILE_SIZE_FAIL,
384 .hksResult = {
385 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
386 .errorMsg = "Invalid file size.",
387 .data = NULL
388 }
389 }, {
390 .innerErrCode = HKS_ERROR_READ_FILE_FAIL,
391 .hksResult = {
392 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
393 .errorMsg = "Failed to read the file.",
394 .data = NULL
395 }
396 }, {
397 .innerErrCode = HKS_ERROR_WRITE_FILE_FAIL,
398 .hksResult = {
399 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
400 .errorMsg = "Failed to write the file.",
401 .data = NULL
402 }
403 }, {
404 .innerErrCode = HKS_ERROR_REMOVE_FILE_FAIL,
405 .hksResult = {
406 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
407 .errorMsg = "Failed to remove the file.",
408 .data = NULL
409 }
410 }, {
411 .innerErrCode = HKS_ERROR_OPEN_FILE_FAIL,
412 .hksResult = {
413 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
414 .errorMsg = "Failed to open the file.",
415 .data = NULL
416 }
417 }, {
418 .innerErrCode = HKS_ERROR_CLOSE_FILE_FAIL,
419 .hksResult = {
420 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
421 .errorMsg = "Failed to close the file.",
422 .data = NULL
423 }
424 }, {
425 .innerErrCode = HKS_ERROR_MAKE_DIR_FAIL,
426 .hksResult = {
427 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
428 .errorMsg = "Failed to create the directory.",
429 .data = NULL
430 }
431 }, {
432 .innerErrCode = HKS_ERROR_INVALID_KEY_FILE,
433 .hksResult = {
434 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
435 .errorMsg = "Failed to read the key from an invalid key file.",
436 .data = NULL
437 }
438 }, {
439 .innerErrCode = HKS_ERROR_IPC_MSG_FAIL,
440 .hksResult = {
441 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
442 .errorMsg = "Failed to get message from IPC.",
443 .data = NULL
444 }
445 }, {
446 .innerErrCode = HKS_ERROR_COMMUNICATION_TIMEOUT,
447 .hksResult = {
448 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
449 .errorMsg = "IPC timed out.",
450 .data = NULL
451 }
452 }, {
453 .innerErrCode = HKS_ERROR_IPC_INIT_FAIL,
454 .hksResult = {
455 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
456 .errorMsg = "IPC initialization failed.",
457 .data = NULL
458 }
459 }, {
460 .innerErrCode = HKS_ERROR_UNKNOWN_ERROR,
461 .hksResult = {
462 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
463 .errorMsg = "IPC async call failed.",
464 .data = NULL
465 }
466 }, {
467 .innerErrCode = HKS_ERROR_CRYPTO_ENGINE_ERROR,
468 .hksResult = {
469 .errorCode = HUKS_ERR_CODE_CRYPTO_FAIL,
470 .errorMsg = "Crypto engine error.",
471 .data = NULL
472 }
473 }, {
474 .innerErrCode = HKS_ERROR_KEY_AUTH_PERMANENTLY_INVALIDATED,
475 .hksResult = {
476 .errorCode = HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED,
477 .errorMsg = "This credential is invalidated permanently.",
478 .data = NULL
479 }
480 }, {
481 .innerErrCode = HKS_ERROR_KEY_AUTH_VERIFY_FAILED,
482 .hksResult = {
483 .errorCode = HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED,
484 .errorMsg = "The authentication token verification failed.",
485 .data = NULL
486 }
487 }, {
488 .innerErrCode = HKS_ERROR_KEY_AUTH_TIME_OUT,
489 .hksResult = {
490 .errorCode = HUKS_ERR_CODE_KEY_AUTH_TIME_OUT,
491 .errorMsg = "This authentication token timed out.",
492 .data = NULL
493 }
494 }, {
495 .innerErrCode = HKS_ERROR_SESSION_REACHED_LIMIT,
496 .hksResult = {
497 .errorCode = HUKS_ERR_CODE_SESSION_LIMIT,
498 .errorMsg = "The number of key operation sessions has reached the limit.",
499 .data = NULL
500 }
501 }, {
502 .innerErrCode = HKS_ERROR_NOT_EXIST,
503 .hksResult = {
504 .errorCode = HUKS_ERR_CODE_ITEM_NOT_EXIST,
505 .errorMsg = "The entity does not exist.",
506 .data = NULL
507 }
508 }, {
509 .innerErrCode = HKS_FAILURE,
510 .hksResult = {
511 .errorCode = HUKS_ERR_CODE_EXTERNAL_ERROR,
512 .errorMsg = "System external error.",
513 .data = NULL
514 }
515 }, {
516 .innerErrCode = HKS_ERROR_BAD_STATE,
517 .hksResult = {
518 .errorCode = HUKS_ERR_CODE_EXTERNAL_ERROR,
519 .errorMsg = "System external error.",
520 .data = NULL
521 }
522 }, {
523 .innerErrCode = HKS_ERROR_INTERNAL_ERROR,
524 .hksResult = {
525 .errorCode = HUKS_ERR_CODE_EXTERNAL_ERROR,
526 .errorMsg = "System external error.",
527 .data = NULL
528 }
529 }, {
530 .innerErrCode = HKS_ERROR_CREDENTIAL_NOT_EXIST,
531 .hksResult = {
532 .errorCode = HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST,
533 .errorMsg = "The credential does not exist.",
534 .data = NULL
535 }
536 }, {
537 .innerErrCode = HKS_ERROR_INSUFFICIENT_MEMORY,
538 .hksResult = {
539 .errorCode = HUKS_ERR_CODE_INSUFFICIENT_MEMORY,
540 .errorMsg = "Insufficient memory.",
541 .data = NULL
542 }
543 }, {
544 .innerErrCode = HKS_ERROR_MALLOC_FAIL,
545 .hksResult = {
546 .errorCode = HUKS_ERR_CODE_INSUFFICIENT_MEMORY,
547 .errorMsg = "Malloc failed.",
548 .data = NULL
549 }
550 }, {
551 .innerErrCode = HKS_ERROR_GET_USERIAM_SECINFO_FAILED,
552 .hksResult = {
553 .errorCode = HUKS_ERR_CODE_CALL_SERVICE_FAILED,
554 .errorMsg = "Failed to obtain the security information via UserIAM.",
555 .data = NULL
556 }
557 }, {
558 .innerErrCode = HKS_ERROR_GET_USERIAM_AUTHINFO_FAILED,
559 .hksResult = {
560 .errorCode = HUKS_ERR_CODE_CALL_SERVICE_FAILED,
561 .errorMsg = "Failed to obtain the authentication information via UserIAM.",
562 .data = NULL
563 }
564 }
565 };
566
567 /**
568 * Convert ErrCode.
569 * Convert internal error code to formal error code and return.
570 * Return HUKS_ERR_CODE_EXTERNAL_ERROR in case of converting failed.
571 */
HksConvertErrCode(int32_t ret)572 struct HksResult HksConvertErrCode(int32_t ret)
573 {
574 struct HksResult result = {HUKS_ERR_CODE_EXTERNAL_ERROR, g_convertErrMsg, NULL};
575 uint32_t i = 0;
576 uint32_t uErrCodeCount = sizeof(g_errCodeTable) / sizeof(g_errCodeTable[0]);
577 for (; i < uErrCodeCount; ++i) {
578 if (ret == g_errCodeTable[i].innerErrCode) {
579 return g_errCodeTable[i].hksResult;
580 }
581 }
582 return result;
583 }
584
585