1 //******************************************************************
3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
30 #include "ocpayloadcbor.h"
33 #include "oic_string.h"
34 #include "oic_malloc.h"
35 #include "ocstackinternal.h"
36 #include "ocpayload.h"
38 #include "oic_string.h"
39 #include "payload_logging.h"
40 #include "rdpayload.h"
42 #define TAG "OCPayloadParse"
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);
52 OCStackResult OCParsePayload(OCPayload** outPayload, OCPayloadType payloadType,
53 const uint8_t* payload, size_t payloadSize)
59 OC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu", payloadSize);
60 if((err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue)) != false)
62 OC_LOG_V(ERROR, TAG, "CBOR Parser init failed: %d", err);
63 return OC_STACK_ERROR;
66 OCStackResult result = OC_STACK_ERROR;
69 case PAYLOAD_TYPE_DISCOVERY:
70 result = OCParseDiscoveryPayload(outPayload, &rootValue);
72 case PAYLOAD_TYPE_DEVICE:
73 result = OCParseDevicePayload(outPayload, &rootValue);
75 case PAYLOAD_TYPE_PLATFORM:
76 result = OCParsePlatformPayload(outPayload, &rootValue);
78 case PAYLOAD_TYPE_REPRESENTATION:
79 result = OCParseRepPayload(outPayload, &rootValue);
81 case PAYLOAD_TYPE_PRESENCE:
82 result = OCParsePresencePayload(outPayload, &rootValue);
84 case PAYLOAD_TYPE_SECURITY:
85 result = OCParseSecurityPayload(outPayload, &rootValue);
88 result = OCRDCborToPayload(&rootValue, outPayload);
91 OC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
92 result = OC_STACK_ERROR;
96 if(result != OC_STACK_OK)
98 OC_LOG_V(INFO, TAG, "Finished parse payload, result is %d", result);
104 void OCFreeOCStringLL(OCStringLL* ll);
106 static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* rootValue)
110 return OC_STACK_INVALID_PARAM;
114 char * securityData = NULL;
116 err = err || cbor_value_enter_container(rootValue, &arrayVal);
118 if(cbor_value_is_map(&arrayVal))
121 err = err || cbor_value_map_find_value(&arrayVal, OC_RSRVD_REPRESENTATION, &curVal);
123 if(cbor_value_is_valid(&curVal))
126 err = err || cbor_value_dup_text_string(&curVal, &securityData, &len, NULL);
131 OC_LOG(ERROR, TAG, "Cbor main value not a map");
132 return OC_STACK_MALFORMED_RESPONSE;
135 err = err || cbor_value_advance(&arrayVal);
136 err = err || cbor_value_leave_container(rootValue, &arrayVal);
140 OC_LOG(ERROR, TAG, "Cbor in error condition");
141 OICFree(securityData);
142 return OC_STACK_MALFORMED_RESPONSE;
145 *outPayload = (OCPayload*)OCSecurityPayloadCreate(securityData);
146 OICFree(securityData);
152 static char* InPlaceStringTrim(char* str)
154 while (str[0] == ' ')
159 size_t lastchar = strlen(str);
161 while (str[lastchar] == ' ')
163 str[lastchar] = '\0';
170 static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* rootValue)
174 return OC_STACK_INVALID_PARAM;
178 OCResourcePayload* resource = NULL;
180 OCDiscoveryPayload* out = OCDiscoveryPayloadCreate();
183 return OC_STACK_NO_MEMORY;
187 err = err || cbor_value_enter_container(rootValue, &arrayVal);
189 if (cbor_value_is_array(&arrayVal))
191 OCLinksPayload *linksPayload = NULL;
192 OCTagsPayload *tagsPayload = NULL;
193 while (cbor_value_is_container(&arrayVal))
197 CborValue colResources;
198 CborError cborFindResult = cbor_value_enter_container(&arrayVal, &colResources);
199 if (CborNoError != cborFindResult)
204 if (OC_STACK_OK != OCTagsCborToPayload(&colResources, &tagsPayload))
206 OC_LOG(ERROR, TAG, "Tags cbor parsing failed.");
207 OCFreeTagsResource(tagsPayload);
211 if (OC_STACK_OK != OCLinksCborToPayload(&colResources, &linksPayload))
213 OC_LOG(ERROR, TAG, "Links cbor parsing failed.");
214 OCFreeTagsResource(tagsPayload);
215 OCFreeLinksResource(linksPayload);
219 if (OC_STACK_OK != OCDiscoveryCollectionPayloadAddResource(out, tagsPayload, linksPayload))
221 OC_LOG(ERROR, TAG, "Memory allocation failed");
222 OCFreeLinksResource(linksPayload);
223 OCFreeTagsResource(tagsPayload);
224 OCDiscoveryPayloadDestroy(out);
225 return OC_STACK_NO_MEMORY;
227 if (CborNoError != cbor_value_advance(&arrayVal))
229 OC_LOG(ERROR, TAG, "Cbor value advanced failed.");
234 if (cbor_value_is_map(&arrayVal))
236 size_t resourceCount = 0;
237 while (cbor_value_is_map(&arrayVal))
239 resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
242 OC_LOG(ERROR, TAG, "Memory allocation failed");
243 OCDiscoveryPayloadDestroy(out);
244 return OC_STACK_NO_MEMORY;
248 err = cbor_value_map_find_value(&arrayVal, OC_RSRVD_DEVICE_ID, &curVal);
249 if (CborNoError != err)
251 OC_LOG(ERROR, TAG, "Cbor find value failed.");
255 err = cbor_value_dup_byte_string(&curVal, &(resource->sid), &len, NULL);
256 if (CborNoError != err)
258 OC_LOG(ERROR, TAG, "Cbor di finding failed.");
264 err = cbor_value_map_find_value(&arrayVal, OC_RSRVD_LINKS, &linkArray);
265 if (CborNoError != err)
267 OC_LOG(ERROR, TAG, "Cbor links finding failed.");
271 err = cbor_value_enter_container(&linkArray, &linkMap);
272 if (CborNoError != err)
274 OC_LOG(ERROR, TAG, "Cbor entering map failed.");
278 err = cbor_value_map_find_value(&linkMap, OC_RSRVD_HREF, &curVal);
279 if (CborNoError != err)
281 OC_LOG(ERROR, TAG, "Cbor finding href type failed.");
284 err = cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL);
285 if (CborNoError != err)
287 OC_LOG(ERROR, TAG, "Cbor finding href value failed.");
292 err = cbor_value_map_find_value(&linkMap, OC_RSRVD_RESOURCE_TYPE, &rtVal);
293 if (CborNoError != err)
295 OC_LOG(ERROR, TAG, "Cbor finding rt type failed.");
298 if (cbor_value_is_text_string(&rtVal))
302 err = cbor_value_dup_text_string(&rtVal, &input, &len, NULL);
303 if (CborNoError != err)
305 OC_LOG(ERROR, TAG, "Cbor finding rt value failed.");
310 char* curPtr = strtok_r(input, " ", &savePtr);
314 char* trimmed = InPlaceStringTrim(curPtr);
315 if (trimmed[0] !='\0')
317 if (!OCResourcePayloadAddResourceType(resource, trimmed))
319 OICFree(resource->uri);
320 OICFree(resource->sid);
321 OCFreeOCStringLL(resource->types);
323 OCDiscoveryPayloadDestroy(out);
324 return OC_STACK_NO_MEMORY;
327 curPtr = strtok_r(NULL, " ", &savePtr);
335 err = cbor_value_map_find_value(&linkMap, OC_RSRVD_INTERFACE, &ifVal);
336 if (CborNoError != err)
338 OC_LOG(ERROR, TAG, "Cbor finding if type failed.");
341 if (!err && cbor_value_is_text_string(&ifVal))
345 err = cbor_value_dup_text_string(&ifVal, &input, &len, NULL);
346 if (CborNoError != err)
348 OC_LOG(ERROR, TAG, "Cbor finding if value failed.");
353 char* curPtr = strtok_r(input, " ", &savePtr);
357 char* trimmed = InPlaceStringTrim(curPtr);
358 if (trimmed[0] !='\0')
360 if (!OCResourcePayloadAddInterface(resource, trimmed))
362 OICFree(resource->uri);
363 OICFree(resource->sid);
364 OCFreeOCStringLL(resource->types);
366 OCDiscoveryPayloadDestroy(out);
367 return OC_STACK_NO_MEMORY;
370 curPtr = strtok_r(NULL, " ", &savePtr);
378 err = cbor_value_map_find_value(&linkMap, OC_RSRVD_POLICY, &policyMap);
379 if (CborNoError != err)
381 OC_LOG(ERROR, TAG, "Cbor finding policy type failed.");
386 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val);
387 if (CborNoError != err)
389 OC_LOG(ERROR, TAG, "Cbor finding bitmap type failed.");
393 err = cbor_value_get_uint64(&val, &temp);
394 if (CborNoError != err)
396 OC_LOG(ERROR, TAG, "Cbor finding bitmap value failed.");
399 resource->bitmap = (uint8_t)temp;
401 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val);
402 if (CborNoError != err)
404 OC_LOG(ERROR, TAG, "Cbor finding secure type failed.");
407 if(cbor_value_is_valid(&val))
409 err = cbor_value_get_boolean(&val, &(resource->secure));
410 if (CborNoError != err)
412 OC_LOG(ERROR, TAG, "Cbor finding secure value failed.");
417 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT,
419 if (CborNoError != err)
421 OC_LOG(ERROR, TAG, "Cbor finding port type failed.");
424 if(cbor_value_is_valid(&port))
426 err = cbor_value_get_uint64(&port, &temp);
427 if (CborNoError != err)
429 OC_LOG(ERROR, TAG, "Cbor finding port value failed.");
432 resource->port = (uint16_t)temp;
437 err = cbor_value_advance(&arrayVal);
438 if (CborNoError != err)
440 OC_LOG(ERROR, TAG, "Cbor advance value failed.");
444 OCDiscoveryPayloadAddNewResource(out, resource);
447 err = err || cbor_value_leave_container(rootValue, &arrayVal);
449 *outPayload = (OCPayload*)out;
453 OICFree(resource->uri);
454 OICFree(resource->sid);
455 OCFreeOCStringLL(resource->types);
456 OCFreeOCStringLL(resource->interfaces);
458 OCDiscoveryPayloadDestroy(out);
459 return OC_STACK_MALFORMED_RESPONSE;
462 OCDiscoveryCollectionPayloadDestroy(out);
463 return OC_STACK_MALFORMED_RESPONSE;
466 static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* rootValue)
470 return OC_STACK_INVALID_PARAM;
475 if(cbor_value_is_map(rootValue))
479 char* specVer = NULL;
484 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &repVal);
486 if(cbor_value_is_valid(&repVal))
488 err = err || cbor_value_dup_byte_string(&repVal, &sid, &len, NULL);
491 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &repVal);
492 if(cbor_value_is_valid(&repVal))
494 err = err || cbor_value_dup_text_string(&repVal, &dname, &len, NULL);
496 // Device Spec Version
497 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &repVal);
498 if(cbor_value_is_valid(&repVal))
500 err = err || cbor_value_dup_text_string(&repVal, &specVer, &len, NULL);
503 // Data Model Version
504 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &repVal);
505 if (cbor_value_is_valid(&repVal))
507 err = err || cbor_value_dup_text_string(&repVal, &dmVer, &len, NULL);
510 err = err || cbor_value_advance(rootValue);
518 OC_LOG_V(ERROR, TAG, "CBOR in error condition %d", err);
519 return OC_STACK_MALFORMED_RESPONSE;
522 *outPayload = (OCPayload*)OCDevicePayloadCreate(sid, dname, specVer, dmVer);
530 return OC_STACK_NO_MEMORY;
537 OC_LOG(ERROR, TAG, "Root device node was not a map");
538 return OC_STACK_MALFORMED_RESPONSE;
543 static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* rootValue)
547 return OC_STACK_INVALID_PARAM;
552 if(cbor_value_is_map(rootValue))
554 OCPlatformInfo info = {0};
559 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
560 if(cbor_value_is_valid(&repVal))
562 err = err || cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
566 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
567 if(cbor_value_is_valid(&repVal))
569 err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
573 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
574 if(cbor_value_is_valid(&repVal))
576 err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
580 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
581 if(cbor_value_is_valid(&repVal))
583 err = err || cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
587 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
588 if(cbor_value_is_valid(&repVal))
590 err = err || cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len,
595 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
596 if(cbor_value_is_valid(&repVal))
598 err = err || cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
602 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
603 if(cbor_value_is_valid(&repVal))
605 err = err || cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion),
610 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
611 if(cbor_value_is_valid(&repVal))
613 err = err || cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len,
618 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
619 if(cbor_value_is_valid(&repVal))
621 err = err || cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len,
626 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
627 if(cbor_value_is_valid(&repVal))
629 err = err || cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
633 err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
634 if(cbor_value_is_valid(&repVal))
636 err = err || cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
639 err = err || cbor_value_advance(rootValue);
643 OICFree(info.dateOfManufacture);
644 OICFree(info.firmwareVersion);
645 OICFree(info.hardwareVersion);
646 OICFree(info.manufacturerName);
647 OICFree(info.manufacturerUrl);
648 OICFree(info.modelNumber);
649 OICFree(info.operatingSystemVersion);
650 OICFree(info.platformID);
651 OICFree(info.platformVersion);
652 OICFree(info.supportUrl);
653 OICFree(info.systemTime);
654 OC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
655 return OC_STACK_MALFORMED_RESPONSE;
658 *outPayload = (OCPayload*)OCPlatformPayloadCreateAsOwner(&info);
662 return OC_STACK_NO_MEMORY;
669 OC_LOG(ERROR, TAG, "Root device node was not a map");
670 return OC_STACK_MALFORMED_RESPONSE;
674 static OCRepPayloadPropType DecodeCborType(CborType type)
679 return OCREP_PROP_NULL;
680 case CborIntegerType:
681 return OCREP_PROP_INT;
683 return OCREP_PROP_DOUBLE;
684 case CborBooleanType:
685 return OCREP_PROP_BOOL;
686 case CborTextStringType:
687 return OCREP_PROP_STRING;
688 case CborByteStringType:
689 return OCREP_PROP_BYTE_STRING;
691 return OCREP_PROP_OBJECT;
693 return OCREP_PROP_ARRAY;
695 return OCREP_PROP_NULL;
698 static bool OCParseArrayFindDimensionsAndType(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
699 OCRepPayloadPropType* type)
702 CborValue insideArray;
703 *type = OCREP_PROP_NULL;
704 dimensions[0] = dimensions[1] = dimensions[2] = 0;
706 err = err || cbor_value_enter_container(parent, &insideArray);
708 while (cbor_value_is_valid(&insideArray))
710 OCRepPayloadPropType tempType = DecodeCborType(cbor_value_get_type(&insideArray));
712 if (tempType == OCREP_PROP_ARRAY)
714 size_t subdim[MAX_REP_ARRAY_DEPTH];
715 tempType = OCREP_PROP_NULL;
716 err = err || OCParseArrayFindDimensionsAndType(&insideArray, subdim, &tempType);
720 OC_LOG(ERROR, TAG, "Parse array helper, sub-array too deep");
723 dimensions[1] = dimensions[1] >= subdim[0] ? dimensions[1] : subdim[0];
724 dimensions[2] = dimensions[2] >= subdim[1] ? dimensions[2] : subdim[1];
726 if (*type != OCREP_PROP_NULL && tempType != OCREP_PROP_NULL
727 && *type != tempType)
729 OC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed (subtype)");
732 else if (*type == OCREP_PROP_NULL)
734 // We don't know the type of this array yet, so the assignment is OK
738 else if (*type == OCREP_PROP_NULL)
740 // We don't know the type of this array yet, so the assignment is OK
743 // tempType is allowed to be NULL, since it might now know the answer yet
744 else if (tempType != OCREP_PROP_NULL && *type != tempType)
746 // this is an invalid situation!
747 OC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed");
752 cbor_value_advance(&insideArray);
758 static size_t getAllocSize(OCRepPayloadPropType type)
763 return sizeof (int64_t);
764 case OCREP_PROP_DOUBLE:
765 return sizeof (double);
766 case OCREP_PROP_BOOL:
767 return sizeof (bool);
768 case OCREP_PROP_STRING:
769 return sizeof (char*);
770 case OCREP_PROP_BYTE_STRING:
771 return sizeof (OCByteString);
772 case OCREP_PROP_OBJECT:
773 return sizeof (OCRepPayload*);
779 static size_t arrayStep(size_t dimensions[MAX_REP_ARRAY_DEPTH], size_t elementNum)
782 (dimensions[1] == 0 ? 1 : dimensions[1]) *
783 (dimensions[2] == 0 ? 1 : dimensions[2]) *
787 static bool OCParseArrayFillArray(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
788 OCRepPayloadPropType type, void* targetArray)
791 CborValue insideArray;
793 err = err || cbor_value_enter_container(parent, &insideArray);
796 char* tempStr = NULL;
797 OCByteString ocByteStr = { .bytes = NULL, .len = 0};
799 OCRepPayload* tempPl = NULL;
801 size_t newdim[MAX_REP_ARRAY_DEPTH];
802 newdim[0] = dimensions[1];
803 newdim[1] = dimensions[2];
806 while (!err && i < dimensions[0] && cbor_value_is_valid(&insideArray))
808 bool noAdvance = false;
809 if (cbor_value_get_type(&insideArray) != CborNullType)
814 if (dimensions[1] == 0)
816 err = err || cbor_value_get_int64(&insideArray,
817 &(((int64_t*)targetArray)[i]));
821 err = err || OCParseArrayFillArray(&insideArray, newdim,
823 &(((int64_t*)targetArray)[arrayStep(dimensions, i)])
827 case OCREP_PROP_DOUBLE:
828 if (dimensions[1] == 0)
830 err = err || cbor_value_get_double(&insideArray,
831 &(((double*)targetArray)[i]));
835 err = err || OCParseArrayFillArray(&insideArray, newdim,
837 &(((double*)targetArray)[arrayStep(dimensions, i)])
841 case OCREP_PROP_BOOL:
842 if (dimensions[1] == 0)
844 err = err || cbor_value_get_boolean(&insideArray,
845 &(((bool*)targetArray)[i]));
849 err = err || OCParseArrayFillArray(&insideArray, newdim,
851 &(((bool*)targetArray)[arrayStep(dimensions, i)])
855 case OCREP_PROP_STRING:
856 if (dimensions[1] == 0)
858 err = err || cbor_value_dup_text_string(&insideArray,
859 &tempStr, &tempLen, NULL);
860 ((char**)targetArray)[i] = tempStr;
865 err = err || OCParseArrayFillArray(&insideArray, newdim,
867 &(((char**)targetArray)[arrayStep(dimensions, i)])
871 case OCREP_PROP_BYTE_STRING:
872 if (dimensions[1] == 0)
874 err = err || cbor_value_dup_byte_string(&insideArray,
875 &(ocByteStr.bytes), &(ocByteStr.len), NULL);
876 ((OCByteString*)targetArray)[i] = ocByteStr;
880 err = err || OCParseArrayFillArray(&insideArray, newdim,
882 &(((OCByteString*)targetArray)[arrayStep(dimensions, i)])
886 case OCREP_PROP_OBJECT:
887 if (dimensions[1] == 0)
889 err = err || OCParseSingleRepPayload(&tempPl, &insideArray);
890 ((OCRepPayload**)targetArray)[i] = tempPl;
896 err = err || OCParseArrayFillArray(&insideArray, newdim,
898 &(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)])
903 OC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
909 if (!noAdvance && cbor_value_is_valid(&insideArray))
911 err = err || cbor_value_advance(&insideArray);
918 static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container)
920 OCRepPayloadPropType type;
921 size_t dimensions[MAX_REP_ARRAY_DEPTH];
922 bool err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
926 OC_LOG(ERROR, TAG, "Array details weren't clear");
930 if (type == OCREP_PROP_NULL)
932 err = err || OCRepPayloadSetNull(out, name);
933 err = err || cbor_value_advance(container);
937 size_t dimTotal = calcDimTotal(dimensions);
938 size_t allocSize = getAllocSize(type);
939 void* arr = OICCalloc(dimTotal, allocSize);
943 OC_LOG(ERROR, TAG, "Array Parse allocation failed");
947 err = err || OCParseArrayFillArray(container, dimensions, type, arr);
952 if (err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
958 case OCREP_PROP_DOUBLE:
959 if (err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
965 case OCREP_PROP_BOOL:
966 if (err || !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
972 case OCREP_PROP_STRING:
973 if (err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
975 for(size_t i = 0; i < dimTotal; ++i)
977 OICFree(((char**)arr)[i]);
983 case OCREP_PROP_BYTE_STRING:
984 if (err || !OCRepPayloadSetByteStringArrayAsOwner(out, name, (OCByteString*)arr, dimensions))
986 for (size_t i = 0; i < dimTotal; ++i)
988 OICFree(((OCByteString*)arr)[i].bytes);
994 case OCREP_PROP_OBJECT:
995 if (err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions))
997 for(size_t i = 0; i < dimTotal; ++i)
999 OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
1006 OC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
1014 static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue *objMap)
1023 if (cbor_value_is_map(objMap))
1027 *outPayload = OCRepPayloadCreate();
1030 return CborErrorOutOfMemory;
1034 OCRepPayload* curPayload = *outPayload;
1038 err = err || cbor_value_enter_container(objMap, &repMap);
1040 while(!err && cbor_value_is_valid(&repMap))
1043 err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
1044 err = err || cbor_value_advance(&repMap);
1046 CborType type = cbor_value_get_type(&repMap);
1050 err = !OCRepPayloadSetNull(curPayload, name);
1052 case CborIntegerType:
1055 err = err || cbor_value_get_int64(&repMap, &intval);
1058 err = !OCRepPayloadSetPropInt(curPayload, name, intval);
1062 case CborDoubleType:
1064 double doubleval = 0;
1065 err = err || cbor_value_get_double(&repMap, &doubleval);
1068 err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval);
1072 case CborBooleanType:
1074 bool boolval = false;
1075 err = err || cbor_value_get_boolean(&repMap, &boolval);
1078 err = !OCRepPayloadSetPropBool(curPayload, name, boolval);
1082 case CborTextStringType:
1084 char* strval = NULL;
1085 err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
1088 err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
1092 case CborByteStringType:
1094 uint8_t* bytestrval = NULL;
1095 err = err || cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL);
1098 OCByteString tmp = {.bytes = bytestrval, .len = len};
1099 err = !OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp);
1105 OCRepPayload *pl = NULL;
1106 err = err || OCParseSingleRepPayload(&pl, &repMap);
1109 err = !OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
1114 err = err || OCParseArray(curPayload, name, &repMap);
1117 OC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
1121 if (type != CborMapType && cbor_value_is_valid(&repMap))
1123 err = err || cbor_value_advance(&repMap);
1128 err = err || cbor_value_leave_container(objMap, &repMap);
1132 OCRepPayloadDestroy(*outPayload);
1140 static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* rootMap)
1144 return OC_STACK_INVALID_PARAM;
1147 OCRepPayload *rootPayload = NULL;
1148 OCRepPayload *curPayload = NULL;
1149 OCRepPayload *temp = OCRepPayloadCreate();
1152 return OC_STACK_NO_MEMORY;
1158 err = err || cbor_value_map_find_value(rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal);
1159 if(cbor_value_is_text_string(&curVal))
1162 err = err || cbor_value_dup_text_string(&curVal, &allRt, &len, NULL);
1166 char* curPtr = strtok_r(allRt, " ", &savePtr);
1169 char* trimmed = InPlaceStringTrim(curPtr);
1170 if (trimmed[0] != '\0')
1172 OCRepPayloadAddResourceType(temp, curPtr);
1174 curPtr = strtok_r(NULL, " ", &savePtr);
1180 err = err || cbor_value_map_find_value(rootMap, OC_RSRVD_INTERFACE, &curVal);
1181 if(cbor_value_is_text_string(&curVal))
1184 err = err || cbor_value_dup_text_string(&curVal, &allIf, &len, NULL);
1188 char* curPtr = strtok_r(allIf, " ", &savePtr);
1191 char* trimmed = InPlaceStringTrim(curPtr);
1192 if (trimmed[0] != '\0')
1194 OCRepPayloadAddInterface(temp, curPtr);
1196 curPtr = strtok_r(NULL, " ", &savePtr);
1202 while (!err && cbor_value_is_map(rootMap))
1204 err = err || OCParseSingleRepPayload(&temp, rootMap);
1206 if(rootPayload == NULL)
1213 curPayload->next = temp;
1214 curPayload = curPayload->next;
1217 if (cbor_value_is_valid(rootMap))
1219 err = err || cbor_value_advance(rootMap);
1224 OCRepPayloadDestroy(rootPayload);
1225 OC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
1226 return OC_STACK_MALFORMED_RESPONSE;
1230 *outPayload = (OCPayload*)rootPayload;
1235 static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* rootValue)
1239 return OC_STACK_INVALID_PARAM;
1244 err = err || cbor_value_enter_container(rootValue, &arrayVal);
1246 if(cbor_value_is_map(&arrayVal))
1248 uint64_t seqNum = 0;
1249 uint64_t maxAge = 0;
1250 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
1251 char* tempStr = NULL;
1256 err = err || cbor_value_map_find_value(&arrayVal, OC_RSRVD_NONCE, &curVal);
1257 err = err || cbor_value_get_uint64(&curVal, &seqNum);
1260 err = err || cbor_value_map_find_value(&arrayVal, OC_RSRVD_TTL, &curVal);
1261 err = err || cbor_value_get_uint64(&curVal, &maxAge);
1264 err = err || cbor_value_map_find_value(&arrayVal, OC_RSRVD_TRIGGER, &curVal);
1265 err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
1266 trigger = convertTriggerStringToEnum(tempStr);
1270 // Resource type name
1271 err = err || cbor_value_map_find_value(&arrayVal, OC_RSRVD_RESOURCE_TYPE, &curVal);
1272 if(cbor_value_is_valid(&curVal))
1274 err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
1277 err = err || cbor_value_advance(&arrayVal);
1278 err = err || cbor_value_leave_container(rootValue, &arrayVal);
1282 *outPayload = (OCPayload*)OCPresencePayloadCreate(seqNum, maxAge, trigger, tempStr);
1288 OCPayloadDestroy(*outPayload);
1289 OC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
1290 return OC_STACK_MALFORMED_RESPONSE;
1295 return OC_STACK_NO_MEMORY;
1302 OC_LOG(ERROR, TAG, "Root presence node was not a map");
1303 return OC_STACK_MALFORMED_RESPONSE;