Merge "Merge branch 'master' into easysetup" into easysetup
[platform/upstream/iotivity.git] / resource / csdk / stack / src / ocpayloadparse.c
1 //******************************************************************
2 //
3 // Copyright 2015 Intel Mobile Communications GmbH 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 // Defining _POSIX_C_SOURCE macro with 200112L (or greater) as value
22 // causes header files to expose definitions
23 // corresponding to the POSIX.1-2001 base
24 // specification (excluding the XSI extension).
25 // For POSIX.1-2001 base specification,
26 // Refer http://pubs.opengroup.org/onlinepubs/009695399/
27 // Required for strok_r
28 #define _POSIX_C_SOURCE 200112L
29 #include <string.h>
30 #include "ocpayloadcbor.h"
31 #include <stdlib.h>
32 #include "logger.h"
33 #include "oic_string.h"
34 #include "oic_malloc.h"
35 #include "ocstackinternal.h"
36 #include "ocpayload.h"
37 #include "cbor.h"
38 #include "oic_string.h"
39 #include "payload_logging.h"
40 #include "rdpayload.h"
41
42 #define TAG "OIC_RI_PAYLOADPARSE"
43
44 static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal);
45 static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* arrayVal);
46 static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* arrayVal);
47 static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repParent);
48 static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* arrayVal);
49 static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal);
50 static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* arrayVal);
51
52 OCStackResult OCParsePayload(OCPayload** outPayload, OCPayloadType payloadType,
53         const uint8_t* payload, size_t payloadSize)
54 {
55     CborParser parser;
56     CborValue rootValue;
57     bool err = false;
58
59     OIC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu", payloadSize);
60     if((err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue)) != false)
61     {
62         OIC_LOG_V(ERROR, TAG, "CBOR Parser init failed: %d", err);
63         return OC_STACK_ERROR;
64     }
65
66     OCStackResult result = OC_STACK_ERROR;
67     switch(payloadType)
68     {
69         case PAYLOAD_TYPE_DISCOVERY:
70             result = OCParseDiscoveryPayload(outPayload, &rootValue);
71             break;
72         case PAYLOAD_TYPE_DEVICE:
73             result = OCParseDevicePayload(outPayload, &rootValue);
74             break;
75         case PAYLOAD_TYPE_PLATFORM:
76             result = OCParsePlatformPayload(outPayload, &rootValue);
77             break;
78         case PAYLOAD_TYPE_REPRESENTATION:
79             result = OCParseRepPayload(outPayload, &rootValue);
80             break;
81         case PAYLOAD_TYPE_PRESENCE:
82             result = OCParsePresencePayload(outPayload, &rootValue);
83             break;
84         case PAYLOAD_TYPE_SECURITY:
85             result = OCParseSecurityPayload(outPayload, &rootValue);
86             break;
87         case PAYLOAD_TYPE_RD:
88             result = OCRDCborToPayload(&rootValue, outPayload);
89             break;
90         default:
91             OIC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
92             result = OC_STACK_ERROR;
93             break;
94     }
95
96     if(result != OC_STACK_OK)
97     {
98         OIC_LOG_V(INFO, TAG, "Finished parse payload, result is %d", result);
99     }
100
101     return result;
102 }
103
104 void OCFreeOCStringLL(OCStringLL* ll);
105
106 static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* rootValue)
107 {
108     if (!outPayload)
109     {
110         return OC_STACK_INVALID_PARAM;
111     }
112
113     bool err = false;
114     char * securityData = NULL;
115     CborValue strVal = {0};
116     size_t len = 0;
117
118     err = cbor_value_enter_container(rootValue, &strVal);
119     if(CborNoError == err && cbor_value_is_text_string(&strVal))
120     {
121         err = cbor_value_dup_text_string(&strVal, &securityData, &len, NULL);
122     }
123
124     if(err)
125     {
126         OIC_LOG(ERROR, TAG, "Cbor in error condition");
127         OICFree(securityData);
128         return OC_STACK_MALFORMED_RESPONSE;
129     }
130
131     *outPayload = (OCPayload*)OCSecurityPayloadCreate(securityData);
132     OICFree(securityData);
133
134     return OC_STACK_OK;
135
136 }
137
138 static char* InPlaceStringTrim(char* str)
139 {
140     while (str[0] == ' ')
141     {
142         ++str;
143     }
144
145     size_t lastchar = strlen(str);
146
147     while (str[lastchar] == ' ')
148     {
149         str[lastchar] = '\0';
150         --lastchar;
151     }
152
153     return str;
154 }
155
156 static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* rootValue)
157 {
158     if (!outPayload)
159     {
160         return OC_STACK_INVALID_PARAM;
161     }
162
163     bool err = false;
164     OCResourcePayload* resource = NULL;
165     uint16_t resourceCount = 0;
166     CborValue resourceMap = { 0 };
167
168     OCDiscoveryPayload* out = OCDiscoveryPayloadCreate();
169     if(!out)
170     {
171         return OC_STACK_NO_MEMORY;
172     }
173
174     // Root value is already inside the main root array
175     CborValue rootMap = { 0 };
176
177     // Enter the main root map
178     err = err || cbor_value_enter_container(rootValue, &rootMap);
179     // Look for DI
180     CborValue curVal = { 0 };
181     err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal);
182     if (CborNoError != err)
183     {
184         OIC_LOG(ERROR, TAG, "Cbor find value failed.");
185         goto malformed_cbor;
186     }
187     size_t len;
188     err = cbor_value_dup_byte_string(&curVal, &(out->sid), &len, NULL);
189
190     // BaseURI - Not a mandatory field
191     err = cbor_value_map_find_value(&rootMap, OC_RSRVD_BASE_URI, &curVal);
192     if (CborNoError == err && cbor_value_is_valid(&curVal))
193     {
194         err = cbor_value_dup_text_string(&curVal, &(out->baseURI), &len, NULL);
195         if (CborNoError != err)
196         {
197             OIC_LOG(ERROR, TAG, "baseURI failed.");
198             goto malformed_cbor;
199         }
200     }
201
202     // Look for Links which will have an array as the value
203     err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &curVal);
204     if (CborNoError != err)
205     {
206         OIC_LOG(ERROR, TAG, "Cbor find value failed.");
207         goto malformed_cbor;
208     }
209
210     // Enter the links array and start iterating through the array processing
211     // each resource which shows up as a map.
212     err = err || cbor_value_enter_container(&curVal, &resourceMap);
213
214     while (cbor_value_is_map(&resourceMap))
215     {
216         resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
217         if(!resource)
218         {
219             OIC_LOG(ERROR, TAG, "Memory allocation failed");
220             OCDiscoveryPayloadDestroy(out);
221             return OC_STACK_NO_MEMORY;
222         }
223
224         // Uri
225         CborValue uriVal = { 0 };
226         err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &uriVal);
227         if (CborNoError != err)
228         {
229             OIC_LOG(ERROR, TAG, "Cbor finding href type failed.");
230             goto malformed_cbor;
231         }
232         err = cbor_value_dup_text_string(&uriVal, &(resource->uri), &len, NULL);
233         if (CborNoError != err)
234         {
235             OIC_LOG(ERROR, TAG, "Cbor finding href value failed.");
236             goto malformed_cbor;
237         }
238         // ResourceTypes
239         CborValue rtVal = { 0 };
240         err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &rtVal);
241         if (CborNoError != err)
242         {
243             OIC_LOG(ERROR, TAG, "Cbor finding rt type failed.");
244             goto malformed_cbor;
245         }
246         if (cbor_value_is_text_string(&rtVal))
247         {
248             char* input = NULL;
249             char* savePtr;
250             err = cbor_value_dup_text_string(&rtVal, &input, &len, NULL);
251             if (CborNoError != err)
252             {
253                 OIC_LOG(ERROR, TAG, "Cbor finding rt value failed.");
254                 goto malformed_cbor;
255             }
256             if (input)
257             {
258                 char* curPtr = strtok_r(input, " ", &savePtr);
259
260                 while (curPtr)
261                 {
262                     char* trimmed = InPlaceStringTrim(curPtr);
263                     if (trimmed[0] !='\0')
264                     {
265                         if (!OCResourcePayloadAddResourceType(resource, trimmed))
266                         {
267                             OICFree(resource->uri);
268                             OCFreeOCStringLL(resource->types);
269                             OICFree(resource);
270                             OCDiscoveryPayloadDestroy(out);
271                             return OC_STACK_NO_MEMORY;
272                         }
273                     }
274                     curPtr = strtok_r(NULL, " ", &savePtr);
275                 }
276                 OICFree(input);
277             }
278         }
279
280         // Interface Types
281         CborValue ifVal = { 0 };
282         err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_INTERFACE, &ifVal);
283         if (CborNoError != err)
284         {
285             OIC_LOG(ERROR, TAG, "Cbor finding if type failed.");
286             goto malformed_cbor;
287         }
288         if (!err && cbor_value_is_text_string(&ifVal))
289         {
290             char* input = NULL;
291             char* savePtr;
292             err = cbor_value_dup_text_string(&ifVal, &input, &len, NULL);
293             if (CborNoError != err)
294             {
295                 OIC_LOG(ERROR, TAG, "Cbor finding if value failed.");
296                 goto malformed_cbor;
297             }
298             if (input)
299             {
300                 char* curPtr = strtok_r(input, " ", &savePtr);
301
302                 while (curPtr)
303                 {
304                     char* trimmed = InPlaceStringTrim(curPtr);
305                     if (trimmed[0] !='\0')
306                     {
307                         if (!OCResourcePayloadAddInterface(resource, trimmed))
308                         {
309                             OICFree(resource->uri);
310                             OCFreeOCStringLL(resource->types);
311                             OICFree(resource);
312                             OCDiscoveryPayloadDestroy(out);
313                             return OC_STACK_NO_MEMORY;
314                         }
315                     }
316                     curPtr = strtok_r(NULL, " ", &savePtr);
317                 }
318                 OICFree(input);
319             }
320         }
321
322         // Policy
323         CborValue policyMap = { 0 };
324         err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap);
325         if (CborNoError != err)
326         {
327             OIC_LOG(ERROR, TAG, "Cbor finding policy type failed.");
328             goto malformed_cbor;
329         }
330         // Bitmap
331         CborValue val = { 0 };
332         err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val);
333         if (CborNoError != err)
334         {
335             OIC_LOG(ERROR, TAG, "Cbor finding bitmap type failed.");
336             goto malformed_cbor;
337         }
338         uint64_t temp = 0;
339         err = cbor_value_get_uint64(&val, &temp);
340         if (CborNoError != err)
341         {
342             OIC_LOG(ERROR, TAG, "Cbor finding bitmap value failed.");
343             goto malformed_cbor;
344         }
345         resource->bitmap = (uint8_t)temp;
346         // Secure Flag
347         err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val);
348         if (CborNoError != err)
349         {
350             OIC_LOG(ERROR, TAG, "Cbor finding secure type failed.");
351             goto malformed_cbor;
352         }
353         if(cbor_value_is_valid(&val))
354         {
355             err = cbor_value_get_boolean(&val, &(resource->secure));
356             if (CborNoError != err)
357             {
358                 OIC_LOG(ERROR, TAG, "Cbor finding secure value failed.");
359                 goto malformed_cbor;
360             }
361             // Port
362             CborValue port = { 0 };
363             err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT,
364                             &port);
365             if (CborNoError != err)
366             {
367                 OIC_LOG(ERROR, TAG, "Cbor finding port type failed.");
368                 goto malformed_cbor;
369             }
370             if (cbor_value_is_valid(&port))
371             {
372                 err = cbor_value_get_uint64(&port, &temp);
373                 if (CborNoError != err)
374                 {
375                     OIC_LOG(ERROR, TAG, "Cbor finding port value failed.");
376                     goto malformed_cbor;
377                 }
378                 resource->port = (uint16_t)temp;
379             }
380         }
381         else if (out->baseURI)
382         {
383             // Port
384             CborValue port = { 0 };
385             err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &port);
386             if (CborNoError != err)
387             {
388                 OIC_LOG(ERROR, TAG, "Cbor finding port type failed.");
389                 goto malformed_cbor;
390             }
391             if(cbor_value_is_valid(&port))
392             {
393                 err = cbor_value_get_uint64(&port, &temp);
394                 if (CborNoError != err)
395                 {
396                     OIC_LOG(ERROR, TAG, "Cbor finding port value failed.");
397                     goto malformed_cbor;
398                 }
399                 resource->port = (uint16_t)temp;
400             }
401         }
402
403         err = cbor_value_advance(&resourceMap);
404         if (CborNoError != err)
405         {
406             OIC_LOG(ERROR, TAG, "Cbor advance value failed.");
407             goto malformed_cbor;
408         }
409         ++resourceCount;
410         OCDiscoveryPayloadAddNewResource(out, resource);
411     }
412
413     err = err || cbor_value_leave_container(rootValue, &resourceMap);
414
415     *outPayload = (OCPayload*)out;
416     return OC_STACK_OK;
417
418 malformed_cbor:
419     OICFree(resource->uri);
420     OCFreeOCStringLL(resource->types);
421     OCFreeOCStringLL(resource->interfaces);
422     OICFree(resource);
423     OCDiscoveryPayloadDestroy(out);
424     return OC_STACK_MALFORMED_RESPONSE;
425 }
426
427 static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* rootValue)
428 {
429     if (!outPayload)
430     {
431         return OC_STACK_INVALID_PARAM;
432     }
433
434     bool err = false;
435
436     if(cbor_value_is_map(rootValue))
437     {
438         uint8_t* sid = NULL;
439         char* dname = NULL;
440         char* specVer = NULL;
441         char* dmVer = NULL;
442
443         CborValue repVal;
444         // Device ID
445         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &repVal);
446         size_t len;
447         if(cbor_value_is_valid(&repVal))
448         {
449             err = err || cbor_value_dup_byte_string(&repVal, &sid, &len, NULL);
450         }
451         // Device Name
452         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &repVal);
453         if(cbor_value_is_valid(&repVal))
454         {
455             err = err || cbor_value_dup_text_string(&repVal, &dname, &len, NULL);
456         }
457         // Device Spec Version
458         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &repVal);
459         if(cbor_value_is_valid(&repVal))
460         {
461             err = err || cbor_value_dup_text_string(&repVal, &specVer, &len, NULL);
462         }
463
464         // Data Model Version
465         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &repVal);
466         if (cbor_value_is_valid(&repVal))
467         {
468             err = err || cbor_value_dup_text_string(&repVal, &dmVer, &len, NULL);
469         }
470
471         err = err || cbor_value_advance(rootValue);
472
473         if(err)
474         {
475             OICFree(sid);
476             OICFree(dname);
477             OICFree(specVer);
478             OICFree(dmVer);
479             OIC_LOG_V(ERROR, TAG, "CBOR in error condition %d", err);
480             return OC_STACK_MALFORMED_RESPONSE;
481         }
482
483         *outPayload = (OCPayload*)OCDevicePayloadCreate(sid, dname, specVer, dmVer);
484
485         OICFree(sid);
486         OICFree(dname);
487         OICFree(specVer);
488         OICFree(dmVer);
489         if(!*outPayload)
490         {
491             return OC_STACK_NO_MEMORY;
492         }
493
494         return OC_STACK_OK;
495     }
496     else
497     {
498         OIC_LOG(ERROR, TAG, "Root device node was not a map");
499         return OC_STACK_MALFORMED_RESPONSE;
500     }
501
502 }
503
504 static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* rootValue)
505 {
506     if (!outPayload)
507     {
508         return OC_STACK_INVALID_PARAM;
509     }
510
511     bool err = false;
512
513     if(cbor_value_is_map(rootValue))
514     {
515         OCPlatformInfo info = {0};
516
517         CborValue repVal;
518         size_t len;
519         // Platform ID
520         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
521         if(cbor_value_is_valid(&repVal))
522          {
523              err = err || cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
524          }
525
526          // MFG Name
527          err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
528          if(cbor_value_is_valid(&repVal))
529          {
530              err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
531          }
532
533         // MFG URL
534         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
535         if(cbor_value_is_valid(&repVal))
536         {
537              err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
538         }
539
540         // Model Num
541         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
542         if(cbor_value_is_valid(&repVal))
543         {
544              err = err || cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
545         }
546
547         // Date of Mfg
548         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
549         if(cbor_value_is_valid(&repVal))
550         {
551              err = err || cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len,
552                     NULL);
553         }
554
555         // Platform Version
556         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
557         if(cbor_value_is_valid(&repVal))
558         {
559              err = err || cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
560         }
561
562         // OS Version
563         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
564         if(cbor_value_is_valid(&repVal))
565         {
566              err = err || cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion),
567                     &len, NULL);
568         }
569
570         // Hardware Version
571         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
572         if(cbor_value_is_valid(&repVal))
573         {
574              err = err || cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len,
575                     NULL);
576         }
577
578         // Firmware Version
579         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
580         if(cbor_value_is_valid(&repVal))
581         {
582              err = err || cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len,
583                     NULL);
584         }
585
586         // Support URL
587         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
588         if(cbor_value_is_valid(&repVal))
589         {
590              err = err || cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
591         }
592
593         // System Time
594         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
595         if(cbor_value_is_valid(&repVal))
596         {
597              err = err || cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
598         }
599
600         err = err || cbor_value_advance(rootValue);
601
602         if(err)
603         {
604             OICFree(info.dateOfManufacture);
605             OICFree(info.firmwareVersion);
606             OICFree(info.hardwareVersion);
607             OICFree(info.manufacturerName);
608             OICFree(info.manufacturerUrl);
609             OICFree(info.modelNumber);
610             OICFree(info.operatingSystemVersion);
611             OICFree(info.platformID);
612             OICFree(info.platformVersion);
613             OICFree(info.supportUrl);
614             OICFree(info.systemTime);
615             OIC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
616             return OC_STACK_MALFORMED_RESPONSE;
617         }
618
619         *outPayload = (OCPayload*)OCPlatformPayloadCreateAsOwner(&info);
620
621         if(!*outPayload)
622         {
623             return OC_STACK_NO_MEMORY;
624         }
625
626         return OC_STACK_OK;
627     }
628     else
629     {
630         OIC_LOG(ERROR, TAG, "Root device node was not a map");
631         return OC_STACK_MALFORMED_RESPONSE;
632     }
633 }
634
635 static OCRepPayloadPropType DecodeCborType(CborType type)
636 {
637     switch (type)
638     {
639             case CborNullType:
640                 return OCREP_PROP_NULL;
641             case CborIntegerType:
642                 return OCREP_PROP_INT;
643             case CborDoubleType:
644                 return OCREP_PROP_DOUBLE;
645             case CborBooleanType:
646                 return OCREP_PROP_BOOL;
647             case CborTextStringType:
648                 return OCREP_PROP_STRING;
649             case CborByteStringType:
650                 return OCREP_PROP_BYTE_STRING;
651             case CborMapType:
652                 return OCREP_PROP_OBJECT;
653             case CborArrayType:
654                 return OCREP_PROP_ARRAY;
655             default:
656                 return OCREP_PROP_NULL;
657     }
658 }
659 static bool OCParseArrayFindDimensionsAndType(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
660         OCRepPayloadPropType* type)
661 {
662     bool err = false;
663     CborValue insideArray;
664     *type = OCREP_PROP_NULL;
665     dimensions[0] = dimensions[1] = dimensions[2] = 0;
666
667     err = err || cbor_value_enter_container(parent, &insideArray);
668
669     while (cbor_value_is_valid(&insideArray))
670     {
671         OCRepPayloadPropType tempType = DecodeCborType(cbor_value_get_type(&insideArray));
672
673         if (tempType == OCREP_PROP_ARRAY)
674         {
675             size_t subdim[MAX_REP_ARRAY_DEPTH];
676             tempType = OCREP_PROP_NULL;
677             err = err || OCParseArrayFindDimensionsAndType(&insideArray, subdim, &tempType);
678
679             if (subdim[2] != 0)
680             {
681                 OIC_LOG(ERROR, TAG, "Parse array helper, sub-array too deep");
682             }
683
684             dimensions[1] = dimensions[1] >= subdim[0] ? dimensions[1] : subdim[0];
685             dimensions[2] = dimensions[2] >= subdim[1] ? dimensions[2] : subdim[1];
686
687             if (*type != OCREP_PROP_NULL && tempType != OCREP_PROP_NULL
688                     && *type != tempType)
689             {
690                 OIC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed (subtype)");
691                 return true;
692             }
693             else if (*type == OCREP_PROP_NULL)
694             {
695                 // We don't know the type of this array yet, so the assignment is OK
696                 *type = tempType;
697             }
698         }
699         else if (*type == OCREP_PROP_NULL)
700         {
701             // We don't know the type of this array yet, so the assignment is OK
702             *type = tempType;
703         }
704         // tempType is allowed to be NULL, since it might now know the answer yet
705         else if (tempType != OCREP_PROP_NULL && *type != tempType)
706         {
707             // this is an invalid situation!
708             OIC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed");
709             return true;
710         }
711
712         ++dimensions[0];
713         cbor_value_advance(&insideArray);
714     }
715
716     return err;
717 }
718
719 static size_t getAllocSize(OCRepPayloadPropType type)
720 {
721     switch (type)
722     {
723         case OCREP_PROP_INT:
724             return sizeof (int64_t);
725         case OCREP_PROP_DOUBLE:
726             return sizeof (double);
727         case OCREP_PROP_BOOL:
728             return sizeof (bool);
729         case OCREP_PROP_STRING:
730             return sizeof (char*);
731         case OCREP_PROP_BYTE_STRING:
732             return sizeof (OCByteString);
733         case OCREP_PROP_OBJECT:
734             return sizeof (OCRepPayload*);
735         default:
736             return 0;
737     }
738 }
739
740 static size_t arrayStep(size_t dimensions[MAX_REP_ARRAY_DEPTH], size_t elementNum)
741 {
742     return
743         (dimensions[1] == 0 ? 1 : dimensions[1]) *
744         (dimensions[2] == 0 ? 1 : dimensions[2]) *
745         elementNum;
746 }
747
748 static bool OCParseArrayFillArray(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
749         OCRepPayloadPropType type, void* targetArray)
750 {
751     bool err = false;
752     CborValue insideArray;
753
754     err = err || cbor_value_enter_container(parent, &insideArray);
755
756     size_t i = 0;
757     char* tempStr = NULL;
758     OCByteString ocByteStr = { .bytes = NULL, .len = 0};
759     size_t tempLen = 0;
760     OCRepPayload* tempPl = NULL;
761
762     size_t newdim[MAX_REP_ARRAY_DEPTH];
763     newdim[0] = dimensions[1];
764     newdim[1] = dimensions[2];
765     newdim[2] = 0;
766
767     while (!err && i < dimensions[0] && cbor_value_is_valid(&insideArray))
768     {
769         bool noAdvance = false;
770         if (cbor_value_get_type(&insideArray) != CborNullType)
771         {
772             switch (type)
773             {
774                 case OCREP_PROP_INT:
775                     if (dimensions[1] == 0)
776                     {
777                         err = err || cbor_value_get_int64(&insideArray,
778                                 &(((int64_t*)targetArray)[i]));
779                     }
780                     else
781                     {
782                         err = err || OCParseArrayFillArray(&insideArray, newdim,
783                             type,
784                             &(((int64_t*)targetArray)[arrayStep(dimensions, i)])
785                             );
786                     }
787                     break;
788                 case OCREP_PROP_DOUBLE:
789                     if (dimensions[1] == 0)
790                     {
791                         err = err || cbor_value_get_double(&insideArray,
792                                 &(((double*)targetArray)[i]));
793                     }
794                     else
795                     {
796                         err = err || OCParseArrayFillArray(&insideArray, newdim,
797                             type,
798                             &(((double*)targetArray)[arrayStep(dimensions, i)])
799                             );
800                     }
801                     break;
802                 case OCREP_PROP_BOOL:
803                     if (dimensions[1] == 0)
804                     {
805                         err = err || cbor_value_get_boolean(&insideArray,
806                                 &(((bool*)targetArray)[i]));
807                     }
808                     else
809                     {
810                         err = err || OCParseArrayFillArray(&insideArray, newdim,
811                             type,
812                             &(((bool*)targetArray)[arrayStep(dimensions, i)])
813                             );
814                     }
815                     break;
816                 case OCREP_PROP_STRING:
817                     if (dimensions[1] == 0)
818                     {
819                         err = err || cbor_value_dup_text_string(&insideArray,
820                                 &tempStr, &tempLen, NULL);
821                         ((char**)targetArray)[i] = tempStr;
822                         tempStr = NULL;
823                     }
824                     else
825                     {
826                         err = err || OCParseArrayFillArray(&insideArray, newdim,
827                             type,
828                             &(((char**)targetArray)[arrayStep(dimensions, i)])
829                             );
830                     }
831                     break;
832                 case OCREP_PROP_BYTE_STRING:
833                     if (dimensions[1] == 0)
834                     {
835                         err = err || cbor_value_dup_byte_string(&insideArray,
836                                 &(ocByteStr.bytes), &(ocByteStr.len), NULL);
837                         ((OCByteString*)targetArray)[i] = ocByteStr;
838                     }
839                     else
840                     {
841                         err = err || OCParseArrayFillArray(&insideArray, newdim,
842                                 type,
843                                 &(((OCByteString*)targetArray)[arrayStep(dimensions, i)])
844                                 );
845                     }
846                     break;
847                 case OCREP_PROP_OBJECT:
848                     if (dimensions[1] == 0)
849                     {
850                         err = err || OCParseSingleRepPayload(&tempPl, &insideArray);
851                         ((OCRepPayload**)targetArray)[i] = tempPl;
852                         tempPl = NULL;
853                         noAdvance = true;
854                     }
855                     else
856                     {
857                         err = err || OCParseArrayFillArray(&insideArray, newdim,
858                             type,
859                             &(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)])
860                             );
861                     }
862                     break;
863                 default:
864                     OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
865                     err = true;
866                     break;
867             }
868         }
869         ++i;
870         if (!noAdvance && cbor_value_is_valid(&insideArray))
871         {
872             err = err || cbor_value_advance(&insideArray);
873         }
874     }
875
876     return err;
877 }
878
879 static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container)
880 {
881     OCRepPayloadPropType type;
882     size_t dimensions[MAX_REP_ARRAY_DEPTH];
883     bool err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
884
885     if (err)
886     {
887         OIC_LOG(ERROR, TAG, "Array details weren't clear");
888         return err;
889     }
890
891     if (type == OCREP_PROP_NULL)
892     {
893         err = err || OCRepPayloadSetNull(out, name);
894         err = err || cbor_value_advance(container);
895         return err;
896     }
897
898     size_t dimTotal = calcDimTotal(dimensions);
899     size_t allocSize = getAllocSize(type);
900     void* arr = OICCalloc(dimTotal, allocSize);
901
902     if (!arr)
903     {
904         OIC_LOG(ERROR, TAG, "Array Parse allocation failed");
905         return true;
906     }
907
908     err = err || OCParseArrayFillArray(container, dimensions, type, arr);
909
910     switch (type)
911     {
912         case OCREP_PROP_INT:
913             if (err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
914             {
915                 OICFree(arr);
916                 err = true;
917             }
918             break;
919         case OCREP_PROP_DOUBLE:
920             if (err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
921             {
922                 OICFree(arr);
923                 err = true;
924             }
925             break;
926         case OCREP_PROP_BOOL:
927             if (err || !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
928             {
929                 OICFree(arr);
930                 err = true;
931             }
932             break;
933         case OCREP_PROP_STRING:
934             if (err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
935             {
936                 for(size_t i = 0; i < dimTotal; ++i)
937                 {
938                     OICFree(((char**)arr)[i]);
939                 }
940                 OICFree(arr);
941                 err = true;
942             }
943             break;
944         case OCREP_PROP_BYTE_STRING:
945             if (err || !OCRepPayloadSetByteStringArrayAsOwner(out, name, (OCByteString*)arr, dimensions))
946             {
947                 for (size_t i = 0; i < dimTotal; ++i)
948                 {
949                     OICFree(((OCByteString*)arr)[i].bytes);
950                 }
951                 OICFree(arr);
952                 err = true;
953             }
954             break;
955         case OCREP_PROP_OBJECT:
956             if (err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions))
957             {
958                 for(size_t i = 0; i < dimTotal; ++i)
959                 {
960                     OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
961                 }
962                 OICFree(arr);
963                 err = true;
964             }
965             break;
966         default:
967             OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
968             err = true;
969             break;
970     }
971
972     return err;
973 }
974
975 static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue *objMap)
976 {
977     if (!outPayload)
978     {
979         return false;
980     }
981
982     bool err = false;
983
984     if (cbor_value_is_map(objMap))
985     {
986         if (!*outPayload)
987         {
988             *outPayload = OCRepPayloadCreate();
989             if(!*outPayload)
990             {
991                 return CborErrorOutOfMemory;
992             }
993         }
994
995         OCRepPayload* curPayload = *outPayload;
996
997         size_t len;
998         CborValue repMap;
999         err = err || cbor_value_enter_container(objMap, &repMap);
1000
1001         while(!err && cbor_value_is_valid(&repMap))
1002         {
1003             char* name;
1004             err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
1005             err = err || cbor_value_advance(&repMap);
1006
1007             CborType type = cbor_value_get_type(&repMap);
1008             switch(type)
1009             {
1010                 case CborNullType:
1011                     err = !OCRepPayloadSetNull(curPayload, name);
1012                     break;
1013                 case CborIntegerType:
1014                     {
1015                         int64_t intval = 0;
1016                         err = err || cbor_value_get_int64(&repMap, &intval);
1017                         if (!err)
1018                         {
1019                             err = !OCRepPayloadSetPropInt(curPayload, name, intval);
1020                         }
1021                     }
1022                     break;
1023                 case CborDoubleType:
1024                     {
1025                         double doubleval = 0;
1026                         err = err || cbor_value_get_double(&repMap, &doubleval);
1027                         if (!err)
1028                         {
1029                             err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval);
1030                         }
1031                     }
1032                     break;
1033                 case CborBooleanType:
1034                     {
1035                         bool boolval = false;
1036                         err = err || cbor_value_get_boolean(&repMap, &boolval);
1037                         if (!err)
1038                         {
1039                             err = !OCRepPayloadSetPropBool(curPayload, name, boolval);
1040                         }
1041                     }
1042                     break;
1043                 case CborTextStringType:
1044                     {
1045                         char* strval = NULL;
1046                         err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
1047                         if (!err)
1048                         {
1049                             err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
1050                         }
1051                     }
1052                     break;
1053                 case CborByteStringType:
1054                     {
1055                         uint8_t* bytestrval = NULL;
1056                         err = err || cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL);
1057                         if (!err)
1058                         {
1059                             OCByteString tmp = {.bytes = bytestrval, .len = len};
1060                             err = !OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp);
1061                         }
1062                     }
1063                     break;
1064                 case CborMapType:
1065                     {
1066                         OCRepPayload *pl = NULL;
1067                         err = err || OCParseSingleRepPayload(&pl, &repMap);
1068                         if (!err)
1069                         {
1070                             err = !OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
1071                         }
1072                     }
1073                     break;
1074                 case CborArrayType:
1075                     err = err || OCParseArray(curPayload, name, &repMap);
1076                     break;
1077                 default:
1078                     OIC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
1079                     err = true;
1080             }
1081
1082             if (type != CborMapType && cbor_value_is_valid(&repMap))
1083             {
1084                 err = err || cbor_value_advance(&repMap);
1085             }
1086             OICFree(name);
1087         }
1088
1089         err = err || cbor_value_leave_container(objMap, &repMap);
1090
1091         if(err)
1092         {
1093             OCRepPayloadDestroy(*outPayload);
1094             *outPayload = NULL;
1095         }
1096     }
1097
1098     return err;
1099 }
1100
1101 static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* rootMap)
1102 {
1103     if (!outPayload)
1104     {
1105         return OC_STACK_INVALID_PARAM;
1106     }
1107
1108     OCRepPayload *rootPayload = NULL;
1109     OCRepPayload *curPayload = NULL;
1110     OCRepPayload *temp = OCRepPayloadCreate();
1111     if (!temp)
1112     {
1113         return OC_STACK_NO_MEMORY;
1114     }
1115
1116     CborValue curVal;
1117     bool err = false;
1118     size_t len;
1119     err = err || cbor_value_map_find_value(rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal);
1120     if(cbor_value_is_text_string(&curVal))
1121     {
1122         char* allRt = NULL;
1123         err = err || cbor_value_dup_text_string(&curVal, &allRt, &len, NULL);
1124         if (allRt)
1125         {
1126             char* savePtr;
1127             char* curPtr = strtok_r(allRt, " ", &savePtr);
1128             while (curPtr)
1129             {
1130                 char* trimmed = InPlaceStringTrim(curPtr);
1131                 if (trimmed[0] != '\0')
1132                 {
1133                     OCRepPayloadAddResourceType(temp, curPtr);
1134                 }
1135                 curPtr = strtok_r(NULL, " ", &savePtr);
1136             }
1137         }
1138         OICFree(allRt);
1139     }
1140
1141     err = err || cbor_value_map_find_value(rootMap, OC_RSRVD_INTERFACE, &curVal);
1142     if(cbor_value_is_text_string(&curVal))
1143     {
1144         char* allIf = NULL;
1145         err = err || cbor_value_dup_text_string(&curVal, &allIf, &len, NULL);
1146         if (allIf)
1147         {
1148             char* savePtr;
1149             char* curPtr = strtok_r(allIf, " ", &savePtr);
1150             while (curPtr)
1151             {
1152                 char* trimmed = InPlaceStringTrim(curPtr);
1153                 if (trimmed[0] != '\0')
1154                 {
1155                     OCRepPayloadAddInterface(temp, curPtr);
1156                 }
1157                 curPtr = strtok_r(NULL, " ", &savePtr);
1158             }
1159         }
1160         OICFree(allIf);
1161     }
1162
1163     while (!err && cbor_value_is_map(rootMap))
1164     {
1165          err = err || OCParseSingleRepPayload(&temp, rootMap);
1166
1167         if(rootPayload == NULL)
1168         {
1169             rootPayload = temp;
1170             curPayload = temp;
1171         }
1172         else
1173         {
1174             curPayload->next = temp;
1175             curPayload = curPayload->next;
1176         }
1177
1178         if (cbor_value_is_valid(rootMap))
1179         {
1180             err = err || cbor_value_advance(rootMap);
1181         }
1182
1183         if(err)
1184         {
1185             OCRepPayloadDestroy(rootPayload);
1186             OIC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
1187             return OC_STACK_MALFORMED_RESPONSE;
1188         }
1189     }
1190
1191     *outPayload = (OCPayload*)rootPayload;
1192
1193     return OC_STACK_OK;
1194 }
1195
1196 static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* rootValue)
1197 {
1198     if (!outPayload)
1199     {
1200         return OC_STACK_INVALID_PARAM;
1201     }
1202
1203     bool err = false;
1204
1205     if(cbor_value_is_map(rootValue))
1206     {
1207         uint64_t seqNum = 0;
1208         uint64_t maxAge = 0;
1209         OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
1210         char* tempStr = NULL;
1211         size_t len = 0;
1212
1213         CborValue curVal;
1214         // Sequence Number
1215         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_NONCE, &curVal);
1216         err = err || cbor_value_get_uint64(&curVal, &seqNum);
1217
1218         // Max Age
1219         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_TTL, &curVal);
1220         err = err || cbor_value_get_uint64(&curVal, &maxAge);
1221
1222         // Trigger
1223         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_TRIGGER, &curVal);
1224         err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
1225         trigger = convertTriggerStringToEnum(tempStr);
1226         OICFree(tempStr);
1227         tempStr = NULL;
1228
1229         // Resource type name
1230         err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
1231         if(cbor_value_is_valid(&curVal))
1232         {
1233              err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
1234         }
1235
1236         err = err || cbor_value_advance(rootValue);
1237
1238         if(!err)
1239         {
1240             *outPayload = (OCPayload*)OCPresencePayloadCreate(seqNum, maxAge, trigger, tempStr);
1241         }
1242         OICFree(tempStr);
1243
1244         if(err)
1245         {
1246             OCPayloadDestroy(*outPayload);
1247             OIC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
1248             return OC_STACK_MALFORMED_RESPONSE;
1249         }
1250
1251         if(!*outPayload)
1252         {
1253             return OC_STACK_NO_MEMORY;
1254         }
1255
1256         return OC_STACK_OK;
1257     }
1258     else
1259     {
1260         OIC_LOG(ERROR, TAG, "Root presence node was not a map");
1261         return OC_STACK_MALFORMED_RESPONSE;
1262     }
1263 }