static OicSecAmacl_t* JSONToAmaclBin(const char * jsonStr)
{
OCStackResult ret = OC_STACK_ERROR;
OicSecAmacl_t * headAmacl = (OicSecAmacl_t*)OICCalloc(1, sizeof(OicSecAmacl_t));
cJSON *jsonRoot = NULL;
cJSON *jsonAmacl = NULL;
VERIFY_NON_NULL(TAG, jsonStr, ERROR);
jsonRoot = cJSON_Parse(jsonStr);
VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
jsonAmacl = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME);
VERIFY_NON_NULL(TAG, jsonAmacl, INFO);
cJSON *jsonObj = NULL;
// Resources -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_RESOURCES_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
// Rlist
cJSON *jsonRlistArray = cJSON_GetObjectItem(jsonObj, OIC_JSON_RLIST_NAME);
VERIFY_NON_NULL(TAG, jsonRlistArray, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Array == jsonRlistArray->type, ERROR);
headAmacl->resourcesLen = (size_t)cJSON_GetArraySize(jsonRlistArray);
headAmacl->resources = (char**)OICCalloc(headAmacl->resourcesLen, sizeof(char*));
size_t idxx = 0;
do
{
cJSON *jsonRsrc = cJSON_GetArrayItem(jsonRlistArray, idxx);
VERIFY_NON_NULL(TAG, jsonRsrc, ERROR);
cJSON *jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_HREF_NAME);
VERIFY_NON_NULL(TAG, jsonRsrcObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonRsrcObj->type, ERROR);
size_t jsonRsrcObjLen = 0;
jsonRsrcObjLen = strlen(jsonRsrcObj->valuestring) + 1;
headAmacl->resources[idxx] = (char*)OICMalloc(jsonRsrcObjLen);
VERIFY_NON_NULL(TAG, (headAmacl->resources[idxx]), ERROR);
OICStrcpy(headAmacl->resources[idxx], jsonRsrcObjLen, jsonRsrcObj->valuestring);
} while ( ++idxx < headAmacl->resourcesLen);
// Ams -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_AMS_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR);
headAmacl->amssLen = (size_t)cJSON_GetArraySize(jsonObj);
VERIFY_SUCCESS(TAG, headAmacl->amssLen > 0, ERROR);
headAmacl->amss = (OicUuid_t*)OICCalloc(headAmacl->amssLen, sizeof(OicUuid_t));
VERIFY_NON_NULL(TAG, headAmacl->amss, ERROR);
idxx = 0;
do
{
cJSON *jsonAms = cJSON_GetArrayItem(jsonObj, idxx);
VERIFY_NON_NULL(TAG, jsonAms, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonAms->type, ERROR);
memcpy(headAmacl->amss[idxx].id, (OicUuid_t *)jsonAms->valuestring, strlen(jsonAms->valuestring));
} while ( ++idxx < headAmacl->amssLen);
// Rowner -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_ROWNERID_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
ret = ConvertStrToUuid(jsonObj->valuestring, &headAmacl->rownerID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
ret = OC_STACK_OK;
exit:
cJSON_Delete(jsonRoot);
if (OC_STACK_OK != ret)
{
DeleteAmaclList(headAmacl);
headAmacl = NULL;
}
return headAmacl;
}
OicSecCred_t * JSONToCredBin(const char * jsonStr)
{
if (NULL == jsonStr)
{
OIC_LOG(ERROR, TAG,"JSONToCredBin jsonStr in NULL");
return NULL;
}
OicSecCred_t *headCred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
OCStackResult ret = OC_STACK_ERROR;
cJSON *jsonRoot = NULL;
VERIFY_NON_NULL(TAG, headCred, ERROR);
jsonRoot = cJSON_Parse(jsonStr);
VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
cJSON *jsonCredMap = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
VERIFY_NON_NULL(TAG, jsonCredMap, ERROR);
// creds
cJSON *jsonCredArray = NULL;
jsonCredArray = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_CREDS_NAME);
VERIFY_NON_NULL(TAG, jsonCredArray, ERROR);
if (cJSON_Array == jsonCredArray->type)
{
int numCred = cJSON_GetArraySize(jsonCredArray);
VERIFY_SUCCESS(TAG, numCred > 0, ERROR);
int idx = 0;
do
{
cJSON *jsonCred = cJSON_GetArrayItem(jsonCredArray, idx);
VERIFY_NON_NULL(TAG, jsonCred, ERROR);
OicSecCred_t *cred = NULL;
if(idx == 0)
{
cred = headCred;
}
else
{
cred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
OicSecCred_t *temp = headCred;
while (temp->next)
{
temp = temp->next;
}
temp->next = cred;
}
VERIFY_NON_NULL(TAG, cred, ERROR);
size_t jsonObjLen = 0;
cJSON *jsonObj = NULL;
//CredId -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDID_NAME);
if(jsonObj)
{
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
cred->credId = jsonObj->valueint;
}
//subject -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_SUBJECTID_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
ret = ConvertStrToUuid(jsonObj->valuestring, &cred->subject);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
//CredType -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDTYPE_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
cred->credType = (OicSecCredType_t)jsonObj->valueint;
//PrivateData is mandatory for some of the credential types listed below.
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PRIVATEDATA_NAME);
if (NULL != jsonObj)
{
cJSON *jsonPriv = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
VERIFY_NON_NULL(TAG, jsonPriv, ERROR);
jsonObjLen = strlen(jsonPriv->valuestring);
cred->privateData.data = (uint8_t *)OICCalloc(1, jsonObjLen);
VERIFY_NON_NULL(TAG, (cred->privateData.data), ERROR);
memcpy(cred->privateData.data, jsonPriv->valuestring, jsonObjLen);
cred->privateData.len = jsonObjLen;
cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME);
VERIFY_NON_NULL(TAG, jsonEncoding, ERROR);
if(strcmp(OIC_SEC_ENCODING_RAW, jsonEncoding->valuestring) == 0)
{
cred->privateData.encoding = OIC_ENCODING_RAW;
}
else if(strcmp(OIC_SEC_ENCODING_BASE64, jsonEncoding->valuestring) == 0)
{
cred->privateData.encoding = OIC_ENCODING_BASE64;
}
else
{
printf("Unknow encoding type dectected!\n");
printf("json2cbor will use \"oic.sec.encoding.raw\" as default encoding type.\n");
cred->privateData.encoding = OIC_ENCODING_RAW;
}
}
#ifdef __WITH_X509__
//PublicData is mandatory only for SIGNED_ASYMMETRIC_KEY credentials type.
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PUBLICDATA_NAME);
if (NULL != jsonObj)
{
cJSON *jsonPub = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
VERIFY_NON_NULL(TAG, jsonPub, ERROR);
jsonObjLen = strlen(jsonPub->valuestring);
cred->publicData.data = (uint8_t *)OICCalloc(1, jsonObjLen);
VERIFY_NON_NULL(TAG, (cred->publicData.data), ERROR);
memcpy(cred->publicData.data, jsonPub->valuestring, jsonObjLen);
cred->publicData.len = jsonObjLen;
}
#endif // __WITH_X509__
//Period -- Not Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PERIOD_NAME);
if(jsonObj && cJSON_String == jsonObj->type)
{
jsonObjLen = strlen(jsonObj->valuestring) + 1;
cred->period = (char *)OICMalloc(jsonObjLen);
VERIFY_NON_NULL(TAG, cred->period, ERROR);
strncpy(cred->period, jsonObj->valuestring, jsonObjLen);
}
cred->next = NULL;
} while( ++idx < numCred);
}
// rownerid
cJSON *jsonCredObj = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_ROWNERID_NAME);
VERIFY_NON_NULL(TAG, jsonCredObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonCredObj->type, ERROR);
ret = ConvertStrToUuid(jsonCredObj->valuestring, &headCred->rownerID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
ret = OC_STACK_OK;
exit:
if (OC_STACK_OK != ret)
{
DeleteCredList(headCred);
headCred = NULL;
}
return headCred;
}
OicSecPstat_t* JSONToPstatBin(const char * jsonStr)
{
printf("IN JSONToPstatBin\n");
if(NULL == jsonStr)
{
return NULL;
}
OCStackResult ret = OC_STACK_ERROR;
OicSecPstat_t *pstat = NULL;
cJSON *jsonPstat = NULL;
cJSON *jsonObj = NULL;
cJSON *jsonRoot = cJSON_Parse(jsonStr);
VERIFY_NON_NULL(TAG, jsonRoot, INFO);
jsonPstat = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME);
VERIFY_NON_NULL(TAG, jsonPstat, INFO);
pstat = (OicSecPstat_t*)OICCalloc(1, sizeof(OicSecPstat_t));
VERIFY_NON_NULL(TAG, pstat, INFO);
jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_ISOP_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type) , ERROR);
pstat->isOp = jsonObj->valueint;
jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_DEVICE_ID_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
ret = ConvertStrToUuid(jsonObj->valuestring, &pstat->deviceID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_ROWNERID_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
ret = ConvertStrToUuid(jsonObj->valuestring, &pstat->rownerID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_CM_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
pstat->cm = (OicSecDpm_t)jsonObj->valueint;
jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_TM_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
pstat->tm = (OicSecDpm_t)jsonObj->valueint;
jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_OM_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
pstat->om = (OicSecDpom_t)jsonObj->valueint;
jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_SM_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
pstat->smLen = 1;
pstat->sm = (OicSecDpom_t*)OICCalloc(pstat->smLen, sizeof(OicSecDpom_t));
pstat->sm[0] = (OicSecDpom_t)jsonObj->valueint;
ret = OC_STACK_OK;
exit:
cJSON_Delete(jsonRoot);
if (OC_STACK_OK != ret)
{
OIC_LOG(ERROR, TAG, "JSONToPstatBin failed");
}
printf("OUT JSONToPstatBin\n");
return pstat;
}
OicSecDoxm_t* JSONToDoxmBin(const char * jsonStr)
{
printf("IN JSONToDoxmBin\n");
if (NULL == jsonStr)
{
return NULL;
}
OCStackResult ret = OC_STACK_ERROR;
OicSecDoxm_t *doxm = NULL;
cJSON *jsonDoxm = NULL;
cJSON *jsonObj = NULL;
size_t jsonObjLen = 0;
cJSON *jsonRoot = cJSON_Parse(jsonStr);
VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
jsonDoxm = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME);
VERIFY_NON_NULL(TAG, jsonDoxm, ERROR);
doxm = (OicSecDoxm_t *)OICCalloc(1, sizeof(OicSecDoxm_t));
VERIFY_NON_NULL(TAG, doxm, ERROR);
//OxmType -- not Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXM_TYPE_NAME);
if ((jsonObj) && (cJSON_Array == jsonObj->type))
{
doxm->oxmTypeLen = (size_t)cJSON_GetArraySize(jsonObj);
VERIFY_SUCCESS(TAG, doxm->oxmTypeLen > 0, ERROR);
doxm->oxmType = (OicUrn_t *)OICCalloc(doxm->oxmTypeLen, sizeof(char *));
VERIFY_NON_NULL(TAG, (doxm->oxmType), ERROR);
for (size_t i = 0; i < doxm->oxmTypeLen ; i++)
{
cJSON *jsonOxmTy = cJSON_GetArrayItem(jsonObj, i);
VERIFY_NON_NULL(TAG, jsonOxmTy, ERROR);
jsonObjLen = strlen(jsonOxmTy->valuestring) + 1;
doxm->oxmType[i] = (char*)OICMalloc(jsonObjLen);
VERIFY_NON_NULL(TAG, doxm->oxmType[i], ERROR);
strncpy((char *)doxm->oxmType[i], (char *)jsonOxmTy->valuestring, jsonObjLen);
}
}
//Oxm -- not Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXMS_NAME);
if (jsonObj && cJSON_Array == jsonObj->type)
{
doxm->oxmLen = (size_t)cJSON_GetArraySize(jsonObj);
VERIFY_SUCCESS(TAG, doxm->oxmLen > 0, ERROR);
doxm->oxm = (OicSecOxm_t*)OICCalloc(doxm->oxmLen, sizeof(OicSecOxm_t));
VERIFY_NON_NULL(TAG, doxm->oxm, ERROR);
for (size_t i = 0; i < doxm->oxmLen ; i++)
{
cJSON *jsonOxm = cJSON_GetArrayItem(jsonObj, i);
VERIFY_NON_NULL(TAG, jsonOxm, ERROR);
doxm->oxm[i] = (OicSecOxm_t)jsonOxm->valueint;
}
}
//OxmSel -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXM_SEL_NAME);
if (jsonObj)
{
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
doxm->oxmSel = (OicSecOxm_t)jsonObj->valueint;
}
//sct -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_SUPPORTED_CRED_TYPE_NAME);
if (jsonObj)
{
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
doxm->sct = (OicSecCredType_t)jsonObj->valueint;
}
//Owned -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OWNED_NAME);
if (jsonObj)
{
VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type), ERROR);
doxm->owned = jsonObj->valueint;
}
//DPC -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DPC_NAME);
if (jsonObj)
{
VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type), ERROR);
doxm->dpc = jsonObj->valueint;
}
//DeviceId -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVICE_ID_NAME);
if (jsonObj)
{
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
if (cJSON_String == jsonObj->type)
{
//Check for empty string, in case DeviceId field has not been set yet
if (jsonObj->valuestring[0])
{
ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->deviceID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
}
}
}
//rowner -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_ROWNERID_NAME);
if (true == doxm->owned)
{
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
}
if (jsonObj)
{
ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->rownerID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
}
//Owner -- will be empty when device status is unowned.
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVOWNERID_NAME);
if (true == doxm->owned)
{
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
}
if (jsonObj)
{
ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->owner);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
}
ret = OC_STACK_OK;
exit:
cJSON_Delete(jsonRoot);
if (OC_STACK_OK != ret)
{
DeleteDoxmBinData(doxm);
doxm = NULL;
}
printf("OUT JSONToDoxmBin\n");
return doxm;
}
OicSecAcl_t* JSONToAclBin(const char * jsonStr)
{
OCStackResult ret = OC_STACK_ERROR;
OicSecAcl_t * headAcl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
cJSON *jsonRoot = NULL;
VERIFY_NON_NULL(TAG, jsonStr, ERROR);
jsonRoot = cJSON_Parse(jsonStr);
VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
cJSON *jsonAclMap = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME);
VERIFY_NON_NULL(TAG, jsonAclMap, ERROR);
cJSON *jsonAclObj = NULL;
// aclist
jsonAclObj = cJSON_GetObjectItem(jsonAclMap, OIC_JSON_ACLIST_NAME);
VERIFY_NON_NULL(TAG, jsonAclObj, ERROR);
// aclist-aces
cJSON *jsonAclArray = NULL;
jsonAclArray = cJSON_GetObjectItem(jsonAclObj, OIC_JSON_ACES_NAME);
VERIFY_NON_NULL(TAG, jsonAclArray, ERROR);
if (cJSON_Array == jsonAclArray->type)
{
int numAcl = cJSON_GetArraySize(jsonAclArray);
int idx = 0;
VERIFY_SUCCESS(TAG, numAcl > 0, INFO);
do
{
cJSON *jsonAcl = cJSON_GetArrayItem(jsonAclArray, idx);
VERIFY_NON_NULL(TAG, jsonAcl, ERROR);
OicSecAce_t *ace = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
VERIFY_NON_NULL(TAG, ace, ERROR);
LL_APPEND(headAcl->aces, ace);
size_t jsonObjLen = 0;
cJSON *jsonObj = NULL;
jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_SUBJECTID_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
if(strcmp(jsonObj->valuestring, WILDCARD_RESOURCE_URI) == 0)
{
ace->subjectuuid.id[0] = '*';
}
else
{
ret = ConvertStrToUuid(jsonObj->valuestring, &ace->subjectuuid);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
}
// Resources -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_RESOURCES_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR);
size_t resourcesLen = (size_t)cJSON_GetArraySize(jsonObj);
VERIFY_SUCCESS(TAG, resourcesLen > 0, ERROR);
for(size_t idxx = 0; idxx < resourcesLen; idxx++)
{
OicSecRsrc_t* rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t));
VERIFY_NON_NULL(TAG, rsrc, ERROR);
cJSON *jsonRsrc = cJSON_GetArrayItem(jsonObj, idxx);
VERIFY_NON_NULL(TAG, jsonRsrc, ERROR);
//href
size_t jsonRsrcObjLen = 0;
cJSON *jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_HREF_NAME);
VERIFY_NON_NULL(TAG, jsonRsrcObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonRsrcObj->type, ERROR);
jsonRsrcObjLen = strlen(jsonRsrcObj->valuestring) + 1;
rsrc->href = (char*)OICMalloc(jsonRsrcObjLen);
VERIFY_NON_NULL(TAG, (rsrc->href), ERROR);
OICStrcpy(rsrc->href, jsonRsrcObjLen, jsonRsrcObj->valuestring);
//rel
jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_REL_NAME);
if(jsonRsrcObj)
{
jsonRsrcObjLen = strlen(jsonRsrcObj->valuestring) + 1;
rsrc->rel = (char*)OICMalloc(jsonRsrcObjLen);
VERIFY_NON_NULL(TAG, (rsrc->rel), ERROR);
OICStrcpy(rsrc->rel, jsonRsrcObjLen, jsonRsrcObj->valuestring);
}
//rt
jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_RT_NAME);
if(jsonRsrcObj && cJSON_Array == jsonRsrcObj->type)
{
rsrc->typeLen = (size_t)cJSON_GetArraySize(jsonRsrcObj);
VERIFY_SUCCESS(TAG, (0 < rsrc->typeLen), ERROR);
rsrc->types = (char**)OICCalloc(rsrc->typeLen, sizeof(char*));
VERIFY_NON_NULL(TAG, (rsrc->types), ERROR);
for(size_t i = 0; i < rsrc->typeLen; i++)
{
cJSON *jsonRsrcType = cJSON_GetArrayItem(jsonRsrcObj, i);
rsrc->types[i] = OICStrdup(jsonRsrcType->valuestring);
VERIFY_NON_NULL(TAG, (rsrc->types[i]), ERROR);
}
}
//if
jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_IF_NAME);
if(jsonRsrcObj && cJSON_Array == jsonRsrcObj->type)
{
rsrc->interfaceLen = (size_t)cJSON_GetArraySize(jsonRsrcObj);
VERIFY_SUCCESS(TAG, (0 < rsrc->interfaceLen), ERROR);
rsrc->interfaces = (char**)OICCalloc(rsrc->interfaceLen, sizeof(char*));
VERIFY_NON_NULL(TAG, (rsrc->interfaces), ERROR);
for(size_t i = 0; i < rsrc->interfaceLen; i++)
{
cJSON *jsonInterface = cJSON_GetArrayItem(jsonRsrcObj, i);
rsrc->interfaces[i] = OICStrdup(jsonInterface->valuestring);
VERIFY_NON_NULL(TAG, (rsrc->interfaces[i]), ERROR);
}
}
LL_APPEND(ace->resources, rsrc);
}
// Permissions -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_PERMISSION_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
ace->permission = jsonObj->valueint;
//Validity -- Not Mandatory
cJSON *jsonValidityObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_VALIDITY_NAME);
if(jsonValidityObj)
{
VERIFY_SUCCESS(TAG, cJSON_Array == jsonValidityObj->type, ERROR);
size_t validityLen = cJSON_GetArraySize(jsonValidityObj);
VERIFY_SUCCESS(TAG, (0 < validityLen), ERROR);
cJSON *jsonValidity = NULL;
for(size_t i = 0; i < validityLen; i++)
{
jsonValidity = cJSON_GetArrayItem(jsonValidityObj, i);
VERIFY_NON_NULL(TAG, jsonValidity, ERROR);
VERIFY_SUCCESS(TAG, (jsonValidity->type == cJSON_Array), ERROR);
OicSecValidity_t* validity = (OicSecValidity_t*)OICCalloc(1, sizeof(OicSecValidity_t));
VERIFY_NON_NULL(TAG, validity, ERROR);
LL_APPEND(ace->validities, validity);
//Period
cJSON* jsonPeriod = cJSON_GetArrayItem(jsonValidity, 0);
if(jsonPeriod)
{
VERIFY_SUCCESS(TAG, (cJSON_String == jsonPeriod->type), ERROR);
jsonObjLen = strlen(jsonPeriod->valuestring) + 1;
validity->period = (char*)OICMalloc(jsonObjLen);
VERIFY_NON_NULL(TAG, validity->period, ERROR);
OICStrcpy(validity->period, jsonObjLen, jsonPeriod->valuestring);
}
//Recurrence
cJSON* jsonRecurObj = cJSON_GetArrayItem(jsonValidity, 1);
if(jsonRecurObj)
{
VERIFY_SUCCESS(TAG, (cJSON_Array == jsonRecurObj->type), ERROR);
validity->recurrenceLen = cJSON_GetArraySize(jsonRecurObj);
VERIFY_SUCCESS(TAG, (0 < validity->recurrenceLen), ERROR);
validity->recurrences = (char**)OICCalloc(validity->recurrenceLen, sizeof(char*));
VERIFY_NON_NULL(TAG, validity->recurrences, ERROR);
cJSON *jsonRecur = NULL;
for(size_t i = 0; i < validity->recurrenceLen; i++)
{
jsonRecur = cJSON_GetArrayItem(jsonRecurObj, i);
VERIFY_NON_NULL(TAG, jsonRecur, ERROR);
jsonObjLen = strlen(jsonRecur->valuestring) + 1;
validity->recurrences[i] = (char*)OICMalloc(jsonObjLen);
VERIFY_NON_NULL(TAG, validity->recurrences[i], ERROR);
OICStrcpy(validity->recurrences[i], jsonObjLen, jsonRecur->valuestring);
}
}
}
}
} while( ++idx < numAcl);
}
// rownerid
jsonAclObj = cJSON_GetObjectItem(jsonAclMap, OIC_JSON_ROWNERID_NAME);
VERIFY_NON_NULL(TAG, jsonAclObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonAclObj->type, ERROR);
ret = ConvertStrToUuid(jsonAclObj->valuestring, &headAcl->rownerID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
ret = OC_STACK_OK;
exit:
cJSON_Delete(jsonRoot);
if (OC_STACK_OK != ret)
{
DeleteACLList(headAcl);
headAcl = NULL;
}
return headAcl;
}
OCStackResult CBORPayloadToPstat(const uint8_t *cborPayload, const size_t size,
OicSecPstat_t **secPstat)
{
if (NULL == cborPayload || NULL == secPstat || NULL != *secPstat || 0 == size)
{
return OC_STACK_INVALID_PARAM;
}
OCStackResult ret = OC_STACK_ERROR;
*secPstat = NULL;
CborValue pstatCbor;
CborParser parser;
CborError cborFindResult = CborNoError;
char *strUuid = NULL;
size_t len = 0;
cbor_parser_init(cborPayload, size, 0, &parser, &pstatCbor);
CborValue pstatMap = { .parser = NULL };
OicSecPstat_t *pstat = NULL;
cborFindResult = cbor_value_enter_container(&pstatCbor, &pstatMap);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PSTAT Map.");
pstat = (OicSecPstat_t *)OICCalloc(1, sizeof(OicSecPstat_t));
VERIFY_NON_NULL(TAG, pstat, ERROR);
cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_ISOP_NAME, &pstatMap);
if (CborNoError == cborFindResult && cbor_value_is_boolean(&pstatMap))
{
cborFindResult = cbor_value_get_boolean(&pstatMap, &pstat->isOp);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding isOp Value.");
}
cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_DEVICE_ID_NAME, &pstatMap);
if (CborNoError == cborFindResult && cbor_value_is_text_string(&pstatMap))
{
cborFindResult = cbor_value_dup_text_string(&pstatMap, &strUuid , &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Device Id Value.");
ret = ConvertStrToUuid(strUuid , &pstat->deviceID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
OICFree(strUuid );
strUuid = NULL;
}
cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_CM_NAME, &pstatMap);
if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
{
cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->cm);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding CM.");
}
cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_TM_NAME, &pstatMap);
if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
{
cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->tm);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding TM.");
}
cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_OM_NAME, &pstatMap);
if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
{
cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->om);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding OM.");
}
cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_SM_NAME, &pstatMap);
if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
{
pstat->smLen = 1;
pstat->sm = (OicSecDpom_t*)OICCalloc(pstat->smLen, sizeof(OicSecDpom_t));
cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->sm[0]);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding SM.");
}
cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_ROWNERID_NAME, &pstatMap);
if (CborNoError == cborFindResult && cbor_value_is_text_string(&pstatMap))
{
cborFindResult = cbor_value_dup_text_string(&pstatMap, &strUuid , &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding ROwner Id Value.");
ret = ConvertStrToUuid(strUuid , &pstat->rownerID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
OICFree(strUuid );
strUuid = NULL;
}
*secPstat = pstat;
ret = OC_STACK_OK;
exit:
if (CborNoError != cborFindResult)
{
OIC_LOG(ERROR, TAG, "CBORPayloadToPstat failed");
DeletePstatBinData(pstat);
pstat = NULL;
*secPstat = NULL;
ret = OC_STACK_ERROR;
}
return ret;
}
