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