resource/csdk/security/tool/json2cbor.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include "utlist.h"
  24 #include "cJSON.h"
  25 #include "base64.h"
  26 #include "cainterface.h"
  27 #include "ocstack.h"
  28 #include "oic_malloc.h"
  29 #include "oic_string.h"
  30 #include "ocpayload.h"
  31 #include "ocpayloadcbor.h"
  32 #include "payload_logging.h"
  33 #include "secureresourcemanager.h"
  34 #include "srmresourcestrings.h"
  35 #include "srmutility.h"
  36 #include "aclresource.h"
  37 #include "pstatresource.h"
  38 #include "doxmresource.h"
  39 #include "amaclresource.h"
  40 #include "credresource.h"
  41 #include "svcresource.h"
  42 #include "security_internals.h"
  43
  44 #define TAG  "OIC_JSON2CBOR"
  45 #define MAX_RANGE   ((size_t)-1)
  46 //SVR database buffer block size
  47 static const size_t DB_FILE_SIZE_BLOCK = 1023;
  48
  49 static OicSecPstat_t* JSONToPstatBin(const char * jsonStr);
  50 static OicSecDoxm_t* JSONToDoxmBin(const char * jsonStr);
  51 static OicSecAcl_t *JSONToAclBin(const char * jsonStr);
  52 static OicSecSvc_t* JSONToSvcBin(const char * jsonStr);
  53 static OicSecAmacl_t* JSONToAmaclBin(const char * jsonStr);
  54 static OicSecCred_t* JSONToCredBin(const char * jsonStr);
  55
  56 static size_t GetJSONFileSize(const char *jsonFileName)
  57 {
  58     size_t size = 0;
  59     size_t bytesRead  = 0;
  60     char buffer[DB_FILE_SIZE_BLOCK];
  61     FILE* fp = fopen(jsonFileName, "r");
  62     if (fp)
  63     {
  64         do
  65         {
  66             bytesRead = fread(buffer, 1, DB_FILE_SIZE_BLOCK, fp);
  67             if (bytesRead >=(MAX_RANGE - size))
  68             {
  69                 fclose(fp);
  70                 return 0;
  71             }
  72             size += bytesRead;
  73         } while (bytesRead > 0);
  74         fclose(fp);
  75     }
  76     return size;
  77 }
  78
  79 static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName)
  80 {
  81     char *jsonStr = NULL;
  82     FILE *fp = NULL;
  83     FILE *fp1 = NULL;
  84     uint8_t *aclCbor = NULL;
  85     uint8_t *pstatCbor = NULL;
  86     uint8_t *doxmCbor = NULL;
  87     uint8_t *amaclCbor = NULL;
  88     uint8_t *svcCbor = NULL;
  89     uint8_t *credCbor = NULL;
  90     cJSON *jsonRoot = NULL;
  91     OCStackResult ret = OC_STACK_ERROR;
  92     size_t size = GetJSONFileSize(jsonFileName);
  93     if (0 == size)
  94     {
  95         OIC_LOG (ERROR, TAG, "Failed converting to JSON");
  96         return;
  97     }
  98
  99     jsonStr = (char *)OICMalloc(size + 1);
 100     VERIFY_NON_NULL(TAG, jsonStr, FATAL);
 101
 102     fp = fopen(jsonFileName, "r");
 103     if (fp)
 104     {
 105         size_t bytesRead = fread(jsonStr, 1, size, fp);
 106         jsonStr[bytesRead] = '\0';
 107
 108         OIC_LOG_V(DEBUG, TAG, "Read %zu bytes", bytesRead);
 109         fclose(fp);
 110         fp = NULL;
 111     }
 112     else
 113     {
 114         OIC_LOG (ERROR, TAG, "Unable to open JSON file!!");
 115         goto exit;
 116     }
 117
 118     jsonRoot = cJSON_Parse(jsonStr);
 119
 120     cJSON *value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME);
 121     //printf("ACL json : \n%s\n", cJSON_PrintUnformatted(value));
 122     size_t aclCborSize = 0;
 123     if (NULL != value)
 124     {
 125         OicSecAcl_t *acl = JSONToAclBin(jsonStr);
 126         VERIFY_NON_NULL(TAG, acl, FATAL);
 127         ret = AclToCBORPayload(acl, &aclCbor, &aclCborSize);
 128         if(OC_STACK_OK != ret)
 129         {
 130             OIC_LOG (ERROR, TAG, "Failed converting Acl to Cbor Payload");
 131             DeleteACLList(acl);
 132             goto exit;
 133         }
 134         printf("ACL Cbor Size: %zd\n", aclCborSize);
 135         DeleteACLList(acl);
 136     }
 137
 138     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME);
 139     size_t pstatCborSize = 0;
 140     if (NULL != value)
 141     {
 142         OicSecPstat_t *pstat = JSONToPstatBin(jsonStr);
 143         VERIFY_NON_NULL(TAG, pstat, FATAL);
 144         ret = PstatToCBORPayload(pstat, &pstatCbor, &pstatCborSize, false);
 145         if(OC_STACK_OK != ret)
 146         {
 147             OIC_LOG (ERROR, TAG, "Failed converting Pstat to Cbor Payload");
 148             DeletePstatBinData(pstat);
 149             goto exit;
 150         }
 151         printf("PSTAT Cbor Size: %zd\n", pstatCborSize);
 152         DeletePstatBinData(pstat);
 153     }
 154     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME);
 155     size_t doxmCborSize = 0;
 156     if (NULL != value)
 157     {
 158         OicSecDoxm_t *doxm = JSONToDoxmBin(jsonStr);
 159         VERIFY_NON_NULL(TAG, doxm, FATAL);
 160         ret = DoxmToCBORPayload(doxm, &doxmCbor, &doxmCborSize, false);
 161         if(OC_STACK_OK != ret)
 162         {
 163             OIC_LOG (ERROR, TAG, "Failed converting Doxm to Cbor Payload");
 164             DeleteDoxmBinData(doxm);
 165             goto exit;
 166         }
 167         printf("DOXM Cbor Size: %zd\n", doxmCborSize);
 168         DeleteDoxmBinData(doxm);
 169     }
 170     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME);
 171     size_t amaclCborSize = 0;
 172     if (NULL != value)
 173     {
 174         OicSecAmacl_t *amacl = JSONToAmaclBin(jsonStr);
 175         VERIFY_NON_NULL(TAG, amacl, FATAL);
 176         ret = AmaclToCBORPayload(amacl, &amaclCbor, &amaclCborSize);
 177         if(OC_STACK_OK != ret)
 178         {
 179             OIC_LOG (ERROR, TAG, "Failed converting Amacl to Cbor Payload");
 180             DeleteAmaclList(amacl);
 181             goto exit;
 182         }
 183         printf("AMACL Cbor Size: %zd\n", amaclCborSize);
 184         DeleteAmaclList(amacl);
 185     }
 186     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_SVC_NAME);
 187     size_t svcCborSize = 0;
 188     if (NULL != value)
 189     {
 190         OicSecSvc_t *svc = JSONToSvcBin(jsonStr);
 191         VERIFY_NON_NULL(TAG, svc, FATAL);
 192         ret = SVCToCBORPayload(svc, &svcCbor, &svcCborSize);
 193         if(OC_STACK_OK != ret)
 194         {
 195             OIC_LOG (ERROR, TAG, "Failed converting Svc to Cbor Payload");
 196             DeleteSVCList(svc);
 197             goto exit;
 198         }
 199         printf("SVC Cbor Size: %zd\n", svcCborSize);
 200         DeleteSVCList(svc);
 201     }
 202     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
 203     //printf("CRED json : \n%s\n", cJSON_PrintUnformatted(value));
 204     size_t credCborSize = 0;
 205     int secureFlag = 0;
 206     if (NULL != value)
 207     {
 208         OicSecCred_t *cred = JSONToCredBin(jsonStr);
 209         VERIFY_NON_NULL(TAG, cred, FATAL);
 210         ret = CredToCBORPayload(cred, &credCbor, &credCborSize, secureFlag);
 211         if(OC_STACK_OK != ret)
 212         {
 213             OIC_LOG (ERROR, TAG, "Failed converting Cred to Cbor Payload");
 214             DeleteCredList(cred);
 215             goto exit;
 216         }
 217         printf("CRED Cbor Size: %zd\n", credCborSize);
 218         DeleteCredList(cred);
 219     }
 220
 221     CborEncoder encoder;
 222     size_t cborSize = aclCborSize + pstatCborSize + doxmCborSize + svcCborSize + credCborSize + amaclCborSize;
 223
 224     printf("Total Cbor Size : %zd\n", cborSize);
 225     cborSize += 255; // buffer margin for adding map and byte string
 226     uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborSize);
 227     VERIFY_NON_NULL(TAG, outPayload, ERROR);
 228     cbor_encoder_init(&encoder, outPayload, cborSize, 0);
 229     CborEncoder map;
 230     CborError cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
 231     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Creating Main Map.");
 232     if (aclCborSize > 0)
 233     {
 234         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_ACL_NAME, strlen(OIC_JSON_ACL_NAME));
 235         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Name.");
 236         cborEncoderResult = cbor_encode_byte_string(&map, aclCbor, aclCborSize);
 237         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Value.");
 238     }
 239
 240     if (pstatCborSize > 0)
 241     {
 242         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_PSTAT_NAME, strlen(OIC_JSON_PSTAT_NAME));
 243         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Name.");
 244         cborEncoderResult = cbor_encode_byte_string(&map, pstatCbor, pstatCborSize);
 245         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Value.");
 246     }
 247     if (doxmCborSize > 0)
 248     {
 249         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_DOXM_NAME, strlen(OIC_JSON_DOXM_NAME));
 250         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Name.");
 251         cborEncoderResult = cbor_encode_byte_string(&map, doxmCbor, doxmCborSize);
 252         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Value.");
 253     }
 254     if (amaclCborSize > 0)
 255     {
 256         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_AMACL_NAME, strlen(OIC_JSON_AMACL_NAME));
 257         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Name.");
 258         cborEncoderResult = cbor_encode_byte_string(&map, amaclCbor, amaclCborSize);
 259         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Value.");
 260     }
 261     if (svcCborSize > 0)
 262     {
 263         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_SVC_NAME, strlen(OIC_JSON_SVC_NAME));
 264         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Name.");
 265         cborEncoderResult = cbor_encode_byte_string(&map, svcCbor, svcCborSize);
 266         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Value.");
 267     }
 268     if (credCborSize > 0)
 269     {
 270         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_CRED_NAME, strlen(OIC_JSON_CRED_NAME));
 271         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Name.");
 272         cborEncoderResult = cbor_encode_byte_string(&map, credCbor, credCborSize);
 273         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Value.");
 274     }
 275
 276     cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
 277     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Container.");
 278
 279     size_t s = encoder.ptr - outPayload;
 280     OIC_LOG_V(DEBUG, TAG, "Payload size %zu", s);
 281
 282     fp1 = fopen(cborFileName, "w");
 283     if (fp1)
 284     {
 285         size_t bytesWritten = fwrite(outPayload, 1, s, fp1);
 286         if (bytesWritten == s)
 287         {
 288             OIC_LOG_V(DEBUG, TAG, "Written %zu bytes", bytesWritten);
 289         }
 290         else
 291         {
 292             OIC_LOG_V(ERROR, TAG, "Failed writing %zu bytes", s);
 293         }
 294         fclose(fp1);
 295         fp1 = NULL;
 296     }
 297 exit:
 298
 299     cJSON_Delete(jsonRoot);
 300     OICFree(aclCbor);
 301     OICFree(doxmCbor);
 302     OICFree(pstatCbor);
 303     OICFree(amaclCbor);
 304     OICFree(svcCbor);
 305     OICFree(credCbor);
 306     OICFree(jsonStr);
 307     return ;
 308 }
 309
 310 OicSecAcl_t* JSONToAclBin(const char * jsonStr)
 311 {
 312     OCStackResult ret = OC_STACK_ERROR;
 313     OicSecAcl_t * headAcl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 314     cJSON *jsonRoot = NULL;
 315
 316     VERIFY_NON_NULL(TAG, jsonStr, ERROR);
 317
 318     jsonRoot = cJSON_Parse(jsonStr);
 319     VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
 320
 321     cJSON *jsonAclMap = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME);
 322     VERIFY_NON_NULL(TAG, jsonAclMap, ERROR);
 323
 324     cJSON *jsonAclObj = NULL;
 325
 326     // aclist
 327     jsonAclObj = cJSON_GetObjectItem(jsonAclMap, OIC_JSON_ACLIST_NAME);
 328     VERIFY_NON_NULL(TAG, jsonAclObj, ERROR);
 329
 330     // aclist-aces
 331     cJSON *jsonAclArray = NULL;
 332     jsonAclArray = cJSON_GetObjectItem(jsonAclObj, OIC_JSON_ACES_NAME);
 333     VERIFY_NON_NULL(TAG, jsonAclArray, ERROR);
 334
 335     if (cJSON_Array == jsonAclArray->type)
 336     {
 337
 338         int numAcl = cJSON_GetArraySize(jsonAclArray);
 339         int idx = 0;
 340
 341         VERIFY_SUCCESS(TAG, numAcl > 0, INFO);
 342         do
 343         {
 344             cJSON *jsonAcl = cJSON_GetArrayItem(jsonAclArray, idx);
 345             VERIFY_NON_NULL(TAG, jsonAcl, ERROR);
 346
 347             OicSecAce_t *ace = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
 348             VERIFY_NON_NULL(TAG, ace, ERROR);
 349             LL_APPEND(headAcl->aces, ace);
 350
 351             size_t jsonObjLen = 0;
 352             cJSON *jsonObj = NULL;
 353             jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_SUBJECTID_NAME);
 354             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 355             VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
 356             if(strcmp(jsonObj->valuestring, WILDCARD_RESOURCE_URI) == 0)
 357             {
 358                 ace->subjectuuid.id[0] = '*';
 359             }
 360             else
 361             {
 362                 ret = ConvertStrToUuid(jsonObj->valuestring, &ace->subjectuuid);
 363                 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 364             }
 365             // Resources -- Mandatory
 366             jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_RESOURCES_NAME);
 367             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 368             VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR);
 369
 370             size_t resourcesLen = (size_t)cJSON_GetArraySize(jsonObj);
 371             VERIFY_SUCCESS(TAG, resourcesLen > 0, ERROR);
 372
 373             for(size_t idxx = 0; idxx < resourcesLen; idxx++)
 374             {
 375                 OicSecRsrc_t* rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t));
 376                 VERIFY_NON_NULL(TAG, rsrc, ERROR);
 377
 378                 cJSON *jsonRsrc = cJSON_GetArrayItem(jsonObj, idxx);
 379                 VERIFY_NON_NULL(TAG, jsonRsrc, ERROR);
 380
 381                 //href
 382                 size_t jsonRsrcObjLen = 0;
 383                 cJSON *jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_HREF_NAME);
 384                 VERIFY_NON_NULL(TAG, jsonRsrcObj, ERROR);
 385                 VERIFY_SUCCESS(TAG, cJSON_String == jsonRsrcObj->type, ERROR);
 386
 387                 jsonRsrcObjLen = strlen(jsonRsrcObj->valuestring) + 1;
 388                 rsrc->href = (char*)OICMalloc(jsonRsrcObjLen);
 389                 VERIFY_NON_NULL(TAG, (rsrc->href), ERROR);
 390                 OICStrcpy(rsrc->href, jsonRsrcObjLen, jsonRsrcObj->valuestring);
 391
 392                 //rel
 393                 jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_REL_NAME);
 394                 if(jsonRsrcObj)
 395                 {
 396                     jsonRsrcObjLen = strlen(jsonRsrcObj->valuestring) + 1;
 397                     rsrc->rel = (char*)OICMalloc(jsonRsrcObjLen);
 398                     VERIFY_NON_NULL(TAG, (rsrc->rel), ERROR);
 399                     OICStrcpy(rsrc->rel, jsonRsrcObjLen, jsonRsrcObj->valuestring);
 400                 }
 401
 402                 //rt
 403                 jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_RT_NAME);
 404                 if(jsonRsrcObj && cJSON_Array == jsonRsrcObj->type)
 405                 {
 406                     rsrc->typeLen = (size_t)cJSON_GetArraySize(jsonRsrcObj);
 407                     VERIFY_SUCCESS(TAG, (0 < rsrc->typeLen), ERROR);
 408                     rsrc->types = (char**)OICCalloc(rsrc->typeLen, sizeof(char*));
 409                     VERIFY_NON_NULL(TAG, (rsrc->types), ERROR);
 410                     for(size_t i = 0; i < rsrc->typeLen; i++)
 411                     {
 412                         cJSON *jsonRsrcType = cJSON_GetArrayItem(jsonRsrcObj, i);
 413                         VERIFY_NON_NULL(TAG, jsonRsrcType, ERROR);
 414                         rsrc->types[i] = OICStrdup(jsonRsrcType->valuestring);
 415                         VERIFY_NON_NULL(TAG, (rsrc->types[i]), ERROR);
 416                     }
 417                 }
 418
 419                 //if
 420                 jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_IF_NAME);
 421                 if(jsonRsrcObj && cJSON_Array == jsonRsrcObj->type)
 422                 {
 423                     rsrc->interfaceLen = (size_t)cJSON_GetArraySize(jsonRsrcObj);
 424                     VERIFY_SUCCESS(TAG, (0 < rsrc->interfaceLen), ERROR);
 425                     rsrc->interfaces = (char**)OICCalloc(rsrc->interfaceLen, sizeof(char*));
 426                     VERIFY_NON_NULL(TAG, (rsrc->interfaces), ERROR);
 427                     for(size_t i = 0; i < rsrc->interfaceLen; i++)
 428                     {
 429                         cJSON *jsonInterface = cJSON_GetArrayItem(jsonRsrcObj, i);
 430                         VERIFY_NON_NULL(TAG, jsonInterface, ERROR);
 431                         rsrc->interfaces[i] = OICStrdup(jsonInterface->valuestring);
 432                         VERIFY_NON_NULL(TAG, (rsrc->interfaces[i]), ERROR);
 433                     }
 434                 }
 435
 436                 LL_APPEND(ace->resources, rsrc);
 437             }
 438
 439             // Permissions -- Mandatory
 440             jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_PERMISSION_NAME);
 441             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 442             VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 443             ace->permission = jsonObj->valueint;
 444
 445             //Validity -- Not Mandatory
 446             cJSON *jsonValidityObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_VALIDITY_NAME);
 447             if(jsonValidityObj)
 448             {
 449                 VERIFY_SUCCESS(TAG, cJSON_Array == jsonValidityObj->type, ERROR);
 450                 size_t validityLen = (size_t) cJSON_GetArraySize(jsonValidityObj);
 451                 VERIFY_SUCCESS(TAG, (0 < validityLen), ERROR);
 452
 453                 cJSON *jsonValidity = NULL;
 454                 for(size_t i = 0; i < validityLen; i++)
 455                 {
 456                     jsonValidity = cJSON_GetArrayItem(jsonValidityObj, i);
 457                     VERIFY_NON_NULL(TAG, jsonValidity, ERROR);
 458                     VERIFY_SUCCESS(TAG, (jsonValidity->type == cJSON_Array), ERROR);
 459
 460                     OicSecValidity_t* validity = (OicSecValidity_t*)OICCalloc(1, sizeof(OicSecValidity_t));
 461                     VERIFY_NON_NULL(TAG, validity, ERROR);
 462                     LL_APPEND(ace->validities, validity);
 463
 464                     //Period
 465                     cJSON* jsonPeriod = cJSON_GetArrayItem(jsonValidity, 0);
 466                     if(jsonPeriod)
 467                     {
 468                         VERIFY_SUCCESS(TAG, (cJSON_String == jsonPeriod->type), ERROR);
 469
 470                         jsonObjLen = strlen(jsonPeriod->valuestring) + 1;
 471                         validity->period = (char*)OICMalloc(jsonObjLen);
 472                         VERIFY_NON_NULL(TAG, validity->period, ERROR);
 473                         OICStrcpy(validity->period, jsonObjLen, jsonPeriod->valuestring);
 474                     }
 475
 476                     //Recurrence
 477                     cJSON* jsonRecurObj = cJSON_GetArrayItem(jsonValidity, 1);
 478                     if(jsonRecurObj)
 479                     {
 480                         VERIFY_SUCCESS(TAG, (cJSON_Array == jsonRecurObj->type), ERROR);
 481                         validity->recurrenceLen = (size_t) cJSON_GetArraySize(jsonRecurObj);
 482                         VERIFY_SUCCESS(TAG, (0 < validity->recurrenceLen), ERROR);
 483
 484                         validity->recurrences = (char**)OICCalloc(validity->recurrenceLen, sizeof(char*));
 485                         VERIFY_NON_NULL(TAG, validity->recurrences, ERROR);
 486
 487                         cJSON *jsonRecur = NULL;
 488                         for(size_t i = 0; i < validity->recurrenceLen; i++)
 489                         {
 490                             jsonRecur = cJSON_GetArrayItem(jsonRecurObj, i);
 491                             VERIFY_NON_NULL(TAG, jsonRecur, ERROR);
 492                             jsonObjLen = strlen(jsonRecur->valuestring) + 1;
 493                             validity->recurrences[i] = (char*)OICMalloc(jsonObjLen);
 494                             VERIFY_NON_NULL(TAG, validity->recurrences[i], ERROR);
 495                             OICStrcpy(validity->recurrences[i], jsonObjLen, jsonRecur->valuestring);
 496                         }
 497                     }
 498                 }
 499             }
 500         } while( ++idx < numAcl);
 501     }
 502
 503
 504     // rownerid
 505     jsonAclObj = cJSON_GetObjectItem(jsonAclMap, OIC_JSON_ROWNERID_NAME);
 506     VERIFY_NON_NULL(TAG, jsonAclObj, ERROR);
 507     VERIFY_SUCCESS(TAG, cJSON_String == jsonAclObj->type, ERROR);
 508     ret = ConvertStrToUuid(jsonAclObj->valuestring, &headAcl->rownerID);
 509     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 510
 511     ret = OC_STACK_OK;
 512
 513 exit:
 514     cJSON_Delete(jsonRoot);
 515     if (OC_STACK_OK != ret)
 516     {
 517         DeleteACLList(headAcl);
 518         headAcl = NULL;
 519     }
 520     return headAcl;
 521 }
 522
 523 OicSecDoxm_t* JSONToDoxmBin(const char * jsonStr)
 524 {
 525     printf("IN JSONToDoxmBin\n");
 526     if (NULL == jsonStr)
 527     {
 528         return NULL;
 529     }
 530
 531     OCStackResult ret = OC_STACK_ERROR;
 532     OicSecDoxm_t *doxm =  NULL;
 533     cJSON *jsonDoxm = NULL;
 534     cJSON *jsonObj = NULL;
 535
 536     size_t jsonObjLen = 0;
 537
 538     cJSON *jsonRoot = cJSON_Parse(jsonStr);
 539     VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
 540
 541     jsonDoxm = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME);
 542     VERIFY_NON_NULL(TAG, jsonDoxm, ERROR);
 543
 544     doxm = (OicSecDoxm_t *)OICCalloc(1, sizeof(OicSecDoxm_t));
 545     VERIFY_NON_NULL(TAG, doxm, ERROR);
 546
 547     //OxmType -- not Mandatory
 548     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXM_TYPE_NAME);
 549     if ((jsonObj) && (cJSON_Array == jsonObj->type))
 550     {
 551         doxm->oxmTypeLen = (size_t)cJSON_GetArraySize(jsonObj);
 552         VERIFY_SUCCESS(TAG, doxm->oxmTypeLen > 0, ERROR);
 553
 554         doxm->oxmType = (OicUrn_t *)OICCalloc(doxm->oxmTypeLen, sizeof(char *));
 555         VERIFY_NON_NULL(TAG, (doxm->oxmType), ERROR);
 556
 557         for (size_t i  = 0; i < doxm->oxmTypeLen ; i++)
 558         {
 559             cJSON *jsonOxmTy = cJSON_GetArrayItem(jsonObj, i);
 560             VERIFY_NON_NULL(TAG, jsonOxmTy, ERROR);
 561
 562             jsonObjLen = strlen(jsonOxmTy->valuestring) + 1;
 563             doxm->oxmType[i] = (char*)OICMalloc(jsonObjLen);
 564             VERIFY_NON_NULL(TAG, doxm->oxmType[i], ERROR);
 565             strncpy((char *)doxm->oxmType[i], (char *)jsonOxmTy->valuestring, jsonObjLen);
 566         }
 567     }
 568
 569     //Oxm -- not Mandatory
 570     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXMS_NAME);
 571     if (jsonObj && cJSON_Array == jsonObj->type)
 572     {
 573         doxm->oxmLen = (size_t)cJSON_GetArraySize(jsonObj);
 574         VERIFY_SUCCESS(TAG, doxm->oxmLen > 0, ERROR);
 575
 576         doxm->oxm = (OicSecOxm_t*)OICCalloc(doxm->oxmLen, sizeof(OicSecOxm_t));
 577         VERIFY_NON_NULL(TAG, doxm->oxm, ERROR);
 578
 579         for (size_t i  = 0; i < doxm->oxmLen ; i++)
 580         {
 581             cJSON *jsonOxm = cJSON_GetArrayItem(jsonObj, i);
 582             VERIFY_NON_NULL(TAG, jsonOxm, ERROR);
 583             doxm->oxm[i] = (OicSecOxm_t)jsonOxm->valueint;
 584         }
 585     }
 586
 587     //OxmSel -- Mandatory
 588     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXM_SEL_NAME);
 589     if (jsonObj)
 590     {
 591         VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 592         doxm->oxmSel = (OicSecOxm_t)jsonObj->valueint;
 593     }
 594
 595     //sct -- Mandatory
 596     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_SUPPORTED_CRED_TYPE_NAME);
 597     if (jsonObj)
 598     {
 599         VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 600         doxm->sct = (OicSecCredType_t)jsonObj->valueint;
 601     }
 602
 603     //Owned -- Mandatory
 604     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OWNED_NAME);
 605     if (jsonObj)
 606     {
 607         VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type), ERROR);
 608         doxm->owned = jsonObj->valueint;
 609     }
 610
 611     //DPC -- Mandatory
 612     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DPC_NAME);
 613     if (jsonObj)
 614     {
 615         VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type), ERROR);
 616         doxm->dpc = jsonObj->valueint;
 617     }
 618
 619 #ifdef _ENABLE_MULTIPLE_OWNER_
 620     //mom -- Not Mandatory
 621     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_MOM_NAME);
 622     if (jsonObj)
 623     {
 624         VERIFY_SUCCESS(TAG, (cJSON_Number == jsonObj->type), ERROR);
 625         doxm->mom = (OicSecMom_t*)OICCalloc(1, sizeof(OicSecMom_t));
 626         VERIFY_NON_NULL(TAG, doxm->mom, ERROR);
 627         doxm->mom->mode = (OicSecMomType_t)jsonObj->valueint;
 628     }
 629 #endif //_ENABLE_MULTIPLE_OWNER_
 630
 631     //DeviceId -- Mandatory
 632     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVICE_ID_NAME);
 633     if (jsonObj)
 634     {
 635         VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
 636         if (cJSON_String == jsonObj->type)
 637         {
 638             //Check for empty string, in case DeviceId field has not been set yet
 639             if (jsonObj->valuestring[0])
 640             {
 641                 ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->deviceID);
 642                 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 643             }
 644         }
 645     }
 646
 647     //rowner -- Mandatory
 648     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_ROWNERID_NAME);
 649     if (true == doxm->owned)
 650     {
 651         VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 652     }
 653     if (jsonObj)
 654     {
 655         ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->rownerID);
 656         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 657     }
 658
 659     //Owner -- will be empty when device status is unowned.
 660     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVOWNERID_NAME);
 661     if (true == doxm->owned)
 662     {
 663         VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 664     }
 665     if (jsonObj)
 666     {
 667         ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->owner);
 668                 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 669     }
 670
 671     ret = OC_STACK_OK;
 672
 673 exit:
 674     cJSON_Delete(jsonRoot);
 675     if (OC_STACK_OK != ret)
 676     {
 677         DeleteDoxmBinData(doxm);
 678         doxm = NULL;
 679     }
 680     printf("OUT JSONToDoxmBin\n");
 681     return doxm;
 682 }
 683
 684 OicSecPstat_t* JSONToPstatBin(const char * jsonStr)
 685 {
 686     printf("IN JSONToPstatBin\n");
 687     if(NULL == jsonStr)
 688     {
 689         return NULL;
 690     }
 691
 692     OCStackResult ret = OC_STACK_ERROR;
 693     OicSecPstat_t *pstat = NULL;
 694     cJSON *jsonPstat = NULL;
 695     cJSON *jsonObj = NULL;
 696
 697     cJSON *jsonRoot = cJSON_Parse(jsonStr);
 698     VERIFY_NON_NULL(TAG, jsonRoot, INFO);
 699
 700     jsonPstat = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME);
 701     VERIFY_NON_NULL(TAG, jsonPstat, INFO);
 702
 703     pstat = (OicSecPstat_t*)OICCalloc(1, sizeof(OicSecPstat_t));
 704     VERIFY_NON_NULL(TAG, pstat, INFO);
 705     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_ISOP_NAME);
 706     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 707     VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type) , ERROR);
 708     pstat->isOp = jsonObj->valueint;
 709
 710     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_DEVICE_ID_NAME);
 711     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 712     VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
 713     ret = ConvertStrToUuid(jsonObj->valuestring, &pstat->deviceID);
 714     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 715
 716     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_ROWNERID_NAME);
 717     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 718     VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
 719     ret = ConvertStrToUuid(jsonObj->valuestring, &pstat->rownerID);
 720     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 721
 722     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_CM_NAME);
 723     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 724     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 725     pstat->cm  = (OicSecDpm_t)jsonObj->valueint;
 726
 727     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_TM_NAME);
 728     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 729     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 730     pstat->tm  = (OicSecDpm_t)jsonObj->valueint;
 731
 732     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_OM_NAME);
 733     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 734     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 735     pstat->om  = (OicSecDpom_t)jsonObj->valueint;
 736
 737     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_SM_NAME);
 738     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 739     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 740     pstat->smLen = 1;
 741     pstat->sm = (OicSecDpom_t*)OICCalloc(pstat->smLen, sizeof(OicSecDpom_t));
 742     pstat->sm[0] = (OicSecDpom_t)jsonObj->valueint;
 743
 744     ret = OC_STACK_OK;
 745
 746 exit:
 747     cJSON_Delete(jsonRoot);
 748     if (OC_STACK_OK != ret)
 749     {
 750         OIC_LOG(ERROR, TAG, "JSONToPstatBin failed");
 751     }
 752     printf("OUT JSONToPstatBin\n");
 753     return pstat;
 754 }
 755
 756 static OicEncodingType_t GetEncodingTypeFromStr(const char* encodingType)
 757 {
 758     if (strcmp(OIC_SEC_ENCODING_RAW, encodingType) == 0)
 759     {
 760         return OIC_ENCODING_RAW;
 761     }
 762     if (strcmp(OIC_SEC_ENCODING_BASE64, encodingType) == 0)
 763     {
 764         return OIC_ENCODING_BASE64;
 765     }
 766     if (strcmp(OIC_SEC_ENCODING_PEM, encodingType) == 0)
 767     {
 768         return OIC_ENCODING_PEM;
 769     }
 770     if (strcmp(OIC_SEC_ENCODING_DER, encodingType) == 0)
 771     {
 772         return OIC_ENCODING_DER;
 773     }
 774     OIC_LOG(WARNING, TAG, "Unknow encoding type dectected!");
 775     OIC_LOG(WARNING, TAG, "json2cbor will use \"oic.sec.encoding.raw\" as default encoding type.");
 776     return OIC_ENCODING_RAW;
 777 }
 778
 779 OicSecCred_t * JSONToCredBin(const char * jsonStr)
 780 {
 781     if (NULL == jsonStr)
 782     {
 783         OIC_LOG(ERROR, TAG,"JSONToCredBin jsonStr in NULL");
 784         return NULL;
 785     }
 786
 787     OicSecCred_t *headCred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
 788     OCStackResult ret = OC_STACK_ERROR;
 789     cJSON *jsonRoot = NULL;
 790     VERIFY_NON_NULL(TAG, headCred, ERROR);
 791
 792     jsonRoot = cJSON_Parse(jsonStr);
 793     VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
 794
 795     cJSON *jsonCredMap = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
 796     VERIFY_NON_NULL(TAG, jsonCredMap, ERROR);
 797
 798     // creds
 799     cJSON *jsonCredArray = NULL;
 800     jsonCredArray = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_CREDS_NAME);
 801     VERIFY_NON_NULL(TAG, jsonCredArray, ERROR);
 802
 803     if (cJSON_Array == jsonCredArray->type)
 804     {
 805         int numCred = cJSON_GetArraySize(jsonCredArray);
 806         VERIFY_SUCCESS(TAG, numCred > 0, ERROR);
 807         int idx = 0;
 808         do
 809         {
 810             cJSON *jsonCred = cJSON_GetArrayItem(jsonCredArray, idx);
 811             VERIFY_NON_NULL(TAG, jsonCred, ERROR);
 812
 813             OicSecCred_t *cred = NULL;
 814             if(idx == 0)
 815             {
 816                 cred = headCred;
 817             }
 818             else
 819             {
 820                 cred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
 821                 OicSecCred_t *temp = headCred;
 822                 while (temp->next)
 823                 {
 824                     temp = temp->next;
 825                 }
 826                 temp->next = cred;
 827             }
 828             VERIFY_NON_NULL(TAG, cred, ERROR);
 829
 830             size_t jsonObjLen = 0;
 831             cJSON *jsonObj = NULL;
 832
 833             //CredId -- Mandatory
 834             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDID_NAME);
 835             if(jsonObj)
 836             {
 837                 VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 838                 cred->credId = jsonObj->valueint;
 839             }
 840
 841             //subject -- Mandatory
 842             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_SUBJECTID_NAME);
 843             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 844             VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
 845             if(strcmp(jsonObj->valuestring, WILDCARD_RESOURCE_URI) == 0)
 846             {
 847                 cred->subject.id[0] = '*';
 848             }
 849             else
 850             {
 851                 ret = ConvertStrToUuid(jsonObj->valuestring, &cred->subject);
 852                 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 853             }
 854
 855             //CredType -- Mandatory
 856             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDTYPE_NAME);
 857             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 858             VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
 859             cred->credType = (OicSecCredType_t)jsonObj->valueint;
 860             //PrivateData is mandatory for some of the credential types listed below.
 861             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PRIVATEDATA_NAME);
 862
 863             if (NULL != jsonObj)
 864             {
 865                 cJSON *jsonPriv = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
 866                 VERIFY_NON_NULL(TAG, jsonPriv, ERROR);
 867                 jsonObjLen = strlen(jsonPriv->valuestring);
 868                 cred->privateData.data = (uint8_t *)OICCalloc(1, jsonObjLen);
 869                 VERIFY_NON_NULL(TAG, (cred->privateData.data), ERROR);
 870                 memcpy(cred->privateData.data, jsonPriv->valuestring, jsonObjLen);
 871                 cred->privateData.len = jsonObjLen;
 872
 873                 cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME);
 874                 VERIFY_NON_NULL(TAG, jsonEncoding, ERROR);
 875                 cred->privateData.encoding = GetEncodingTypeFromStr(jsonEncoding->valuestring);
 876             }
 877 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 878             //PublicData is mandatory only for SIGNED_ASYMMETRIC_KEY credentials type.
 879             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PUBLICDATA_NAME);
 880
 881             if (NULL != jsonObj)
 882             {
 883                 cJSON *jsonPub = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
 884                 VERIFY_NON_NULL(TAG, jsonPub, ERROR);
 885                 jsonObjLen = strlen(jsonPub->valuestring);
 886                 cred->publicData.data = (uint8_t *)OICCalloc(1, jsonObjLen);
 887                 VERIFY_NON_NULL(TAG, (cred->publicData.data), ERROR);
 888                 memcpy(cred->publicData.data, jsonPub->valuestring, jsonObjLen);
 889                 cred->publicData.len = jsonObjLen;
 890             }
 891
 892             //Optional Data
 893             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_OPTDATA_NAME);
 894             if (NULL != jsonObj)
 895             {
 896                 cJSON *jsonOpt = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
 897                 VERIFY_NON_NULL(TAG, jsonOpt, ERROR);
 898                 jsonObjLen = strlen(jsonOpt->valuestring);
 899                 cred->optionalData.data =  (uint8_t *)OICCalloc(1, jsonObjLen);
 900                 VERIFY_NON_NULL(TAG, (cred->optionalData.data), ERROR);
 901                 memcpy(cred->optionalData.data, jsonOpt->valuestring, jsonObjLen);
 902                 cred->optionalData.len = jsonObjLen;
 903
 904                 cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME);
 905                 VERIFY_NON_NULL(TAG, jsonEncoding, ERROR);
 906                 cred->optionalData.encoding = GetEncodingTypeFromStr(jsonEncoding->valuestring);
 907             }
 908
 909             //CredUsage
 910             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDUSAGE_NAME);
 911             if (NULL != jsonObj)
 912             {
 913                 jsonObjLen = strlen(jsonObj->valuestring);
 914                 cred->credUsage = OICStrdup(jsonObj->valuestring);
 915                 VERIFY_NON_NULL(TAG, (cred->credUsage), ERROR);
 916             }
 917
 918 #endif // defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 919
 920             //Period -- Not Mandatory
 921             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PERIOD_NAME);
 922             if(jsonObj && cJSON_String == jsonObj->type)
 923             {
 924                 jsonObjLen = strlen(jsonObj->valuestring) + 1;
 925                 cred->period = (char *)OICMalloc(jsonObjLen);
 926                 VERIFY_NON_NULL(TAG, cred->period, ERROR);
 927                 strncpy(cred->period, jsonObj->valuestring, jsonObjLen);
 928             }
 929             cred->next = NULL;
 930         } while( ++idx < numCred);
 931     }
 932
 933     // rownerid
 934     cJSON *jsonCredObj = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_ROWNERID_NAME);
 935     VERIFY_NON_NULL(TAG, jsonCredObj, ERROR);
 936     VERIFY_SUCCESS(TAG, cJSON_String == jsonCredObj->type, ERROR);
 937     ret = ConvertStrToUuid(jsonCredObj->valuestring, &headCred->rownerID);
 938     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 939     ret = OC_STACK_OK;
 940
 941 exit:
 942     cJSON_Delete(jsonRoot);
 943     if (OC_STACK_OK != ret)
 944     {
 945         DeleteCredList(headCred);
 946         headCred = NULL;
 947     }
 948     return headCred;
 949 }
 950
 951 static OicSecSvc_t* JSONToSvcBin(const char * jsonStr)
 952 {
 953     OCStackResult ret = OC_STACK_ERROR;
 954     OicSecSvc_t * headSvc = NULL;
 955     OicSecSvc_t * prevSvc = NULL;
 956     cJSON *jsonRoot = NULL;
 957     cJSON *jsonSvcArray = NULL;
 958
 959     VERIFY_NON_NULL(TAG, jsonStr, ERROR);
 960
 961     jsonRoot = cJSON_Parse(jsonStr);
 962     VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
 963
 964     jsonSvcArray = cJSON_GetObjectItem(jsonRoot, OIC_JSON_SVC_NAME);
 965     VERIFY_NON_NULL(TAG, jsonSvcArray, INFO);
 966
 967     if (cJSON_Array == jsonSvcArray->type)
 968     {
 969         int numSvc = cJSON_GetArraySize(jsonSvcArray);
 970         int idx = 0;
 971
 972         VERIFY_SUCCESS(TAG, numSvc > 0, INFO);
 973         do
 974         {
 975             cJSON *jsonSvc = cJSON_GetArrayItem(jsonSvcArray, idx);
 976             VERIFY_NON_NULL(TAG, jsonSvc, ERROR);
 977
 978             OicSecSvc_t *svc = (OicSecSvc_t*)OICCalloc(1, sizeof(OicSecSvc_t));
 979             VERIFY_NON_NULL(TAG, svc, ERROR);
 980
 981             headSvc = (headSvc) ? headSvc : svc;
 982             if (prevSvc)
 983             {
 984                 prevSvc->next = svc;
 985             }
 986
 987             cJSON *jsonObj = NULL;
 988             unsigned char base64Buff[sizeof(((OicUuid_t*)0)->id)] = {};
 989             uint32_t outLen = 0;
 990             B64Result b64Ret = B64_OK;
 991
 992             // Service Device Identity
 993             jsonObj = cJSON_GetObjectItem(jsonSvc, OIC_JSON_SERVICE_DEVICE_ID);
 994             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
 995             VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
 996             outLen = 0;
 997             b64Ret = b64Decode(jsonObj->valuestring, strlen(jsonObj->valuestring), base64Buff,
 998                        sizeof(base64Buff), &outLen);
 999             VERIFY_SUCCESS(TAG, (b64Ret == B64_OK && outLen <= sizeof(svc->svcdid.id)), ERROR);
1000             memcpy(svc->svcdid.id, base64Buff, outLen);
1001
1002             // Service Type
1003             jsonObj = cJSON_GetObjectItem(jsonSvc, OIC_JSON_SERVICE_TYPE);
1004             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
1005             VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
1006             svc->svct = (OicSecSvcType_t)jsonObj->valueint;
1007
1008             // Resource Owners
1009             jsonObj = cJSON_GetObjectItem(jsonSvc, OIC_JSON_OWNERS_NAME);
1010             VERIFY_NON_NULL(TAG, jsonObj, ERROR);
1011             VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR);
1012
1013             svc->ownersLen = (size_t)cJSON_GetArraySize(jsonObj);
1014             VERIFY_SUCCESS(TAG, svc->ownersLen > 0, ERROR);
1015             svc->owners = (OicUuid_t*)OICCalloc(svc->ownersLen, sizeof(OicUuid_t));
1016             VERIFY_NON_NULL(TAG, (svc->owners), ERROR);
1017
1018             size_t idxx = 0;
1019             do
1020             {
1021                 cJSON *jsonOwnr = cJSON_GetArrayItem(jsonObj, idxx);
1022                 VERIFY_NON_NULL(TAG, jsonOwnr, ERROR);
1023                 VERIFY_SUCCESS(TAG, cJSON_String == jsonOwnr->type, ERROR);
1024                 outLen = 0;
1025                 b64Ret = b64Decode(jsonOwnr->valuestring, strlen(jsonOwnr->valuestring), base64Buff,
1026                            sizeof(base64Buff), &outLen);
1027
1028                 VERIFY_SUCCESS(TAG, (b64Ret == B64_OK && outLen <= sizeof(svc->owners[idxx].id)),
1029                                    ERROR);
1030                 memcpy(svc->owners[idxx].id, base64Buff, outLen);
1031             } while ( ++idxx < svc->ownersLen);
1032
1033             prevSvc = svc;
1034         } while( ++idx < numSvc);
1035     }
1036
1037     ret = OC_STACK_OK;
1038
1039 exit:
1040     cJSON_Delete(jsonRoot);
1041     if (OC_STACK_OK != ret)
1042     {
1043         DeleteSVCList(headSvc);
1044         headSvc = NULL;
1045     }
1046     return headSvc;
1047 }
1048
1049 static OicSecAmacl_t* JSONToAmaclBin(const char * jsonStr)
1050 {
1051     OCStackResult ret = OC_STACK_ERROR;
1052     OicSecAmacl_t * headAmacl = (OicSecAmacl_t*)OICCalloc(1, sizeof(OicSecAmacl_t));
1053
1054     cJSON *jsonRoot = NULL;
1055     cJSON *jsonAmacl = NULL;
1056
1057     VERIFY_NON_NULL(TAG, jsonStr, ERROR);
1058
1059     jsonRoot = cJSON_Parse(jsonStr);
1060     VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
1061
1062     jsonAmacl = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME);
1063     VERIFY_NON_NULL(TAG, jsonAmacl, INFO);
1064
1065     cJSON *jsonObj = NULL;
1066
1067     // Resources -- Mandatory
1068     jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_RESOURCES_NAME);
1069     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
1070
1071     // Rlist
1072     cJSON *jsonRlistArray = cJSON_GetObjectItem(jsonObj, OIC_JSON_RLIST_NAME);
1073     VERIFY_NON_NULL(TAG, jsonRlistArray, ERROR);
1074     VERIFY_SUCCESS(TAG, cJSON_Array == jsonRlistArray->type, ERROR);
1075
1076     headAmacl->resourcesLen = (size_t)cJSON_GetArraySize(jsonRlistArray);
1077     headAmacl->resources = (char**)OICCalloc(headAmacl->resourcesLen, sizeof(char*));
1078     size_t idxx = 0;
1079     do
1080     {
1081         cJSON *jsonRsrc = cJSON_GetArrayItem(jsonRlistArray, idxx);
1082         VERIFY_NON_NULL(TAG, jsonRsrc, ERROR);
1083
1084         cJSON *jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_HREF_NAME);
1085         VERIFY_NON_NULL(TAG, jsonRsrcObj, ERROR);
1086         VERIFY_SUCCESS(TAG, cJSON_String == jsonRsrcObj->type, ERROR);
1087
1088         size_t jsonRsrcObjLen = 0;
1089         jsonRsrcObjLen = strlen(jsonRsrcObj->valuestring) + 1;
1090         headAmacl->resources[idxx] = (char*)OICMalloc(jsonRsrcObjLen);
1091         VERIFY_NON_NULL(TAG, (headAmacl->resources[idxx]), ERROR);
1092         OICStrcpy(headAmacl->resources[idxx], jsonRsrcObjLen, jsonRsrcObj->valuestring);
1093
1094     } while ( ++idxx < headAmacl->resourcesLen);
1095
1096     // Ams -- Mandatory
1097     jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_AMS_NAME);
1098     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
1099     VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR);
1100
1101     headAmacl->amssLen = (size_t)cJSON_GetArraySize(jsonObj);
1102     VERIFY_SUCCESS(TAG, headAmacl->amssLen > 0, ERROR);
1103     headAmacl->amss = (OicUuid_t*)OICCalloc(headAmacl->amssLen, sizeof(OicUuid_t));
1104     VERIFY_NON_NULL(TAG, headAmacl->amss, ERROR);
1105
1106     idxx = 0;
1107     do
1108     {
1109         cJSON *jsonAms = cJSON_GetArrayItem(jsonObj, idxx);
1110         VERIFY_NON_NULL(TAG, jsonAms, ERROR);
1111         VERIFY_SUCCESS(TAG, cJSON_String == jsonAms->type, ERROR);
1112
1113         memcpy(headAmacl->amss[idxx].id, (OicUuid_t *)jsonAms->valuestring, strlen(jsonAms->valuestring));
1114
1115     } while ( ++idxx < headAmacl->amssLen);
1116
1117
1118     // Rowner -- Mandatory
1119     jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_ROWNERID_NAME);
1120     VERIFY_NON_NULL(TAG, jsonObj, ERROR);
1121     VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
1122
1123     ret = ConvertStrToUuid(jsonObj->valuestring, &headAmacl->rownerID);
1124     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
1125
1126     ret = OC_STACK_OK;
1127
1128 exit:
1129     cJSON_Delete(jsonRoot);
1130     if (OC_STACK_OK != ret)
1131     {
1132         DeleteAmaclList(headAmacl);
1133         headAmacl = NULL;
1134     }
1135     return headAmacl;
1136 }
1137
1138 int main(int argc, char* argv[])
1139 {
1140     if (argc == 3)
1141     {
1142         printf("JSON File Name: %s\n CBOR File Name: %s \n", argv[1], argv[2]);
1143         ConvertJsonToCBOR(argv[1], argv[2]);
1144     }
1145     else
1146     {
1147         printf("This program requires two inputs:\n");
1148         printf("1. First input is a json file tha will be converted to cbor. \n");
1149         printf("2. Second input is a resulting cbor file that will store converted cbor. \n");
1150         printf("\t json2cbor <json_file_name> <cbor_file_name>. \n");
1151     }
1152 }