1 /*
2  * Copyright (C) 2022-2024 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 "idm_file_manager.h"
17 
18 #include "securec.h"
19 
20 #include "adaptor_file.h"
21 #include "adaptor_log.h"
22 #include "adaptor_memory.h"
23 #include "buffer.h"
24 #include "idm_common.h"
25 
26 #define IDM_USER_INFO "/data/service/el1/public/userauth/userinfo"
27 #define GLOBAL_CONFIG_INFO "/data/service/el1/public/userauth/globalConfigInfo"
28 #define MAX_BUFFER_LEN 512000
29 #define DEFAULT_EXPANSION_RATIO 2
30 #define PRE_APPLY_LEN 2048
31 #define VERSION 0
32 
33 #ifdef IAM_TEST_ENABLE
34 #define IAM_STATIC
35 #else
36 #define IAM_STATIC static
37 #endif
38 
GetRemainSpace(const Buffer * object)39 IAM_STATIC uint32_t GetRemainSpace(const Buffer *object)
40 {
41     return object->maxSize - object->contentSize;
42 }
43 
GetStreamAddress(const Buffer * object)44 IAM_STATIC uint8_t *GetStreamAddress(const Buffer *object)
45 {
46     return object->buf + object->contentSize;
47 }
48 
CapacityExpansion(Buffer * object,uint32_t targetCapacity)49 IAM_STATIC ResultCode CapacityExpansion(Buffer *object, uint32_t targetCapacity)
50 {
51     if (!IsBufferValid(object) || object->maxSize > MAX_BUFFER_LEN / DEFAULT_EXPANSION_RATIO) {
52         LOG_ERROR("invalid params");
53         return RESULT_BAD_PARAM;
54     }
55     uint32_t targetSize = object->maxSize;
56     while (targetSize < targetCapacity && targetSize <= MAX_BUFFER_LEN / DEFAULT_EXPANSION_RATIO) {
57         targetSize = targetSize * DEFAULT_EXPANSION_RATIO;
58     }
59     if (targetSize < targetCapacity) {
60         LOG_ERROR("target capacity can not reach");
61         return RESULT_BAD_PARAM;
62     }
63     uint8_t *buf = Malloc(targetSize);
64     if (buf == NULL) {
65         LOG_ERROR("malloc failed");
66         return RESULT_NO_MEMORY;
67     }
68     if (memcpy_s(buf, targetSize, object->buf, object->contentSize) != EOK) {
69         LOG_ERROR("copy failed");
70         Free(buf);
71         return RESULT_NO_MEMORY;
72     }
73     Free(object->buf);
74     object->buf = buf;
75     object->maxSize = targetSize;
76     return RESULT_SUCCESS;
77 }
78 
StreamWrite(Buffer * parcel,void * from,uint32_t size)79 IAM_STATIC ResultCode StreamWrite(Buffer *parcel, void *from, uint32_t size)
80 {
81     if (!IsBufferValid(parcel) || from == NULL) {
82         LOG_ERROR("invalid params");
83         return RESULT_BAD_PARAM;
84     }
85     if (GetRemainSpace(parcel) < size) {
86         ResultCode result = CapacityExpansion(parcel, size);
87         if (result != RESULT_SUCCESS) {
88             LOG_ERROR("CapacityExpansion failed");
89             return result;
90         }
91     }
92     if (memcpy_s(GetStreamAddress(parcel), GetRemainSpace(parcel), from, size) != EOK) {
93         LOG_ERROR("copy failed");
94         return RESULT_NO_MEMORY;
95     }
96     parcel->contentSize += size;
97     return RESULT_SUCCESS;
98 }
99 
StreamWriteEnrolledInfo(Buffer * parcel,LinkedList * enrolledList)100 IAM_STATIC ResultCode StreamWriteEnrolledInfo(Buffer *parcel, LinkedList *enrolledList)
101 {
102     if (!IsBufferValid(parcel) || enrolledList == NULL) {
103         LOG_ERROR("invalid params");
104         return RESULT_BAD_PARAM;
105     }
106     uint32_t size = enrolledList->getSize(enrolledList);
107     ResultCode ret = StreamWrite(parcel, &size, sizeof(uint32_t));
108     if (ret != RESULT_SUCCESS) {
109         LOG_ERROR("StreamWrite failed");
110         return ret;
111     }
112     LinkedListNode *temp = enrolledList->head;
113     for (uint32_t i = 0; i < size; ++i) {
114         if (temp == NULL) {
115             LOG_ERROR("listSize is invalid");
116             return RESULT_BAD_PARAM;
117         }
118         if (StreamWrite(parcel, temp->data, sizeof(EnrolledInfoHal)) != RESULT_SUCCESS) {
119             LOG_ERROR("enrolledInfo streamWrite failed");
120             return RESULT_GENERAL_ERROR;
121         }
122         temp = temp->next;
123     }
124     return RESULT_SUCCESS;
125 }
126 
StreamWriteCredentialList(Buffer * parcel,LinkedList * credentialList)127 IAM_STATIC ResultCode StreamWriteCredentialList(Buffer *parcel, LinkedList *credentialList)
128 {
129     if (!IsBufferValid(parcel) || credentialList == NULL) {
130         LOG_ERROR("invalid params");
131         return RESULT_BAD_PARAM;
132     }
133     uint32_t size = credentialList->getSize(credentialList);
134     ResultCode ret = StreamWrite(parcel, &size, sizeof(uint32_t));
135     if (ret != RESULT_SUCCESS) {
136         LOG_ERROR("StreamWrite failed");
137         return ret;
138     }
139     LinkedListNode *temp = credentialList->head;
140     for (uint32_t i = 0; i < size; ++i) {
141         if (temp == NULL) {
142             LOG_ERROR("listSize is invalid");
143             return RESULT_BAD_PARAM;
144         }
145         if (StreamWrite(parcel, temp->data, sizeof(CredentialInfoHal)) != RESULT_SUCCESS) {
146             LOG_ERROR("credentialInfo streamWrite failed");
147             return RESULT_GENERAL_ERROR;
148         }
149         temp = temp->next;
150     }
151     return RESULT_SUCCESS;
152 }
153 
StreamWriteUserInfo(Buffer * parcel,UserInfo * userInfo)154 IAM_STATIC ResultCode StreamWriteUserInfo(Buffer *parcel, UserInfo *userInfo)
155 {
156     if (!IsBufferValid(parcel) || userInfo == NULL) {
157         LOG_ERROR("invalid params");
158         return RESULT_BAD_PARAM;
159     }
160     ResultCode result;
161     result = StreamWrite(parcel, &userInfo->userId, sizeof(int32_t));
162     if (result != RESULT_SUCCESS) {
163         LOG_ERROR("userId streamWrite failed");
164         return result;
165     }
166     LOG_INFO("userInfo userId %{public}d", userInfo->userId);
167     result = StreamWrite(parcel, &userInfo->userType, sizeof(int32_t));
168     if (result != RESULT_SUCCESS) {
169         LOG_ERROR("userType streamWrite failed");
170         return result;
171     }
172     LOG_INFO("userInfo userType %{public}d", userInfo->userType);
173     result = StreamWrite(parcel, &userInfo->secUid, sizeof(uint64_t));
174     if (result != RESULT_SUCCESS) {
175         LOG_ERROR("secUid streamWrite failed");
176         return result;
177     }
178     result = StreamWriteCredentialList(parcel, userInfo->credentialInfoList);
179     if (result != RESULT_SUCCESS) {
180         LOG_ERROR("credentialInfoList streamWrite failed");
181         return result;
182     }
183     result = StreamWriteEnrolledInfo(parcel, userInfo->enrolledInfoList);
184     if (result != RESULT_SUCCESS) {
185         LOG_ERROR("enrolledInfoList streamWrite failed");
186         return result;
187     }
188     return RESULT_SUCCESS;
189 }
190 
WriteUserInfo(LinkedList * userInfoList,Buffer * parcel)191 IAM_STATIC ResultCode WriteUserInfo(LinkedList *userInfoList, Buffer *parcel)
192 {
193     LinkedListNode *temp = userInfoList->head;
194     uint32_t size = userInfoList->getSize(userInfoList);
195     for (uint32_t i = 0; i < size; ++i) {
196         if (temp == NULL || temp->data == NULL) {
197             LOG_ERROR("temp is null");
198             return RESULT_NEED_INIT;
199         }
200         if (StreamWriteUserInfo(parcel, (UserInfo *)temp->data) != RESULT_SUCCESS) {
201             LOG_ERROR("StreamWriteUserInfo failed");
202             return RESULT_GENERAL_ERROR;
203         }
204         temp = temp->next;
205     }
206     return RESULT_SUCCESS;
207 }
208 
UpdateFileInfo(LinkedList * userInfoList)209 ResultCode UpdateFileInfo(LinkedList *userInfoList)
210 {
211     LOG_INFO("start");
212     if (userInfoList == NULL) {
213         LOG_ERROR("userInfo list is null");
214         return RESULT_BAD_PARAM;
215     }
216     Buffer *parcel = CreateBufferBySize(PRE_APPLY_LEN);
217     if (parcel == NULL) {
218         LOG_ERROR("parcel is null");
219         return RESULT_BAD_PARAM;
220     }
221     uint32_t version = VERSION;
222     ResultCode ret = StreamWrite(parcel, &version, sizeof(uint32_t));
223     if (ret != RESULT_SUCCESS) {
224         LOG_ERROR("StreamWrite failed");
225         goto EXIT;
226     }
227 
228     uint32_t size = userInfoList->getSize(userInfoList);
229     ret = StreamWrite(parcel, &size, sizeof(uint32_t));
230     if (ret != RESULT_SUCCESS) {
231         LOG_ERROR("StreamWrite failed");
232         goto EXIT;
233     }
234 
235     ret = WriteUserInfo(userInfoList, parcel);
236     if (ret != RESULT_SUCCESS) {
237         LOG_ERROR("WriteUserInfo failed");
238         goto EXIT;
239     }
240 
241     FileOperator *fileOperator = GetFileOperator(DEFAULT_FILE_OPERATOR);
242     if (!IsFileOperatorValid(fileOperator)) {
243         LOG_ERROR("invalid file operation");
244         ret = RESULT_BAD_WRITE;
245         goto EXIT;
246     }
247 
248     // This is for example only. Should be implemented in trusted environment.
249     ret = (ResultCode)fileOperator->writeFile(IDM_USER_INFO, parcel->buf, parcel->contentSize);
250     if (ret != RESULT_SUCCESS) {
251         LOG_ERROR("write file failed, %{public}u", parcel->contentSize);
252     }
253 
254 EXIT:
255     DestoryBuffer(parcel);
256     return ret;
257 }
258 
StreamWriteGlobalConfig(Buffer * parcel,GlobalConfigParamHal globalConfigInfo)259 IAM_STATIC ResultCode StreamWriteGlobalConfig(Buffer *parcel, GlobalConfigParamHal globalConfigInfo)
260 {
261     ResultCode result = StreamWrite(parcel, &(globalConfigInfo.type), sizeof(int32_t));
262     if (result != RESULT_SUCCESS) {
263         LOG_ERROR("StreamWrite global config type failed");
264         return RESULT_GENERAL_ERROR;
265     }
266     switch (globalConfigInfo.type) {
267         case PIN_EXPIRED_PERIOD:
268             result = StreamWrite(parcel, &(globalConfigInfo.value.pinExpiredPeriod), sizeof(int64_t));
269             break;
270         default:
271             LOG_ERROR("globalConfigType not support, type:%{public}d.", globalConfigInfo.type);
272             result = RESULT_GENERAL_ERROR;
273     }
274     if (result != RESULT_SUCCESS) {
275         LOG_ERROR("StreamWrite pinExpiredPeriod failed");
276         return RESULT_GENERAL_ERROR;
277     }
278     return RESULT_SUCCESS;
279 }
280 
UpdateGlobalConfigFile(GlobalConfigParamHal * globalConfigArray,uint32_t configInfoNum)281 ResultCode UpdateGlobalConfigFile(GlobalConfigParamHal *globalConfigArray, uint32_t configInfoNum)
282 {
283     LOG_INFO("start");
284     if (globalConfigArray == NULL) {
285         LOG_ERROR("globalConfigArray is null");
286         return RESULT_BAD_PARAM;
287     }
288     FileOperator *fileOperator = GetFileOperator(DEFAULT_FILE_OPERATOR);
289     if (!IsFileOperatorValid(fileOperator)) {
290         LOG_ERROR("invalid file operation");
291         return RESULT_GENERAL_ERROR;
292     }
293 
294     int32_t configInfoSize = sizeof(uint32_t) * 2 + sizeof(GlobalConfigParamHal) * MAX_GLOBAL_CONFIG_NUM;
295     Buffer *parcel = CreateBufferBySize(configInfoSize);
296     if (parcel == NULL) {
297         LOG_ERROR("parcel is null");
298         return RESULT_BAD_PARAM;
299     }
300     uint32_t version = VERSION;
301     ResultCode ret = StreamWrite(parcel, &version, sizeof(uint32_t));
302     if (ret != RESULT_SUCCESS) {
303         LOG_ERROR("StreamWrite failed");
304         DestoryBuffer(parcel);
305         return RESULT_GENERAL_ERROR;
306     }
307     ret = StreamWrite(parcel, &configInfoNum, sizeof(uint32_t));
308     if (ret != RESULT_SUCCESS) {
309         LOG_ERROR("StreamWrite failed");
310         DestoryBuffer(parcel);
311         return RESULT_GENERAL_ERROR;
312     }
313     for (uint32_t i = 0; i < configInfoNum; i++) {
314         ret = StreamWriteGlobalConfig(parcel, globalConfigArray[i]);
315         if (ret != RESULT_SUCCESS) {
316             LOG_ERROR("StreamWriteGlobalConfig failed");
317             DestoryBuffer(parcel);
318             return RESULT_GENERAL_ERROR;
319         }
320     }
321     // This is for example only. Should be implemented in trusted environment.
322     ret = (ResultCode)fileOperator->writeFile(GLOBAL_CONFIG_INFO, parcel->buf, parcel->contentSize);
323     if (ret != RESULT_SUCCESS) {
324         LOG_ERROR("write file failed, %{public}u", parcel->contentSize);
325     }
326     return ret;
327 }
328 
StreamRead(Buffer * parcel,uint32_t * index,void * to,uint32_t size)329 IAM_STATIC ResultCode StreamRead(Buffer *parcel, uint32_t *index, void *to, uint32_t size)
330 {
331     if (parcel->contentSize <= *index || parcel->contentSize - *index < size) {
332         LOG_ERROR("the buffer length is insufficient");
333         return RESULT_BAD_PARAM;
334     }
335     if (memcpy_s(to, size, parcel->buf + *index, size) != EOK) {
336         LOG_ERROR("copy failed");
337         return RESULT_NO_MEMORY;
338     }
339     *index += size;
340     return RESULT_SUCCESS;
341 }
342 
StreamReadCredentialList(Buffer * parcel,uint32_t * index,LinkedList * credentialList)343 IAM_STATIC ResultCode StreamReadCredentialList(Buffer *parcel, uint32_t *index, LinkedList *credentialList)
344 {
345     if (!IsBufferValid(parcel) || credentialList == NULL) {
346         LOG_ERROR("invalid params");
347         return RESULT_BAD_PARAM;
348     }
349     uint32_t credentialNum;
350     ResultCode result = StreamRead(parcel, index, &credentialNum, sizeof(uint32_t));
351     if (result != RESULT_SUCCESS) {
352         LOG_ERROR("stream read failed");
353         return RESULT_BAD_READ;
354     }
355     if (credentialNum > MAX_CREDENTIAL) {
356         LOG_ERROR("Bad credential num");
357         return RESULT_BAD_READ;
358     }
359     for (uint32_t i = 0; i < credentialNum; ++i) {
360         CredentialInfoHal *credentialInfo = Malloc(sizeof(CredentialInfoHal));
361         if (credentialInfo == NULL) {
362             LOG_ERROR("credentialInfo malloc failed");
363             return RESULT_NO_MEMORY;
364         }
365         result = StreamRead(parcel, index, credentialInfo, sizeof(CredentialInfoHal));
366         if (result != RESULT_SUCCESS) {
367             LOG_ERROR("StreamRead failed");
368             Free(credentialInfo);
369             return result;
370         }
371         result = credentialList->insert(credentialList, credentialInfo);
372         if (result != RESULT_SUCCESS) {
373             LOG_ERROR("credentialList insert failed");
374             Free(credentialInfo);
375             return result;
376         }
377     }
378     return RESULT_SUCCESS;
379 }
380 
StreamReadEnrolledList(Buffer * parcel,uint32_t * index,LinkedList * enrolledList)381 IAM_STATIC ResultCode StreamReadEnrolledList(Buffer *parcel, uint32_t *index, LinkedList *enrolledList)
382 {
383     if (!IsBufferValid(parcel) || enrolledList == NULL) {
384         LOG_ERROR("invalid params");
385         return RESULT_BAD_PARAM;
386     }
387     uint32_t enrolledNum;
388     ResultCode result = StreamRead(parcel, index, &enrolledNum, sizeof(uint32_t));
389     if (result != RESULT_SUCCESS) {
390         LOG_ERROR("stream read failed");
391         return RESULT_BAD_READ;
392     }
393     if (enrolledNum > MAX_CREDENTIAL) {
394         LOG_ERROR("bad enrolled num");
395         return RESULT_BAD_READ;
396     }
397     for (uint32_t i = 0; i < enrolledNum; ++i) {
398         EnrolledInfoHal *enrolledInfo = Malloc(sizeof(EnrolledInfoHal));
399         if (enrolledInfo == NULL) {
400             LOG_ERROR("enrolledInfo malloc failed");
401             return RESULT_NO_MEMORY;
402         }
403         result = StreamRead(parcel, index, enrolledInfo, sizeof(EnrolledInfoHal));
404         if (result != RESULT_SUCCESS) {
405             LOG_ERROR("StreamRead failed");
406             Free(enrolledInfo);
407             return result;
408         }
409         result = enrolledList->insert(enrolledList, enrolledInfo);
410         if (result != RESULT_SUCCESS) {
411             LOG_ERROR("enrolledList insert failed");
412             Free(enrolledInfo);
413             return result;
414         }
415     }
416     return RESULT_SUCCESS;
417 }
418 
StreamReadUserInfo(Buffer * parcel,uint32_t * index,UserInfo * userInfo)419 IAM_STATIC ResultCode StreamReadUserInfo(Buffer *parcel, uint32_t *index, UserInfo *userInfo)
420 {
421     ResultCode result = StreamRead(parcel, index, &userInfo->userId, sizeof(int32_t));
422     if (result != RESULT_SUCCESS) {
423         LOG_ERROR("Read userId failed");
424         return RESULT_GENERAL_ERROR;
425     }
426     LOG_INFO("userInfo userId %{public}d", userInfo->userId);
427     result = StreamRead(parcel, index, &userInfo->userType, sizeof(int32_t));
428     if (result != RESULT_SUCCESS) {
429         LOG_ERROR("Read userType failed");
430         return RESULT_GENERAL_ERROR;
431     }
432     LOG_INFO("userInfo userType %{public}d", userInfo->userType);
433     result = StreamRead(parcel, index, &userInfo->secUid, sizeof(uint64_t));
434     if (result != RESULT_SUCCESS) {
435         LOG_ERROR("Read secUid failed");
436         return RESULT_GENERAL_ERROR;
437     }
438     result = StreamReadCredentialList(parcel, index, userInfo->credentialInfoList);
439     if (result != RESULT_SUCCESS) {
440         LOG_ERROR("Read credentialInfoList failed");
441         return RESULT_GENERAL_ERROR;
442     }
443     result = StreamReadEnrolledList(parcel, index, userInfo->enrolledInfoList);
444     if (result != RESULT_SUCCESS) {
445         LOG_ERROR("Read enrolledInfoList failed");
446         return RESULT_GENERAL_ERROR;
447     }
448     return RESULT_SUCCESS;
449 }
450 
ReadFileInfo(void)451 IAM_STATIC Buffer *ReadFileInfo(void)
452 {
453     FileOperator *fileOperator = GetFileOperator(DEFAULT_FILE_OPERATOR);
454     if (!IsFileOperatorValid(fileOperator)) {
455         LOG_ERROR("invalid file operation");
456         return NULL;
457     }
458     uint32_t fileSize;
459     int32_t ret = fileOperator->getFileLen(IDM_USER_INFO, &fileSize);
460     if (ret != RESULT_SUCCESS) {
461         LOG_ERROR("open file failed");
462         return NULL;
463     }
464     Buffer *parcel = CreateBufferBySize(fileSize);
465     if (parcel == NULL) {
466         LOG_ERROR("parcel create failed");
467         return NULL;
468     }
469     if (fileOperator->readFile(IDM_USER_INFO, parcel->buf, parcel->maxSize) != RESULT_SUCCESS) {
470         LOG_ERROR("read failed");
471         DestoryBuffer(parcel);
472         return NULL;
473     }
474     parcel->contentSize = fileSize;
475     return parcel;
476 }
477 
StreamReadFileInfo(Buffer * parcel,LinkedList * userInfoList)478 IAM_STATIC bool StreamReadFileInfo(Buffer *parcel, LinkedList *userInfoList)
479 {
480     uint32_t index = 0;
481     uint32_t userNum;
482     uint32_t version;
483     ResultCode result = StreamRead(parcel, &index, &version, sizeof(uint32_t));
484     if (result != RESULT_SUCCESS) {
485         LOG_ERROR("read version failed");
486         return false;
487     }
488     result = StreamRead(parcel, &index, &userNum, sizeof(uint32_t));
489     if (result != RESULT_SUCCESS) {
490         LOG_ERROR("read userNum failed");
491         return false;
492     }
493     if (userNum > MAX_USER) {
494         LOG_ERROR("bad user num");
495         return false;
496     }
497     for (uint32_t i = 0; i < userNum; ++i) {
498         UserInfo *userInfo = InitUserInfoNode();
499         if (userInfo == NULL) {
500             LOG_ERROR("userInfoNode init failed");
501             return false;
502         }
503         result = StreamReadUserInfo(parcel, &index, userInfo);
504         if (result != RESULT_SUCCESS) {
505             LOG_ERROR("StreamRead failed");
506             DestroyUserInfoNode(userInfo);
507             return false;
508         }
509         result = userInfoList->insert(userInfoList, userInfo);
510         if (result != RESULT_SUCCESS) {
511             LOG_ERROR("userInfoList insert failed");
512             DestroyUserInfoNode(userInfo);
513             return false;
514         }
515     }
516     return true;
517 }
518 
LoadFileInfo(void)519 LinkedList *LoadFileInfo(void)
520 {
521     LOG_INFO("start");
522     FileOperator *fileOperator = GetFileOperator(DEFAULT_FILE_OPERATOR);
523     if (!IsFileOperatorValid(fileOperator)) {
524         LOG_ERROR("invalid file operation");
525         return NULL;
526     }
527     if (!fileOperator->isFileExist(IDM_USER_INFO)) {
528         LOG_ERROR("file is not exist");
529         return CreateLinkedList(DestroyUserInfoNode);
530     }
531     Buffer *parcel = ReadFileInfo();
532     if (parcel == NULL) {
533         LOG_ERROR("read file info failed");
534         return NULL;
535     }
536 
537     LinkedList *userInfoList = CreateLinkedList(DestroyUserInfoNode);
538     if (userInfoList == NULL) {
539         LOG_ERROR("list create failed");
540         DestoryBuffer(parcel);
541         return NULL;
542     }
543     if (!StreamReadFileInfo(parcel, userInfoList)) {
544         LOG_ERROR("StreamReadFileInfo failed");
545         DestoryBuffer(parcel);
546         DestroyLinkedList(userInfoList);
547         return NULL;
548     }
549     DestoryBuffer(parcel);
550     return userInfoList;
551 }
552 
ReadGlobalConfigFile(FileOperator * fileOperator)553 IAM_STATIC Buffer *ReadGlobalConfigFile(FileOperator *fileOperator)
554 {
555     uint32_t fileSize;
556     int32_t ret = fileOperator->getFileLen(GLOBAL_CONFIG_INFO, &fileSize);
557     if (ret != RESULT_SUCCESS) {
558         LOG_ERROR("open file failed");
559         return NULL;
560     }
561     Buffer *parcel = CreateBufferBySize(fileSize);
562     if (parcel == NULL) {
563         LOG_ERROR("parcel create failed");
564         DestoryBuffer(parcel);
565         return NULL;
566     }
567     if (fileOperator->readFile(GLOBAL_CONFIG_INFO, parcel->buf, parcel->maxSize) != RESULT_SUCCESS) {
568         LOG_ERROR("read failed");
569         DestoryBuffer(parcel);
570         return NULL;
571     }
572     parcel->contentSize = fileSize;
573     return parcel;
574 }
575 
StreamReadGlobalConfig(Buffer * parcel,uint32_t * index,GlobalConfigParamHal * globalConfigInfo)576 IAM_STATIC ResultCode StreamReadGlobalConfig(Buffer *parcel, uint32_t *index, GlobalConfigParamHal *globalConfigInfo)
577 {
578     ResultCode result = StreamRead(parcel, index, &(globalConfigInfo->type), sizeof(int32_t));
579     if (result != RESULT_SUCCESS) {
580         LOG_ERROR("read globalConfig type failed");
581         return RESULT_GENERAL_ERROR;
582     }
583     switch (globalConfigInfo->type) {
584         case PIN_EXPIRED_PERIOD:
585             result = StreamRead(parcel, index, &(globalConfigInfo->value.pinExpiredPeriod), sizeof(int64_t));
586             break;
587         default:
588             LOG_ERROR("globalConfigType not support, type:%{public}d.", globalConfigInfo->type);
589             result = RESULT_GENERAL_ERROR;
590     }
591     if (result != RESULT_SUCCESS) {
592         LOG_ERROR("read pinExpiredPeriod value failed");
593         return RESULT_GENERAL_ERROR;
594     }
595     return RESULT_SUCCESS;
596 }
597 
ReadGlobalConfigInfo(Buffer * parcel,GlobalConfigParamHal * globalConfigInfo,uint32_t * configInfoNum,uint32_t maxNum)598 IAM_STATIC ResultCode ReadGlobalConfigInfo(Buffer *parcel, GlobalConfigParamHal *globalConfigInfo,
599     uint32_t *configInfoNum, uint32_t maxNum)
600 {
601     uint32_t index = 0;
602     uint32_t version = 0;
603     ResultCode result = StreamRead(parcel, &index, &version, sizeof(uint32_t));
604     if (result != RESULT_SUCCESS) {
605         LOG_ERROR("read version failed");
606         return RESULT_GENERAL_ERROR;
607     }
608     result = StreamRead(parcel, &index, configInfoNum, sizeof(uint32_t));
609     if (result != RESULT_SUCCESS || (*configInfoNum) > maxNum) {
610         LOG_ERROR("read configInfoNum failed");
611         return RESULT_GENERAL_ERROR;
612     }
613     for (uint32_t i = 0; i < (*configInfoNum); i++) {
614         result = StreamReadGlobalConfig(parcel, &index, &globalConfigInfo[i]);
615         if (result != RESULT_SUCCESS) {
616             LOG_ERROR("read StreamReadExpiredPeriod failed");
617             return RESULT_GENERAL_ERROR;
618         }
619     }
620     return RESULT_SUCCESS;
621 }
622 
LoadGlobalConfigInfo(GlobalConfigParamHal * globalConfigInfo,uint32_t len,uint32_t * configInfoNum)623 ResultCode LoadGlobalConfigInfo(GlobalConfigParamHal *globalConfigInfo, uint32_t len, uint32_t *configInfoNum)
624 {
625     LOG_INFO("start");
626     if (globalConfigInfo == NULL || configInfoNum == NULL) {
627         LOG_ERROR("bad param");
628         return RESULT_BAD_PARAM;
629     }
630     (void)memset_s(globalConfigInfo, sizeof(GlobalConfigParamHal) * len, 0, sizeof(GlobalConfigParamHal) * len);
631     *configInfoNum = 0;
632     FileOperator *fileOperator = GetFileOperator(DEFAULT_FILE_OPERATOR);
633     if (!IsFileOperatorValid(fileOperator)) {
634         LOG_ERROR("invalid file operation");
635         return RESULT_GENERAL_ERROR;
636     }
637     if (!fileOperator->isFileExist(GLOBAL_CONFIG_INFO)) {
638         LOG_ERROR("file is not exist");
639         *configInfoNum = 0;
640         return RESULT_SUCCESS;
641     }
642     Buffer *parcel = ReadGlobalConfigFile(fileOperator);
643     if (parcel == NULL) {
644         LOG_ERROR("ReadGlobalConfigFile failed");
645         return RESULT_GENERAL_ERROR;
646     }
647     ResultCode ret = ReadGlobalConfigInfo(parcel, globalConfigInfo, configInfoNum, len);
648     if (ret != RESULT_SUCCESS) {
649         LOG_ERROR("ReadGlobalConfigInfo failed");
650         DestoryBuffer(parcel);
651         (void)memset_s(globalConfigInfo, sizeof(GlobalConfigParamHal) * len, 0, sizeof(GlobalConfigParamHal) * len);
652         *configInfoNum = 0;
653         return ret;
654     }
655     DestoryBuffer(parcel);
656     return RESULT_SUCCESS;
657 }