1 /*
2  * Copyright (c) 2021-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 <stdio.h>
17 #include <stdint.h>
18 #include <stdlib.h>
19 #include <errno.h>
20 #include <string.h>
21 #include <limits.h>
22 #include <sys/stat.h>
23 #include "securec.h"
24 #include "cJSON.h"
25 #include "endian_internal.h"
26 #include "create_pcid.h"
27 #include "context_tool.h"
28 #include "common_method.h"
29 
30 #ifdef SYSCAP_DEFINE_EXTERN_ENABLE
31 #include "syscap_define_custom.h"
32 #else
33 #include "syscap_define.h"
34 #endif
35 
36 #define SYSCAP_PREFIX_LEN 17
37 #define SINGLE_FEAT_LEN (SINGLE_SYSCAP_LEN - SYSCAP_PREFIX_LEN)
38 #define PCID_OUT_BUFFER 32
39 #define PRIVATE_SYSCAP_SIZE 1000
40 #define UINT8_BIT 8
41 
42 #define U32_TO_STR_MAX_LEN 11
43 #define FREE_CREATE_PCID_BUFFER_OUT 1
44 
45 #define FREE_DECODE_PCID_CONVERT_OUT 1
46 #define FREE_DECODE_PCID_ROOT_OUT 2
47 #define FREE_DECODE_PCID_SYSCAP_OUT 3
48 #define FREE_DECODE_PCID_CONTEXT_OUT 4
49 
50 #define ENCODE_PCID_OUTPUT 1
51 #define FREE_ENCODE_PCID_OUT 2
52 #define FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT 3
53 #define FREE_ENCODE_PCID_CONTEXT_OUT 4
54 
55 struct FreeEncodePcidInfo {
56     char *output;
57     char *priSyscapFull;
58     char *contextBuffer;
59     char *outDirPathFinal;
60 };
61 
62 struct FreeDecodePcidJsonInfo {
63     char *strJson;
64     char *contextBuffer;
65     cJSON *jsonRootObj;
66     cJSON *sysCapObj;
67     int32_t flag;
68 };
69 
SetOsSyscap(PCIDMain *pcidBuffer, uint32_t osCapSize, const cJSON *jsonOsSyscapObj, const cJSON *allOsSyscapObj)70 int32_t SetOsSyscap(PCIDMain *pcidBuffer, uint32_t osCapSize,
71                     const cJSON *jsonOsSyscapObj, const cJSON *allOsSyscapObj)
72 {
73     int32_t sectorOfBits, posOfBits;
74     cJSON *jsonArrayItem = NULL;
75     cJSON *osCapIndex = NULL;
76 
77     for (uint32_t i = 0; i < osCapSize; i++) {
78         jsonArrayItem = cJSON_GetArrayItem(jsonOsSyscapObj, (int)i);
79         if (jsonArrayItem == NULL || !cJSON_IsString(jsonArrayItem)) {
80             PRINT_ERR("Get jsonArrayItem failed.");
81             return -1;
82         }
83         osCapIndex = cJSON_GetObjectItem(allOsSyscapObj, jsonArrayItem->valuestring);
84         if (osCapIndex == NULL) {
85             PRINT_ERR("can't find the syscap: %s, please add it in syscap_define.h.\n", jsonArrayItem->valuestring);
86             return -1;
87         }
88         if (!cJSON_IsNumber(osCapIndex)) {
89             PRINT_ERR("Get osCapIndex failed.");
90             return -1;
91         }
92         sectorOfBits = (osCapIndex->valueint) / UINT8_BIT;
93         posOfBits = (osCapIndex->valueint) % UINT8_BIT;
94         if (sectorOfBits >= OS_SYSCAP_BYTES) {
95             PRINT_ERR("num of \"os syscap\" is out of 960\n");
96             return -1;
97         }
98         pcidBuffer->osSyscap[sectorOfBits] |= 1 << (posOfBits);
99     }
100 
101     return 0;
102 }
103 
SetPriSyscap(PCIDMain *pcidBuffer, cJSON *jsonPriSyscapObj, uint32_t privateCapSize, uint16_t allPriSyscapStrLen)104 int32_t SetPriSyscap(PCIDMain *pcidBuffer, cJSON *jsonPriSyscapObj,
105                      uint32_t privateCapSize, uint16_t allPriSyscapStrLen)
106 {
107     char *priSyscapHead = (char *)(pcidBuffer + 1);
108     char *priSyscapStr = NULL;
109     for (uint32_t i = 0; i < privateCapSize; i++) {
110         cJSON *jsonArrayItem = cJSON_GetArrayItem(jsonPriSyscapObj, (int)i);
111         if (jsonArrayItem == NULL || !cJSON_IsString(jsonArrayItem)) {
112             PRINT_ERR("get jsonArrayItem failed!");
113             return -1;
114         }
115         priSyscapStr = strchr(jsonArrayItem->valuestring, '.');
116         if (priSyscapStr == NULL) {
117             PRINT_ERR("get priSyscapStr failed!");
118             return -1;
119         }
120         priSyscapStr += 1;
121         errno_t nRet = strcat_s(priSyscapHead, allPriSyscapStrLen + 1, priSyscapStr);
122         nRet += strcat_s(priSyscapHead, allPriSyscapStrLen + 1, ",");
123         if (nRet != EOK) {
124             PRINT_ERR("strcat_s \"pri\" string is failed\n");
125             return -1;
126         }
127     }
128     return 0;
129 }
130 
SetPCIDHeader(PCIDMain *pcidBuffer, const cJSON *jsonRootObj)131 int32_t SetPCIDHeader(PCIDMain *pcidBuffer, const cJSON *jsonRootObj)
132 {
133     cJSON *jsonSyscapObj = cJSON_GetObjectItem(jsonRootObj, "api_version");
134     if (jsonSyscapObj == NULL || !cJSON_IsNumber(jsonSyscapObj)) {
135         PRINT_ERR("get \"api_version\" failed\n");
136         return -1;
137     }
138     pcidBuffer->apiVersion = HtonsInter((uint16_t)jsonSyscapObj->valueint);
139     pcidBuffer->apiVersionType = 0;
140 
141     jsonSyscapObj = cJSON_GetObjectItem(jsonRootObj, "system_type");
142     if (jsonSyscapObj == NULL || !cJSON_IsString(jsonSyscapObj)) {
143         PRINT_ERR("get \"system_type\" failed\n");
144         return -1;
145     }
146     char *systemType = jsonSyscapObj->valuestring;
147     pcidBuffer->systemType = !strcmp(systemType, "mini") ? 0b001 :
148                              (!strcmp(systemType, "small") ? 0b010 :
149                               (!strcmp(systemType, "standard") ? 0b100 : 0));
150     if (pcidBuffer->systemType == 0) {
151         PRINT_ERR("\"system_type\" is invaild, systemType = \"%s\"\n", systemType);
152         return -1;
153     }
154 
155     jsonSyscapObj = cJSON_GetObjectItem(jsonRootObj, "manufacturer_id");
156     if (jsonSyscapObj == NULL || !cJSON_IsNumber(jsonSyscapObj)) {
157         PRINT_ERR("get \"manufacturer_id\" failed\n");
158         return -1;
159     }
160     pcidBuffer->manufacturerID = HtonlInter((uint32_t)jsonSyscapObj->valueint);
161 
162     return 0;
163 }
164 
GetOsAndPriSyscapSize(const cJSON *osSyscap, const cJSON *priSyscap, uint32_t *osCapSize, uint32_t *privateCapSize)165 int32_t GetOsAndPriSyscapSize(const cJSON *osSyscap, const cJSON *priSyscap,
166                               uint32_t *osCapSize, uint32_t *privateCapSize)
167 {
168     *osCapSize = 0;
169     *privateCapSize = 0;
170 
171     // get os syscap size
172     if (osSyscap == NULL || !cJSON_IsArray(osSyscap)) {
173         PRINT_ERR("get \"os\" array failed\n");
174         return -1;
175     }
176     int32_t ret = cJSON_GetArraySize(osSyscap);
177     if (ret < 0) {
178         PRINT_ERR("get \"os\" array size failed\n");
179         return -1;
180     }
181     *osCapSize = (uint32_t)ret;
182 
183     // get private syscap size
184     if (priSyscap != NULL && cJSON_IsArray(priSyscap)) {
185         ret = cJSON_GetArraySize(priSyscap);
186         if (ret < 0) {
187             PRINT_ERR("get \"private syscap\" array size failed\n");
188             return -1;
189         }
190         *privateCapSize = (uint32_t)ret;
191     } else if (priSyscap == NULL) {
192         *privateCapSize = 0;
193     } else {
194         PRINT_ERR("get \"private\" array failed\n");
195         return -1;
196     }
197 
198     return 0;
199 }
200 
GetPriSyscapLen(uint32_t privateCapSize, cJSON *jsonPriSyscapObj, uint16_t *len)201 int32_t GetPriSyscapLen(uint32_t privateCapSize, cJSON *jsonPriSyscapObj, uint16_t *len)
202 {
203     for (uint32_t i = 0; i < privateCapSize; i++) {
204         cJSON *jsonArrayItem = cJSON_GetArrayItem(jsonPriSyscapObj, (int)i);
205         if (jsonArrayItem == NULL || !cJSON_IsString(jsonArrayItem)) {
206             PRINT_ERR("Get jsonArrayItem failed.");
207             return -1;
208         }
209         *len += (uint16_t)strlen(strchr(jsonArrayItem->valuestring, '.') + 1);
210         (*len)++; // for separator ','
211     }
212     if ((*len + 1) > PRIVATE_SYSCAP_SIZE) {
213         PRINT_ERR("context of \"pri\" array is too many.\n");
214         return -1;
215     }
216     return 0;
217 }
218 
CheckConvertedContextSaveAsFile(char *outDirPath, PCIDMain *pcidBuffer, uint16_t pcidLength, int32_t ret)219 static int32_t CheckConvertedContextSaveAsFile(char *outDirPath, PCIDMain *pcidBuffer, uint16_t pcidLength, int32_t ret)
220 {
221     const char pcidFileName[] = "pcid.sc";
222     ret = ConvertedContextSaveAsFile(outDirPath, pcidFileName, (char *)pcidBuffer, pcidLength);
223     if (ret != 0) {
224         PRINT_ERR("Save as file failed, outDirPath:%s, filename:%s\n", outDirPath, pcidFileName);
225     }
226     return ret;
227 }
228 
FreeAfterCreatePCID(PCIDMain *pcidBuffer, cJSON *allOsSyscapObj, char *contextBuffer, int32_t type, int32_t ret)229 static int32_t FreeAfterCreatePCID(PCIDMain *pcidBuffer, cJSON *allOsSyscapObj, char *contextBuffer,
230     int32_t type, int32_t ret)
231 {
232     if (type == FREE_CREATE_PCID_BUFFER_OUT) {
233         free(pcidBuffer);
234     }
235     cJSON_Delete(allOsSyscapObj);
236     FreeContextBuffer(contextBuffer);
237     return ret;
238 }
239 
PreFreeAfterCreatePCID(PCIDMain *pcidBuffer, cJSON *allOsSyscapObj, cJSON *jsonRootObj, char *contextBuffer, int32_t type)240 static int32_t PreFreeAfterCreatePCID(PCIDMain *pcidBuffer, cJSON *allOsSyscapObj, cJSON *jsonRootObj,
241     char *contextBuffer, int32_t type)
242 {
243     cJSON_Delete(jsonRootObj);
244     return FreeAfterCreatePCID(pcidBuffer, allOsSyscapObj, contextBuffer, type, -1);
245 }
246 
CreatePCID(char *inputFile, char *outDirPath)247 int32_t CreatePCID(char *inputFile, char *outDirPath)
248 {
249     uint32_t privateCapSize, osCapSize;
250     uint32_t contextBufLen;
251     char *contextBuffer = NULL;
252 
253     cJSON *allOsSyscapObj = CreateWholeSyscapJsonObj();
254     int32_t ret = CheckFileAndGetFileContext(inputFile, &contextBuffer, (uint32_t *)&contextBufLen);
255     if (ret != 0) {
256         return FreeAfterCreatePCID(NULL, allOsSyscapObj, contextBuffer, 0, -1);
257     }
258 
259     cJSON *jsonRootObj = cJSON_ParseWithLength(contextBuffer, contextBufLen);
260     if (jsonRootObj == NULL) {
261         PRINT_ERR("cJSON_Parse failed, context buffer is:\n%s\n", contextBuffer);
262         return PreFreeAfterCreatePCID(NULL, allOsSyscapObj, jsonRootObj, contextBuffer, 0);
263     }
264 
265     cJSON *jsonSyscapObj = cJSON_GetObjectItem(jsonRootObj, "syscap");
266     if (jsonSyscapObj == NULL || !cJSON_IsObject(jsonSyscapObj)) {
267         PRINT_ERR("get \"syscap\" object failed\n");
268         return PreFreeAfterCreatePCID(NULL, allOsSyscapObj, jsonRootObj, contextBuffer, 0);
269     }
270 
271     cJSON *jsonOsSyscapObj = cJSON_GetObjectItem(jsonSyscapObj, "os");
272     cJSON *jsonPriSyscapObj = cJSON_GetObjectItem(jsonSyscapObj, "private");
273 
274     ret = GetOsAndPriSyscapSize(jsonOsSyscapObj, jsonPriSyscapObj, &osCapSize, &privateCapSize);
275     if (ret != 0) {
276         return PreFreeAfterCreatePCID(NULL, allOsSyscapObj, jsonRootObj, contextBuffer, 0);
277     }
278 
279     uint16_t allPriSyscapStrLen = 0;
280     ret = GetPriSyscapLen(privateCapSize, jsonPriSyscapObj, &allPriSyscapStrLen);
281     if (ret != 0) {
282         return PreFreeAfterCreatePCID(NULL, allOsSyscapObj, jsonRootObj, contextBuffer, 0);
283     }
284 
285     uint16_t pcidLength = sizeof(PCIDMain) + allPriSyscapStrLen + 1;
286     PCIDMain *pcidBuffer = (PCIDMain *)malloc(pcidLength);
287     if (pcidBuffer == NULL) {
288         PRINT_ERR("malloc for pcid buffer failed\n");
289         return PreFreeAfterCreatePCID(NULL, allOsSyscapObj, jsonRootObj, contextBuffer, 0);
290     }
291     (void)memset_s(pcidBuffer, pcidLength, 0, pcidLength);
292 
293     ret = SetOsSyscap(pcidBuffer, osCapSize, jsonOsSyscapObj, allOsSyscapObj);
294     ret += SetPriSyscap(pcidBuffer, jsonPriSyscapObj, privateCapSize, allPriSyscapStrLen);
295     ret += SetPCIDHeader(pcidBuffer, jsonRootObj);
296     if (ret != 0) {
297         return PreFreeAfterCreatePCID(pcidBuffer, allOsSyscapObj, jsonRootObj, contextBuffer,
298             FREE_CREATE_PCID_BUFFER_OUT);
299     }
300 
301     ret = CheckConvertedContextSaveAsFile(outDirPath, pcidBuffer, pcidLength, ret);
302     cJSON_Delete(jsonRootObj);
303     return FreeAfterCreatePCID(pcidBuffer, allOsSyscapObj, contextBuffer, FREE_CREATE_PCID_BUFFER_OUT, ret);
304 }
305 
GetOsSyscap(PCIDMain *pcidMain, cJSON *sysCapObject)306 int32_t GetOsSyscap(PCIDMain *pcidMain, cJSON *sysCapObject)
307 {
308     uint32_t i, j, countOfSyscap = 0;
309     uint8_t osSyscap[OS_SYSCAP_BYTES] = {0};
310     uint16_t indexOfSyscap[OS_SYSCAP_BYTES * UINT8_BIT] = {0};
311 
312     cJSON *capVectorPtr = cJSON_CreateArray();
313     if (capVectorPtr == NULL) {
314         PRINT_ERR("cJSON_CreateArray failed\n");
315         return -1;
316     }
317 
318     // 8, bytes of pcid header
319     errno_t nRet = memcpy_s(osSyscap, OS_SYSCAP_BYTES, (uint8_t *)pcidMain + 8, OS_SYSCAP_BYTES);
320     if (nRet != EOK) {
321         PRINT_ERR("memcpy_s failed.");
322         cJSON_Delete(capVectorPtr);
323         return -1;
324     }
325 
326     for (i = 0; i < OS_SYSCAP_BYTES; i++) {
327         for (j = 0; j < UINT8_BIT; j++) {
328             if (osSyscap[i] & (0x01 << j)) {
329                 indexOfSyscap[countOfSyscap++] = i * UINT8_BIT + j;
330             }
331         }
332     }
333     for (i = 0; i < countOfSyscap; i++) {
334         for (j = 0; j < sizeof(g_arraySyscap) / sizeof(SyscapWithNum); j++) {
335             if (g_arraySyscap[j].num != indexOfSyscap[i]) {
336                 continue;
337             }
338             if (!cJSON_AddItemToArray(capVectorPtr, cJSON_CreateString(g_arraySyscap[j].str))) {
339                 printf("cJSON_AddItemToArray or cJSON_CreateString failed\n");
340                 cJSON_Delete(capVectorPtr);
341                 return -1;
342             }
343         }
344     }
345 
346     if (!cJSON_AddItemToObject(sysCapObject, "os", capVectorPtr)) {
347         PRINT_ERR("cJSON_AddItemToObject failed\n");
348         cJSON_Delete(capVectorPtr);
349         return -1;
350     }
351 
352     return 0;
353 }
354 
GetPriSyscapResult(cJSON *capVectorPtr, int32_t ret)355 static int32_t GetPriSyscapResult(cJSON *capVectorPtr, int32_t ret)
356 {
357     cJSON_Delete(capVectorPtr);
358     return ret;
359 }
360 
GetPriSyscap(PCIDMain *pcidMain, cJSON *sysCapObject, int32_t contextBufLen)361 static int32_t GetPriSyscap(PCIDMain *pcidMain, cJSON *sysCapObject, int32_t contextBufLen)
362 {
363     cJSON *capVectorPtr = cJSON_CreateArray();
364     if (capVectorPtr == NULL) {
365         PRINT_ERR("cJSON_CreateArray failed\n");
366         return -1;
367     }
368 
369     int32_t privateSyscapLen = contextBufLen - sizeof(PCIDMain) - 1;
370     if (privateSyscapLen < 0 || privateSyscapLen > INT32_MAX) {
371         PRINT_ERR("parse private syscap failed.");
372         return GetPriSyscapResult(capVectorPtr, -1);
373     } else if (privateSyscapLen == 0) {
374         return GetPriSyscapResult(capVectorPtr, 0);
375     }
376 
377     char fullCapStr[SINGLE_SYSCAP_LEN] = {0};
378     char priSyscapStr[SINGLE_SYSCAP_LEN] = {0};
379     char *tempPriSyscapStr = priSyscapStr;
380     char *ptrPrivateSyscap = (char *)(pcidMain + 1);
381     while (*ptrPrivateSyscap != '\0') {
382         if (*ptrPrivateSyscap == ',') {
383             *tempPriSyscapStr = '\0';
384             int32_t ret = sprintf_s(fullCapStr, SINGLE_SYSCAP_LEN, "SystemCapability.%s", priSyscapStr);
385             if (ret == -1) {
386                 printf("sprintf_s failed\n");
387                 return GetPriSyscapResult(capVectorPtr, -1);
388             }
389             if (!cJSON_AddItemToArray(capVectorPtr, cJSON_CreateString(fullCapStr))) {
390                 printf("cJSON_AddItemToArray or cJSON_CreateString failed\n");
391                 return GetPriSyscapResult(capVectorPtr, -1);
392             }
393             tempPriSyscapStr = priSyscapStr;
394             ptrPrivateSyscap++;
395             continue;
396         }
397         *tempPriSyscapStr++ = *ptrPrivateSyscap++;
398     }
399     if (!cJSON_AddItemToObject(sysCapObject, "private", capVectorPtr)) {
400         PRINT_ERR("cJSON_AddItemToObject failed\n");
401         return GetPriSyscapResult(capVectorPtr, -1);
402     }
403     return 0;
404 }
405 
CheckSysCapObj(struct FreeDecodePcidJsonInfo freePcidJsonInfo, PCIDMain *pcidMain, uint32_t contextBufLen, int32_t ret)406 static int32_t CheckSysCapObj(struct FreeDecodePcidJsonInfo freePcidJsonInfo, PCIDMain *pcidMain,
407         uint32_t contextBufLen, int32_t ret)
408 {
409     if (freePcidJsonInfo.sysCapObj == NULL) {
410         PRINT_ERR("cJSON_CreateObject failed\n");
411         freePcidJsonInfo.flag = -1;
412         return -1;
413     }
414     if (GetOsSyscap(pcidMain, freePcidJsonInfo.sysCapObj) != 0) {
415         freePcidJsonInfo.flag = -1;
416         return ret;
417     }
418     if (GetPriSyscap(pcidMain, freePcidJsonInfo.sysCapObj, contextBufLen) != 0) {
419         freePcidJsonInfo.flag = -1;
420     }
421     return ret;
422 }
423 
CheckJsonRootObj(struct FreeDecodePcidJsonInfo freePcidJsonInfo, PCIDMain *pcidMain, char *systemType)424 static int32_t CheckJsonRootObj(struct FreeDecodePcidJsonInfo freePcidJsonInfo, PCIDMain *pcidMain, char *systemType)
425 {
426     if (!cJSON_AddNumberToObject(freePcidJsonInfo.jsonRootObj, "api_version", NtohsInter(pcidMain->apiVersion))) {
427         PRINT_ERR("cJSON_AddNumberToObject failed\n");
428         return -1;
429     }
430     if (!cJSON_AddNumberToObject(freePcidJsonInfo.jsonRootObj, "manufacturer_id",
431                                  NtohlInter(pcidMain->manufacturerID))) {
432         PRINT_ERR("cJSON_AddNumberToObject failed\n");
433         return -1;
434     }
435     if (!cJSON_AddStringToObject(freePcidJsonInfo.jsonRootObj, "system_type", systemType)) {
436         PRINT_ERR("cJSON_AddStringToObject failed\n");
437         return -1;
438     }
439     if (!cJSON_AddItemToObject(freePcidJsonInfo.jsonRootObj, "syscap", freePcidJsonInfo.sysCapObj)) {
440         PRINT_ERR("cJSON_AddItemToObject failed\n");
441         return -1;
442     }
443     return 0;
444 }
445 
FreeAfterDecodePCID(struct FreeDecodePcidJsonInfo freePcidJsonInfo, int32_t type, int32_t ret)446 static int32_t FreeAfterDecodePCID(struct FreeDecodePcidJsonInfo freePcidJsonInfo, int32_t type, int32_t ret)
447 {
448     switch (type) {
449         case FREE_DECODE_PCID_CONVERT_OUT:
450             cJSON_free(freePcidJsonInfo.strJson);
451             cJSON_Delete(freePcidJsonInfo.jsonRootObj);
452             FreeContextBuffer(freePcidJsonInfo.contextBuffer);
453             break;
454         case FREE_DECODE_PCID_ROOT_OUT:
455             cJSON_Delete(freePcidJsonInfo.jsonRootObj);
456             cJSON_Delete(freePcidJsonInfo.sysCapObj);
457             FreeContextBuffer(freePcidJsonInfo.contextBuffer);
458             break;
459         case FREE_DECODE_PCID_SYSCAP_OUT:
460             cJSON_Delete(freePcidJsonInfo.sysCapObj);
461             FreeContextBuffer(freePcidJsonInfo.contextBuffer);
462             break;
463         case FREE_DECODE_PCID_CONTEXT_OUT:
464             cJSON_Delete(freePcidJsonInfo.sysCapObj);
465             FreeContextBuffer(freePcidJsonInfo.contextBuffer);
466             break;
467         default:
468             FreeContextBuffer(freePcidJsonInfo.contextBuffer);
469     }
470     return ret;
471 }
472 
DecodePCID(char *inputFile, char *outDirPath)473 int32_t DecodePCID(char *inputFile, char *outDirPath)
474 {
475     int32_t ret = 0;
476     uint32_t contextBufLen;
477     struct FreeDecodePcidJsonInfo freePcidJsonInfo;
478     freePcidJsonInfo.strJson = NULL;
479     freePcidJsonInfo.contextBuffer = NULL;
480     freePcidJsonInfo.jsonRootObj = NULL;
481     freePcidJsonInfo.sysCapObj = NULL;
482     freePcidJsonInfo.flag = 0;
483 
484     ret = CheckFileAndGetFileContext(inputFile, &freePcidJsonInfo.contextBuffer, (uint32_t *)&contextBufLen);
485     if (ret != 0) {
486         return -1;
487     }
488 
489     PCIDMain *pcidMain = (PCIDMain *)freePcidJsonInfo.contextBuffer;
490 
491     /* api version */
492     if (pcidMain->apiVersionType != 0) {
493         PRINT_ERR("Prase file failed, apiVersionType is invaild, input file : %s\n", inputFile);
494         return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, -1);
495     }
496 
497     /* system type */
498     char *systemType = pcidMain->systemType == 0b001 ? "mini" :
499                        (pcidMain->systemType == 0b010 ? "small" :
500                         (pcidMain->systemType == 0b100 ? "standard" : NULL));
501     if (systemType == NULL) {
502         PRINT_ERR("prase file failed, systemType is invaild, %u\n", pcidMain->systemType);
503         return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, -1);
504     }
505 
506     /* syscap */
507     freePcidJsonInfo.sysCapObj = cJSON_CreateObject();
508     ret = CheckSysCapObj(freePcidJsonInfo, pcidMain, contextBufLen, ret);
509     if (freePcidJsonInfo.flag == -1) {
510         return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, ret);
511     }
512 
513     // create json root
514     freePcidJsonInfo.jsonRootObj = cJSON_CreateObject();
515     if (freePcidJsonInfo.jsonRootObj == NULL) {
516         PRINT_ERR("cJSON_CreateObject failed\n");
517         return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_SYSCAP_OUT, -1);
518     }
519 
520     ret = CheckJsonRootObj(freePcidJsonInfo, pcidMain, systemType);
521     if (ret == -1) {
522         return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_ROOT_OUT, ret);
523     }
524 
525     freePcidJsonInfo.strJson = cJSON_Print(freePcidJsonInfo.jsonRootObj);
526 
527     const char outputFileName[] = "pcid.json";
528     ret = ConvertedContextSaveAsFile(outDirPath, outputFileName, freePcidJsonInfo.strJson,
529                                      strlen(freePcidJsonInfo.strJson));
530     if (ret != 0) {
531         PRINT_ERR("ConvertedContextSaveAsFile failed, outDirPath:%s, filename:%s\n", outDirPath, outputFileName);
532     }
533     return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONVERT_OUT, ret);
534 }
535 
536 #define U32_TO_STR_MAX_LEN 11
537 #define OS_SYSCAP_NUM 30
538 #define PCID_HEADER 2
ParseStringSyscap(char *input, uint32_t *osSyscap, uint32_t osSyscapNum, uint32_t *header, uint32_t headerLen)539 static int32_t ParseStringSyscap(char *input, uint32_t *osSyscap, uint32_t osSyscapNum,
540                                  uint32_t *header, uint32_t headerLen)
541 {
542     int32_t ret;
543     uint32_t tempNum;
544     uint32_t i = 0;
545     size_t inputLen = strlen(input);
546 
547     if (osSyscapNum != OS_SYSCAP_NUM || headerLen != PCID_HEADER) {
548         PRINT_ERR("Input osSyscapNum(%u) or headerLen(%u) error.\n", osSyscapNum, headerLen);
549         return -1;
550     }
551 
552     if (sscanf_s(input, "%u,%u,%s", &header[0], &header[1], input, inputLen) != 3) { // 3, return val of "%u,%u,%s"
553         PRINT_ERR("Get pcid header failed.\n");
554         return -1;
555     }
556 
557     while ((ret = sscanf_s(input, "%u,%s", &tempNum, input, inputLen)) > 0) {
558         osSyscap[i++] = tempNum;
559         if (i >= OS_SYSCAP_NUM) {
560             break;
561         }
562     }
563     if (ret == -1) {
564         PRINT_ERR("sscanf_s failed, i = %u.\n", i);
565         return -1;
566     }
567 
568     if (strlen(input) <= 1) {
569         *input = '\0';
570     }
571 
572     return 0;
573 }
574 
AddHeaderToJsonObj(uint32_t *pcidHeader, uint32_t pcidHeaderLen, cJSON *rootObj)575 static int32_t AddHeaderToJsonObj(uint32_t *pcidHeader, uint32_t pcidHeaderLen, cJSON *rootObj)
576 {
577     if (pcidHeaderLen != PCID_HEADER) {
578         PRINT_ERR("input pcidHeader(%u) error.\n", pcidHeaderLen);
579         return -1;
580     }
581 
582     PCIDHeader *header = (PCIDHeader *)pcidHeader;
583     // trans system type to string
584     char *systemType = header->systemType  == 0b001 ? "mini" :
585                        (header->systemType == 0b010 ? "small" :
586                        (header->systemType == 0b100 ? "standard" : NULL));
587     if (systemType == NULL) {
588         PRINT_ERR("prase system type failed.\n");
589         return -1;
590     }
591 
592     // add to json
593     if (!cJSON_AddNumberToObject(rootObj, "api_version", NtohsInter(header->apiVersion))) {
594         PRINT_ERR("add api_version(%u) to json object failed.\n", NtohsInter(header->apiVersion));
595         return -1;
596     }
597     if (!cJSON_AddNumberToObject(rootObj, "manufacturer_id", NtohlInter(header->manufacturerID))) {
598         PRINT_ERR("add manufacturer_id(%u) to json object failed\n", NtohlInter(header->manufacturerID));
599         return -1;
600     }
601     if (!cJSON_AddStringToObject(rootObj, "system_type", systemType)) {
602         PRINT_ERR("add system_type(%s) to json object failed\n", systemType);
603         return -1;
604     }
605     return 0;
606 }
607 
AddOsSyscapToJsonObj(uint32_t *osSyscapArray, uint32_t osSyscapArrayLen, cJSON *sysCapObj)608 static int32_t AddOsSyscapToJsonObj(uint32_t *osSyscapArray, uint32_t osSyscapArrayLen, cJSON *sysCapObj)
609 {
610     cJSON *sysCapArray = cJSON_CreateArray();
611     if (sysCapArray == NULL) {
612         PRINT_ERR("Create cJSON array failed.\n");
613         return -1;
614     }
615 
616     if (osSyscapArrayLen != OS_SYSCAP_NUM) {
617         PRINT_ERR("Input os syscap array len error.\n");
618         free(sysCapArray);
619         return -1;
620     }
621     uint8_t *osSysCapArrayUint8 = (uint8_t *)osSyscapArray;
622 
623     uint32_t i, j;
624     uint32_t osSyscapCount = 0;
625     uint16_t index[OS_SYSCAP_BYTES * UINT8_BIT] = {0};
626     for (i = 0; i < OS_SYSCAP_BYTES; i++) {
627         for (j = 0; j < UINT8_BIT; j++) {
628             if (osSysCapArrayUint8[i] & (0x01 << j)) {
629                 index[osSyscapCount++] = i * UINT8_BIT + j;
630             }
631         }
632     }
633 
634     for (i = 0; i < osSyscapCount; i++) {
635         for (j = 0; j < sizeof(g_arraySyscap) / sizeof(SyscapWithNum); j++) {
636             if (index[i] != g_arraySyscap[j].num) {
637                 continue;
638             }
639             if (!cJSON_AddItemToArray(sysCapArray, cJSON_CreateString(g_arraySyscap[j].str))) {
640                 PRINT_ERR("Add os syscap string to json failed.\n");
641                 free(sysCapArray);
642                 return -1;
643             }
644             break;
645         }
646     }
647 
648     if (!cJSON_AddItemToObject(sysCapObj, "os", sysCapArray)) {
649         PRINT_ERR("Add os syscap item to json object failed.\n");
650         free(sysCapArray);
651         return -1;
652     }
653     return 0;
654 }
655 
AddPriSyscapToJsonObj(char *priSyscapString, uint32_t priSyscapStringLen, cJSON *sysCapObj)656 static int32_t AddPriSyscapToJsonObj(char *priSyscapString, uint32_t priSyscapStringLen, cJSON *sysCapObj)
657 {
658     char *token = NULL;
659 
660     cJSON *sysCapArray = cJSON_CreateArray();
661     if (sysCapArray == NULL) {
662         PRINT_ERR("Create cJSON array failed.\n");
663         return -1;
664     }
665     if (priSyscapStringLen == 0) {
666         if (!cJSON_AddItemToObject(sysCapObj, "private", sysCapArray)) {
667             PRINT_ERR("Add private syscap array to json failed.\n");
668             cJSON_Delete(sysCapArray);
669             return -1;
670         }
671         cJSON_Delete(sysCapArray);
672         return 0;
673     }
674 
675     token = strtok(priSyscapString, ",");
676     while (token != NULL) {
677         if (!cJSON_AddItemToArray(sysCapArray, cJSON_CreateString(token))) {
678             PRINT_ERR("Add private syscap string to json failed.\n");
679             cJSON_Delete(sysCapArray);
680             return -1;
681         }
682         token = strtok(NULL, ",");
683     }
684     if (!cJSON_AddItemToObject(sysCapObj, "private", sysCapArray)) {
685         PRINT_ERR("Add private syscap array to json failed.\n");
686         cJSON_Delete(sysCapArray);
687         return -1;
688     }
689     return 0;
690 }
691 
GetSyscapStr(char *input, char const *priSyscapStr, uint32_t* osSyscap, uint32_t *pcidHeader)692 static int32_t GetSyscapStr(char *input, char const *priSyscapStr, uint32_t* osSyscap, uint32_t *pcidHeader)
693 {
694     if (input == NULL) {
695         PRINT_ERR("inputFile is null.\n");
696         return -1;
697     }
698     char *ctx = NULL;
699     uint32_t fileContextLen;
700     if (GetFileContext(input, &ctx, (uint32_t *)&fileContextLen) != 0) {
701         PRINT_ERR("GetFileContext failed, input file : %s\n", input);
702         return -1;
703     }
704     if (ParseStringSyscap(ctx, osSyscap, OS_SYSCAP_NUM, pcidHeader, PCID_HEADER) != 0) {
705         PRINT_ERR("Parse string syscap failed.\n");
706         free(ctx);
707         return -1;
708     }
709     priSyscapStr = ctx;
710     return 0;
711 }
712 
DecodeStringPCIDToJson(char *input, char *outDirPath)713 int32_t DecodeStringPCIDToJson(char *input, char *outDirPath)
714 {
715     int32_t ret = -1;
716     uint32_t osSyscap[OS_SYSCAP_NUM] = {0};
717     uint32_t pcidHeader[PCID_HEADER];
718     char *priSyscapStr = NULL;
719     char *jsonBuffer = NULL;
720 
721     ret = GetSyscapStr(input, priSyscapStr, osSyscap, pcidHeader);
722     if (ret == -1) {
723         return ret;
724     }
725 
726     // add to json object
727     cJSON *sysCapObj = cJSON_CreateObject();
728     cJSON *rootObj = cJSON_CreateObject();
729     if (sysCapObj == NULL || rootObj == NULL) {
730         PRINT_ERR("Failed to create cJSON objects.\n");
731         goto FAILED;
732     }
733 
734     if (!cJSON_AddItemToObject(rootObj, "syscap", sysCapObj)) {
735         PRINT_ERR("Add syscap to json failed.\n");
736         goto FAILED;
737     }
738     if (AddHeaderToJsonObj(pcidHeader, PCID_HEADER, rootObj) != 0) {
739         PRINT_ERR("Add header to json object failed.\n");
740         goto FAILED;
741     }
742     if (AddOsSyscapToJsonObj(osSyscap, OS_SYSCAP_NUM, sysCapObj) != 0) {
743         PRINT_ERR("Add os syscap json object failed.\n");
744         goto FAILED;
745     }
746 
747     if (AddPriSyscapToJsonObj(priSyscapStr, (uint32_t) strlen(priSyscapStr), sysCapObj) != 0) {
748         PRINT_ERR("Add private syscap json object failed.\n");
749         goto FAILED;
750     }
751     // save as json file
752     jsonBuffer = cJSON_Print(rootObj);
753     if (jsonBuffer == NULL) {
754         PRINT_ERR("json buffer is null.\n");
755         goto FAILED;
756     }
757     const char outputFileName[] = "pcid.json";
758     if (ConvertedContextSaveAsFile(outDirPath, outputFileName, jsonBuffer, strlen(jsonBuffer)) != 0) {
759         PRINT_ERR("Save as json file failed.\n");
760         goto FAILED;
761     }
762     ret = 0;
763 
764 FAILED:
765     cJSON_free(jsonBuffer);
766     SafeFree(priSyscapStr);
767     cJSON_Delete(sysCapObj);
768     cJSON_Delete(rootObj);
769     return ret;
770 }
771 
FreeAfterEncodePCID(struct FreeEncodePcidInfo freePcidInfo, int32_t type, int32_t ret)772 static int32_t FreeAfterEncodePCID(struct FreeEncodePcidInfo freePcidInfo, int32_t type, int32_t ret)
773 {
774     switch (type) {
775         case FREE_ENCODE_PCID_OUT:
776             free(freePcidInfo.output);
777             free(freePcidInfo.priSyscapFull);
778             free(freePcidInfo.contextBuffer);
779             break;
780         case FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT:
781             free(freePcidInfo.priSyscapFull);
782             free(freePcidInfo.contextBuffer);
783             break;
784         case FREE_ENCODE_PCID_CONTEXT_OUT:
785         default:
786             free(freePcidInfo.contextBuffer);
787     }
788     return ret;
789 }
790 
GetEncodePCIDOut(uint16_t priSyscapCount, uint32_t privateSyscapLen, uint32_t *mainSyscap, struct FreeEncodePcidInfo freePcidInfo, int32_t ret)791 static int32_t GetEncodePCIDOut(uint16_t priSyscapCount, uint32_t privateSyscapLen, uint32_t *mainSyscap,
792         struct FreeEncodePcidInfo freePcidInfo, int32_t ret)
793 {
794     // 17, size of "SystemCapability."
795     uint32_t outputLen = U32_TO_STR_MAX_LEN * PCID_OUT_BUFFER + 17 * priSyscapCount + privateSyscapLen + 1;
796     char *output = NULL;
797     uint32_t i;
798     output = (char *)malloc(outputLen);
799     if (output == NULL) {
800         PRINT_ERR("malloc failed\n");
801         return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
802     }
803     (void)memset_s(output, outputLen, 0, outputLen);
804     ret = sprintf_s(output, outputLen, "%u", mainSyscap[0]);
805     if (ret == -1) {
806         PRINT_ERR("sprintf_s failed\n");
807         free(output);
808         return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
809     }
810     for (i = 1; i < PCID_OUT_BUFFER; i++) {
811         ret = sprintf_s(output, outputLen, "%s,%u", output, mainSyscap[i]);
812         if (ret == -1) {
813             PRINT_ERR("sprintf_s failed\n");
814             free(output);
815             return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
816         }
817     }
818     for (i = 0; i < priSyscapCount; i++) {
819         ret = sprintf_s(output, outputLen, "%s,%s", output, freePcidInfo.priSyscapFull + i * SINGLE_SYSCAP_LEN);
820         if (ret == -1) {
821             PRINT_ERR("sprintf_s failed\n");
822             free(output);
823             return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
824         }
825     }
826     // save as file
827     const char outputFileName[] = "pcid.txt";
828     ret = ConvertedContextSaveAsFile(freePcidInfo.outDirPathFinal, outputFileName, output, strlen(output));
829     if (ret != 0) {
830         PRINT_ERR("ConvertedContextSaveAsFile failed, outDirPath:%s, filename:%s\n",
831                   freePcidInfo.outDirPathFinal, outputFileName);
832     }
833     free(output);
834     return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
835 }
836 
CheckPrivateSyCap(struct FreeEncodePcidInfo freePcidInfo, uint32_t privateSyscapLen, char *privateSyscap, int32_t ret)837 static int32_t CheckPrivateSyCap(struct FreeEncodePcidInfo freePcidInfo, uint32_t privateSyscapLen,
838     char *privateSyscap, int32_t ret)
839 {
840     uint32_t i, j;
841     char tempSyscap[SINGLE_SYSCAP_LEN] = {0};
842     char *temp = tempSyscap;
843     for (i = 0, j = 0; i < privateSyscapLen; i++) {
844         if (*privateSyscap == ',') {
845             *temp = '\0';
846             ret = sprintf_s(freePcidInfo.priSyscapFull + j * SINGLE_SYSCAP_LEN, SINGLE_SYSCAP_LEN,
847                             "SystemCapability.%s", tempSyscap);
848             if (ret == -1) {
849                 PRINT_ERR("sprintf_s failed\n");
850                 return ret;
851             }
852             temp = tempSyscap;
853             privateSyscap++;
854             j++;
855             continue;
856         }
857         *temp++ = *privateSyscap++;
858     }
859     return ret;
860 }
861 
EncodePcidscToString(char *inputFile, char *outDirPath)862 int32_t EncodePcidscToString(char *inputFile, char *outDirPath)
863 {
864     int32_t ret = 0;
865     uint32_t bufferLen, privateSyscapLen;
866     uint32_t i;
867     uint32_t *mainSyscap = NULL;
868     uint16_t priSyscapCount = 0;
869 
870     char *privateSyscap = NULL;
871     struct FreeEncodePcidInfo freePcidInfo;
872     freePcidInfo.contextBuffer = NULL;
873     freePcidInfo.priSyscapFull = NULL;
874     freePcidInfo.output = NULL;
875     freePcidInfo.outDirPathFinal = outDirPath;
876     PCIDMain *pcidMain = NULL;
877 
878     ret = CheckFileAndGetFileContext(inputFile, &freePcidInfo.contextBuffer, (uint32_t *)&bufferLen);
879     if (ret != 0) {
880         return -1;
881     }
882 
883     if (bufferLen > 1128) { // 1128, max size of pcid.sc
884         PRINT_ERR("Input pcid file too large, pcid file size: %u\n", bufferLen);
885         return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_CONTEXT_OUT, ret);
886     }
887 
888     pcidMain = (PCIDMain *)freePcidInfo.contextBuffer;
889     privateSyscap = (char *)(pcidMain + 1);
890     privateSyscapLen = strlen(privateSyscap);
891 
892     // process os syscap
893     mainSyscap = (uint32_t *)pcidMain;
894 
895     // process private syscap
896     for (i = 0; i < privateSyscapLen; i++) {
897         if (privateSyscap[i] == ',') {
898             priSyscapCount++;
899         }
900     }
901     if (priSyscapCount == 0) {
902         return GetEncodePCIDOut(priSyscapCount, privateSyscapLen, mainSyscap,  freePcidInfo, ret);
903     }
904     freePcidInfo.priSyscapFull = (char *)malloc(priSyscapCount * SINGLE_SYSCAP_LEN);
905     if (freePcidInfo.priSyscapFull == NULL) {
906         PRINT_ERR("malloc failed\n");
907         return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_CONTEXT_OUT, ret);
908     }
909     (void)memset_s(freePcidInfo.priSyscapFull, priSyscapCount * SINGLE_SYSCAP_LEN,
910                    0, priSyscapCount * SINGLE_SYSCAP_LEN);
911 
912     ret = CheckPrivateSyCap(freePcidInfo, privateSyscapLen, privateSyscap, ret);
913     if (ret == -1) {
914         return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
915     }
916 
917     // output
918     return GetEncodePCIDOut(priSyscapCount, privateSyscapLen, mainSyscap,  freePcidInfo, ret);
919 }