/**
* Function to update persistent storage
*/
static bool UpdatePersistentStorage(OicSecPstat_t *pstat)
{
bool bRet = false;
size_t size = 0;
uint8_t *cborPayload = NULL;
OCStackResult ret = PstatToCBORPayload(pstat, &cborPayload, &size);
if (OC_STACK_OK == ret)
{
if (OC_STACK_OK == UpdateSecureResourceInPS(OIC_JSON_PSTAT_NAME, cborPayload, size))
{
bRet = true;
}
OICFree(cborPayload);
}
return bRet;
}
/**
* The entity handler determines how to process a GET request.
*/
static OCEntityHandlerResult HandlePstatGetRequest (const OCEntityHandlerRequest * ehRequest)
{
OIC_LOG(INFO, TAG, "HandlePstatGetRequest processing GET request");
// Convert ACL data into CBOR for transmission
size_t size = 0;
uint8_t *payload = NULL;
OCStackResult res = PstatToCBORPayload(gPstat, &payload, &size);
// A device should always have a default pstat. Therefore, payload should never be NULL.
OCEntityHandlerResult ehRet = (res == OC_STACK_OK) ? OC_EH_OK : OC_EH_ERROR;
// Send response payload to request originator
if (OC_STACK_OK != SendSRMResponse(ehRequest, ehRet, payload, size))
{
ehRet = OC_EH_ERROR;
OIC_LOG(ERROR, TAG, "SendSRMResponse failed in HandlePstatGetRequest");
}
OICFree(payload);
return ehRet;
}
OCStackResult SetPstatRownerId(const OicUuid_t* newROwner)
{
OCStackResult ret = OC_STACK_ERROR;
uint8_t *cborPayload = NULL;
size_t size = 0;
OicUuid_t prevId = {.id={0}};
if(NULL == newROwner)
{
ret = OC_STACK_INVALID_PARAM;
}
if(NULL == gPstat)
{
ret = OC_STACK_NO_RESOURCE;
}
if(newROwner && gPstat)
{
memcpy(prevId.id, gPstat->rownerID.id, sizeof(prevId.id));
memcpy(gPstat->rownerID.id, newROwner->id, sizeof(newROwner->id));
ret = PstatToCBORPayload(gPstat, &cborPayload, &size);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
ret = UpdateSecureResourceInPS(OIC_JSON_PSTAT_NAME, cborPayload, size);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
OICFree(cborPayload);
}
return ret;
exit:
OICFree(cborPayload);
memcpy(gPstat->rownerID.id, prevId.id, sizeof(prevId.id));
return ret;
}
static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName)
{
char *jsonStr = NULL;
FILE *fp = NULL;
FILE *fp1 = NULL;
uint8_t *aclCbor = NULL;
uint8_t *pstatCbor = NULL;
uint8_t *doxmCbor = NULL;
uint8_t *amaclCbor = NULL;
uint8_t *svcCbor = NULL;
uint8_t *credCbor = NULL;
cJSON *jsonRoot = NULL;
OCStackResult ret = OC_STACK_ERROR;
size_t size = GetJSONFileSize(jsonFileName);
if (0 == size)
{
OIC_LOG (ERROR, TAG, "Failed converting to JSON");
return;
}
jsonStr = (char *)OICMalloc(size + 1);
VERIFY_NON_NULL(TAG, jsonStr, FATAL);
fp = fopen(jsonFileName, "r");
if (fp)
{
size_t bytesRead = fread(jsonStr, 1, size, fp);
jsonStr[bytesRead] = '\0';
OIC_LOG_V(DEBUG, TAG, "Read %zu bytes", bytesRead);
fclose(fp);
fp = NULL;
}
else
{
OIC_LOG (ERROR, TAG, "Unable to open JSON file!!");
goto exit;
}
jsonRoot = cJSON_Parse(jsonStr);
cJSON *value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME);
//printf("ACL json : \n%s\n", cJSON_PrintUnformatted(value));
size_t aclCborSize = 0;
if (NULL != value)
{
OicSecAcl_t *acl = JSONToAclBin(jsonStr);
VERIFY_NON_NULL(TAG, acl, FATAL);
ret = AclToCBORPayload(acl, &aclCbor, &aclCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Acl to Cbor Payload");
DeleteACLList(acl);
goto exit;
}
printf("ACL Cbor Size: %zd\n", aclCborSize);
DeleteACLList(acl);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME);
size_t pstatCborSize = 0;
if (NULL != value)
{
OicSecPstat_t *pstat = JSONToPstatBin(jsonStr);
VERIFY_NON_NULL(TAG, pstat, FATAL);
ret = PstatToCBORPayload(pstat, &pstatCbor, &pstatCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Pstat to Cbor Payload");
DeletePstatBinData(pstat);
goto exit;
}
printf("PSTAT Cbor Size: %zd\n", pstatCborSize);
DeletePstatBinData(pstat);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME);
size_t doxmCborSize = 0;
if (NULL != value)
{
OicSecDoxm_t *doxm = JSONToDoxmBin(jsonStr);
VERIFY_NON_NULL(TAG, doxm, FATAL);
ret = DoxmToCBORPayload(doxm, &doxmCbor, &doxmCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Doxm to Cbor Payload");
DeleteDoxmBinData(doxm);
goto exit;
}
printf("DOXM Cbor Size: %zd\n", doxmCborSize);
DeleteDoxmBinData(doxm);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME);
size_t amaclCborSize = 0;
if (NULL != value)
{
OicSecAmacl_t *amacl = JSONToAmaclBin(jsonStr);
VERIFY_NON_NULL(TAG, amacl, FATAL);
ret = AmaclToCBORPayload(amacl, &amaclCbor, &amaclCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Amacl to Cbor Payload");
DeleteAmaclList(amacl);
goto exit;
}
printf("AMACL Cbor Size: %zd\n", amaclCborSize);
DeleteAmaclList(amacl);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_SVC_NAME);
size_t svcCborSize = 0;
if (NULL != value)
{
OicSecSvc_t *svc = JSONToSvcBin(jsonStr);
VERIFY_NON_NULL(TAG, svc, FATAL);
ret = SVCToCBORPayload(svc, &svcCbor, &svcCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Svc to Cbor Payload");
DeleteSVCList(svc);
goto exit;
}
printf("SVC Cbor Size: %zd\n", svcCborSize);
DeleteSVCList(svc);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
//printf("CRED json : \n%s\n", cJSON_PrintUnformatted(value));
size_t credCborSize = 0;
int secureFlag = 0;
if (NULL != value)
{
OicSecCred_t *cred = JSONToCredBin(jsonStr);
VERIFY_NON_NULL(TAG, cred, FATAL);
ret = CredToCBORPayload(cred, &credCbor, &credCborSize, secureFlag);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Cred to Cbor Payload");
DeleteCredList(cred);
goto exit;
}
printf("CRED Cbor Size: %zd\n", credCborSize);
DeleteCredList(cred);
}
CborEncoder encoder;
size_t cborSize = aclCborSize + pstatCborSize + doxmCborSize + svcCborSize + credCborSize + amaclCborSize;
printf("Total Cbor Size : %zd\n", cborSize);
cborSize += 255; // buffer margin for adding map and byte string
uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborSize);
VERIFY_NON_NULL(TAG, outPayload, ERROR);
cbor_encoder_init(&encoder, outPayload, cborSize, 0);
CborEncoder map;
CborError cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Creating Main Map.");
if (aclCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_ACL_NAME, strlen(OIC_JSON_ACL_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Name.");
cborEncoderResult = cbor_encode_byte_string(&map, aclCbor, aclCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Value.");
}
if (pstatCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_PSTAT_NAME, strlen(OIC_JSON_PSTAT_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Name.");
cborEncoderResult = cbor_encode_byte_string(&map, pstatCbor, pstatCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Value.");
}
if (doxmCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_DOXM_NAME, strlen(OIC_JSON_DOXM_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Name.");
cborEncoderResult = cbor_encode_byte_string(&map, doxmCbor, doxmCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Value.");
}
if (amaclCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_AMACL_NAME, strlen(OIC_JSON_AMACL_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Name.");
cborEncoderResult = cbor_encode_byte_string(&map, amaclCbor, amaclCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Value.");
}
if (svcCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_SVC_NAME, strlen(OIC_JSON_SVC_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Name.");
cborEncoderResult = cbor_encode_byte_string(&map, svcCbor, svcCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Value.");
}
if (credCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_CRED_NAME, strlen(OIC_JSON_CRED_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Name.");
cborEncoderResult = cbor_encode_byte_string(&map, credCbor, credCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Value.");
}
cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Container.");
size_t s = encoder.ptr - outPayload;
OIC_LOG_V(DEBUG, TAG, "Payload size %zu", s);
fp1 = fopen(cborFileName, "w");
if (fp1)
{
size_t bytesWritten = fwrite(outPayload, 1, s, fp1);
if (bytesWritten == s)
{
OIC_LOG_V(DEBUG, TAG, "Written %zu bytes", bytesWritten);
}
else
{
OIC_LOG_V(ERROR, TAG, "Failed writing %zu bytes", s);
}
fclose(fp1);
fp1 = NULL;
}
exit:
cJSON_Delete(jsonRoot);
OICFree(aclCbor);
OICFree(doxmCbor);
OICFree(pstatCbor);
OICFree(amaclCbor);
OICFree(svcCbor);
OICFree(credCbor);
OICFree(jsonStr);
return ;
}
OCStackResult PstatToCBORPayload(const OicSecPstat_t *pstat, uint8_t **payload, size_t *size)
{
if (NULL == pstat || NULL == payload || NULL != *payload || NULL == size)
{
return OC_STACK_INVALID_PARAM;
}
size_t cborLen = *size;
if (0 == cborLen)
{
cborLen = CBOR_SIZE;
}
*payload = NULL;
*size = 0;
OCStackResult ret = OC_STACK_ERROR;
CborEncoder encoder;
CborEncoder pstatMap;
char* strUuid = NULL;
int64_t cborEncoderResult = CborNoError;
uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
VERIFY_NON_NULL(TAG, outPayload, ERROR);
cbor_encoder_init(&encoder, outPayload, cborLen, 0);
cborEncoderResult = cbor_encoder_create_map(&encoder, &pstatMap, PSTAT_MAP_SIZE);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Pstat Map.");
cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_ISOP_NAME,
strlen(OIC_JSON_ISOP_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ISOP Name Tag.");
cborEncoderResult = cbor_encode_boolean(&pstatMap, pstat->isOp);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ISOP Name Value.");
cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_DEVICE_ID_NAME,
strlen(OIC_JSON_DEVICE_ID_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Device Id Tag.");
ret = ConvertUuidToStr(&pstat->deviceID, &strUuid);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR);
cborEncoderResult = cbor_encode_text_string(&pstatMap, strUuid, strlen(strUuid));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Device Id Value.");
OICFree(strUuid);
strUuid = NULL;
cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_CM_NAME,
strlen(OIC_JSON_CM_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CM Name Tag.");
cborEncoderResult = cbor_encode_int(&pstatMap, pstat->cm);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CM Name Value.");
cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_TM_NAME,
strlen(OIC_JSON_TM_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding TM Name Tag.");
cborEncoderResult = cbor_encode_int(&pstatMap, pstat->tm);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding TM Name Value.");
cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_OM_NAME,
strlen(OIC_JSON_OM_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding OM Name Tag.");
cborEncoderResult = cbor_encode_int(&pstatMap, pstat->om);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding OM Name Value.");
cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_SM_NAME,
strlen(OIC_JSON_SM_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SM Name Tag.");
cborEncoderResult = cbor_encode_int(&pstatMap, pstat->sm[0]);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SM Name Value.");
cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_ROWNERID_NAME,
strlen(OIC_JSON_ROWNERID_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROwner Id Tag.");
ret = ConvertUuidToStr(&pstat->rownerID, &strUuid);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR);
cborEncoderResult = cbor_encode_text_string(&pstatMap, strUuid, strlen(strUuid));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROwner Id Value.");
OICFree(strUuid);
strUuid = NULL;
cborEncoderResult = cbor_encoder_close_container(&encoder, &pstatMap);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Closing PSTAT Map.");
if (CborNoError == cborEncoderResult)
{
*size = encoder.ptr - outPayload;
*payload = outPayload;
ret = OC_STACK_OK;
}
exit:
if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE))
{
// reallocate and try again!
OICFree(outPayload);
// Since the allocated initial memory failed, double the memory.
cborLen += encoder.ptr - encoder.end;
cborEncoderResult = CborNoError;
ret = PstatToCBORPayload(pstat, payload, &cborLen);
if (OC_STACK_OK == ret)
{
*size = cborLen;
}
}
if ((CborNoError != cborEncoderResult) || (OC_STACK_OK != ret))
{
OICFree(outPayload);
outPayload = NULL;
*payload = NULL;
*size = 0;
ret = OC_STACK_ERROR;
}
return ret;
}
