Merge branch '1.3-rel' (5fdb8a1)
[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 <inttypes.h>
24 #include "utlist.h"
25 #include "cJSON.h"
26 #include "base64.h"
27 #include "cainterface.h"
28 #include "ocstack.h"
29 #include "oic_malloc.h"
30 #include "oic_string.h"
31 #include "ocpayload.h"
32 #include "ocpayloadcbor.h"
33 #include "experimental/payload_logging.h"
34 #include "secureresourcemanager.h"
35 #include "srmresourcestrings.h"
36 #include "srmutility.h"
37 #include "aclresource.h"
38 #include "pstatresource.h"
39 #include "experimental/doxmresource.h"
40 #include "amaclresource.h"
41 #include "credresource.h"
42 #include "security_internals.h"
43 #include "ocresourcehandler.h"
44
45 #define TAG  "OIC_JSON2CBOR"
46 #define MAX_RANGE   SIZE_MAX
47 //SVR database buffer block size
48
49 #define DB_FILE_SIZE_BLOCK 1023
50 #define DELTA_ERROR 0.0000001
51
52 static OicSecPstat_t *JSONToPstatBin(const char *jsonStr);
53 static OicSecDoxm_t *JSONToDoxmBin(const char *jsonStr);
54 static OicSecAcl_t *JSONToAclBin(OicSecAclVersion_t *aclVersion,
55                                  const char *jsonStr);
56 static OicSecAmacl_t *JSONToAmaclBin(const char *jsonStr);
57 static OicSecCred_t *JSONToCredBinWithRowner(const char *jsonStr,OicUuid_t *rownerId);
58 static OCDeviceProperties *JSONToDPBin(const char *jsonStr);
59
60 static size_t GetJSONFileSize(const char *jsonFileName)
61 {
62     size_t size = 0;
63     size_t bytesRead  = 0;
64     char buffer[DB_FILE_SIZE_BLOCK];
65     FILE *fp = fopen(jsonFileName, "r");
66     if (fp)
67     {
68         do
69         {
70             bytesRead = fread(buffer, 1, DB_FILE_SIZE_BLOCK, fp);
71             if (bytesRead >= (MAX_RANGE - size))
72             {
73                 fclose(fp);
74                 return 0;
75             }
76             size += bytesRead;
77         }
78         while (bytesRead > 0);
79         fclose(fp);
80     }
81     return size;
82 }
83
84 /** @return OC_STACK_OK on success **/
85 static OCStackResult ReadBufferFromFile(const char *fileName, uint8_t **buffer, size_t *bufferSize)
86 {
87     OCStackResult ret = OC_STACK_ERROR;
88     FILE *fp = NULL;
89     size_t size = 0;
90     VERIFY_NOT_NULL(TAG, buffer, FATAL);
91     VERIFY_NOT_NULL(TAG, bufferSize, FATAL);
92
93     size = GetJSONFileSize(fileName);
94     if (0 == size)
95     {
96         OIC_LOG(ERROR, TAG, "Unable to get file size");
97         return OC_STACK_ERROR;
98     }
99     fp = fopen(fileName, "r");
100     if (fp)
101     {
102         *buffer = (uint8_t *)OICMalloc(size + 1);
103         VERIFY_NOT_NULL(TAG, *buffer, FATAL);
104         size_t bytesRead = fread(*buffer, 1, size, fp);
105         (*buffer)[bytesRead] = '\0';
106         OIC_LOG_V(DEBUG, TAG, "Read %" PRIuPTR " bytes", bytesRead);
107         if (bytesRead)
108         {
109             ret = OC_STACK_OK;
110             *bufferSize = bytesRead + 1;
111         }
112         if (0 != fclose(fp))
113         {
114             OIC_LOG_V(ERROR, TAG, "Failed to close file \"%s\"", fileName);
115             ret = OC_STACK_ERROR;
116         }
117     }
118     else
119     {
120         OIC_LOG(ERROR, TAG, "Unable to open JSON file!!");
121     }
122 exit:
123     if (OC_STACK_OK != ret)
124     {
125         OIC_LOG_V(ERROR, TAG, "%s: exiting (%d)", __func__, ret);
126         *bufferSize = 0;
127         OICFreeAndSetToNull((void**)buffer);
128     }
129     return ret;
130 }
131
132 /** @return OC_STACK_OK on success **/
133 static OCStackResult WriteBufferToFile(const char *fileName, uint8_t *buffer, size_t size)
134 {
135     OCStackResult ret = OC_STACK_ERROR;
136     if ((fileName == NULL) || (buffer == NULL) || (size == 0))
137     {
138         OIC_LOG(ERROR, TAG, "Invalid Parameters to WriteBufferToFile");
139         return OC_STACK_ERROR;
140     }
141     FILE *fp = fopen(fileName, "wb");
142     if (fp)
143     {
144         size_t bytesWritten = fwrite(buffer, 1, size, fp);
145         if (bytesWritten == size)
146         {
147             OIC_LOG_V(DEBUG, TAG, "Written %" PRIuPTR " bytes", bytesWritten);
148             ret = OC_STACK_OK;
149         }
150         else
151         {
152             OIC_LOG_V(ERROR, TAG, "Failed writing %" PRIuPTR " bytes - Error: %d",
153                       size, ferror(fp));
154         }
155         if (0 != fclose(fp))
156         {
157             OIC_LOG_V(ERROR, TAG, "Failed to close file \"%s\"", fileName);
158             ret = OC_STACK_ERROR;
159         }
160     }
161     else
162     {
163         OIC_LOG_V(ERROR, TAG, "Error opening file [%s] for Write", fileName);
164     }
165     return ret;
166 }
167
168 CborError EncodeJson(CborEncoder *encoder, cJSON *jsonObj)
169 {
170     CborError err = CborNoError;
171     switch (jsonObj->type)
172     {
173         case cJSON_Object:
174             {
175                 CborEncoder rootMap;
176                 err = cbor_encoder_create_map(encoder, &rootMap, CborIndefiniteLength);
177                 if (CborNoError == err)
178                 {
179                     cJSON *child = jsonObj->child;
180                     while (child)
181                     {
182                         err = cbor_encode_text_string(&rootMap, child->string, strlen(child->string));
183                         if (CborNoError != err)
184                         {
185                             break;
186                         }
187                         err = EncodeJson(&rootMap, child);
188                         if (CborNoError != err)
189                         {
190                             break;
191                         }
192                         child = child->next;
193                     }
194                 }
195                 if (CborNoError == err)
196                 {
197                     err = cbor_encoder_close_container(encoder, &rootMap);
198                 }
199             }
200             break;
201         case cJSON_Array:
202             {
203                 CborEncoder cborArray;
204                 err = cbor_encoder_create_array(encoder, &cborArray, CborIndefiniteLength);
205                 if (CborNoError == err)
206                 {
207                     cJSON *child = jsonObj->child;
208                     while (child)
209                     {
210                         err = EncodeJson(&cborArray, child);
211                         if (CborNoError != err)
212                         {
213                             break;
214                         }
215                         child = child->next;
216                     }
217                 }
218                 if (CborNoError == err)
219                 {
220                     err = cbor_encoder_close_container(encoder, &cborArray);
221                 }
222             }
223             break;
224         case cJSON_String:
225             err = cbor_encode_text_string(encoder, jsonObj->valuestring,
226                                           strlen(jsonObj->valuestring));
227             break;
228         case cJSON_Number:
229             if ((jsonObj->valuedouble - jsonObj->valueint) > DELTA_ERROR)
230             {
231                 err = cbor_encode_double(encoder, jsonObj->valuedouble);
232             }
233             else
234             {
235                 err = cbor_encode_int(encoder, jsonObj->valueint);
236             }
237             break;
238         case cJSON_NULL:
239             err = cbor_encode_null(encoder);
240             break;
241         case cJSON_True:
242             err = cbor_encode_boolean(encoder, true);
243             break;
244         case cJSON_False:
245             err = cbor_encode_boolean(encoder, false);
246             break;
247         default:
248             OIC_LOG(ERROR, TAG, "Unknown cjson type");
249             break;
250     }
251     return err;
252 }
253
254 /** @return OC_STACK_OK on success **/
255 static OCStackResult ConvertJSONStringToCBORFile(const char *jsonStr, const char *cborFileName)
256 {
257     OCStackResult ret = OC_STACK_ERROR;
258     CborEncoder encoder;
259     CborError err;
260     cJSON *jsonObj = NULL;
261     uint8_t *buffer = NULL;
262     size_t size = 0;
263
264     OIC_LOG_V(INFO, TAG, "%s: enterring ", __func__);
265     jsonObj = cJSON_Parse(jsonStr);
266     if (jsonObj == NULL)
267     {
268         OIC_LOG(ERROR, TAG, "Unable to parse JSON string");
269         goto exit;
270     }
271     size = strlen(jsonStr) + 1;
272     size_t bufferSize = 0;
273     buffer = (uint8_t *)OICMalloc(size);
274     if (!buffer)
275     {
276         OIC_LOG(ERROR, TAG, "Unable to allocate enough memory");
277         goto exit;
278     }
279
280     cbor_encoder_init(&encoder, buffer, size, 0);
281
282     err = EncodeJson(&encoder, jsonObj);
283     if (CborNoError != err)
284     {
285         OIC_LOG(ERROR, TAG, "Error encoding json");
286         goto exit;
287     }
288     else
289     {
290         bufferSize = cbor_encoder_get_buffer_size(&encoder, buffer);
291     }
292     ret = WriteBufferToFile(cborFileName, buffer, bufferSize);
293 exit:
294     if (OC_STACK_OK != ret)
295     {
296         OIC_LOG_V(ERROR, TAG, "%s: exiting (%d)", __func__, ret);
297     }
298     if (jsonObj)
299     {
300         cJSON_Delete(jsonObj);
301     }
302     OICFree(buffer);
303     return ret;
304 }
305
306
307 /** @return ::OC_STACK_OK on success **/
308 static OCStackResult ConvertOCJSONStringToCBORFile(const char *jsonStr, const char *cborFileName)
309 {
310     OCStackResult ret = OC_STACK_ERROR;
311     uint8_t *aclCbor = NULL;
312     uint8_t *pstatCbor = NULL;
313     uint8_t *doxmCbor = NULL;
314     uint8_t *amaclCbor = NULL;
315     uint8_t *credCbor = NULL;
316     uint8_t *dpCbor = NULL;
317     cJSON *jsonRoot = NULL;
318     OCDeviceProperties *deviceProps = NULL;
319     uint8_t *outPayload = NULL;
320     jsonRoot = cJSON_Parse(jsonStr);
321     cJSON *value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME);
322     char *text = cJSON_PrintUnformatted(value);
323     printf("/acl json : \n%s\n", text);
324     OICFree(text);
325     size_t aclCborSize = 0;
326     if (value)
327     {
328         OicSecAclVersion_t version = OIC_SEC_ACL_V2; // default to V2
329         OicSecAcl_t *acl = JSONToAclBin(&version, jsonStr);
330         VERIFY_NOT_NULL(TAG, acl, FATAL);
331         ret = AclToCBORPayload(acl, version, &aclCbor, &aclCborSize);
332         if (OC_STACK_OK != ret)
333         {
334             OIC_LOG (ERROR, TAG, "Failed converting Acl to Cbor Payload");
335             DeleteACLList(acl);
336             goto exit;
337         }
338         printf("ACL Cbor Size: %" PRIuPTR "\n", aclCborSize);
339         DeleteACLList(acl);
340     }
341     else
342     {
343         printf("JSON contains no /acl\n");
344     }
345
346     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME);
347     text = cJSON_PrintUnformatted(value);
348     printf("/pstat json : \n%s\n", text);
349     OICFree(text);
350     size_t pstatCborSize = 0;
351     if (NULL != value)
352     {
353         OicSecPstat_t *pstat = JSONToPstatBin(jsonStr);
354         VERIFY_NOT_NULL(TAG, pstat, FATAL);
355         ret = PstatToCBORPayload(pstat, &pstatCbor, &pstatCborSize);
356         if (OC_STACK_OK != ret)
357         {
358             OIC_LOG (ERROR, TAG, "Failed converting Pstat to Cbor Payload");
359             DeletePstatBinData(pstat);
360             goto exit;
361         }
362         printf("PSTAT Cbor Size: %" PRIuPTR "\n", pstatCborSize);
363         DeletePstatBinData(pstat);
364     }
365     else
366     {
367         printf("JSON contains no /pstat\n");
368     }
369
370     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME);
371     text = cJSON_PrintUnformatted(value);
372     printf("/doxm json : \n%s\n", text);
373     OICFree(text);
374     size_t doxmCborSize = 0;
375     if (NULL != value)
376     {
377         OicSecDoxm_t *doxm = JSONToDoxmBin(jsonStr);
378         VERIFY_NOT_NULL(TAG, doxm, FATAL);
379         ret = DoxmToCBORPayload(doxm, &doxmCbor, &doxmCborSize);
380         if (OC_STACK_OK != ret)
381         {
382             OIC_LOG (ERROR, TAG, "Failed converting Doxm to Cbor Payload");
383             DeleteDoxmBinData(doxm);
384             goto exit;
385         }
386         printf("DOXM Cbor Size: %" PRIuPTR "\n", doxmCborSize);
387         DeleteDoxmBinData(doxm);
388     }
389     else
390     {
391         printf("JSON contains no /doxm\n");
392     }
393
394     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME);
395     printf("/amacl json : \n%s\n", cJSON_PrintUnformatted(value));
396     size_t amaclCborSize = 0;
397     if (NULL != value)
398     {
399         OicSecAmacl_t *amacl = JSONToAmaclBin(jsonStr);
400         VERIFY_NOT_NULL(TAG, amacl, FATAL);
401         ret = AmaclToCBORPayload(amacl, &amaclCbor, &amaclCborSize);
402         if (OC_STACK_OK != ret)
403         {
404             OIC_LOG (ERROR, TAG, "Failed converting Amacl to Cbor Payload");
405             DeleteAmaclList(amacl);
406             goto exit;
407         }
408         printf("AMACL Cbor Size: %" PRIuPTR "\n", amaclCborSize);
409         DeleteAmaclList(amacl);
410     }
411     else
412     {
413         printf("JSON contains no /amacl\n");
414     }
415
416     value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
417     printf("/cred json : \n%s\n", cJSON_PrintUnformatted(value));
418     size_t credCborSize = 0;
419     int secureFlag = 0;
420     if (NULL != value)
421     {
422         OicUuid_t rownerId;
423         OicSecCred_t *cred = JSONToCredBinWithRowner(jsonStr,&rownerId);
424         VERIFY_NOT_NULL(TAG, cred, FATAL);
425         // The source code line below is just a workaround for IOT-2407.
426         // It should be deleted when IOT-2407 gets fixed. There is no clear
427         // correlation between strlen(jsonStr) and the CBOR size, but
428         // CredToCBORPayload happens to work better when initializing
429         // credCborSize this way.
430         credCborSize = strlen(jsonStr);
431         ret = CredToCBORPayloadWithRowner(cred, &rownerId,&credCbor, &credCborSize, secureFlag);
432         if (OC_STACK_OK != ret)
433         {
434             OIC_LOG (ERROR, TAG, "Failed converting Cred to Cbor Payload");
435             DeleteCredList(cred);
436             goto exit;
437         }
438         printf("CRED Cbor Size: %" PRIuPTR "\n", credCborSize);
439         DeleteCredList(cred);
440     }
441     else
442     {
443         printf("JSON contains no /cred\n");
444     }
445
446     value = cJSON_GetObjectItem(jsonRoot, OC_JSON_DEVICE_PROPS_NAME);
447     size_t dpCborSize = 0;
448     if (NULL != value)
449     {
450         deviceProps = JSONToDPBin(jsonStr);
451         VERIFY_NOT_NULL(TAG, deviceProps, FATAL);
452         ret = DevicePropertiesToCBORPayload(deviceProps, &dpCbor, &dpCborSize);
453         if (OC_STACK_OK != ret)
454         {
455             OIC_LOG(ERROR, TAG, "Failed converting OCDeviceProperties to Cbor Payload");
456             goto exit;
457         }
458         printf("Device Properties Cbor Size: %" PRIuPTR "\n", dpCborSize);
459     }
460     else
461     {
462         printf("JSON contains no deviceProps\n");
463     }
464
465     CborEncoder encoder;
466     size_t cborSize = aclCborSize + pstatCborSize + doxmCborSize + credCborSize + amaclCborSize +
467                       dpCborSize;
468
469     printf("Total Cbor Size : %" PRIuPTR "\n", cborSize);
470     cborSize += 255; // buffer margin for adding map and byte string
471     outPayload = (uint8_t *)OICCalloc(1, cborSize);
472     VERIFY_NOT_NULL(TAG, outPayload, ERROR);
473     cbor_encoder_init(&encoder, outPayload, cborSize, 0);
474     CborEncoder map;
475     CborError cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
476     VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Creating Main Map.");
477     if ((aclCborSize > 0) && aclCbor)
478     {
479         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_ACL_NAME, strlen(OIC_JSON_ACL_NAME));
480         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding ACL Name.");
481         cborEncoderResult = cbor_encode_byte_string(&map, aclCbor, aclCborSize);
482         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding ACL Value.");
483     }
484
485     if ((pstatCborSize > 0) && pstatCbor)
486     {
487         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_PSTAT_NAME, strlen(OIC_JSON_PSTAT_NAME));
488         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding PSTAT Name.");
489         cborEncoderResult = cbor_encode_byte_string(&map, pstatCbor, pstatCborSize);
490         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding PSTAT Value.");
491     }
492     if ((doxmCborSize > 0) && doxmCbor)
493     {
494         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_DOXM_NAME, strlen(OIC_JSON_DOXM_NAME));
495         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding DOXM Name.");
496         cborEncoderResult = cbor_encode_byte_string(&map, doxmCbor, doxmCborSize);
497         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding DOXM Value.");
498     }
499     if ((amaclCborSize > 0) && amaclCbor)
500     {
501         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_AMACL_NAME, strlen(OIC_JSON_AMACL_NAME));
502         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding AMACL Name.");
503         cborEncoderResult = cbor_encode_byte_string(&map, amaclCbor, amaclCborSize);
504         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding AMACL Value.");
505     }
506     if ((credCborSize > 0) && credCbor)
507     {
508         cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_CRED_NAME, strlen(OIC_JSON_CRED_NAME));
509         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding CRED Name.");
510         cborEncoderResult = cbor_encode_byte_string(&map, credCbor, credCborSize);
511         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding CRED Value.");
512     }
513     if ((dpCborSize > 0) && dpCbor)
514     {
515         cborEncoderResult = cbor_encode_text_string(&map, OC_JSON_DEVICE_PROPS_NAME,
516                             strlen(OC_JSON_DEVICE_PROPS_NAME));
517         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding Device Properties Name.");
518         cborEncoderResult = cbor_encode_byte_string(&map, dpCbor, dpCborSize);
519         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Adding Device Properties Value.");
520     }
521
522     cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
523     VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborEncoderResult, "Failed Closing Container.");
524
525     size_t s = cbor_encoder_get_buffer_size(&encoder, outPayload);
526     OIC_LOG_V(DEBUG, TAG, "Payload size %" PRIuPTR, s);
527     ret = WriteBufferToFile(cborFileName, outPayload, s);
528 exit:
529     if (OC_STACK_OK != ret)
530     {
531         OIC_LOG_V(ERROR, TAG, "%s: exiting (%d)", __func__, ret);
532     }
533     cJSON_Delete(jsonRoot);
534     OICFree(outPayload);
535     OICFree(aclCbor);
536     OICFree(doxmCbor);
537     OICFree(pstatCbor);
538     OICFree(amaclCbor);
539     OICFree(credCbor);
540     OICFree(dpCbor);
541     CleanUpDeviceProperties(&deviceProps);
542     return ret;
543 }
544
545 OicSecAcl_t *JSONToAclBin(OicSecAclVersion_t *aclVersion, const char *jsonStr)
546 {
547     if (NULL == jsonStr)
548     {
549         return NULL;
550     }
551
552     OCStackResult ret = OC_STACK_ERROR;
553     OicSecAcl_t *headAcl = (OicSecAcl_t *)OICCalloc(1, sizeof(OicSecAcl_t));
554     VERIFY_NOT_NULL_RETURN(TAG, headAcl, ERROR, NULL);
555     cJSON *jsonRoot = NULL;
556
557     VERIFY_NOT_NULL(TAG, jsonStr, ERROR);
558
559     jsonRoot = cJSON_Parse(jsonStr);
560     VERIFY_NOT_NULL(TAG, jsonRoot, ERROR);
561
562     cJSON *jsonAclMap = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME);
563     VERIFY_NOT_NULL(TAG, jsonAclMap, ERROR);
564
565     cJSON *jsonAclObj = NULL;
566
567     jsonAclObj = cJSON_GetObjectItem(jsonAclMap, OIC_JSON_ACLIST_NAME);
568     if (jsonAclObj)
569     {
570         printf("Found 'aclist' tag... resource is oic.r.acl type.\n");
571         *aclVersion = OIC_SEC_ACL_V1;
572     }
573     else
574     {
575         jsonAclObj = cJSON_GetObjectItem(jsonAclMap, OIC_JSON_ACLIST2_NAME);
576         VERIFY_NOT_NULL(TAG, jsonAclObj, ERROR);
577         printf("Found 'aclist2' tag... resource is oic.r.acl2 type.\n");
578         *aclVersion = OIC_SEC_ACL_V2;
579     }
580     VERIFY_NOT_NULL(TAG, jsonAclObj, ERROR);
581
582     cJSON *jsonAclArray = NULL;
583
584     if (OIC_SEC_ACL_V1 == *aclVersion) // aclist-aces
585     {
586         jsonAclArray = cJSON_GetObjectItem(jsonAclObj, OIC_JSON_ACES_NAME);
587         VERIFY_NOT_NULL(TAG, jsonAclArray, ERROR);
588     }
589     else
590     {
591         jsonAclArray = jsonAclObj;
592     }
593
594     if (cJSON_Array == jsonAclArray->type)
595     {
596
597         int numAcl = cJSON_GetArraySize(jsonAclArray);
598         int idx = 0;
599
600         VERIFY_SUCCESS(TAG, numAcl > 0, INFO);
601         do
602         {
603             cJSON *jsonAcl = cJSON_GetArrayItem(jsonAclArray, idx);
604             VERIFY_NOT_NULL(TAG, jsonAcl, ERROR);
605
606             OicSecAce_t *ace = (OicSecAce_t *)OICCalloc(1, sizeof(OicSecAce_t));
607             VERIFY_NOT_NULL(TAG, ace, ERROR);
608             LL_APPEND(headAcl->aces, ace);
609
610             cJSON *jsonObj = NULL;
611
612             if (OIC_SEC_ACL_V2 == *aclVersion)
613             {
614                 jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_ACEID_NAME);
615                 VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
616                 VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
617                 VERIFY_SUCCESS(TAG, jsonObj->valueint <= UINT16_MAX, ERROR);
618                 ace->aceid = (uint16_t)jsonObj->valueint;
619             }
620
621             if (OIC_SEC_ACL_V1 == *aclVersion)
622             {
623                 jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_SUBJECTID_NAME);
624                 VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
625                 VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
626
627                 if (strcmp(jsonObj->valuestring, WILDCARD_RESOURCE_URI) == 0)
628                 {
629                     ace->subjectuuid.id[0] = '*';
630                 }
631                 else
632                 {
633                     ret = ConvertStrToUuid(jsonObj->valuestring, &ace->subjectuuid);
634                     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
635                 }
636                 ace->subjectType = OicSecAceUuidSubject;
637             }
638             else // v2
639             {
640                 jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_SUBJECT_NAME);
641                 VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
642                 VERIFY_SUCCESS(TAG, cJSON_Object == jsonObj->type, ERROR);
643
644                 // Enter the object and get "uuid" string...
645                 cJSON *uuidJson = NULL;
646                 uuidJson = cJSON_GetObjectItem(jsonObj, OIC_JSON_UUID_NAME);
647                 if (uuidJson) // "uuid" type
648                 {
649                     VERIFY_NOT_NULL(TAG, uuidJson, ERROR);
650                     VERIFY_SUCCESS(TAG, cJSON_String == uuidJson->type, ERROR);
651                     ret = ConvertStrToUuid(uuidJson->valuestring, &ace->subjectuuid);
652                     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
653                     ace->subjectType = OicSecAceUuidSubject;
654                 }
655                 else // "conntype"
656                 {
657                     cJSON *conntypeJson = NULL;
658                     conntypeJson = cJSON_GetObjectItem(jsonObj, OIC_JSON_CONNTYPE_NAME);
659                     VERIFY_NOT_NULL(TAG, conntypeJson, ERROR);
660                     VERIFY_SUCCESS(TAG, cJSON_String == conntypeJson->type, ERROR);
661                     char *connTypeStr = NULL;
662                     connTypeStr = OICStrdup(conntypeJson->valuestring);
663                     VERIFY_NOT_NULL(TAG, connTypeStr, ERROR);
664                     if (0 == strcmp(connTypeStr, OIC_JSON_ANONCLEAR_NAME))
665                     {
666                         ace->subjectConn = ANON_CLEAR;
667                         ace->subjectType = OicSecAceConntypeSubject;
668                     }
669                     else if (0 == strcmp(connTypeStr, OIC_JSON_AUTHCRYPT_NAME))
670                     {
671                         ace->subjectConn = AUTH_CRYPT;
672                         ace->subjectType = OicSecAceConntypeSubject;
673                     }
674                     OICFree(connTypeStr);
675                     VERIFY_SUCCESS(TAG, ace->subjectType == OicSecAceConntypeSubject, ERROR);
676                 }
677             }
678             // Resources -- Mandatory
679             jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_RESOURCES_NAME);
680             VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
681             VERIFY_SUCCESS(TAG, cJSON_Array == jsonObj->type, ERROR);
682
683             size_t resourcesLen = cJSON_GetArraySize(jsonObj);
684             VERIFY_SUCCESS(TAG, resourcesLen > 0, ERROR);
685
686             for (size_t idxx = 0; idxx < resourcesLen; idxx++)
687             {
688                 OicSecRsrc_t *rsrc = (OicSecRsrc_t *)OICCalloc(1, sizeof(OicSecRsrc_t));
689                 VERIFY_NOT_NULL(TAG, rsrc, ERROR);
690
691 // Needs to be removed once IOT-1746 is resolved.
692 #ifdef _MSC_VER
693 #pragma warning(suppress : 4267)
694                 cJSON *jsonRsrc = cJSON_GetArrayItem(jsonObj, idxx);
695
696 #else
697                 cJSON *jsonRsrc = cJSON_GetArrayItem(jsonObj, idxx);
698
699 #endif
700                 VERIFY_NOT_NULL(TAG, jsonRsrc, ERROR);
701
702                 //href
703                 cJSON *jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_HREF_NAME);
704                 if (NULL != jsonRsrcObj)
705                 {
706                     VERIFY_SUCCESS(TAG, cJSON_String == jsonRsrcObj->type, ERROR);
707                     rsrc->href = OICStrdup(jsonRsrcObj->valuestring);
708                     VERIFY_NOT_NULL(TAG, (rsrc->href), ERROR);
709                     rsrc->wildcard = NO_WILDCARD; // normally if href != NULL, then no wc
710                     if (0 == strcmp(WILDCARD_RESOURCE_URI, rsrc->href))
711                     {
712                         free(rsrc->href);
713                         rsrc->href = NULL;
714                         rsrc->wildcard = ALL_RESOURCES;
715                         OIC_LOG_V(DEBUG, TAG, "%s: replaced \"*\" href with wildcard = ALL_RESOURCES.",
716                                   __func__);
717                     }
718                 }
719
720                 //rel
721                 jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_REL_NAME);
722                 if (NULL != jsonRsrcObj)
723                 {
724                     rsrc->rel = OICStrdup(jsonRsrcObj->valuestring);
725                     VERIFY_NOT_NULL(TAG, (rsrc->rel), ERROR);
726                 }
727
728                 //rt
729                 jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_RT_NAME);
730                 if ((NULL != jsonRsrcObj) && (cJSON_Array == jsonRsrcObj->type))
731                 {
732                     rsrc->typeLen = cJSON_GetArraySize(jsonRsrcObj);
733                     VERIFY_SUCCESS(TAG, (0 < rsrc->typeLen), ERROR);
734                     rsrc->types = (char **)OICCalloc(rsrc->typeLen, sizeof(char *));
735                     VERIFY_NOT_NULL(TAG, (rsrc->types), ERROR);
736                     for (size_t i = 0; i < rsrc->typeLen; i++)
737                     {
738 // Needs to be removed once IOT-1746 is resolved.
739 #ifdef _MSC_VER
740 #pragma warning(suppress : 4267)
741                         cJSON *jsonRsrcType = cJSON_GetArrayItem(jsonRsrcObj, i);
742
743 #else
744                         cJSON *jsonRsrcType = cJSON_GetArrayItem(jsonRsrcObj, i);
745
746 #endif
747                         VERIFY_NOT_NULL(TAG, jsonRsrcType, ERROR);
748                         rsrc->types[i] = OICStrdup(jsonRsrcType->valuestring);
749                         VERIFY_NOT_NULL(TAG, (rsrc->types[i]), ERROR);
750                     }
751                 }
752
753                 //if
754                 jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_IF_NAME);
755                 if ((NULL != jsonRsrcObj) && (cJSON_Array == jsonRsrcObj->type))
756                 {
757                     rsrc->interfaceLen = cJSON_GetArraySize(jsonRsrcObj);
758                     VERIFY_SUCCESS(TAG, (0 < rsrc->interfaceLen), ERROR);
759                     rsrc->interfaces = (char **)OICCalloc(rsrc->interfaceLen, sizeof(char *));
760                     VERIFY_NOT_NULL(TAG, (rsrc->interfaces), ERROR);
761                     for (size_t i = 0; i < rsrc->interfaceLen; i++)
762                     {
763 // Needs to be removed once IOT-1746 is resolved.
764 #ifdef _MSC_VER
765 #pragma warning(suppress : 4267)
766                         cJSON *jsonInterface = cJSON_GetArrayItem(jsonRsrcObj, i);
767
768 #else
769                         cJSON *jsonInterface = cJSON_GetArrayItem(jsonRsrcObj, i);
770
771 #endif
772                         VERIFY_NOT_NULL(TAG, jsonInterface, ERROR);
773                         rsrc->interfaces[i] = OICStrdup(jsonInterface->valuestring);
774                         VERIFY_NOT_NULL(TAG, (rsrc->interfaces[i]), ERROR);
775                     }
776                 }
777
778                 //wc
779                 jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_WC_NAME);
780                 if (NULL != jsonRsrcObj)
781                 {
782                     char *wc = NULL;
783                     VERIFY_SUCCESS(TAG, cJSON_String == jsonRsrcObj->type, ERROR);
784                     wc = OICStrdup(jsonRsrcObj->valuestring);
785                     VERIFY_NOT_NULL(TAG, wc, ERROR);
786                     if (0 == strcmp(OIC_JSON_WC_ASTERISK_NAME, wc))
787                     {
788                         rsrc->wildcard = ALL_RESOURCES;
789                     }
790                     else if (0 == strcmp(OIC_JSON_WC_PLUS_NAME, wc))
791                     {
792                         rsrc->wildcard = ALL_DISCOVERABLE;
793                     }
794                     else if (0 == strcmp(OIC_JSON_WC_MINUS_NAME, wc))
795                     {
796                         rsrc->wildcard = ALL_NON_DISCOVERABLE;
797                     }
798                     else
799                     {
800                         rsrc->wildcard = NO_WILDCARD;
801                     }
802                     OICFree(wc);
803                 }
804                 LL_APPEND(ace->resources, rsrc);
805             }
806
807             // Permissions -- Mandatory
808             jsonObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_PERMISSION_NAME);
809             VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
810             VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
811             VERIFY_SUCCESS(TAG, jsonObj->valueint <= UINT16_MAX, ERROR);
812             ace->permission = (uint16_t)jsonObj->valueint;
813
814             //Validity -- Not Mandatory
815             cJSON *jsonValidityObj = cJSON_GetObjectItem(jsonAcl, OIC_JSON_VALIDITY_NAME);
816             if (jsonValidityObj)
817             {
818                 VERIFY_SUCCESS(TAG, cJSON_Array == jsonValidityObj->type, ERROR);
819                 size_t validityLen = cJSON_GetArraySize(jsonValidityObj);
820                 VERIFY_SUCCESS(TAG, (0 < validityLen), ERROR);
821
822                 cJSON *jsonValidity = NULL;
823                 for (size_t i = 0; i < validityLen; i++)
824                 {
825 // Needs to be removed once IOT-1746 is resolved.
826 #ifdef _MSC_VER
827 #pragma warning(suppress : 4267)
828                     jsonValidity = cJSON_GetArrayItem(jsonValidityObj, i);
829
830 #else
831                     jsonValidity = cJSON_GetArrayItem(jsonValidityObj, i);
832
833 #endif
834                     VERIFY_NOT_NULL(TAG, jsonValidity, ERROR);
835                     VERIFY_SUCCESS(TAG, (jsonValidity->type == cJSON_Array), ERROR);
836
837                     OicSecValidity_t *validity = (OicSecValidity_t *)OICCalloc(1, sizeof(OicSecValidity_t));
838                     VERIFY_NOT_NULL(TAG, validity, ERROR);
839                     LL_APPEND(ace->validities, validity);
840
841                     //Period
842                     cJSON *jsonPeriod = cJSON_GetArrayItem(jsonValidity, 0);
843                     if (jsonPeriod)
844                     {
845                         VERIFY_SUCCESS(TAG, (cJSON_String == jsonPeriod->type), ERROR);
846
847                         validity->period = OICStrdup(jsonPeriod->valuestring);
848                         VERIFY_NOT_NULL(TAG, validity->period, ERROR);
849                     }
850
851                     //Recurrence
852                     cJSON *jsonRecurObj = cJSON_GetArrayItem(jsonValidity, 1);
853                     if (jsonRecurObj)
854                     {
855                         VERIFY_SUCCESS(TAG, (cJSON_Array == jsonRecurObj->type), ERROR);
856                         validity->recurrenceLen = cJSON_GetArraySize(jsonRecurObj);
857                         VERIFY_SUCCESS(TAG, (0 < validity->recurrenceLen), ERROR);
858
859                         validity->recurrences = (char **)OICCalloc(validity->recurrenceLen, sizeof(char *));
860                         VERIFY_NOT_NULL(TAG, validity->recurrences, ERROR);
861
862                         cJSON *jsonRecur = NULL;
863                         for (size_t j = 0; j < validity->recurrenceLen; j++)
864                         {
865 // Needs to be removed once IOT-1746 is resolved.
866 #ifdef _MSC_VER
867 #pragma warning(suppress : 4267)
868                             jsonRecur = cJSON_GetArrayItem(jsonRecurObj, j);
869
870 #else
871                             jsonRecur = cJSON_GetArrayItem(jsonRecurObj, j);
872
873 #endif
874                             VERIFY_NOT_NULL(TAG, jsonRecur, ERROR);
875                             validity->recurrences[j] = OICStrdup(jsonRecur->valuestring);
876                             VERIFY_NOT_NULL(TAG, validity->recurrences[j], ERROR);
877                         }
878                     }
879                 }
880             }
881         }
882         while ( ++idx < numAcl);
883     }
884
885
886     // rownerid
887     jsonAclObj = cJSON_GetObjectItem(jsonAclMap, OIC_JSON_ROWNERID_NAME);
888     VERIFY_NOT_NULL(TAG, jsonAclObj, ERROR);
889     VERIFY_SUCCESS(TAG, cJSON_String == jsonAclObj->type, ERROR);
890     ret = ConvertStrToUuid(jsonAclObj->valuestring, &headAcl->rownerID);
891     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
892
893     ret = OC_STACK_OK;
894
895 exit:
896     cJSON_Delete(jsonRoot);
897     if (OC_STACK_OK != ret)
898     {
899         OIC_LOG_V(ERROR, TAG, "%s: exiting (%d)", __func__, ret);
900         DeleteACLList(headAcl);
901         headAcl = NULL;
902     }
903     printf("OUT %s: %s\n", __func__, (headAcl != NULL) ? "success" : "failure");
904     return headAcl;
905 }
906
907 OicSecDoxm_t *JSONToDoxmBin(const char *jsonStr)
908 {
909     printf("IN JSONToDoxmBin\n");
910     if (NULL == jsonStr)
911     {
912         return NULL;
913     }
914
915     OCStackResult ret = OC_STACK_ERROR;
916     OicSecDoxm_t *doxm =  NULL;
917     cJSON *jsonDoxm = NULL;
918     cJSON *jsonObj = NULL;
919
920     cJSON *jsonRoot = cJSON_Parse(jsonStr);
921     VERIFY_NOT_NULL(TAG, jsonRoot, ERROR);
922
923     jsonDoxm = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME);
924     VERIFY_NOT_NULL(TAG, jsonDoxm, ERROR);
925
926     doxm = (OicSecDoxm_t *)OICCalloc(1, sizeof(OicSecDoxm_t));
927     VERIFY_NOT_NULL(TAG, doxm, ERROR);
928
929     //Oxm -- not Mandatory
930     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXMS_NAME);
931     if (jsonObj && cJSON_Array == jsonObj->type)
932     {
933         doxm->oxmLen = cJSON_GetArraySize(jsonObj);
934         VERIFY_SUCCESS(TAG, doxm->oxmLen > 0, ERROR);
935
936         doxm->oxm = (OicSecOxm_t *)OICCalloc(doxm->oxmLen, sizeof(OicSecOxm_t));
937         VERIFY_NOT_NULL(TAG, doxm->oxm, ERROR);
938
939         for (size_t i  = 0; i < doxm->oxmLen ; i++)
940         {
941 // Needs to be removed once IOT-1746 is resolved.
942 #ifdef _MSC_VER
943 #pragma warning(suppress : 4267)
944             cJSON *jsonOxm = cJSON_GetArrayItem(jsonObj, i);
945
946 #else
947             cJSON *jsonOxm = cJSON_GetArrayItem(jsonObj, i);
948
949 #endif
950             VERIFY_NOT_NULL(TAG, jsonOxm, ERROR);
951             doxm->oxm[i] = (OicSecOxm_t)jsonOxm->valueint;
952         }
953     }
954
955     //OxmSel -- Mandatory
956 // Needs to be removed once IOT-1746 is resolved.
957 #ifdef _MSC_VER
958 #pragma warning(suppress : 4267)
959     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXM_SEL_NAME);
960
961 #else
962     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OXM_SEL_NAME);
963
964 #endif
965     if (jsonObj)
966     {
967         VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
968         doxm->oxmSel = (OicSecOxm_t)jsonObj->valueint;
969     }
970
971     //sct -- Mandatory
972     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_SUPPORTED_CRED_TYPE_NAME);
973     if (jsonObj)
974     {
975         VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
976         doxm->sct = (OicSecCredType_t)jsonObj->valueint;
977     }
978
979     //Owned -- Mandatory
980     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_OWNED_NAME);
981     if (jsonObj)
982     {
983         VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type), ERROR);
984         doxm->owned = jsonObj->valueint;
985     }
986
987 #ifdef MULTIPLE_OWNER
988     //mom -- Not Mandatory
989     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_MOM_NAME);
990     if (jsonObj)
991     {
992         VERIFY_SUCCESS(TAG, (cJSON_Number == jsonObj->type), ERROR);
993         doxm->mom = (OicSecMom_t *)OICCalloc(1, sizeof(OicSecMom_t));
994         VERIFY_NOT_NULL(TAG, doxm->mom, ERROR);
995         doxm->mom->mode = (OicSecMomType_t)jsonObj->valueint;
996     }
997 #endif //MULTIPLE_OWNER
998
999     //DeviceId -- Mandatory
1000     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVICE_ID_NAME);
1001     if (jsonObj)
1002     {
1003         VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
1004         if (cJSON_String == jsonObj->type)
1005         {
1006             //Check for empty string, in case DeviceId field has not been set yet
1007             if (jsonObj->valuestring[0])
1008             {
1009                 ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->deviceID);
1010                 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
1011             }
1012         }
1013     }
1014
1015     //rowner -- Mandatory
1016     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_ROWNERID_NAME);
1017     if (true == doxm->owned)
1018     {
1019         VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1020     }
1021     if (jsonObj)
1022     {
1023         ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->rownerID);
1024         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
1025     }
1026
1027     //Owner -- will be empty when device status is unowned.
1028     jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVOWNERID_NAME);
1029     if (true == doxm->owned)
1030     {
1031         VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1032     }
1033     if (jsonObj)
1034     {
1035         ret = ConvertStrToUuid(jsonObj->valuestring, &doxm->owner);
1036         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
1037     }
1038
1039     ret = OC_STACK_OK;
1040
1041 exit:
1042     cJSON_Delete(jsonRoot);
1043     if (OC_STACK_OK != ret)
1044     {
1045         DeleteDoxmBinData(doxm);
1046         doxm = NULL;
1047     }
1048     printf("OUT %s: %s\n", __func__, (doxm != NULL) ? "success" : "failure");
1049     return doxm;
1050 }
1051
1052 OicSecPstat_t *JSONToPstatBin(const char *jsonStr)
1053 {
1054     OCStackResult ret = OC_STACK_ERROR;
1055     OicSecPstat_t *pstat = NULL;
1056     cJSON *jsonObj = NULL;
1057     cJSON *jsonPstat = NULL;
1058     cJSON *jsonDos = NULL;
1059     cJSON *jsonDosObj = NULL;
1060     cJSON *jsonRoot = NULL;
1061
1062     VERIFY_NOT_NULL(TAG, jsonStr, INFO);
1063     jsonRoot = cJSON_Parse(jsonStr);
1064     VERIFY_NOT_NULL(TAG, jsonRoot, INFO);
1065     OIC_LOG(INFO, TAG, "Using pstat with mandatory .dos object.");
1066     jsonPstat = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME);
1067     VERIFY_NOT_NULL(TAG, jsonPstat, INFO);
1068     pstat = (OicSecPstat_t *)OICCalloc(1, sizeof(OicSecPstat_t));
1069     VERIFY_NOT_NULL(TAG, pstat, INFO);
1070
1071     jsonDos = cJSON_GetObjectItem(jsonPstat, OIC_JSON_DOS_NAME);
1072     if (jsonDos) // do not abort if no .dos found, but print warning
1073     {
1074         OIC_LOG(INFO, TAG, "pstat.dos object found in jsonPstat");
1075
1076         jsonDosObj = cJSON_GetObjectItem(jsonDos, OIC_JSON_S_NAME);
1077         VERIFY_NOT_NULL(TAG, jsonDosObj, ERROR);
1078         OIC_LOG(INFO, TAG, "pstat.dos.s object found in jsonDos");
1079         pstat->dos.state = jsonDosObj->valueint;
1080         OIC_LOG_V(INFO, TAG, "pstat.dos.s = %d", pstat->dos.state);
1081
1082         jsonDosObj = cJSON_GetObjectItem(jsonDos, OIC_JSON_P_NAME);
1083         VERIFY_NOT_NULL(TAG, jsonDosObj, ERROR);
1084         OIC_LOG(INFO, TAG, "pstat.dos.p object found in jsonDos");
1085         VERIFY_SUCCESS(TAG, (cJSON_True == jsonDosObj->type || cJSON_False == jsonDosObj->type) , ERROR);
1086         pstat->dos.pending = (bool)jsonDosObj->valueint;
1087         OIC_LOG_V(INFO, TAG, "pstat.dos.p = %s", pstat->dos.pending ? "true" : "false");
1088     }
1089     else
1090     {
1091         pstat->dos.state = DOS_RFOTM;
1092         pstat->dos.pending = false;
1093         printf("\n***** Pstat.dos Property not found in JSON file. *****\
1094             \n***** Pstat.dos Property is MANDATORY as of OCF 1.0 *****\
1095             \n***** Using default .dos vals: s = %d, p = %s *****\n\n", pstat->dos.state, \
1096                pstat->dos.pending ? "true" : "false");
1097     }
1098
1099     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_ISOP_NAME);
1100     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1101     VERIFY_SUCCESS(TAG, (cJSON_True == jsonObj->type || cJSON_False == jsonObj->type) , ERROR);
1102     pstat->isOp = jsonObj->valueint;
1103
1104     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_ROWNERID_NAME);
1105     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1106     VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
1107     ret = ConvertStrToUuid(jsonObj->valuestring, &pstat->rownerID);
1108     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
1109
1110     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_CM_NAME);
1111     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1112     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
1113     pstat->cm  = (OicSecDpm_t)jsonObj->valueint;
1114
1115     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_TM_NAME);
1116     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1117     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
1118     pstat->tm  = (OicSecDpm_t)jsonObj->valueint;
1119
1120     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_OM_NAME);
1121     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1122     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
1123     pstat->om  = (OicSecDpom_t)jsonObj->valueint;
1124
1125     jsonObj = cJSON_GetObjectItem(jsonPstat, OIC_JSON_SM_NAME);
1126     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1127     VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
1128     pstat->smLen = 1;
1129     pstat->sm = (OicSecDpom_t *)OICCalloc(pstat->smLen, sizeof(OicSecDpom_t));
1130     VERIFY_NOT_NULL(TAG, pstat->sm, ERROR);
1131     pstat->sm[0] = (OicSecDpom_t)jsonObj->valueint;
1132
1133     ret = OC_STACK_OK;
1134
1135 exit:
1136     cJSON_Delete(jsonRoot);
1137     if (OC_STACK_OK != ret)
1138     {
1139         DeletePstatBinData(pstat);
1140         pstat = NULL;
1141     }
1142     printf("OUT %s: %s\n", __func__, (pstat != NULL) ? "success" : "failure");
1143     return pstat;
1144 }
1145
1146 static OicEncodingType_t GetEncodingTypeFromStr(const char *encodingType)
1147 {
1148     if (strcmp(OIC_SEC_ENCODING_RAW, encodingType) == 0)
1149     {
1150         return OIC_ENCODING_RAW;
1151     }
1152     if (strcmp(OIC_SEC_ENCODING_BASE64, encodingType) == 0)
1153     {
1154         return OIC_ENCODING_BASE64;
1155     }
1156     if (strcmp(OIC_SEC_ENCODING_PEM, encodingType) == 0)
1157     {
1158         return OIC_ENCODING_PEM;
1159     }
1160     if (strcmp(OIC_SEC_ENCODING_DER, encodingType) == 0)
1161     {
1162         return OIC_ENCODING_DER;
1163     }
1164     OIC_LOG(WARNING, TAG, "Unknown encoding type dectected!");
1165     OIC_LOG(WARNING, TAG, "json2cbor will use \"oic.sec.encoding.raw\" as default encoding type.");
1166     return OIC_ENCODING_RAW;
1167 }
1168
1169 static OicSecCred_t *JSONToCredBinWithRowner(const char *jsonStr,OicUuid_t *rownerId)
1170 {
1171     if (NULL == jsonStr)
1172     {
1173         OIC_LOG(ERROR, TAG, "JSONToCredBin jsonStr in NULL");
1174         return NULL;
1175     }
1176
1177     OicSecCred_t *headCred = (OicSecCred_t *)OICCalloc(1, sizeof(OicSecCred_t));
1178     OCStackResult ret = OC_STACK_ERROR;
1179     cJSON *jsonRoot = NULL;
1180     VERIFY_NOT_NULL(TAG, headCred, ERROR);
1181
1182     jsonRoot = cJSON_Parse(jsonStr);
1183     VERIFY_NOT_NULL(TAG, jsonRoot, ERROR);
1184
1185     cJSON *jsonCredMap = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
1186     VERIFY_NOT_NULL(TAG, jsonCredMap, ERROR);
1187
1188     // creds
1189     cJSON *jsonCredArray = NULL;
1190     jsonCredArray = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_CREDS_NAME);
1191     VERIFY_NOT_NULL(TAG, jsonCredArray, ERROR);
1192
1193     if (cJSON_Array == jsonCredArray->type)
1194     {
1195         int numCred = cJSON_GetArraySize(jsonCredArray);
1196         VERIFY_SUCCESS(TAG, numCred > 0, ERROR);
1197         int idx = 0;
1198         do
1199         {
1200             cJSON *jsonCred = cJSON_GetArrayItem(jsonCredArray, idx);
1201             VERIFY_NOT_NULL(TAG, jsonCred, ERROR);
1202
1203             OicSecCred_t *cred = NULL;
1204             if (idx == 0)
1205             {
1206                 cred = headCred;
1207             }
1208             else
1209             {
1210                 cred = (OicSecCred_t *)OICCalloc(1, sizeof(OicSecCred_t));
1211                 OicSecCred_t *temp = headCred;
1212                 while (temp->next)
1213                 {
1214                     temp = temp->next;
1215                 }
1216                 temp->next = cred;
1217             }
1218             VERIFY_NOT_NULL(TAG, cred, ERROR);
1219
1220             size_t jsonObjLen = 0;
1221             cJSON *jsonObj = NULL;
1222
1223             //CredId -- Mandatory
1224             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDID_NAME);
1225             if (jsonObj)
1226             {
1227                 VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
1228                 VERIFY_SUCCESS(TAG, jsonObj->valueint <= UINT16_MAX, ERROR);
1229                 cred->credId = (uint16_t)jsonObj->valueint;
1230             }
1231
1232             //subject -- Mandatory
1233             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_SUBJECTID_NAME);
1234             VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1235             VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
1236             if (strcmp(jsonObj->valuestring, WILDCARD_RESOURCE_URI) == 0)
1237             {
1238                 cred->subject.id[0] = '*';
1239             }
1240             else
1241             {
1242                 ret = ConvertStrToUuid(jsonObj->valuestring, &cred->subject);
1243                 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
1244             }
1245
1246             //CredType -- Mandatory
1247             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDTYPE_NAME);
1248             VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1249             VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
1250             cred->credType = (OicSecCredType_t)jsonObj->valueint;
1251             //PrivateData is mandatory for some of the credential types listed below.
1252             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PRIVATEDATA_NAME);
1253
1254             if (NULL != jsonObj)
1255             {
1256                 cJSON *jsonPriv = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
1257                 VERIFY_NOT_NULL(TAG, jsonPriv, ERROR);
1258                 jsonObjLen = strlen(jsonPriv->valuestring);
1259
1260                 ret = (jsonObjLen % 2 == 0) ? ret : OC_STACK_ERROR;
1261
1262                 char tmp[3];
1263                 char *buf = (char *)OICCalloc(1, jsonObjLen/2);
1264                 for(size_t i = 0, p = 0 ; i < jsonObjLen; i+=2, ++p)
1265                 {
1266                     sprintf(tmp, "%c%c", jsonPriv->valuestring[i], jsonPriv->valuestring[i+1]);
1267                     buf[p] = (char)strtol(tmp, NULL, 16);
1268                 }
1269                 cred->privateData.len = jsonObjLen/2;
1270                 cred->privateData.data = (uint8_t *)OICCalloc(1, cred->privateData.len);
1271                 VERIFY_NOT_NULL(TAG, (cred->privateData.data), ERROR);
1272                 memcpy(cred->privateData.data, buf, cred->privateData.len);
1273
1274                 cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME);
1275                 VERIFY_NOT_NULL(TAG, jsonEncoding, ERROR);
1276                 cred->privateData.encoding = GetEncodingTypeFromStr(jsonEncoding->valuestring);
1277             }
1278 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
1279             //PublicData is mandatory only for SIGNED_ASYMMETRIC_KEY credentials type.
1280             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PUBLICDATA_NAME);
1281             if (NULL != jsonObj)
1282             {
1283                 cJSON *jsonPub = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
1284                 VERIFY_NOT_NULL(TAG, jsonPub, ERROR);
1285                 jsonObjLen = strlen(jsonPub->valuestring);
1286
1287                 ret = (jsonObjLen % 2 == 0) ? ret : OC_STACK_ERROR;
1288
1289                 char tmp[3];
1290                 char *buf = (char *)OICCalloc(1, jsonObjLen/2);
1291                 for(size_t i = 0, p = 0 ; i < jsonObjLen; i+=2, ++p)
1292                 {
1293                     sprintf(tmp, "%c%c", jsonPub->valuestring[i], jsonPub->valuestring[i+1]);
1294                     buf[p] = (char)strtol(tmp, NULL, 16);
1295                 }
1296                 cred->publicData.len = jsonObjLen/2;
1297                 cred->publicData.data = (uint8_t *)OICCalloc(1, cred->publicData.len);
1298                 VERIFY_NOT_NULL(TAG, (cred->publicData.data), ERROR);
1299                 memcpy(cred->publicData.data, buf, cred->publicData.len);
1300
1301                 cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME);
1302
1303                 VERIFY_NOT_NULL(TAG, jsonEncoding, ERROR);
1304                 cred->publicData.encoding = GetEncodingTypeFromStr(jsonEncoding->valuestring);
1305             }
1306
1307             //Optional Data
1308             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_OPTDATA_NAME);
1309             if (NULL != jsonObj)
1310             {
1311                 cJSON *jsonOpt = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
1312                 VERIFY_NOT_NULL(TAG, jsonOpt, ERROR);
1313                 jsonObjLen = strlen(jsonOpt->valuestring);
1314
1315                 ret = (jsonObjLen % 2 == 0) ? ret : OC_STACK_ERROR;
1316                 char tmp[3];
1317                 char *buf = (char *)OICCalloc(1, jsonObjLen/2);
1318                 for(size_t i = 0, p = 0; i < jsonObjLen; i+=2, ++p)
1319                 {
1320                     sprintf(tmp, "%c%c", jsonOpt->valuestring[i], jsonOpt->valuestring[i+1]);
1321                     buf[p] = (char)strtol(tmp, NULL, 16);
1322                 }
1323                 cred->optionalData.len = jsonObjLen/2;
1324
1325                 cred->optionalData.data =  (uint8_t *)OICCalloc(1, cred->optionalData.len);
1326                 VERIFY_NOT_NULL(TAG, (cred->optionalData.data), ERROR);
1327                 memcpy(cred->optionalData.data, buf, cred->optionalData.len);
1328
1329                 cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME);
1330                 VERIFY_NOT_NULL(TAG, jsonEncoding, ERROR);
1331                 cred->optionalData.encoding = GetEncodingTypeFromStr(jsonEncoding->valuestring);
1332                 cJSON *jsonRevstat = cJSON_GetObjectItem(jsonObj, OIC_JSON_REVOCATION_STATUS_NAME);
1333                 VERIFY_NOT_NULL(TAG, jsonRevstat, ERROR);
1334                 cred->optionalData.revstat = jsonObj->valueint;
1335             }
1336
1337             //CredUsage
1338             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDUSAGE_NAME);
1339             if (NULL != jsonObj)
1340             {
1341                 jsonObjLen = strlen(jsonObj->valuestring);
1342                 cred->credUsage = OICStrdup(jsonObj->valuestring);
1343                 VERIFY_NOT_NULL(TAG, (cred->credUsage), ERROR);
1344             }
1345
1346 #endif // defined(__WITH_DTLS__) || defined(__WITH_TLS__)
1347
1348             //Period -- Not Mandatory
1349             jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PERIOD_NAME);
1350             if (jsonObj && cJSON_String == jsonObj->type)
1351             {
1352                 cred->period = OICStrdup(jsonObj->valuestring);
1353                 VERIFY_NOT_NULL(TAG, cred->period, ERROR);
1354             }
1355             cred->next = NULL;
1356         }
1357         while ( ++idx < numCred);
1358     }
1359
1360     // rownerid
1361     cJSON *jsonCredObj = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_ROWNERID_NAME);
1362     VERIFY_NOT_NULL(TAG, jsonCredObj, ERROR);
1363     VERIFY_SUCCESS(TAG, cJSON_String == jsonCredObj->type, ERROR);
1364     ret = ConvertStrToUuid(jsonCredObj->valuestring, rownerId);
1365     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
1366     ret = OC_STACK_OK;
1367
1368 exit:
1369     cJSON_Delete(jsonRoot);
1370     if (OC_STACK_OK != ret)
1371     {
1372         DeleteCredList(headCred);
1373         headCred = NULL;
1374     }
1375     return headCred;
1376 }
1377
1378 static OicSecAmacl_t *JSONToAmaclBin(const char *jsonStr)
1379 {
1380     OCStackResult ret = OC_STACK_ERROR;
1381     OicSecAmacl_t *headAmacl = (OicSecAmacl_t *)OICCalloc(1, sizeof(OicSecAmacl_t));
1382     VERIFY_NOT_NULL_RETURN(TAG, headAmacl, ERROR, NULL);
1383     cJSON *jsonRoot = NULL;
1384     cJSON *jsonAmacl = NULL;
1385
1386     VERIFY_NOT_NULL(TAG, jsonStr, ERROR);
1387
1388     jsonRoot = cJSON_Parse(jsonStr);
1389     VERIFY_NOT_NULL(TAG, jsonRoot, ERROR);
1390
1391     jsonAmacl = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME);
1392     VERIFY_NOT_NULL(TAG, jsonAmacl, INFO);
1393
1394     cJSON *jsonObj = NULL;
1395
1396     // Resources -- Mandatory
1397     jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_RESOURCES_NAME);
1398     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1399
1400     // Rlist
1401     cJSON *jsonRlistArray = cJSON_GetObjectItem(jsonObj, OIC_JSON_RLIST_NAME);
1402     VERIFY_NOT_NULL(TAG, jsonRlistArray, ERROR);
1403     VERIFY_SUCCESS(TAG, cJSON_Array == jsonRlistArray->type, ERROR);
1404
1405     headAmacl->resourcesLen = cJSON_GetArraySize(jsonRlistArray);
1406     headAmacl->resources = (char **)OICCalloc(headAmacl->resourcesLen, sizeof(char *));
1407     VERIFY_NOT_NULL(TAG, headAmacl->resources, ERROR);
1408     size_t idxx = 0;
1409     do
1410     {
1411 // Needs to be removed once IOT-1746 is resolved.
1412 #ifdef _MSC_VER
1413 #pragma warning(suppress : 4267)
1414         cJSON *jsonRsrc = cJSON_GetArrayItem(jsonRlistArray, idxx);
1415
1416 #else
1417         cJSON *jsonRsrc = cJSON_GetArrayItem(jsonRlistArray, idxx);
1418
1419 #endif
1420         VERIFY_NOT_NULL(TAG, jsonRsrc, ERROR);
1421
1422         cJSON *jsonRsrcObj = cJSON_GetObjectItem(jsonRsrc, OIC_JSON_HREF_NAME);
1423         VERIFY_NOT_NULL(TAG, jsonRsrcObj, ERROR);
1424         VERIFY_SUCCESS(TAG, cJSON_String == jsonRsrcObj->type, ERROR);
1425
1426         headAmacl->resources[idxx] = OICStrdup(jsonRsrcObj->valuestring);
1427         VERIFY_NOT_NULL(TAG, (headAmacl->resources[idxx]), ERROR);
1428
1429     }
1430     while ( ++idxx < headAmacl->resourcesLen);
1431
1432     // Rowner -- Mandatory
1433     jsonObj = cJSON_GetObjectItem(jsonAmacl, OIC_JSON_ROWNERID_NAME);
1434     VERIFY_NOT_NULL(TAG, jsonObj, ERROR);
1435     VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
1436
1437     ret = OC_STACK_OK;
1438
1439 exit:
1440     cJSON_Delete(jsonRoot);
1441     if (OC_STACK_OK != ret)
1442     {
1443         DeleteAmaclList(headAmacl);
1444         headAmacl = NULL;
1445     }
1446     return headAmacl;
1447 }
1448
1449 OCDeviceProperties *JSONToDPBin(const char *jsonStr)
1450 {
1451     OIC_LOG(DEBUG, TAG, "JSONToDPBin IN");
1452     if (NULL == jsonStr)
1453     {
1454         return NULL;
1455     }
1456
1457     OCStackResult ret = OC_STACK_ERROR;
1458     OCDeviceProperties *deviceProps = NULL;
1459     cJSON *jsonDeviceProps = NULL;
1460     cJSON *jsonObj = NULL;
1461
1462     cJSON *jsonRoot = cJSON_Parse(jsonStr);
1463     VERIFY_NOT_NULL(TAG, jsonRoot, ERROR);
1464
1465     jsonDeviceProps = cJSON_GetObjectItem(jsonRoot, OC_JSON_DEVICE_PROPS_NAME);
1466     VERIFY_NOT_NULL(TAG, jsonDeviceProps, ERROR);
1467
1468     deviceProps = (OCDeviceProperties *)OICCalloc(1, sizeof(OCDeviceProperties));
1469     VERIFY_NOT_NULL(TAG, deviceProps, ERROR);
1470
1471     // Protocol Independent ID -- Mandatory
1472     jsonObj = cJSON_GetObjectItem(jsonDeviceProps, OC_RSRVD_PROTOCOL_INDEPENDENT_ID);
1473     if (jsonObj && (cJSON_String == jsonObj->type))
1474     {
1475         OICStrcpy(deviceProps->protocolIndependentId, UUID_STRING_SIZE, jsonObj->valuestring);
1476     }
1477
1478     ret = OC_STACK_OK;
1479
1480 exit:
1481     cJSON_Delete(jsonRoot);
1482     if (OC_STACK_OK != ret)
1483     {
1484         CleanUpDeviceProperties(&deviceProps);
1485     }
1486     OIC_LOG_V(DEBUG, TAG, "OUT %s: %s\n", __func__, (deviceProps != NULL) ? "success" : "failure");
1487
1488     return deviceProps;
1489 }
1490
1491 /** @return OC_STACK_OK on success **/
1492 static OCStackResult ConvertJSONFileToCBORFile(const char *jsonFileName, const char *cborFileName)
1493 {
1494     OCStackResult ret = OC_STACK_ERROR;
1495     char *jsonStr = NULL;
1496     size_t size = 0;
1497     ret = ReadBufferFromFile(jsonFileName, (uint8_t **)&jsonStr, &size);
1498     if ((size == 0) || !jsonStr || (OC_STACK_OK != ret))
1499     {
1500         OIC_LOG(ERROR, TAG, "Failed to read from file");
1501         goto exit;
1502     }
1503     cJSON *jsonRoot = NULL;
1504     jsonRoot = cJSON_Parse(jsonStr);
1505     if (!jsonRoot)
1506     {
1507         OIC_LOG(ERROR, TAG, "Failed to parse file");
1508         goto exit;
1509     }
1510     //TODO: It's assumed that no such field is used in non swagger files
1511     cJSON *value = cJSON_GetObjectItem(jsonRoot, "swagger");
1512     OICFree(jsonRoot);
1513     if (value)
1514     {
1515         OICFree(value);
1516         ret = ConvertJSONStringToCBORFile(jsonStr, cborFileName);
1517     }
1518     else
1519     {
1520         ret = ConvertOCJSONStringToCBORFile(jsonStr, cborFileName);
1521     }
1522 exit:
1523     if (OC_STACK_OK != ret)
1524     {
1525         OIC_LOG_V(ERROR, TAG, "%s: exiting (%d)", __func__, ret);
1526     }
1527     OICFree(jsonStr);
1528     return ret;
1529 }
1530
1531 /** @return 0 on success **/
1532 int main(int argc, char *argv[])
1533 {
1534     OCStackResult status = OC_STACK_ERROR;
1535     if (argc == 3)
1536     {
1537         printf("JSON File Name: %s\n CBOR File Name: %s \n", argv[1], argv[2]);
1538         status = ConvertJSONFileToCBORFile(argv[1], argv[2]);
1539     }
1540     else
1541     {
1542         printf("This program requires two inputs:\n");
1543         printf("1. First input is a json file that will be converted to cbor. \n");
1544         printf("2. Second input is a resulting cbor file that will store converted cbor. \n");
1545         printf("Usage: json2cbor <json_file_name> <cbor_file_name>\n");
1546     }
1547     return (OC_STACK_OK != status);
1548 }