X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=resource%2Fcsdk%2Fsecurity%2Ftool%2Fjson2cbor.c;h=b6fa1aa8a6216e3c2a0856a3a4a58037defb0050;hb=7f00f942c39b7bc27c7eeecf213a239c3fe4173c;hp=09191cb605d5a6613ff15ee76e08612de885d7e0;hpb=ef332833dd3989e8e4aa4da5572423e0b2ffd89b;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/security/tool/json2cbor.c b/resource/csdk/security/tool/json2cbor.c index 09191cb..b6fa1aa 100644 --- a/resource/csdk/security/tool/json2cbor.c +++ b/resource/csdk/security/tool/json2cbor.c @@ -20,7 +20,12 @@ #include #include +#include "utlist.h" +#if defined (__TIZENRT__) +#include +#else #include "cJSON.h" +#endif #include "base64.h" #include "cainterface.h" #include "ocstack.h" @@ -37,10 +42,9 @@ #include "doxmresource.h" #include "amaclresource.h" #include "credresource.h" -#include "svcresource.h" #include "security_internals.h" -#define TAG "JSON2CBOR" +#define TAG "OIC_JSON2CBOR" #define MAX_RANGE ((size_t)-1) //SVR database buffer block size static const size_t DB_FILE_SIZE_BLOCK = 1023; @@ -48,7 +52,6 @@ static const size_t DB_FILE_SIZE_BLOCK = 1023; static OicSecPstat_t* JSONToPstatBin(const char * jsonStr); static OicSecDoxm_t* JSONToDoxmBin(const char * jsonStr); static OicSecAcl_t *JSONToAclBin(const char * jsonStr); -static OicSecSvc_t* JSONToSvcBin(const char * jsonStr); static OicSecAmacl_t* JSONToAmaclBin(const char * jsonStr); static OicSecCred_t* JSONToCredBin(const char * jsonStr); @@ -84,7 +87,6 @@ static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName 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; @@ -140,7 +142,7 @@ static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName { OicSecPstat_t *pstat = JSONToPstatBin(jsonStr); VERIFY_NON_NULL(TAG, pstat, FATAL); - ret = PstatToCBORPayload(pstat, &pstatCbor, &pstatCborSize); + ret = PstatToCBORPayload(pstat, &pstatCbor, &pstatCborSize, false); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Pstat to Cbor Payload"); @@ -156,7 +158,7 @@ static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName { OicSecDoxm_t *doxm = JSONToDoxmBin(jsonStr); VERIFY_NON_NULL(TAG, doxm, FATAL); - ret = DoxmToCBORPayload(doxm, &doxmCbor, &doxmCborSize); + ret = DoxmToCBORPayload(doxm, &doxmCbor, &doxmCborSize, false); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Doxm to Cbor Payload"); @@ -182,30 +184,15 @@ static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName 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); + ret = CredToCBORPayload(cred, &credCbor, &credCborSize, secureFlag); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Cred to Cbor Payload"); @@ -217,7 +204,7 @@ static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName } CborEncoder encoder; - size_t cborSize = aclCborSize + pstatCborSize + doxmCborSize + svcCborSize + credCborSize + amaclCborSize; + size_t cborSize = aclCborSize + pstatCborSize + doxmCborSize + credCborSize + amaclCborSize; printf("Total Cbor Size : %zd\n", cborSize); cborSize += 255; // buffer margin for adding map and byte string @@ -256,13 +243,6 @@ static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName 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)); @@ -274,7 +254,7 @@ static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName cborEncoderResult = cbor_encoder_close_container(&encoder, &map); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Container."); - size_t s = encoder.ptr - outPayload; + size_t s = cbor_encoder_get_buffer_size(&encoder, outPayload); OIC_LOG_V(DEBUG, TAG, "Payload size %zu", s); fp1 = fopen(cborFileName, "w"); @@ -299,7 +279,6 @@ exit: OICFree(doxmCbor); OICFree(pstatCbor); OICFree(amaclCbor); - OICFree(svcCbor); OICFree(credCbor); OICFree(jsonStr); return ; @@ -342,23 +321,9 @@ OicSecAcl_t* JSONToAclBin(const char * jsonStr) cJSON *jsonAcl = cJSON_GetArrayItem(jsonAclArray, idx); VERIFY_NON_NULL(TAG, jsonAcl, ERROR); - OicSecAcl_t *acl = NULL; - if(idx == 0) - { - acl = headAcl; - } - else - { - acl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t)); - OicSecAcl_t *temp = headAcl; - while (temp->next) - { - temp = temp->next; - } - temp->next = acl; - } - - VERIFY_NON_NULL(TAG, acl, 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; @@ -367,11 +332,11 @@ OicSecAcl_t* JSONToAclBin(const char * jsonStr) VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR); if(strcmp(jsonObj->valuestring, WILDCARD_RESOURCE_URI) == 0) { - acl->subject.id[0] = '*'; + ace->subjectuuid.id[0] = '*'; } else { - ret = ConvertStrToUuid(jsonObj->valuestring, &acl->subject); + ret = ConvertStrToUuid(jsonObj->valuestring, &ace->subjectuuid); VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR); } // Resources -- Mandatory @@ -379,87 +344,136 @@ OicSecAcl_t* JSONToAclBin(const char * jsonStr) VERIFY_NON_NULL(TAG, jsonObj, ERROR); VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR); - acl->resourcesLen = (size_t)cJSON_GetArraySize(jsonObj); + size_t resourcesLen = (size_t)cJSON_GetArraySize(jsonObj); + VERIFY_SUCCESS(TAG, resourcesLen > 0, ERROR); - VERIFY_SUCCESS(TAG, acl->resourcesLen > 0, ERROR); - acl->resources = (char**)OICCalloc(acl->resourcesLen, sizeof(char*)); - VERIFY_NON_NULL(TAG, (acl->resources), ERROR); - - size_t idxx = 0; - do + 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; - acl->resources[idxx] = (char*)OICMalloc(jsonRsrcObjLen); + rsrc->href = (char*)OICMalloc(jsonRsrcObjLen); + VERIFY_NON_NULL(TAG, (rsrc->href), ERROR); + OICStrcpy(rsrc->href, jsonRsrcObjLen, jsonRsrcObj->valuestring); - VERIFY_NON_NULL(TAG, (acl->resources[idxx]), ERROR); - OICStrcpy(acl->resources[idxx], 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); + } - } while ( ++idxx < acl->resourcesLen); + //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); + VERIFY_NON_NULL(TAG, jsonRsrcType, ERROR); + 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); + VERIFY_NON_NULL(TAG, jsonInterface, ERROR); + 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); - acl->permission = jsonObj->valueint; - //Period -- Not Mandatory - cJSON *jsonPeriodObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_PERIOD_NAME); - if(jsonPeriodObj) + ace->permission = jsonObj->valueint; + + //Validity -- Not Mandatory + cJSON *jsonValidityObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_VALIDITY_NAME); + if(jsonValidityObj) { - VERIFY_SUCCESS(TAG, cJSON_Array == jsonPeriodObj->type, ERROR); - acl->prdRecrLen = (size_t)cJSON_GetArraySize(jsonPeriodObj); - if(acl->prdRecrLen > 0) + VERIFY_SUCCESS(TAG, cJSON_Array == jsonValidityObj->type, ERROR); + size_t validityLen = (size_t) cJSON_GetArraySize(jsonValidityObj); + VERIFY_SUCCESS(TAG, (0 < validityLen), ERROR); + + cJSON *jsonValidity = NULL; + for(size_t i = 0; i < validityLen; i++) { - acl->periods = (char**)OICCalloc(acl->prdRecrLen, sizeof(char*)); - VERIFY_NON_NULL(TAG, acl->periods, ERROR); + 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); - cJSON *jsonPeriod = NULL; - for(size_t i = 0; i < acl->prdRecrLen; i++) + //Period + cJSON* jsonPeriod = cJSON_GetArrayItem(jsonValidity, 0); + if(jsonPeriod) { - jsonPeriod = cJSON_GetArrayItem(jsonPeriodObj, i); - VERIFY_NON_NULL(TAG, jsonPeriod, ERROR); + VERIFY_SUCCESS(TAG, (cJSON_String == jsonPeriod->type), ERROR); jsonObjLen = strlen(jsonPeriod->valuestring) + 1; - acl->periods[i] = (char*)OICMalloc(jsonObjLen); - VERIFY_NON_NULL(TAG, acl->periods[i], ERROR); - OICStrcpy(acl->periods[i], jsonObjLen, jsonPeriod->valuestring); + validity->period = (char*)OICMalloc(jsonObjLen); + VERIFY_NON_NULL(TAG, validity->period, ERROR); + OICStrcpy(validity->period, jsonObjLen, jsonPeriod->valuestring); } - } - } - //Recurrence -- Not mandatory - cJSON *jsonRecurObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_RECURRENCES_NAME); - if(jsonRecurObj) - { - - VERIFY_SUCCESS(TAG, cJSON_Array == jsonRecurObj->type, ERROR); - if(acl->prdRecrLen > 0) - { - acl->recurrences = (char**)OICCalloc(acl->prdRecrLen, sizeof(char*)); - VERIFY_NON_NULL(TAG, acl->recurrences, ERROR); - - cJSON *jsonRecur = NULL; - for(size_t i = 0; i < acl->prdRecrLen; i++) + //Recurrence + cJSON* jsonRecurObj = cJSON_GetArrayItem(jsonValidity, 1); + if(jsonRecurObj) { - jsonRecur = cJSON_GetArrayItem(jsonRecurObj, i); - VERIFY_NON_NULL(TAG, jsonRecur, ERROR); - jsonObjLen = strlen(jsonRecur->valuestring) + 1; - acl->recurrences[i] = (char*)OICMalloc(jsonObjLen); - VERIFY_NON_NULL(TAG, acl->recurrences[i], ERROR); - OICStrcpy(acl->recurrences[i], jsonObjLen, jsonRecur->valuestring); + VERIFY_SUCCESS(TAG, (cJSON_Array == jsonRecurObj->type), ERROR); + validity->recurrenceLen = (size_t) 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); + } } } } - - acl->next = NULL; - } while( ++idx < numAcl); } @@ -571,13 +585,17 @@ OicSecDoxm_t* JSONToDoxmBin(const char * jsonStr) doxm->owned = jsonObj->valueint; } - //DPC -- Mandatory - jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DPC_NAME); +#ifdef MULTIPLE_OWNER + //mom -- Not Mandatory + jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_MOM_NAME); if (jsonObj) { - VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type), ERROR); - doxm->dpc = jsonObj->valueint; + VERIFY_SUCCESS(TAG, (cJSON_Number == jsonObj->type), ERROR); + doxm->mom = (OicSecMom_t*)OICCalloc(1, sizeof(OicSecMom_t)); + VERIFY_NON_NULL(TAG, doxm->mom, ERROR); + doxm->mom->mode = (OicSecMomType_t)jsonObj->valueint; } +#endif //MULTIPLE_OWNER //DeviceId -- Mandatory jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVICE_ID_NAME); @@ -704,6 +722,29 @@ exit: return pstat; } +static OicEncodingType_t GetEncodingTypeFromStr(const char* encodingType) +{ + if (strcmp(OIC_SEC_ENCODING_RAW, encodingType) == 0) + { + return OIC_ENCODING_RAW; + } + if (strcmp(OIC_SEC_ENCODING_BASE64, encodingType) == 0) + { + return OIC_ENCODING_BASE64; + } + if (strcmp(OIC_SEC_ENCODING_PEM, encodingType) == 0) + { + return OIC_ENCODING_PEM; + } + if (strcmp(OIC_SEC_ENCODING_DER, encodingType) == 0) + { + return OIC_ENCODING_DER; + } + OIC_LOG(WARNING, TAG, "Unknow encoding type dectected!"); + OIC_LOG(WARNING, TAG, "json2cbor will use \"oic.sec.encoding.raw\" as default encoding type."); + return OIC_ENCODING_RAW; +} + OicSecCred_t * JSONToCredBin(const char * jsonStr) { if (NULL == jsonStr) @@ -733,7 +774,6 @@ OicSecCred_t * JSONToCredBin(const char * jsonStr) int numCred = cJSON_GetArraySize(jsonCredArray); VERIFY_SUCCESS(TAG, numCred > 0, ERROR); int idx = 0; - size_t ownersLen = 0; do { cJSON *jsonCred = cJSON_GetArrayItem(jsonCredArray, idx); @@ -771,8 +811,15 @@ OicSecCred_t * JSONToCredBin(const char * jsonStr) 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); + if(strcmp(jsonObj->valuestring, WILDCARD_RESOURCE_URI) == 0) + { + cred->subject.id[0] = '*'; + } + else + { + ret = ConvertStrToUuid(jsonObj->valuestring, &cred->subject); + VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR); + } //CredType -- Mandatory jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDTYPE_NAME); @@ -786,13 +833,17 @@ OicSecCred_t * JSONToCredBin(const char * jsonStr) { cJSON *jsonPriv = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME); VERIFY_NON_NULL(TAG, jsonPriv, ERROR); - jsonObjLen = strlen(jsonPriv->valuestring); + jsonObjLen = strlen(jsonPriv->valuestring) + 1; 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); + cred->privateData.encoding = GetEncodingTypeFromStr(jsonEncoding->valuestring); } -#ifdef __WITH_X509__ +#if defined(__WITH_DTLS__) || defined(__WITH_TLS__) //PublicData is mandatory only for SIGNED_ASYMMETRIC_KEY credentials type. jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PUBLICDATA_NAME); @@ -800,13 +851,45 @@ OicSecCred_t * JSONToCredBin(const char * jsonStr) { cJSON *jsonPub = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME); VERIFY_NON_NULL(TAG, jsonPub, ERROR); - jsonObjLen = strlen(jsonPub->valuestring); + jsonObjLen = strlen(jsonPub->valuestring) + 1; 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__ + + //Optional Data + jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_OPTDATA_NAME); + if (NULL != jsonObj) + { + cJSON *jsonOpt = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME); + VERIFY_NON_NULL(TAG, jsonOpt, ERROR); + jsonObjLen = strlen(jsonOpt->valuestring) + 1; + cred->optionalData.data = (uint8_t *)OICCalloc(1, jsonObjLen); + VERIFY_NON_NULL(TAG, (cred->optionalData.data), ERROR); + memcpy(cred->optionalData.data, jsonOpt->valuestring, jsonObjLen); + cred->optionalData.len = jsonObjLen; + + cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME); + VERIFY_NON_NULL(TAG, jsonEncoding, ERROR); + cred->optionalData.encoding = GetEncodingTypeFromStr(jsonEncoding->valuestring); + + cJSON *jsonRevstat = cJSON_GetObjectItem(jsonObj, OIC_JSON_REVOCATION_STATUS_NAME); + VERIFY_NON_NULL(TAG, jsonRevstat, ERROR); + cred->optionalData.revstat = jsonObj->valueint; + } + + //CredUsage + jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDUSAGE_NAME); + if (NULL != jsonObj) + { + jsonObjLen = strlen(jsonObj->valuestring); + cred->credUsage = OICStrdup(jsonObj->valuestring); + VERIFY_NON_NULL(TAG, (cred->credUsage), ERROR); + } + +#endif // defined(__WITH_DTLS__) || defined(__WITH_TLS__) + //Period -- Not Mandatory jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PERIOD_NAME); if(jsonObj && cJSON_String == jsonObj->type) @@ -829,7 +912,7 @@ OicSecCred_t * JSONToCredBin(const char * jsonStr) ret = OC_STACK_OK; exit: - + cJSON_Delete(jsonRoot); if (OC_STACK_OK != ret) { DeleteCredList(headCred); @@ -838,104 +921,6 @@ exit: return headCred; } -static OicSecSvc_t* JSONToSvcBin(const char * jsonStr) -{ - OCStackResult ret = OC_STACK_ERROR; - OicSecSvc_t * headSvc = NULL; - OicSecSvc_t * prevSvc = NULL; - cJSON *jsonRoot = NULL; - cJSON *jsonSvcArray = NULL; - - VERIFY_NON_NULL(TAG, jsonStr, ERROR); - - jsonRoot = cJSON_Parse(jsonStr); - VERIFY_NON_NULL(TAG, jsonRoot, ERROR); - - jsonSvcArray = cJSON_GetObjectItem(jsonRoot, OIC_JSON_SVC_NAME); - VERIFY_NON_NULL(TAG, jsonSvcArray, INFO); - - if (cJSON_Array == jsonSvcArray->type) - { - int numSvc = cJSON_GetArraySize(jsonSvcArray); - int idx = 0; - - VERIFY_SUCCESS(TAG, numSvc > 0, INFO); - do - { - cJSON *jsonSvc = cJSON_GetArrayItem(jsonSvcArray, idx); - VERIFY_NON_NULL(TAG, jsonSvc, ERROR); - - OicSecSvc_t *svc = (OicSecSvc_t*)OICCalloc(1, sizeof(OicSecSvc_t)); - VERIFY_NON_NULL(TAG, svc, ERROR); - - headSvc = (headSvc) ? headSvc : svc; - if (prevSvc) - { - prevSvc->next = svc; - } - - cJSON *jsonObj = NULL; - unsigned char base64Buff[sizeof(((OicUuid_t*)0)->id)] = {}; - uint32_t outLen = 0; - B64Result b64Ret = B64_OK; - - // Service Device Identity - jsonObj = cJSON_GetObjectItem(jsonSvc, OIC_JSON_SERVICE_DEVICE_ID); - VERIFY_NON_NULL(TAG, jsonObj, ERROR); - VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR); - outLen = 0; - b64Ret = b64Decode(jsonObj->valuestring, strlen(jsonObj->valuestring), base64Buff, - sizeof(base64Buff), &outLen); - VERIFY_SUCCESS(TAG, (b64Ret == B64_OK && outLen <= sizeof(svc->svcdid.id)), ERROR); - memcpy(svc->svcdid.id, base64Buff, outLen); - - // Service Type - jsonObj = cJSON_GetObjectItem(jsonSvc, OIC_JSON_SERVICE_TYPE); - VERIFY_NON_NULL(TAG, jsonObj, ERROR); - VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR); - svc->svct = (OicSecSvcType_t)jsonObj->valueint; - - // Resource Owners - jsonObj = cJSON_GetObjectItem(jsonSvc, OIC_JSON_OWNERS_NAME); - VERIFY_NON_NULL(TAG, jsonObj, ERROR); - VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR); - - svc->ownersLen = (size_t)cJSON_GetArraySize(jsonObj); - VERIFY_SUCCESS(TAG, svc->ownersLen > 0, ERROR); - svc->owners = (OicUuid_t*)OICCalloc(svc->ownersLen, sizeof(OicUuid_t)); - VERIFY_NON_NULL(TAG, (svc->owners), ERROR); - - size_t idxx = 0; - do - { - cJSON *jsonOwnr = cJSON_GetArrayItem(jsonObj, idxx); - VERIFY_NON_NULL(TAG, jsonOwnr, ERROR); - VERIFY_SUCCESS(TAG, cJSON_String == jsonOwnr->type, ERROR); - outLen = 0; - b64Ret = b64Decode(jsonOwnr->valuestring, strlen(jsonOwnr->valuestring), base64Buff, - sizeof(base64Buff), &outLen); - - VERIFY_SUCCESS(TAG, (b64Ret == B64_OK && outLen <= sizeof(svc->owners[idxx].id)), - ERROR); - memcpy(svc->owners[idxx].id, base64Buff, outLen); - } while ( ++idxx < svc->ownersLen); - - prevSvc = svc; - } while( ++idx < numSvc); - } - - ret = OC_STACK_OK; - -exit: - cJSON_Delete(jsonRoot); - if (OC_STACK_OK != ret) - { - DeleteSVCList(headSvc); - headSvc = NULL; - } - return headSvc; -} - static OicSecAmacl_t* JSONToAmaclBin(const char * jsonStr) { OCStackResult ret = OC_STACK_ERROR;