openharmony/developtools_syscap_codec
1
0
Fork 0
mirror of https://github.com/openharmony/developtools_syscap_codec.git synced 2026-08-27 10:21:25 -04:00
Code Issues Packages Projects Releases Wiki Activity

修改napi_query_syscap.cpp, syscap_interface.c syscap_tool.c指标问题,修改create_pcid编译告警

Browse Source 
Signed-off-by: lichao <lichao74@huawei.com>
This commit is contained in:
lichao
2023-12-21 11:31:34 +08:00
parent 4c1fe8378f
commit 6dc4d20bd2
4 changed files with 714 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files
interfaces/inner_api/syscap_interface.c
+241 -113
View File
@@ -42,6 +42,12 @@
#define INT_BIT 32
#define U32_TO_STR_MAX_LEN 11
#define FREE_MALLOC_PRISYSCAP_AFTER_DECODE_RPCID 1
#define FREE_MALLOC_OSSYSCAP_AFTER_DECODE_RPCID 2
#define FREE_WHOLE_SYSCAP_AFTER_DECODE_RPCID 3
#define FREE_RPCID_ROOT_AFTER_DECODE_RPCID 4
#define FREE_CONTEXT_OUT_AFTER_DECODE_RPCID 5
typedef struct ProductCompatibilityID {
uint16_t apiVersion : 15;
uint16_t apiVersionType : 1;
@@ -53,6 +59,24 @@ typedef struct ProductCompatibilityID {
static const char *g_pcidPath = "/system/etc/PCID.sc";
struct FreeAfterDecodeRpcidInfo {
char *priSyscap;
char *contextBuffer;
cJSON *sysCapDefine;
cJSON *rpcidRoot;
uint16_t *osSysCapIndex;
int32_t sysCapArraySize;
};
struct PcidPriSyscapInfo {
uint32_t rpcidPriSyscapLen;
uint32_t pcidPriSyscapLen;
char *rpcidPriSyscap;
char *pcidPriSyscap;
uint16_t ossyscapFlag;
int32_t ret;
};
bool EncodeOsSyscap(char *output, int len)
{
int32_t ret;
@@ -299,96 +323,140 @@ FREE_SYSCAP_OUT:
return ret;
}
int32_t TransStringFormatAndSaveSyscap(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, cJSON *sysCapArray,
const char *inputFile);
void PartSysCapAndOutBuffer(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, char *outBuffer,
char *priSyscapArray, cJSON *sysCapArray);
char *FreeAfterDecodeRpcidToString(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, int32_t type,
char *outBuffer);
void PrintResultToOutBuffer(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, char *outBuffer,
char *priSyscapArray, uint16_t indexOs, uint16_t indexPri);
char *DecodeRpcidToStringFormat(const char *inputFile)
{
int32_t ret = 0;
int32_t sysCapArraySize;
uint32_t bufferLen, i;
uint16_t indexOs = 0;
uint16_t indexPri = 0;
uint16_t *osSysCapIndex;
char *contextBuffer = NULL;
uint32_t bufferLen;
char *priSyscapArray = NULL;
char *priSyscap = NULL;
char *outBuffer = NULL;
cJSON *cJsonTemp = NULL;
cJSON *rpcidRoot = NULL;
cJSON *sysCapDefine = NULL;
cJSON *sysCapArray = NULL;
struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo;
gFreeAfterDecodeRpcidInfo.priSyscap = NULL;
gFreeAfterDecodeRpcidInfo.osSysCapIndex = 0;
gFreeAfterDecodeRpcidInfo.sysCapDefine = NULL;
gFreeAfterDecodeRpcidInfo.rpcidRoot = NULL;
gFreeAfterDecodeRpcidInfo.contextBuffer = NULL;
gFreeAfterDecodeRpcidInfo.sysCapArraySize = 0;
// check rpcid.sc
if (CheckRpcidFormat(inputFile, &contextBuffer, &bufferLen)) {
if (CheckRpcidFormat(inputFile, &gFreeAfterDecodeRpcidInfo.contextBuffer, &bufferLen)) {
PRINT_ERR("Check rpcid.sc format failed. Input file: %s\n", inputFile);
goto FREE_CONTEXT_OUT;
return FreeAfterDecodeRpcidToString(gFreeAfterDecodeRpcidInfo, FREE_CONTEXT_OUT_AFTER_DECODE_RPCID, outBuffer);
}
// parse rpcid to json
rpcidRoot = cJSON_CreateObject();
if (ParseRpcidToJson(contextBuffer, bufferLen, rpcidRoot)) {
gFreeAfterDecodeRpcidInfo.rpcidRoot = cJSON_CreateObject();
if (ParseRpcidToJson(gFreeAfterDecodeRpcidInfo.contextBuffer, bufferLen, gFreeAfterDecodeRpcidInfo.rpcidRoot)) {
PRINT_ERR("Prase rpcid to json failed. Input file: %s\n", inputFile);
goto FREE_RPCID_ROOT;
return FreeAfterDecodeRpcidToString(gFreeAfterDecodeRpcidInfo, FREE_RPCID_ROOT_AFTER_DECODE_RPCID, outBuffer);
}
ret = TransStringFormatAndSaveSyscap(gFreeAfterDecodeRpcidInfo, sysCapArray, inputFile);
if (ret == -1) {
return FreeAfterDecodeRpcidToString(gFreeAfterDecodeRpcidInfo, FREE_WHOLE_SYSCAP_AFTER_DECODE_RPCID, outBuffer);
}
(void)memset_s(gFreeAfterDecodeRpcidInfo.osSysCapIndex, sizeof(uint16_t) * gFreeAfterDecodeRpcidInfo
.sysCapArraySize, 0, sizeof(uint16_t) * gFreeAfterDecodeRpcidInfo.sysCapArraySize);
// malloc for save private syscap string
priSyscapArray = (char *)malloc(gFreeAfterDecodeRpcidInfo.sysCapArraySize * SINGLE_SYSCAP_LEN);
if (priSyscapArray == NULL) {
PRINT_ERR("malloc(%u) failed.\n", (uint32_t)gFreeAfterDecodeRpcidInfo.sysCapArraySize * SINGLE_SYSCAP_LEN);
return FreeAfterDecodeRpcidToString(gFreeAfterDecodeRpcidInfo, FREE_MALLOC_OSSYSCAP_AFTER_DECODE_RPCID,
outBuffer);
}
PartSysCapAndOutBuffer(gFreeAfterDecodeRpcidInfo, outBuffer, priSyscapArray, sysCapArray);
return FreeAfterDecodeRpcidToString(gFreeAfterDecodeRpcidInfo, FREE_MALLOC_PRISYSCAP_AFTER_DECODE_RPCID, outBuffer);
}
int32_t TransStringFormatAndSaveSyscap(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, cJSON *sysCapArray,
const char *inputFile)
{
// trans to string format
sysCapDefine = CreateWholeSyscapJsonObj();
sysCapArray = cJSON_GetObjectItem(rpcidRoot, "syscap");
gFreeAfterDecodeRpcidInfo.sysCapDefine = CreateWholeSyscapJsonObj();
sysCapArray = cJSON_GetObjectItem(gFreeAfterDecodeRpcidInfo.rpcidRoot, "syscap");
if (sysCapArray == NULL || !cJSON_IsArray(sysCapArray)) {
PRINT_ERR("Get syscap failed. Input file: %s\n", inputFile);
goto FREE_WHOLE_SYSCAP;
return -1;
}
sysCapArraySize = cJSON_GetArraySize(sysCapArray);
if (sysCapArraySize < 0) {
gFreeAfterDecodeRpcidInfo.sysCapArraySize = cJSON_GetArraySize(sysCapArray);
if (gFreeAfterDecodeRpcidInfo.sysCapArraySize < 0) {
PRINT_ERR("Get syscap size failed. Input file: %s\n", inputFile);
goto FREE_WHOLE_SYSCAP;
return -1;
}
// malloc for save os syscap index
osSysCapIndex = (uint16_t *)malloc(sizeof(uint16_t) * sysCapArraySize);
if (osSysCapIndex == NULL) {
gFreeAfterDecodeRpcidInfo.osSysCapIndex = (uint16_t *)malloc(sizeof(uint16_t) * gFreeAfterDecodeRpcidInfo.sysCapArraySize);
if (gFreeAfterDecodeRpcidInfo.osSysCapIndex == NULL) {
PRINT_ERR("malloc failed.\n");
goto FREE_WHOLE_SYSCAP;
return -1;
}
(void)memset_s(osSysCapIndex, sizeof(uint16_t) * sysCapArraySize,
0, sizeof(uint16_t) * sysCapArraySize);
// malloc for save private syscap string
priSyscapArray = (char *)malloc(sysCapArraySize * SINGLE_SYSCAP_LEN);
if (priSyscapArray == NULL) {
PRINT_ERR("malloc(%u) failed.\n", (uint32_t)sysCapArraySize * SINGLE_SYSCAP_LEN);
goto FREE_MALLOC_OSSYSCAP;
}
(void)memset_s(priSyscapArray, sysCapArraySize * SINGLE_SYSCAP_LEN,
0, sysCapArraySize * SINGLE_SYSCAP_LEN);
priSyscap = priSyscapArray;
return 0;
}
void PartSysCapAndOutBuffer(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, char *outBuffer,
char *priSyscapArray, cJSON *sysCapArray) {
uint32_t i;
int32_t ret = 0;
uint16_t indexOs = 0;
uint16_t indexPri = 0;
cJSON *cJsonTemp = NULL;
(void)memset_s(priSyscapArray, gFreeAfterDecodeRpcidInfo.sysCapArraySize * SINGLE_SYSCAP_LEN,
0, gFreeAfterDecodeRpcidInfo.sysCapArraySize * SINGLE_SYSCAP_LEN);
gFreeAfterDecodeRpcidInfo.priSyscap = priSyscapArray;
// part os syscap and ptivate syscap
for (i = 0; i < (uint32_t)sysCapArraySize; i++) {
for (i = 0; i < (uint32_t)gFreeAfterDecodeRpcidInfo.sysCapArraySize; i++) {
cJSON *cJsonItem = cJSON_GetArrayItem(sysCapArray, i);
cJsonTemp = cJSON_GetObjectItem(sysCapDefine, cJsonItem->valuestring);
cJsonTemp = cJSON_GetObjectItem(gFreeAfterDecodeRpcidInfo.sysCapDefine, cJsonItem->valuestring);
if (cJsonTemp != NULL) {
osSysCapIndex[indexOs++] = (uint16_t)(cJsonTemp->valueint);
gFreeAfterDecodeRpcidInfo.osSysCapIndex[indexOs++] = (uint16_t)(cJsonTemp->valueint);
} else {
ret = strcpy_s(priSyscap, SINGLE_SYSCAP_LEN, cJsonItem->valuestring);
ret = strcpy_s(gFreeAfterDecodeRpcidInfo.priSyscap, SINGLE_SYSCAP_LEN, cJsonItem->valuestring);
if (ret != EOK) {
PRINT_ERR("strcpy_s failed.\n");
goto FREE_MALLOC_PRISYSCAP;
return;
}
priSyscapArray += SINGLE_SYSCAP_LEN;
indexPri++;
}
}
PrintResultToOutBuffer(gFreeAfterDecodeRpcidInfo, outBuffer, priSyscapArray, indexOs, indexPri);
}
void PrintResultToOutBuffer(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, char *outBuffer,
char *priSyscapArray, uint16_t indexOs, uint16_t indexPri)
{
int32_t ret = 0;
uint32_t i;
uint32_t outUint[RPCID_OUT_BUFFER] = {0};
outUint[0] = *(uint32_t *)contextBuffer;
outUint[1] = *(uint32_t *)(contextBuffer + sizeof(uint32_t));
outUint[0] = *(uint32_t *)gFreeAfterDecodeRpcidInfo.contextBuffer;
outUint[1] = *(uint32_t *)(gFreeAfterDecodeRpcidInfo.contextBuffer + sizeof(uint32_t));
uint8_t *osOutUint = (uint8_t *)(outUint + 2);
if (SetOsSysCapBitMap(osOutUint, 120, osSysCapIndex, indexOs)) { // 120, len of osOutUint
if (SetOsSysCapBitMap(osOutUint, 120, gFreeAfterDecodeRpcidInfo.osSysCapIndex, indexOs)) { // 120, len of osOutUint
PRINT_ERR("Set os syscap bit map failed.\n");
goto FREE_MALLOC_PRISYSCAP;
return;
}
uint16_t outBufferLen = U32_TO_STR_MAX_LEN * RPCID_OUT_BUFFER +
SINGLE_SYSCAP_LEN * indexPri;
uint16_t outBufferLen = U32_TO_STR_MAX_LEN * RPCID_OUT_BUFFER + SINGLE_SYSCAP_LEN * indexPri;
outBuffer = (char *)malloc(outBufferLen);
if (outBuffer == NULL) {
PRINT_ERR("malloc(%u) failed.\n", outBufferLen);
goto FREE_MALLOC_PRISYSCAP;
return;
}
(void)memset_s(outBuffer, outBufferLen, 0, outBufferLen);
@@ -397,7 +465,7 @@ char *DecodeRpcidToStringFormat(const char *inputFile)
PRINT_ERR("sprintf_s failed.\n");
free(outBuffer);
outBuffer = NULL;
goto FREE_MALLOC_PRISYSCAP;
return;
}
for (i = 1; i < RPCID_OUT_BUFFER; i++) {
ret = sprintf_s(outBuffer, outBufferLen, "%s,%u", outBuffer, outUint[i]);
@@ -405,56 +473,72 @@ char *DecodeRpcidToStringFormat(const char *inputFile)
PRINT_ERR("sprintf_s failed.\n");
free(outBuffer);
outBuffer = NULL;
goto FREE_MALLOC_PRISYSCAP;
return;
}
}
for (i = 0; i < indexPri; i++) {
ret = sprintf_s(outBuffer, outBufferLen, "%s,%s", outBuffer,
priSyscapArray + i * SINGLE_SYSCAP_LEN);
ret = sprintf_s(outBuffer, outBufferLen, "%s,%s", outBuffer, priSyscapArray + i * SINGLE_SYSCAP_LEN);
if (ret == -1) {
PRINT_ERR("sprintf_s failed.\n");
free(outBuffer);
outBuffer = NULL;
goto FREE_MALLOC_PRISYSCAP;
return;
}
}
}
FREE_MALLOC_PRISYSCAP:
free(priSyscap);
FREE_MALLOC_OSSYSCAP:
free(osSysCapIndex);
FREE_WHOLE_SYSCAP:
cJSON_Delete(sysCapDefine);
FREE_RPCID_ROOT:
cJSON_Delete(rpcidRoot);
FREE_CONTEXT_OUT:
FreeContextBuffer(contextBuffer);
char *FreeAfterDecodeRpcidToString(struct FreeAfterDecodeRpcidInfo gFreeAfterDecodeRpcidInfo, int32_t type,
char *outBuffer) {
switch (type) {
case FREE_MALLOC_PRISYSCAP_AFTER_DECODE_RPCID:
free(gFreeAfterDecodeRpcidInfo.priSyscap);
case FREE_MALLOC_OSSYSCAP_AFTER_DECODE_RPCID:
free(gFreeAfterDecodeRpcidInfo.osSysCapIndex);
case FREE_WHOLE_SYSCAP_AFTER_DECODE_RPCID:
cJSON_Delete(gFreeAfterDecodeRpcidInfo.sysCapDefine);
case FREE_RPCID_ROOT_AFTER_DECODE_RPCID:
cJSON_Delete(gFreeAfterDecodeRpcidInfo.rpcidRoot);
case FREE_CONTEXT_OUT_AFTER_DECODE_RPCID:
default:
FreeContextBuffer(gFreeAfterDecodeRpcidInfo.contextBuffer);
}
return outBuffer;
}
int32_t ComparePcidWithOsSyscap(struct PcidPriSyscapInfo gPcidPriSyscapInfo, uint32_t pcidOsAarry[PCID_OUT_BUFFER],
uint32_t rpcidOsAarry[PCID_OUT_BUFFER], CompareError *result, const size_t allSyscapNum);
int32_t CheckPcidEachBit(struct PcidPriSyscapInfo gPcidPriSyscapInfo, CompareError *result, const size_t allSyscapNum,
uint32_t i, uint32_t blockBits);
int32_t CopySyscopToRet(struct PcidPriSyscapInfo gPcidPriSyscapInfo, const size_t allSyscapNum, char *tempSyscap,
uint32_t i, uint8_t k);
int32_t ComparePcidWithPriSyscap(struct PcidPriSyscapInfo gPcidPriSyscapInfo, CompareError *result,
uint16_t versionFlag);
int32_t ComparePcidString(const char *pcidString, const char *rpcidString, CompareError *result)
{
int32_t ret;
uint16_t versionFlag = 0;
uint16_t ossyscapFlag = 0;
uint16_t prisyscapFlag = 0;
char *pcidPriSyscap = NULL;
char *rpcidPriSyscap = NULL;
bool priSysFound;
uint32_t pcidPriSyscapLen, rpcidPriSyscapLen;
uint32_t i, j;
uint32_t retFlag = 0;
int32_t errorFlag = 0;
struct PcidPriSyscapInfo gPcidPriSyscapInfo;
gPcidPriSyscapInfo.pcidPriSyscap = NULL;
gPcidPriSyscapInfo.rpcidPriSyscap = NULL;
gPcidPriSyscapInfo.pcidPriSyscapLen = 0;
gPcidPriSyscapInfo.rpcidPriSyscapLen = 0;
gPcidPriSyscapInfo.ossyscapFlag = 0;
gPcidPriSyscapInfo.ret = 0;
uint32_t pcidOsAarry[PCID_OUT_BUFFER] = {0};
uint32_t rpcidOsAarry[PCID_OUT_BUFFER] = {0};
const size_t allSyscapNum = sizeof(g_arraySyscap) / sizeof(SyscapWithNum);
ret = SeparateSyscapFromString(pcidString, pcidOsAarry, PCID_OUT_BUFFER,
&pcidPriSyscap, &pcidPriSyscapLen);
ret += SeparateSyscapFromString(rpcidString, rpcidOsAarry, RPCID_OUT_BUFFER,
&rpcidPriSyscap, &rpcidPriSyscapLen);
if (ret != 0) {
PRINT_ERR("Separate syscap from string failed. ret = %d\n", ret);
gPcidPriSyscapInfo.ret = SeparateSyscapFromString(pcidString, pcidOsAarry, PCID_OUT_BUFFER,
&gPcidPriSyscapInfo.pcidPriSyscap, &gPcidPriSyscapInfo.pcidPriSyscapLen);
gPcidPriSyscapInfo.ret += SeparateSyscapFromString(rpcidString, rpcidOsAarry, RPCID_OUT_BUFFER,
&gPcidPriSyscapInfo.rpcidPriSyscap, &gPcidPriSyscapInfo.rpcidPriSyscapLen);
if (gPcidPriSyscapInfo.ret != 0) {
PRINT_ERR("Separate syscap from string failed. ret = %d\n", gPcidPriSyscapInfo.ret);
return -1;
}
result->missSyscapNum = 0;
@@ -465,44 +549,88 @@ int32_t ComparePcidString(const char *pcidString, const char *rpcidString, Compa
result->targetApiVersion = rpcidVersion;
versionFlag = 1;
}
// compare os sysscap
errorFlag = ComparePcidWithOsSyscap(gPcidPriSyscapInfo, pcidOsAarry, rpcidOsAarry, result, allSyscapNum);
if (errorFlag == -1) {
return errorFlag;
}
// compare pri syscap
return ComparePcidWithPriSyscap(gPcidPriSyscapInfo, result, versionFlag);
}
int32_t ComparePcidWithOsSyscap(struct PcidPriSyscapInfo gPcidPriSyscapInfo, uint32_t pcidOsAarry[PCID_OUT_BUFFER],
uint32_t rpcidOsAarry[PCID_OUT_BUFFER], CompareError *result, const size_t allSyscapNum)
{
uint32_t i;
int32_t ret = 0;
for (i = 2; i < PCID_OUT_BUFFER; i++) { // 2, header of pcid & rpcid
uint32_t blockBits = (pcidOsAarry[i] ^ rpcidOsAarry[i]) & rpcidOsAarry[i];
if (!blockBits) {
continue;
}
for (uint8_t k = 0; k < INT_BIT; k++) {
if (blockBits & (1U << k)) {
char *tempSyscap = (char *)malloc(sizeof(char) * SINGLE_SYSCAP_LEN);
if (tempSyscap == NULL) {
PRINT_ERR("malloc failed.\n");
FreeCompareError(result);
return -1;
}
uint32_t pos = (i - 2) * INT_BIT + k;
uint32_t t;
for (t = 0; t < allSyscapNum; t++) {
if (g_arraySyscap[t].num == pos) {
break;
}
}
ret = strcpy_s(tempSyscap, sizeof(char) * SINGLE_SYSCAP_LEN,
g_arraySyscap[t].str); // 2, header of pcid & rpcid
if (ret != EOK) {
PRINT_ERR("strcpy_s failed.\n");
FreeCompareError(result);
return -1;
}
result->syscap[ossyscapFlag++] = tempSyscap;
}
ret = CheckPcidEachBit(gPcidPriSyscapInfo, result, allSyscapNum, i, blockBits);
if (ret == -1) {
return -1;
}
}
// compare pri syscap
priSysFound = false;
for (i = 0; i < rpcidPriSyscapLen; i++) {
for (j = 0; j < pcidPriSyscapLen; j++) {
if (strcmp(rpcidPriSyscap + SINGLE_SYSCAP_LEN * i,
pcidPriSyscap + SINGLE_SYSCAP_LEN * j) == 0) {
return 0;
}
int32_t CheckPcidEachBit(struct PcidPriSyscapInfo gPcidPriSyscapInfo, CompareError *result, const size_t allSyscapNum,
uint32_t i, uint32_t blockBits)
{
int32_t flag = 0;
for (uint8_t k = 0; k < INT_BIT; k++) {
if (blockBits & (1U << k)) {
char *tempSyscap = (char *)malloc(sizeof(char) * SINGLE_SYSCAP_LEN);
if (tempSyscap == NULL) {
PRINT_ERR("malloc failed.\n");
FreeCompareError(result);
return -1;
}
flag = CopySyscopToRet(gPcidPriSyscapInfo, allSyscapNum, tempSyscap, i, k);
if (flag != EOK) {
PRINT_ERR("strcpy_s failed.\n");
FreeCompareError(result);
return -1;
}
result->syscap[gPcidPriSyscapInfo.ossyscapFlag++] = tempSyscap;
}
}
return 0;
}
int32_t CopySyscopToRet(struct PcidPriSyscapInfo gPcidPriSyscapInfo, const size_t allSyscapNum, char *tempSyscap,
uint32_t i, uint8_t k) {
uint32_t pos = (i - 2) * INT_BIT + k;
uint32_t t;
for (t = 0; t < allSyscapNum; t++) {
if (g_arraySyscap[t].num == pos) {
break;
}
}
gPcidPriSyscapInfo.ret = strcpy_s(tempSyscap, sizeof(char) * SINGLE_SYSCAP_LEN, g_arraySyscap[t].str); // 2, header of pcid & rpcid
if (gPcidPriSyscapInfo.ret != EOK) {
return -1;
}
return 0;
}
int32_t ComparePcidWithPriSyscap(struct PcidPriSyscapInfo gPcidPriSyscapInfo, CompareError *result,
uint16_t versionFlag)
{
uint32_t i, j;
uint16_t prisyscapFlag = 0;
uint32_t retFlag = 0;
bool priSysFound = false;
for (i = 0; i < gPcidPriSyscapInfo.rpcidPriSyscapLen; i++) {
for (j = 0; j < gPcidPriSyscapInfo.pcidPriSyscapLen; j++) {
if (strcmp(gPcidPriSyscapInfo.rpcidPriSyscap + SINGLE_SYSCAP_LEN * i,
gPcidPriSyscapInfo.pcidPriSyscap + SINGLE_SYSCAP_LEN * j) == 0) {
priSysFound = true;
break;
}
@@ -514,14 +642,14 @@ int32_t ComparePcidString(const char *pcidString, const char *rpcidString, Compa
FreeCompareError(result);
return -1;
}
ret = strcpy_s(temp, sizeof(char) * SINGLE_SYSCAP_LEN,
rpcidPriSyscap + SINGLE_SYSCAP_LEN * i);
if (ret != EOK) {
gPcidPriSyscapInfo.ret = strcpy_s(temp, sizeof(char) * SINGLE_SYSCAP_LEN,
gPcidPriSyscapInfo.rpcidPriSyscap + SINGLE_SYSCAP_LEN * i);
if (gPcidPriSyscapInfo.ret != EOK) {
FreeCompareError(result);
PRINT_ERR("strcpy_s failed.\n");
return -1;
}
result->syscap[ossyscapFlag + prisyscapFlag] = temp;
result->syscap[gPcidPriSyscapInfo.ossyscapFlag + prisyscapFlag] = temp;
++prisyscapFlag;
}
priSysFound = false;
@@ -530,9 +658,9 @@ int32_t ComparePcidString(const char *pcidString, const char *rpcidString, Compa
if (versionFlag > 0) {
retFlag |= 1U << 0;
}
if (ossyscapFlag > 0 || prisyscapFlag > 0) {
if (gPcidPriSyscapInfo.ossyscapFlag > 0 || prisyscapFlag > 0) {
retFlag |= 1U << 1;
result->missSyscapNum = ossyscapFlag + prisyscapFlag;
result->missSyscapNum = gPcidPriSyscapInfo.ossyscapFlag + prisyscapFlag;
}
return (int32_t)retFlag;
}
napi/napi_query_syscap.cpp
+59 -44
View File
@@ -29,6 +29,9 @@ constexpr size_t PCID_MAIN_U32 = OS_SYSCAP_U32_NUM + 2;
constexpr size_t U32_TO_STR_MAX_LEN = 11;
constexpr size_t KEY_BUFFER_SIZE = 32;
#define FREE_PRICAP_ARRAY_AFTER_GET_SYS_CAP 1
#define FREE_PRIOUTPUT_AFTER_GET_SYS_CAP 2
#define GET_PARAMS(env, info, num) \
size_t argc = num; \
napi_value argv[num] = {0}; \
@@ -50,47 +53,21 @@ struct SystemCapabilityAsyncContext {
int status = 0;
};
static char* GetSystemCapability()
static char* CalculateAllStringLength(char *priOutput, char osCapArray[PCID_MAIN_U32][U32_TO_STR_MAX_LEN],
char (*priCapArray)[SINGLE_SYSCAP_LEN], char *allSyscapBuffer)
{
bool retBool;
int retError, priOutputLen, priCapArrayCnt, sumLen;
char osOutput[SINGLE_SYSCAP_LEN] = {};
errno_t err = EOK;
uint32_t *osCapU32 = nullptr;
char *priOutput = nullptr;
char *temp = nullptr;
char *allSyscapBuffer = nullptr;
char osCapArray[PCID_MAIN_U32][U32_TO_STR_MAX_LEN] = {};
char (*priCapArray)[SINGLE_SYSCAP_LEN] = nullptr;
retBool = EncodeOsSyscap(osOutput, PCID_MAIN_BYTES);
if (!retBool) {
PRINT_ERR("get encoded os syscap failed.");
return nullptr;
}
retBool = EncodePrivateSyscap(&priOutput, &priOutputLen);
if (!retBool) {
PRINT_ERR("get encoded private syscap failed.");
goto FREE_PRIOUTPUT;
}
osCapU32 = reinterpret_cast<uint32_t *>(osOutput);
for (size_t i = 0; i < PCID_MAIN_U32; i++) { // 2, header of pcid.sc
retError = sprintf_s(osCapArray[i], U32_TO_STR_MAX_LEN, "%u", osCapU32[i]);
if (retError == -1) {
PRINT_ERR("get uint32_t syscap string failed.");
goto FREE_PRIOUTPUT;
}
}
int retError, priCapArrayCnt;
int sumLen = 0;
retBool = DecodePrivateSyscap(priOutput, &priCapArray, &priCapArrayCnt);
if (!retBool) {
PRINT_ERR("get encoded private syscap failed.");
goto FREE_PRICAP_ARRAY;
return allSyscapBuffer;
}
// calculate all string length
sumLen = 0;
for (size_t i = 0; i < PCID_MAIN_U32; i++) {
sumLen += strlen(osCapArray[i]);
}
@@ -103,14 +80,13 @@ static char* GetSystemCapability()
allSyscapBuffer = (char *)malloc(sumLen);
if (allSyscapBuffer == nullptr) {
PRINT_ERR("malloc failed!");
goto FREE_PRICAP_ARRAY;
return allSyscapBuffer;
}
err = memset_s(allSyscapBuffer, sumLen, 0, sumLen);
if (err != EOK) {
PRINT_ERR("memset failed!");
free(allSyscapBuffer);
allSyscapBuffer = nullptr;
goto FREE_PRICAP_ARRAY;
return nullptr;
}
temp = *osCapArray;
@@ -119,8 +95,7 @@ static char* GetSystemCapability()
if (retError == -1) {
PRINT_ERR("splicing os syscap string failed.");
free(allSyscapBuffer);
allSyscapBuffer = nullptr;
goto FREE_PRICAP_ARRAY;
return nullptr;
}
temp = allSyscapBuffer;
}
@@ -129,20 +104,60 @@ static char* GetSystemCapability()
if (retError == -1) {
PRINT_ERR("splicing pri syscap string failed.");
free(allSyscapBuffer);
allSyscapBuffer = nullptr;
goto FREE_PRICAP_ARRAY;
return nullptr;
}
temp = allSyscapBuffer;
}
FREE_PRICAP_ARRAY:
free(priCapArray);
FREE_PRIOUTPUT:
free(priOutput);
return allSyscapBuffer;
}
static char* FreeAfterGetSysCap(char *priOutput, char (*priCapArray)[SINGLE_SYSCAP_LEN], char *allSyscapBuffer,
int32_t type)
{
if (type == FREE_PRICAP_ARRAY_AFTER_GET_SYS_CAP) {
free(priCapArray);
}
free(priOutput);
return allSyscapBuffer;
}
static char* GetSystemCapability()
{
bool retBool;
int retError, priOutputLen;
char osOutput[SINGLE_SYSCAP_LEN] = {};
uint32_t *osCapU32 = nullptr;
char *priOutput = nullptr;
char *allSyscapBuffer = nullptr;
char osCapArray[PCID_MAIN_U32][U32_TO_STR_MAX_LEN] = {};
char (*priCapArray)[SINGLE_SYSCAP_LEN] = nullptr;
retBool = EncodeOsSyscap(osOutput, PCID_MAIN_BYTES);
if (!retBool) {
PRINT_ERR("get encoded os syscap failed.");
return nullptr;
}
retBool = EncodePrivateSyscap(&priOutput, &priOutputLen);
if (!retBool) {
PRINT_ERR("get encoded private syscap failed.");
return FreeAfterGetSysCap(priOutput, priCapArray, allSyscapBuffer, FREE_PRIOUTPUT_AFTER_GET_SYS_CAP);
}
osCapU32 = reinterpret_cast<uint32_t *>(osOutput);
for (size_t i = 0; i < PCID_MAIN_U32; i++) { // 2, header of pcid.sc
retError = sprintf_s(osCapArray[i], U32_TO_STR_MAX_LEN, "%u", osCapU32[i]);
if (retError == -1) {
PRINT_ERR("get uint32_t syscap string failed.");
return FreeAfterGetSysCap(priOutput, priCapArray, allSyscapBuffer, FREE_PRIOUTPUT_AFTER_GET_SYS_CAP);
}
}
allSyscapBuffer = CalculateAllStringLength(priOutput, osCapArray, priCapArray, allSyscapBuffer);
return FreeAfterGetSysCap(priOutput, priCapArray, allSyscapBuffer, FREE_PRICAP_ARRAY_AFTER_GET_SYS_CAP);
}
napi_value QuerySystemCapability(napi_env env, napi_callback_info info)
{
GET_PARAMS(env, info, 1);
src/create_pcid.c
+169 -181
View File
@@ -211,10 +211,26 @@ int32_t GetPriSyscapLen(uint32_t privateCapSize, cJSON *jsonPriSyscapObj, uint16
return 0;
}
int32_t FreeAfterCreatePCID(PCIDMain *pcidBuffer, cJSON *allOsSyscapObj, char *contextBuffer,
int32_t type, int32_t ret);
static int32_t CheckConvertedContextSaveAsFile(char *outDirPath, PCIDMain *pcidBuffer, uint16_t pcidLength, int32_t ret)
{
const char pcidFileName[] = "PCID.sc";
ret = ConvertedContextSaveAsFile(outDirPath, pcidFileName, (char *)pcidBuffer, pcidLength);
if (ret != 0) {
PRINT_ERR("Save as file failed, outDirPath:%s, filename:%s\n", outDirPath, pcidFileName);
}
return ret;
}
int32_t CheckConvertedContextSaveAsFile(char *outDirPath, PCIDMain *pcidBuffer, uint16_t pcidLength, int32_t ret);
static int32_t FreeAfterCreatePCID(PCIDMain *pcidBuffer, cJSON *allOsSyscapObj, char *contextBuffer,
int32_t type, int32_t ret)
{
if (type == FREE_CREATE_PCID_BUFFER_OUT) {
free(pcidBuffer);
}
cJSON_Delete(allOsSyscapObj);
FreeContextBuffer(contextBuffer);
return ret;
}
int32_t CreatePCID(char *inputFile, char *outDirPath)
{
@@ -273,27 +289,6 @@ int32_t CreatePCID(char *inputFile, char *outDirPath)
return FreeAfterCreatePCID(pcidBuffer, allOsSyscapObj, contextBuffer, FREE_CREATE_PCID_BUFFER_OUT, ret);
}
int32_t CheckConvertedContextSaveAsFile(char *outDirPath, PCIDMain *pcidBuffer, uint16_t pcidLength, int32_t ret)
{
const char pcidFileName[] = "PCID.sc";
ret = ConvertedContextSaveAsFile(outDirPath, pcidFileName, (char *)pcidBuffer, pcidLength);
if (ret != 0) {
PRINT_ERR("Save as file failed, outDirPath:%s, filename:%s\n", outDirPath, pcidFileName);
}
return ret;
}
int32_t FreeAfterCreatePCID(PCIDMain *pcidBuffer, cJSON *allOsSyscapObj, char *contextBuffer,
int32_t type, int32_t ret)
{
if (type == FREE_CREATE_PCID_BUFFER_OUT) {
free(pcidBuffer);
}
cJSON_Delete(allOsSyscapObj);
FreeContextBuffer(contextBuffer);
return ret;
}
int32_t GetOsSyscap(PCIDMain *pcidMain, cJSON *sysCapObject)
{
uint32_t i, j, countOfSyscap = 0;
@@ -386,35 +381,88 @@ int32_t GetPriSyscap(PCIDMain *pcidMain, cJSON *sysCapObject, size_t contextBufL
return 0;
}
int32_t CheckJsonRootObj(struct FreeDecodePcidJsonInfo gFreePcidJsonInfo, PCIDMain *pcidMain, char *systemType);
static int32_t CheckSysCapObj(struct FreeDecodePcidJsonInfo freePcidJsonInfo, PCIDMain *pcidMain,
uint32_t contextBufLen, int32_t ret)
{
freePcidJsonInfo.flag = 0;
if (freePcidJsonInfo.sysCapObj == NULL) {
PRINT_ERR("cJSON_CreateObject failed\n");
freePcidJsonInfo.flag = -1;
return -1;
}
if (GetOsSyscap(pcidMain, freePcidJsonInfo.sysCapObj) != 0) {
freePcidJsonInfo.flag = -1;
return ret;
}
if (GetPriSyscap(pcidMain, freePcidJsonInfo.sysCapObj, contextBufLen) != 0) {
freePcidJsonInfo.flag = -1;
}
return ret;
}
int32_t FreeAfterDecodePCID(struct FreeDecodePcidJsonInfo gFreePcidJsonInfo, int32_t type, int32_t ret);
static int32_t CheckJsonRootObj(struct FreeDecodePcidJsonInfo freePcidJsonInfo, PCIDMain *pcidMain, char *systemType)
{
if (!cJSON_AddNumberToObject(freePcidJsonInfo.jsonRootObj, "api_version", NtohsInter(pcidMain->apiVersion))) {
PRINT_ERR("cJSON_AddNumberToObject failed\n");
return -1;
}
if (!cJSON_AddNumberToObject(freePcidJsonInfo.jsonRootObj, "manufacturer_id",
NtohlInter(pcidMain->manufacturerID))) {
PRINT_ERR("cJSON_AddNumberToObject failed\n");
return -1;
}
if (!cJSON_AddStringToObject(freePcidJsonInfo.jsonRootObj, "system_type", systemType)) {
PRINT_ERR("cJSON_AddStringToObject failed\n");
return -1;
}
if (!cJSON_AddItemToObject(freePcidJsonInfo.jsonRootObj, "syscap", freePcidJsonInfo.sysCapObj)) {
PRINT_ERR("cJSON_AddItemToObject failed\n");
return -1;
}
return 0;
}
int32_t CheckSysCapObj(struct FreeDecodePcidJsonInfo gFreePcidJsonInfo, PCIDMain *pcidMain,
uint32_t contextBufLen, int32_t ret);
static int32_t FreeAfterDecodePCID(struct FreeDecodePcidJsonInfo freePcidJsonInfo, int32_t type, int32_t ret)
{
switch (type) {
case FREE_DECODE_PCID_CONVERT_OUT:
free(freePcidJsonInfo.strJson);
/* fall-through */
case FREE_DECODE_PCID_ROOT_OUT:
cJSON_Delete(freePcidJsonInfo.jsonRootObj);
/* fall-through */
case FREE_DECODE_PCID_SYSCAP_OUT:
cJSON_Delete(freePcidJsonInfo.sysCapObj);
/* fall-through */
case FREE_DECODE_PCID_CONTEXT_OUT:
default:
FreeContextBuffer(freePcidJsonInfo.contextBuffer);
}
return ret;
}
int32_t DecodePCID(char *inputFile, char *outDirPath)
{
int32_t ret = 0;
uint32_t contextBufLen;
struct FreeDecodePcidJsonInfo gFreePcidJsonInfo;
gFreePcidJsonInfo.strJson = NULL;
gFreePcidJsonInfo.contextBuffer = NULL;
gFreePcidJsonInfo.jsonRootObj = NULL;
gFreePcidJsonInfo.sysCapObj = NULL;
struct FreeDecodePcidJsonInfo freePcidJsonInfo;
freePcidJsonInfo.strJson = NULL;
freePcidJsonInfo.contextBuffer = NULL;
freePcidJsonInfo.jsonRootObj = NULL;
freePcidJsonInfo.sysCapObj = NULL;
ret = GetFileContext(inputFile, &gFreePcidJsonInfo.contextBuffer, (uint32_t *)&contextBufLen);
ret = GetFileContext(inputFile, &freePcidJsonInfo.contextBuffer, (uint32_t *)&contextBufLen);
if (ret != 0) {
PRINT_ERR("GetFileContext failed, input file : %s\n", inputFile);
return -1;
}
PCIDMain *pcidMain = (PCIDMain *)gFreePcidJsonInfo.contextBuffer;
PCIDMain *pcidMain = (PCIDMain *)freePcidJsonInfo.contextBuffer;
/* api version */
if (pcidMain->apiVersionType != 0) {
PRINT_ERR("Prase file failed, apiVersionType is invaild, input file : %s\n", inputFile);
return FreeAfterDecodePCID(gFreePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, -1);
return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, -1);
}
/* system type */
@@ -423,94 +471,37 @@ int32_t DecodePCID(char *inputFile, char *outDirPath)
(pcidMain->systemType == 0b100 ? "standard" : NULL));
if (systemType == NULL) {
PRINT_ERR("prase file failed, systemType is invaild, %u\n", pcidMain->systemType);
return FreeAfterDecodePCID(gFreePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, -1);
return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, -1);
}
/* syscap */
gFreePcidJsonInfo.sysCapObj = cJSON_CreateObject();
ret = CheckSysCapObj(gFreePcidJsonInfo, pcidMain, contextBufLen, ret);
if (gFreePcidJsonInfo.flag == -1) {
return FreeAfterDecodePCID(gFreePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, ret);
freePcidJsonInfo.sysCapObj = cJSON_CreateObject();
ret = CheckSysCapObj(freePcidJsonInfo, pcidMain, contextBufLen, ret);
if (freePcidJsonInfo.flag == -1) {
return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONTEXT_OUT, ret);
}
// create json root
gFreePcidJsonInfo.jsonRootObj = cJSON_CreateObject();
if (gFreePcidJsonInfo.jsonRootObj == NULL) {
freePcidJsonInfo.jsonRootObj = cJSON_CreateObject();
if (freePcidJsonInfo.jsonRootObj == NULL) {
PRINT_ERR("cJSON_CreateObject failed\n");
return FreeAfterDecodePCID(gFreePcidJsonInfo, FREE_DECODE_PCID_SYSCAP_OUT, -1);
return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_SYSCAP_OUT, -1);
}
ret = CheckJsonRootObj(gFreePcidJsonInfo, pcidMain, systemType);
ret = CheckJsonRootObj(freePcidJsonInfo, pcidMain, systemType);
if (ret == -1) {
return FreeAfterDecodePCID(gFreePcidJsonInfo, FREE_DECODE_PCID_ROOT_OUT, ret);
return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_ROOT_OUT, ret);
}
gFreePcidJsonInfo.sysCapObj = NULL; // avoid being released repeatedly.
freePcidJsonInfo.sysCapObj = NULL; // avoid being released repeatedly.
char *strJson = cJSON_Print(gFreePcidJsonInfo.jsonRootObj);
char *strJson = cJSON_Print(freePcidJsonInfo.jsonRootObj);
const char outputFileName[] = "PCID.json";
ret = ConvertedContextSaveAsFile(outDirPath, outputFileName, strJson, strlen(strJson));
if (ret != 0) {
PRINT_ERR("ConvertedContextSaveAsFile failed, outDirPath:%s, filename:%s\n", outDirPath, outputFileName);
}
return FreeAfterDecodePCID(gFreePcidJsonInfo, FREE_DECODE_PCID_CONVERT_OUT, ret);
}
int32_t CheckSysCapObj(struct FreeDecodePcidJsonInfo gFreePcidJsonInfo, PCIDMain *pcidMain,
uint32_t contextBufLen, int32_t ret)
{
gFreePcidJsonInfo.flag = 0;
if (gFreePcidJsonInfo.sysCapObj == NULL) {
PRINT_ERR("cJSON_CreateObject failed\n");
gFreePcidJsonInfo.flag = -1;
return -1;
}
if (GetOsSyscap(pcidMain, gFreePcidJsonInfo.sysCapObj) != 0) {
gFreePcidJsonInfo.flag = -1;
return ret;
}
if (GetPriSyscap(pcidMain, gFreePcidJsonInfo.sysCapObj, contextBufLen) != 0) {
gFreePcidJsonInfo.flag = -1;
}
return ret;
}
int32_t CheckJsonRootObj(struct FreeDecodePcidJsonInfo gFreePcidJsonInfo, PCIDMain *pcidMain, char *systemType)
{
if (!cJSON_AddNumberToObject(gFreePcidJsonInfo.jsonRootObj, "api_version", NtohsInter(pcidMain->apiVersion))) {
PRINT_ERR("cJSON_AddNumberToObject failed\n");
return -1;
}
if (!cJSON_AddNumberToObject(gFreePcidJsonInfo.jsonRootObj, "manufacturer_id",
NtohlInter(pcidMain->manufacturerID))) {
PRINT_ERR("cJSON_AddNumberToObject failed\n");
return -1;
}
if (!cJSON_AddStringToObject(gFreePcidJsonInfo.jsonRootObj, "system_type", systemType)) {
PRINT_ERR("cJSON_AddStringToObject failed\n");
return -1;
}
if (!cJSON_AddItemToObject(gFreePcidJsonInfo.jsonRootObj, "syscap", gFreePcidJsonInfo.sysCapObj)) {
PRINT_ERR("cJSON_AddItemToObject failed\n");
return -1;
}
return 0;
}
int32_t FreeAfterDecodePCID(struct FreeDecodePcidJsonInfo gFreePcidJsonInfo, int32_t type, int32_t ret)
{
switch (type) {
case FREE_DECODE_PCID_CONVERT_OUT:
free(gFreePcidJsonInfo.strJson);
case FREE_DECODE_PCID_ROOT_OUT:
cJSON_Delete(gFreePcidJsonInfo.jsonRootObj);
case FREE_DECODE_PCID_SYSCAP_OUT:
cJSON_Delete(gFreePcidJsonInfo.sysCapObj);
case FREE_DECODE_PCID_CONTEXT_OUT:
default:
FreeContextBuffer(gFreePcidJsonInfo.contextBuffer);
}
return ret;
return FreeAfterDecodePCID(freePcidJsonInfo, FREE_DECODE_PCID_CONVERT_OUT, ret);
}
#define U32_TO_STR_MAX_LEN 11
@@ -726,10 +717,63 @@ int32_t DecodeStringPCIDToJson(char *input, char *outDirPath)
return ret;
}
int32_t FreeAfterEncodePCID(struct FreeEncodePcidInfo gFreePcidInfo, int32_t type, int32_t ret);
static int32_t FreeAfterEncodePCID(struct FreeEncodePcidInfo freePcidInfo, int32_t type, int32_t ret)
{
switch (type) {
case FREE_ENCODE_PCID_OUT:
free(freePcidInfo.output);
/* fall-through */
case FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT:
free(freePcidInfo.priSyscapFull);
/* fall-through */
case FREE_ENCODE_PCID_CONTEXT_OUT:
default:
free(freePcidInfo.contextBuffer);
}
return ret;
}
int32_t GetEncodePCIDOut(uint16_t priSyscapCount, uint32_t privateSyscapLen, uint32_t *mainSyscap,
struct FreeEncodePcidInfo gFreePcidInfo, int32_t ret);
static int32_t GetEncodePCIDOut(uint16_t priSyscapCount, uint32_t privateSyscapLen, uint32_t *mainSyscap,
struct FreeEncodePcidInfo freePcidInfo, int32_t ret)
{
// 17, size of "SystemCapability."
uint32_t outputLen = U32_TO_STR_MAX_LEN * PCID_OUT_BUFFER + 17 * priSyscapCount + privateSyscapLen + 1;
char *output = NULL;
uint32_t i;
output = (char *)malloc(outputLen);
if (output == NULL) {
PRINT_ERR("malloc failed\n");
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
}
(void)memset_s(output, outputLen, 0, outputLen);
ret = sprintf_s(output, outputLen, "%u", mainSyscap[0]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed\n");
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
for (i = 1; i < PCID_OUT_BUFFER; i++) {
ret = sprintf_s(output, outputLen, "%s,%u", output, mainSyscap[i]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed\n");
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
}
for (i = 0; i < priSyscapCount; i++) {
ret = sprintf_s(output, outputLen, "%s,%s", output, freePcidInfo.priSyscapFull + i * SINGLE_SYSCAP_LEN);
if (ret == -1) {
PRINT_ERR("sprintf_s failed\n");
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
}
// save as file
const char outputFileName[] = "PCID.txt";
ret = ConvertedContextSaveAsFile(freePcidInfo.outDirPathFinal, outputFileName, output, strlen(output));
if (ret != 0) {
PRINT_ERR("ConvertedContextSaveAsFile failed, outDirPath:%s, filename:%s\n",
freePcidInfo.outDirPathFinal, outputFileName);
}
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
int32_t EncodePcidscToString(char *inputFile, char *outDirPath)
{
@@ -740,14 +784,14 @@ int32_t EncodePcidscToString(char *inputFile, char *outDirPath)
uint16_t priSyscapCount = 0;
char *privateSyscap = NULL;
struct FreeEncodePcidInfo gFreePcidInfo;
gFreePcidInfo.contextBuffer = NULL;
gFreePcidInfo.priSyscapFull = NULL;
gFreePcidInfo.output = NULL;
gFreePcidInfo.outDirPathFinal = outDirPath;
struct FreeEncodePcidInfo freePcidInfo;
freePcidInfo.contextBuffer = NULL;
freePcidInfo.priSyscapFull = NULL;
freePcidInfo.output = NULL;
freePcidInfo.outDirPathFinal = outDirPath;
PCIDMain *pcidMain = NULL;
ret = GetFileContext(inputFile, &gFreePcidInfo.contextBuffer, (uint32_t *)&bufferLen);
ret = GetFileContext(inputFile, &freePcidInfo.contextBuffer, (uint32_t *)&bufferLen);
if (ret != 0) {
PRINT_ERR("Get pcid file failed, pcid file path: %s\n", inputFile);
return -1;
@@ -755,10 +799,10 @@ int32_t EncodePcidscToString(char *inputFile, char *outDirPath)
if (bufferLen > 1128) { // 1128, max size of pcid.sc
PRINT_ERR("Input pcid file too large, pcid file size: %u\n", bufferLen);
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_CONTEXT_OUT, ret);
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_CONTEXT_OUT, ret);
}
pcidMain = (PCIDMain *)gFreePcidInfo.contextBuffer;
pcidMain = (PCIDMain *)freePcidInfo.contextBuffer;
privateSyscap = (char *)(pcidMain + 1);
privateSyscapLen = strlen(privateSyscap);
@@ -772,25 +816,25 @@ int32_t EncodePcidscToString(char *inputFile, char *outDirPath)
}
}
if (priSyscapCount == 0) {
return GetEncodePCIDOut(priSyscapCount, privateSyscapLen, mainSyscap, gFreePcidInfo, ret);
return GetEncodePCIDOut(priSyscapCount, privateSyscapLen, mainSyscap, freePcidInfo, ret);
}
gFreePcidInfo.priSyscapFull = (char *)malloc(priSyscapCount * SINGLE_SYSCAP_LEN);
if (gFreePcidInfo.priSyscapFull == NULL) {
freePcidInfo.priSyscapFull = (char *)malloc(priSyscapCount * SINGLE_SYSCAP_LEN);
if (freePcidInfo.priSyscapFull == NULL) {
PRINT_ERR("malloc failed\n");
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
}
(void)memset_s(gFreePcidInfo.priSyscapFull, priSyscapCount * SINGLE_SYSCAP_LEN,
(void)memset_s(freePcidInfo.priSyscapFull, priSyscapCount * SINGLE_SYSCAP_LEN,
0, priSyscapCount * SINGLE_SYSCAP_LEN);
char tempSyscap[SINGLE_SYSCAP_LEN] = {0};
char *temp = tempSyscap;
for (i = 0, j = 0; i < privateSyscapLen; i++) {
if (*privateSyscap == ',') {
*temp = '\0';
ret = sprintf_s(gFreePcidInfo.priSyscapFull + j * SINGLE_SYSCAP_LEN, SINGLE_SYSCAP_LEN,
ret = sprintf_s(freePcidInfo.priSyscapFull + j * SINGLE_SYSCAP_LEN, SINGLE_SYSCAP_LEN,
"SystemCapability.%s", tempSyscap);
if (ret == -1) {
PRINT_ERR("sprintf_s failed\n");
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
return FreeAfterEncodePCID(freePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
}
temp = tempSyscap;
privateSyscap++;
@@ -800,61 +844,5 @@ int32_t EncodePcidscToString(char *inputFile, char *outDirPath)
*temp++ = *privateSyscap++;
}
// output
return GetEncodePCIDOut(priSyscapCount, privateSyscapLen, mainSyscap, gFreePcidInfo, ret);
}
int32_t GetEncodePCIDOut(uint16_t priSyscapCount, uint32_t privateSyscapLen, uint32_t *mainSyscap,
struct FreeEncodePcidInfo gFreePcidInfo, int32_t ret)
{
// 17, size of "SystemCapability."
uint32_t outputLen = U32_TO_STR_MAX_LEN * PCID_OUT_BUFFER + 17 * priSyscapCount + privateSyscapLen + 1;
char *output = NULL;
uint32_t i;
output = (char *)malloc(outputLen);
if (output == NULL) {
PRINT_ERR("malloc failed\n");
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT, ret);
}
(void)memset_s(output, outputLen, 0, outputLen);
ret = sprintf_s(output, outputLen, "%u", mainSyscap[0]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed\n");
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
for (i = 1; i < PCID_OUT_BUFFER; i++) {
ret = sprintf_s(output, outputLen, "%s,%u", output, mainSyscap[i]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed\n");
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
}
for (i = 0; i < priSyscapCount; i++) {
ret = sprintf_s(output, outputLen, "%s,%s", output, gFreePcidInfo.priSyscapFull + i * SINGLE_SYSCAP_LEN);
if (ret == -1) {
PRINT_ERR("sprintf_s failed\n");
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
}
// save as file
const char outputFileName[] = "PCID.txt";
ret = ConvertedContextSaveAsFile(gFreePcidInfo.outDirPathFinal, outputFileName, output, strlen(output));
if (ret != 0) {
PRINT_ERR("ConvertedContextSaveAsFile failed, outDirPath:%s, filename:%s\n",
gFreePcidInfo.outDirPathFinal, outputFileName);
}
return FreeAfterEncodePCID(gFreePcidInfo, FREE_ENCODE_PCID_OUT, ret);
}
int32_t FreeAfterEncodePCID(struct FreeEncodePcidInfo gFreePcidInfo, int32_t type, int32_t ret)
{
switch (type) {
case FREE_ENCODE_PCID_OUT:
free(gFreePcidInfo.output);
case FREE_ENCODE_PCID_PRISYSCAP_FULL_OUT:
free(gFreePcidInfo.priSyscapFull);
case FREE_ENCODE_PCID_CONTEXT_OUT:
default:
free(gFreePcidInfo.contextBuffer);
}
return ret;
return GetEncodePCIDOut(priSyscapCount, privateSyscapLen, mainSyscap, freePcidInfo, ret);
}
src/syscap_tool.c
+245 -167
View File
@@ -44,6 +44,88 @@
#define U32_TO_STR_MAX_LEN 11
#define STRING_FORMAT_LEN_MAX 1024
#define FREE_CONVERT_OUT_RPCID_ENCODE 1
#define FREE_CONTEXT_OUT_RPCID_ENCODE 2
#define FREE_OUTBUFFER_AFTER_RPCIDSC 1
#define FREE_MALLOC_RPISYSCAP_AFTER_RPCIDSC 2
#define FREE_MALLOC_OSSYSCAP_AFTER_RPCIDSC 3
#define FREE_WHOLE_SYSCAP_AFTER_RPCIDSC 4
#define FREE_RPCID_ROOT_AFTER_RPCIDSC 5
#define FREE_CONTEXT_OUT_AFTER_RPCIDSC 6
struct JsonObjectSysCap{
cJSON *cjsonObjectRoot;
cJSON *sysCapPtr;
};
struct FreeAfterEncodeRpcidscInfo {
char *outBuffer;
char *priSyscapArray;
uint16_t *osSysCapIndex;
cJSON *sysCapDefine;
cJSON *rpcidRoot;
char *contextBuffer;
int32_t type;
int16_t flag;
};
static int32_t FillOsCapLength(char *convertedBuffer, char *contextBuffer, struct JsonObjectSysCap gJsonObjectSysCap,
uint32_t sysCapSize, int32_t ret)
{
RPCIDHead *headPtr = NULL;
char *fillTmpPtr = NULL;
cJSON *apiVerItem = NULL;
cJSON *arrayItemPtr = NULL;
headPtr = (RPCIDHead *)convertedBuffer;
apiVerItem = cJSON_GetObjectItem(gJsonObjectSysCap.cjsonObjectRoot, "api_version");
if (apiVerItem == NULL || !cJSON_IsNumber(apiVerItem)) {
PRINT_ERR("get \"api_version\" failed\n");
return -1;
}
headPtr->apiVersion = HtonsInter((uint16_t)apiVerItem->valueint);
headPtr->apiVersionType = 1;
fillTmpPtr = convertedBuffer + sizeof(RPCIDHead);
*(uint16_t *)fillTmpPtr = HtonsInter(2); // 2, SysCap Type, 2: request Cap
fillTmpPtr += sizeof(uint16_t);
// fill osCap Length
*(uint16_t *)fillTmpPtr = HtonsInter((uint16_t)(sysCapSize * SINGLE_FEAT_LEN));
fillTmpPtr += sizeof(uint16_t);
for (uint32_t i = 0; i < sysCapSize; i++) {
arrayItemPtr = cJSON_GetArrayItem(gJsonObjectSysCap.sysCapPtr, (int)i);
char *pointPos = strchr(arrayItemPtr->valuestring, '.');
if (pointPos == NULL) {
PRINT_ERR("context of \"syscap\" array is invalid\n");
return -1;
}
ret = strncmp(arrayItemPtr->valuestring, "SystemCapability.", pointPos - arrayItemPtr->valuestring + 1);
if (ret != 0) {
PRINT_ERR("context of \"syscap\" array is invalid\n");
return -1;
}
ret = memcpy_s(fillTmpPtr, SINGLE_FEAT_LEN, pointPos + 1, strlen(pointPos + 1));
if (ret != 0) {
PRINT_ERR("context of \"syscap\" array is invalid\n");
return -1;
}
fillTmpPtr += SINGLE_FEAT_LEN;
}
return ret;
}
static int32_t FreeAfterRPCIDEncode(char *convertedBuffer, char *contextBuffer, int32_t type, int32_t ret)
{
if (type == FREE_CONVERT_OUT_RPCID_ENCODE) {
free(convertedBuffer);
}
FreeContextBuffer(contextBuffer);
return ret;
}
int32_t RPCIDEncode(char *inputFile, char *outputPath)
{
int32_t ret;
@@ -51,12 +133,9 @@ int32_t RPCIDEncode(char *inputFile, char *outputPath)
uint32_t bufferLen, sysCapSize;
char *convertedBuffer = NULL;
uint32_t convertedBufLen = sizeof(RPCIDHead);
RPCIDHead *headPtr = NULL;
char *fillTmpPtr = NULL;
cJSON *cjsonObjectRoot = NULL;
cJSON *apiVerItem = NULL;
cJSON *sysCapPtr = NULL;
cJSON *arrayItemPtr = NULL;
struct JsonObjectSysCap gJsonObjectSysCap;
gJsonObjectSysCap.cjsonObjectRoot = NULL;
gJsonObjectSysCap.sysCapPtr = NULL;
ret = GetFileContext(inputFile, &contextBuffer, &bufferLen);
if (ret != 0) {
@@ -64,25 +143,22 @@ int32_t RPCIDEncode(char *inputFile, char *outputPath)
return ret;
}
cjsonObjectRoot = cJSON_ParseWithLength(contextBuffer, bufferLen);
if (cjsonObjectRoot == NULL) {
gJsonObjectSysCap.cjsonObjectRoot = cJSON_ParseWithLength(contextBuffer, bufferLen);
if (gJsonObjectSysCap.cjsonObjectRoot == NULL) {
PRINT_ERR("cJSON_Parse failed, context buffer is:\n%s\n", contextBuffer);
ret = -1;
goto FREE_CONTEXT_OUT;
return FreeAfterRPCIDEncode(convertedBuffer, contextBuffer, FREE_CONTEXT_OUT_RPCID_ENCODE, -1);
}
sysCapPtr = cJSON_GetObjectItem(cjsonObjectRoot, "syscap");
if (sysCapPtr == NULL || !cJSON_IsArray(sysCapPtr)) {
gJsonObjectSysCap.sysCapPtr = cJSON_GetObjectItem(gJsonObjectSysCap.cjsonObjectRoot, "syscap");
if (gJsonObjectSysCap.sysCapPtr == NULL || !cJSON_IsArray(gJsonObjectSysCap.sysCapPtr)) {
PRINT_ERR("get \"syscap\" object failed.\n");
ret = -1;
goto FREE_CONTEXT_OUT;
return FreeAfterRPCIDEncode(convertedBuffer, contextBuffer, FREE_CONTEXT_OUT_RPCID_ENCODE, -1);
}
ret = cJSON_GetArraySize(sysCapPtr);
ret = cJSON_GetArraySize(gJsonObjectSysCap.sysCapPtr);
if (ret < 0) {
PRINT_ERR("get \"syscap\" array size failed\n");
ret = -1;
goto FREE_CONTEXT_OUT;
return FreeAfterRPCIDEncode(convertedBuffer, contextBuffer, FREE_CONTEXT_OUT_RPCID_ENCODE, -1);
}
sysCapSize = (uint32_t)ret;
// 2, to save SysCaptype & SysCapLength
@@ -91,63 +167,19 @@ int32_t RPCIDEncode(char *inputFile, char *outputPath)
convertedBuffer = (char *)malloc(convertedBufLen);
if (convertedBuffer == NULL) {
PRINT_ERR("malloc failed\n");
ret = -1;
goto FREE_CONTEXT_OUT;
return FreeAfterRPCIDEncode(convertedBuffer, contextBuffer, FREE_CONTEXT_OUT_RPCID_ENCODE, -1);
}
(void)memset_s(convertedBuffer, convertedBufLen, 0, convertedBufLen);
headPtr = (RPCIDHead *)convertedBuffer;
apiVerItem = cJSON_GetObjectItem(cjsonObjectRoot, "api_version");
if (apiVerItem == NULL || !cJSON_IsNumber(apiVerItem)) {
PRINT_ERR("get \"api_version\" failed\n");
ret = -1;
goto FREE_CONVERT_OUT;
ret = FillOsCapLength(convertedBuffer, contextBuffer, gJsonObjectSysCap, sysCapSize, ret);
if (ret == -1) {
return FreeAfterRPCIDEncode(convertedBuffer, contextBuffer, FREE_CONVERT_OUT_RPCID_ENCODE, ret);
}
headPtr->apiVersion = HtonsInter((uint16_t)apiVerItem->valueint);
headPtr->apiVersionType = 1;
fillTmpPtr = convertedBuffer + sizeof(RPCIDHead);
*(uint16_t *)fillTmpPtr = HtonsInter(2); // 2, SysCap Type, 2: request Cap
fillTmpPtr += sizeof(uint16_t);
// fill osCap Length
*(uint16_t *)fillTmpPtr = HtonsInter((uint16_t)(sysCapSize * SINGLE_FEAT_LEN));
fillTmpPtr += sizeof(uint16_t);
for (uint32_t i = 0; i < sysCapSize; i++) {
arrayItemPtr = cJSON_GetArrayItem(sysCapPtr, (int)i);
char *pointPos = strchr(arrayItemPtr->valuestring, '.');
if (pointPos == NULL) {
PRINT_ERR("context of \"syscap\" array is invalid\n");
ret = -1;
goto FREE_CONVERT_OUT;
}
ret = strncmp(arrayItemPtr->valuestring, "SystemCapability.", pointPos - arrayItemPtr->valuestring + 1);
if (ret != 0) {
PRINT_ERR("context of \"syscap\" array is invalid\n");
ret = -1;
goto FREE_CONVERT_OUT;
}
ret = memcpy_s(fillTmpPtr, SINGLE_FEAT_LEN, pointPos + 1, strlen(pointPos + 1));
if (ret != 0) {
PRINT_ERR("context of \"syscap\" array is invalid\n");
ret = -1;
goto FREE_CONVERT_OUT;
}
fillTmpPtr += SINGLE_FEAT_LEN;
}
ret = ConvertedContextSaveAsFile(outputPath, "RPCID.sc", convertedBuffer, convertedBufLen);
if (ret != 0) {
PRINT_ERR("ConvertedContextSaveAsFile failed, outputPath:%s, filename:rpcid.sc\n", outputPath);
goto FREE_CONVERT_OUT;
}
FREE_CONVERT_OUT:
free(convertedBuffer);
FREE_CONTEXT_OUT:
FreeContextBuffer(contextBuffer);
return ret;
return FreeAfterRPCIDEncode(convertedBuffer, contextBuffer, FREE_CONVERT_OUT_RPCID_ENCODE, ret);
}
static int32_t ParseRpcidToJson(char *input, uint32_t inputLen, cJSON *rpcidJson)
@@ -256,142 +288,188 @@ static int SetOsSysCapBitMap(uint8_t *out, uint16_t outLen, const uint16_t *inde
return 0;
}
int32_t EncodeRpcidscToString(char *inputFile, char *outDirPath)
static int32_t PrintOutputToFile(struct FreeAfterEncodeRpcidscInfo freeAfterEncodeRpcidscInfo, uint16_t outBufferLen,
uint32_t outUint[RPCID_OUT_BUFFER], uint16_t indexPri, char *outDirPath)
{
int32_t ret = 0;
int32_t sysCapArraySize;
uint32_t bufferLen;
uint16_t indexPri = 0;
uint16_t *osSysCapIndex;
char *contextBuffer = NULL;
char *priSyscapArray = NULL;
freeAfterEncodeRpcidscInfo.type = FREE_OUTBUFFER_AFTER_RPCIDSC;
(void)memset_s(freeAfterEncodeRpcidscInfo.outBuffer, outBufferLen, 0, outBufferLen);
ret = sprintf_s(freeAfterEncodeRpcidscInfo.outBuffer, outBufferLen, "%u", outUint[0]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed.\n");
freeAfterEncodeRpcidscInfo.flag = 1;
return ret;
}
for (int i = 1; i < RPCID_OUT_BUFFER; i++) {
ret = sprintf_s(freeAfterEncodeRpcidscInfo.outBuffer, outBufferLen, "%s,%u",
freeAfterEncodeRpcidscInfo.outBuffer, outUint[i]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed.\n");
freeAfterEncodeRpcidscInfo.flag = 1;
return ret;
}
}
for (uint16_t i = 0; i < indexPri; i++) {
ret = sprintf_s(freeAfterEncodeRpcidscInfo.outBuffer, outBufferLen, "%s,%s",
freeAfterEncodeRpcidscInfo.outBuffer, freeAfterEncodeRpcidscInfo.priSyscapArray + i * SINGLE_SYSCAP_LEN);
if (ret == -1) {
PRINT_ERR("sprintf_s failed.\n");
freeAfterEncodeRpcidscInfo.flag = 1;
return ret;
}
}
const char outputFilename[] = "RPCID.txt";
ret = ConvertedContextSaveAsFile(outDirPath, outputFilename, freeAfterEncodeRpcidscInfo.outBuffer,
strlen(freeAfterEncodeRpcidscInfo.outBuffer));
if (ret != 0) {
PRINT_ERR("Save to txt file failed. Output path:%s/%s\n", outDirPath, outputFilename);
freeAfterEncodeRpcidscInfo.flag = 1;
}
return ret;
}
static int32_t OutputSetMemAndPrintToFile(struct FreeAfterEncodeRpcidscInfo freeAfterEncodeRpcidscInfo,
int32_t sysCapArraySize, cJSON *sysCapArray, char *outDirPath)
{
char *priSyscap = NULL;
cJSON *cJsonTemp = NULL;
cJSON *rpcidRoot = NULL;
cJSON *sysCapDefine = NULL;
cJSON *sysCapArray = NULL;
uint16_t indexPri = 0;
int32_t ret = 0;
freeAfterEncodeRpcidscInfo.type = FREE_MALLOC_OSSYSCAP_AFTER_RPCIDSC;
// check rpcid.sc
if (CheckRpcidFormat(inputFile, &contextBuffer, &bufferLen) != 0) {
PRINT_ERR("Check rpcid.sc format failed. Input file: %s\n", inputFile);
goto FREE_CONTEXT_OUT;
}
// parse rpcid to json
rpcidRoot = cJSON_CreateObject();
if (ParseRpcidToJson(contextBuffer, bufferLen, rpcidRoot) != 0) {
PRINT_ERR("Prase rpcid to json failed. Input file: %s\n", inputFile);
goto FREE_RPCID_ROOT;
}
// trans to string format
sysCapDefine = CreateWholeSyscapJsonObj();
sysCapArray = cJSON_GetObjectItem(rpcidRoot, "syscap");
if (sysCapArray == NULL || !cJSON_IsArray(sysCapArray)) {
PRINT_ERR("Get syscap failed. Input file: %s\n", inputFile);
goto FREE_WHOLE_SYSCAP;
}
sysCapArraySize = cJSON_GetArraySize(sysCapArray);
if (sysCapArraySize < 0) {
PRINT_ERR("Get syscap size failed. Input file: %s\n", inputFile);
goto FREE_WHOLE_SYSCAP;
}
// malloc for save os syscap index
osSysCapIndex = (uint16_t *)malloc(sizeof(uint16_t) * sysCapArraySize);
if (osSysCapIndex == NULL) {
PRINT_ERR("malloc failed.\n");
goto FREE_WHOLE_SYSCAP;
}
(void)memset_s(osSysCapIndex, sizeof(uint16_t) * sysCapArraySize,
(void)memset_s(freeAfterEncodeRpcidscInfo.osSysCapIndex, sizeof(uint16_t) * sysCapArraySize,
0, sizeof(uint16_t) * sysCapArraySize);
// malloc for save private syscap string
priSyscapArray = (char *)malloc((uint32_t)sysCapArraySize * SINGLE_SYSCAP_LEN);
if (priSyscapArray == NULL) {
freeAfterEncodeRpcidscInfo.priSyscapArray = (char *)malloc((uint32_t)sysCapArraySize * SINGLE_SYSCAP_LEN);
if (freeAfterEncodeRpcidscInfo.priSyscapArray == NULL) {
PRINT_ERR("malloc(%d) failed.\n", sysCapArraySize * SINGLE_SYSCAP_LEN);
goto FREE_MALLOC_OSSYSCAP;
freeAfterEncodeRpcidscInfo.flag = 1;
return ret;
}
(void)memset_s(priSyscapArray, (size_t)(sysCapArraySize * SINGLE_SYSCAP_LEN),
(void)memset_s(freeAfterEncodeRpcidscInfo.priSyscapArray, (size_t)(sysCapArraySize * SINGLE_SYSCAP_LEN),
0, (size_t)(sysCapArraySize * SINGLE_SYSCAP_LEN));
priSyscap = priSyscapArray;
priSyscap = freeAfterEncodeRpcidscInfo.priSyscapArray;
// part os syscap and ptivate syscap
uint16_t indexOs = 0;
for (int i = 0; i < sysCapArraySize; i++) {
cJSON *cJsonItem = cJSON_GetArrayItem(sysCapArray, i);
cJsonTemp = cJSON_GetObjectItem(sysCapDefine, cJsonItem->valuestring);
cJsonTemp = cJSON_GetObjectItem(freeAfterEncodeRpcidscInfo.sysCapDefine, cJsonItem->valuestring);
if (cJsonTemp != NULL) {
osSysCapIndex[indexOs++] = (uint16_t)(cJsonTemp->valueint);
freeAfterEncodeRpcidscInfo.osSysCapIndex[indexOs++] = (uint16_t)(cJsonTemp->valueint);
} else {
ret = strcpy_s(priSyscap, SINGLE_SYSCAP_LEN, cJsonItem->valuestring);
if (ret != EOK) {
PRINT_ERR("strcpy_s failed.\n");
goto FREE_MALLOC_PRISYSCAP;
freeAfterEncodeRpcidscInfo.flag = 1;
return ret;
}
priSyscap += SINGLE_SYSCAP_LEN;
indexPri++;
}
}
uint32_t outUint[RPCID_OUT_BUFFER] = {0};
outUint[0] = *(uint32_t *)contextBuffer;
outUint[1] = *(uint32_t *)(contextBuffer + sizeof(uint32_t));
outUint[0] = *(uint32_t *)freeAfterEncodeRpcidscInfo.contextBuffer;
outUint[1] = *(uint32_t *)(freeAfterEncodeRpcidscInfo.contextBuffer + sizeof(uint32_t));
uint8_t *osOutUint = (uint8_t *)(outUint + 2);
if (SetOsSysCapBitMap(osOutUint, 120, osSysCapIndex, indexOs) != 0) { // 120, len of osOutUint
if (SetOsSysCapBitMap(osOutUint, 120, freeAfterEncodeRpcidscInfo.osSysCapIndex, indexOs) != 0) { // 120, len of osOutUint
PRINT_ERR("Set os syscap bit map failed.\n");
goto FREE_MALLOC_PRISYSCAP;
freeAfterEncodeRpcidscInfo.flag = 1;
return ret;
}
uint16_t outBufferLen = U32_TO_STR_MAX_LEN * RPCID_OUT_BUFFER
+ SINGLE_SYSCAP_LEN * indexPri;
char *outBuffer = (char *)malloc(outBufferLen);
if (outBuffer == NULL) {
uint16_t outBufferLen = U32_TO_STR_MAX_LEN * RPCID_OUT_BUFFER + SINGLE_SYSCAP_LEN * indexPri;
freeAfterEncodeRpcidscInfo.outBuffer = (char *)malloc(outBufferLen);
if (freeAfterEncodeRpcidscInfo.outBuffer == NULL) {
PRINT_ERR("malloc(%u) failed.\n", outBufferLen);
goto FREE_MALLOC_PRISYSCAP;
freeAfterEncodeRpcidscInfo.flag = 1;
return ret;
}
(void)memset_s(outBuffer, outBufferLen, 0, outBufferLen);
return PrintOutputToFile(freeAfterEncodeRpcidscInfo, outBufferLen, outUint, indexPri, outDirPath);
}
ret = sprintf_s(outBuffer, outBufferLen, "%u", outUint[0]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed.\n");
goto FREE_OUTBUFFER;
static int32_t FreeAfterEncodeRpcidsc(struct FreeAfterEncodeRpcidscInfo freeAfterEncodeRpcidscInfo, int32_t type,
int32_t ret)
{
switch (type) {
case FREE_OUTBUFFER_AFTER_RPCIDSC:
free(freeAfterEncodeRpcidscInfo.outBuffer);
/* fall-through */
case FREE_MALLOC_RPISYSCAP_AFTER_RPCIDSC:
free(freeAfterEncodeRpcidscInfo.priSyscapArray);
/* fall-through */
case FREE_MALLOC_OSSYSCAP_AFTER_RPCIDSC:
free(freeAfterEncodeRpcidscInfo.osSysCapIndex);
/* fall-through */
case FREE_WHOLE_SYSCAP_AFTER_RPCIDSC:
cJSON_Delete(freeAfterEncodeRpcidscInfo.sysCapDefine);
/* fall-through */
case FREE_RPCID_ROOT_AFTER_RPCIDSC:
cJSON_Delete(freeAfterEncodeRpcidscInfo.rpcidRoot);
/* fall-through */
case FREE_CONTEXT_OUT_AFTER_RPCIDSC:
default:
FreeContextBuffer(freeAfterEncodeRpcidscInfo.contextBuffer);
}
for (int i = 1; i < RPCID_OUT_BUFFER; i++) {
ret = sprintf_s(outBuffer, outBufferLen, "%s,%u", outBuffer, outUint[i]);
if (ret == -1) {
PRINT_ERR("sprintf_s failed.\n");
goto FREE_OUTBUFFER;
}
}
for (uint16_t i = 0; i < indexPri; i++) {
ret = sprintf_s(outBuffer, outBufferLen, "%s,%s", outBuffer,
priSyscapArray + i * SINGLE_SYSCAP_LEN);
if (ret == -1) {
PRINT_ERR("sprintf_s failed.\n");
goto FREE_OUTBUFFER;
}
}
const char outputFilename[] = "RPCID.txt";
ret = ConvertedContextSaveAsFile(outDirPath, outputFilename, outBuffer, strlen(outBuffer));
if (ret != 0) {
PRINT_ERR("Save to txt file failed. Output path:%s/%s\n", outDirPath, outputFilename);
goto FREE_OUTBUFFER;
}
FREE_OUTBUFFER:
free(outBuffer);
FREE_MALLOC_PRISYSCAP:
free(priSyscapArray);
FREE_MALLOC_OSSYSCAP:
free(osSysCapIndex);
FREE_WHOLE_SYSCAP:
cJSON_Delete(sysCapDefine);
FREE_RPCID_ROOT:
cJSON_Delete(rpcidRoot);
FREE_CONTEXT_OUT:
FreeContextBuffer(contextBuffer);
return ret;
}
int32_t EncodeRpcidscToString(char *inputFile, char *outDirPath)
{
int32_t ret = 0;
int32_t sysCapArraySize;
uint32_t bufferLen;
cJSON *sysCapArray = NULL;
struct FreeAfterEncodeRpcidscInfo freeAfterEncodeRpcidscInfo;
freeAfterEncodeRpcidscInfo.priSyscapArray = NULL;
freeAfterEncodeRpcidscInfo.osSysCapIndex = NULL;
freeAfterEncodeRpcidscInfo.sysCapDefine = NULL;
freeAfterEncodeRpcidscInfo.rpcidRoot = NULL;
freeAfterEncodeRpcidscInfo.contextBuffer = NULL;
freeAfterEncodeRpcidscInfo.type = 0;
freeAfterEncodeRpcidscInfo.flag = 0;
// check rpcid.sc
if (CheckRpcidFormat(inputFile, &freeAfterEncodeRpcidscInfo.contextBuffer, &bufferLen) != 0) {
PRINT_ERR("Check rpcid.sc format failed. Input file: %s\n", inputFile);
return FreeAfterEncodeRpcidsc(freeAfterEncodeRpcidscInfo, FREE_CONTEXT_OUT_AFTER_RPCIDSC, ret);
}
// parse rpcid to json
freeAfterEncodeRpcidscInfo.rpcidRoot = cJSON_CreateObject();
if (ParseRpcidToJson(freeAfterEncodeRpcidscInfo.contextBuffer, bufferLen,
freeAfterEncodeRpcidscInfo.rpcidRoot) != 0) {
PRINT_ERR("Prase rpcid to json failed. Input file: %s\n", inputFile);
return FreeAfterEncodeRpcidsc(freeAfterEncodeRpcidscInfo, FREE_RPCID_ROOT_AFTER_RPCIDSC, ret);
}
// trans to string format
freeAfterEncodeRpcidscInfo.sysCapDefine = CreateWholeSyscapJsonObj();
sysCapArray = cJSON_GetObjectItem(freeAfterEncodeRpcidscInfo.rpcidRoot, "syscap");
if (sysCapArray == NULL || !cJSON_IsArray(sysCapArray)) {
PRINT_ERR("Get syscap failed. Input file: %s\n", inputFile);
return FreeAfterEncodeRpcidsc(freeAfterEncodeRpcidscInfo, FREE_WHOLE_SYSCAP_AFTER_RPCIDSC, ret);
}
sysCapArraySize = cJSON_GetArraySize(sysCapArray);
if (sysCapArraySize < 0) {
PRINT_ERR("Get syscap size failed. Input file: %s\n", inputFile);
return FreeAfterEncodeRpcidsc(freeAfterEncodeRpcidscInfo, FREE_WHOLE_SYSCAP_AFTER_RPCIDSC, ret);
}
// malloc for save os syscap index
freeAfterEncodeRpcidscInfo.osSysCapIndex = (uint16_t *)malloc(sizeof(uint16_t) * sysCapArraySize);
if (freeAfterEncodeRpcidscInfo.osSysCapIndex == NULL) {
PRINT_ERR("malloc failed.\n");
return FreeAfterEncodeRpcidsc(freeAfterEncodeRpcidscInfo, FREE_WHOLE_SYSCAP_AFTER_RPCIDSC, ret);
}
ret = OutputSetMemAndPrintToFile(freeAfterEncodeRpcidscInfo, sysCapArraySize, sysCapArray, outDirPath);
if (freeAfterEncodeRpcidscInfo.flag == 1) {
return FreeAfterEncodeRpcidsc(freeAfterEncodeRpcidscInfo, freeAfterEncodeRpcidscInfo.type, ret);
}
return FreeAfterEncodeRpcidsc(freeAfterEncodeRpcidscInfo, FREE_OUTBUFFER_AFTER_RPCIDSC, ret);
}
char *CopyInputString(const char *inputString)
{
if (inputString == NULL || *inputString == '\0') {
@@ -607,4 +685,4 @@ int32_t ComparePcidWithRpcidString(char *pcidFile, char *rpcidFile, uint32_t typ
printf("Fail! The pcid does not meet the rpcid\n");
}
return 0;
}
}