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 #include "ocpayloadcbor.h"
24 #include "oic_malloc.h"
25 #include "ocstackinternal.h"
26 #include "ocpayload.h"
29 #define TAG PCF("OCPayloadParse")
31 static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal);
32 static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* arrayVal);
33 static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* arrayVal);
34 static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repParent);
35 static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* arrayVal);
36 static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal);
37 static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* arrayVal);
39 OCStackResult OCParsePayload(OCPayload** outPayload, const uint8_t* payload, size_t payloadSize)
45 OC_LOG_V(INFO, TAG, "CBOR Parsing size: %d", payloadSize, payload);
46 if((err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue)) != false)
48 OC_LOG_V(ERROR, TAG, "CBOR Parser init failed: %d", err);
49 return OC_STACK_ERROR;
52 if(!cbor_value_is_array(&rootValue))
54 OC_LOG_V(ERROR, TAG, "CBOR payload root object is not an array :%x", rootValue.type);
55 return OC_STACK_MALFORMED_RESPONSE;
60 err = err || cbor_value_enter_container(&rootValue, &arrayValue);
63 err = err || cbor_value_get_int(&arrayValue, &payloadType);
64 err = err || cbor_value_advance_fixed(&arrayValue);
68 OC_LOG_V(ERROR, TAG, "CBOR payload parse failed :%d", err);
69 return OC_STACK_MALFORMED_RESPONSE;
72 OCStackResult result = OC_STACK_ERROR;
75 case PAYLOAD_TYPE_DISCOVERY:
76 result = OCParseDiscoveryPayload(outPayload, &arrayValue);
78 case PAYLOAD_TYPE_DEVICE:
79 result = OCParseDevicePayload(outPayload, &arrayValue);
81 case PAYLOAD_TYPE_PLATFORM:
82 result = OCParsePlatformPayload(outPayload, &arrayValue);
84 case PAYLOAD_TYPE_REPRESENTATION:
85 result = OCParseRepPayload(outPayload, &arrayValue);
87 case PAYLOAD_TYPE_PRESENCE:
88 result = OCParsePresencePayload(outPayload, &arrayValue);
90 case PAYLOAD_TYPE_SECURITY:
91 result = OCParseSecurityPayload(outPayload, &arrayValue);
94 OC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
95 result = OC_STACK_ERROR;
99 if(result == OC_STACK_OK)
101 err = err || cbor_value_leave_container(&rootValue, &arrayValue);
102 if(err != CborNoError)
104 return OC_STACK_MALFORMED_RESPONSE;
109 OC_LOG_V(INFO, TAG, "Finished parse payload, result is %d", result);
115 void OCFreeOCStringLL(OCStringLL* ll);
117 static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* arrayVal)
120 char * securityData = NULL;
122 if(cbor_value_is_map(arrayVal))
125 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_REPRESENTATION, &curVal);
127 if(cbor_value_is_valid(&curVal))
130 err = err || cbor_value_dup_text_string(&curVal, &securityData, &len, NULL);
135 OC_LOG_V(ERROR, TAG, PCF("Cbor main value not a map"));
136 return OC_STACK_MALFORMED_RESPONSE;
139 err = err || cbor_value_advance(arrayVal);
143 OC_LOG_V(ERROR, TAG, "Cbor in error condition");
144 OICFree(securityData);
145 return OC_STACK_MALFORMED_RESPONSE;
148 *outPayload = (OCPayload*)OCSecurityPayloadCreate(securityData);
149 OICFree(securityData);
155 static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal)
159 OCDiscoveryPayload* out = OCDiscoveryPayloadCreate();
163 return OC_STACK_NO_MEMORY;
166 size_t resourceCount = 0;
168 cbor_value_is_map(arrayVal))
170 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
173 OC_LOG_V(ERROR, TAG, "Memory allocation failed");
174 return OC_STACK_NO_MEMORY;
179 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_HREF, &curVal);
181 err = err || cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL);
184 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_SERVER_INSTANCE_ID, &curVal);
185 err = err || cbor_value_dup_byte_string(&curVal, &(resource->sid), &len, NULL);
189 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_PROPERTY, &curVal);
192 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE, &rtArray);
195 err = err || cbor_value_enter_container(&rtArray, &rtVal);
197 OCStringLL* llPtr = NULL;
198 while(!err && cbor_value_is_text_string(&rtVal))
200 if(resource->types == NULL)
202 resource->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
203 llPtr = resource->types;
206 OC_LOG_V(ERROR, TAG, "Memory allocation failed");
207 OICFree(resource->uri);
208 OICFree(resource->sid);
210 return OC_STACK_NO_MEMORY;
215 llPtr->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
219 OC_LOG_V(ERROR, TAG, "Memory allocation failed");
220 OICFree(resource->uri);
221 OICFree(resource->sid);
222 OCFreeOCStringLL(resource->types);
224 return OC_STACK_NO_MEMORY;
229 err = err || cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL);
230 err = err || cbor_value_advance(&rtVal);
233 err = err || cbor_value_leave_container(&rtArray, &rtVal);
237 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &ifArray);
239 err = err || cbor_value_enter_container(&ifArray, &ifVal);
242 while(!err && cbor_value_is_text_string(&ifVal))
244 if(resource->interfaces == NULL)
246 resource->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
247 llPtr = resource->interfaces;
250 OC_LOG_V(ERROR, TAG, "Memory allocation failed");
251 OICFree(resource->uri);
252 OICFree(resource->sid);
253 OCFreeOCStringLL(resource->types);
255 return OC_STACK_NO_MEMORY;
260 llPtr->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
264 OC_LOG_V(ERROR, TAG, "Memory allocation failed");
265 OICFree(resource->uri);
266 OICFree(resource->sid);
267 OCFreeOCStringLL(resource->types);
268 OCFreeOCStringLL(resource->interfaces);
270 return OC_STACK_NO_MEMORY;
274 err = err || cbor_value_dup_text_string(&ifVal, &(llPtr->value), &len, NULL);
275 err = err || cbor_value_advance(&ifVal);
277 err = err || cbor_value_leave_container(&ifArray, &ifVal);
282 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_POLICY, &policyMap);
286 err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val);
288 err = err || cbor_value_get_uint64(&val, &temp);
289 resource->bitmap = (uint8_t)temp;
291 err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val);
292 if(cbor_value_is_valid(&val))
294 err = err || cbor_value_get_boolean(&val, &(resource->secure));
297 err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT,
299 if(cbor_value_is_valid(&port))
301 err = err || cbor_value_get_uint64(&port, &temp);
302 resource->port = (uint16_t)temp;
308 err = err || cbor_value_advance(arrayVal);
311 OICFree(resource->uri);
312 OICFree(resource->sid);
313 OCFreeOCStringLL(resource->types);
314 OCFreeOCStringLL(resource->interfaces);
316 OCDiscoveryPayloadDestroy(out);
317 OC_LOG_V(ERROR, TAG, "CBOR in error condition", err);
318 return OC_STACK_MALFORMED_RESPONSE;
321 OCDiscoveryPayloadAddNewResource(out, resource);
324 *outPayload = (OCPayload*)out;
329 static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* arrayVal)
333 if(cbor_value_is_map(arrayVal))
338 char* specVer = NULL;
341 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_HREF, &curVal);
343 err = err || cbor_value_dup_text_string(&curVal, &uri, &len, NULL);
347 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_REPRESENTATION, &curVal);
351 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_DEVICE_ID, &repVal);
352 err = err || cbor_value_dup_byte_string(&repVal, &sid, &len, NULL);
354 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_DEVICE_NAME, &repVal);
355 err = err || cbor_value_dup_text_string(&repVal, &dname, &len, NULL);
356 // Device Spec Version
357 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_SPEC_VERSION, &repVal);
358 err = err || cbor_value_dup_text_string(&repVal, &specVer, &len, NULL);
359 // Data Model Version
360 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_DATA_MODEL_VERSION, &repVal);
361 err = err || cbor_value_dup_text_string(&repVal, &dmVer, &len, NULL);
365 err = err || cbor_value_advance(arrayVal);
374 OC_LOG_V(ERROR, TAG, "CBOR in error condition %d", err);
375 return OC_STACK_MALFORMED_RESPONSE;
378 *outPayload = (OCPayload*)OCDevicePayloadCreate(uri, sid, dname, specVer, dmVer);
387 return OC_STACK_NO_MEMORY;
394 OC_LOG(ERROR, TAG, PCF("Root device node was not a map"));
395 return OC_STACK_MALFORMED_RESPONSE;
400 static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* arrayVal)
404 if(cbor_value_is_map(arrayVal))
407 OCPlatformInfo info = {};
409 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_HREF, &curVal);
411 err = err || cbor_value_dup_text_string(&curVal, &uri, &len, NULL);
415 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_REPRESENTATION, &curVal);
419 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_PLATFORM_ID, &repVal);
420 err = err || cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
423 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_MFG_NAME, &repVal);
424 err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
427 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_MFG_URL, &repVal);
428 if(cbor_value_is_valid(&repVal))
430 err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
434 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_MODEL_NUM, &repVal);
435 if(cbor_value_is_valid(&repVal))
437 err = err || cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
441 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_MFG_DATE, &repVal);
442 if(cbor_value_is_valid(&repVal))
444 err = err || cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len,
449 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_PLATFORM_VERSION, &repVal);
450 if(cbor_value_is_valid(&repVal))
452 err = err || cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len,
457 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_OS_VERSION, &repVal);
458 if(cbor_value_is_valid(&repVal))
460 err = err || cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion),
465 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_HARDWARE_VERSION, &repVal);
466 if(cbor_value_is_valid(&repVal))
468 err = err || cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len,
473 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_FIRMWARE_VERSION, &repVal);
474 if(cbor_value_is_valid(&repVal))
476 err = err || cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len,
481 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_SUPPORT_URL, &repVal);
482 if(cbor_value_is_valid(&repVal))
484 err = err || cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
488 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_SYSTEM_TIME, &repVal);
489 if(cbor_value_is_valid(&repVal))
491 err = err || cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
495 err = err || cbor_value_advance(arrayVal);
499 OICFree(info.dateOfManufacture);
500 OICFree(info.firmwareVersion);
501 OICFree(info.hardwareVersion);
502 OICFree(info.manufacturerName);
503 OICFree(info.manufacturerUrl);
504 OICFree(info.modelNumber);
505 OICFree(info.operatingSystemVersion);
506 OICFree(info.platformID);
507 OICFree(info.platformVersion);
508 OICFree(info.supportUrl);
509 OICFree(info.systemTime);
510 OC_LOG(ERROR, TAG, PCF("CBOR error In ParsePlatformPayload"));
511 return OC_STACK_MALFORMED_RESPONSE;
514 *outPayload = (OCPayload*)OCPlatformPayloadCreateAsOwner(uri, &info);
518 return OC_STACK_NO_MEMORY;
525 OC_LOG(ERROR, TAG, PCF("Root device node was not a map"));
526 return OC_STACK_MALFORMED_RESPONSE;
530 static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container)
532 CborValue insideArray;
534 uint64_t tempInt = 0;
535 OCRepPayloadPropType type;
536 size_t dimensions[MAX_REP_ARRAY_DEPTH];
537 err = err || cbor_value_enter_container(container, &insideArray);
539 err = err || cbor_value_get_uint64(&insideArray, &tempInt);
540 err = err || cbor_value_advance_fixed(&insideArray);
541 type = (OCRepPayloadPropType)tempInt;
543 for(int i = 0; i < MAX_REP_ARRAY_DEPTH; ++ i)
545 err = err || cbor_value_get_uint64(&insideArray, &tempInt);
546 err = err || cbor_value_advance_fixed(&insideArray);
547 dimensions[i] = tempInt;
550 size_t dimTotal = calcDimTotal(dimensions);
559 arr = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
560 for(size_t i = 0; i < dimTotal && !err; ++i)
562 err = err || cbor_value_get_int64(&insideArray, &(((int64_t*)arr)[i]));
563 err = err || cbor_value_advance_fixed(&insideArray);
566 OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
570 err = CborUnknownError;
573 case OCREP_PROP_DOUBLE:
574 arr = (double*)OICMalloc(dimTotal * sizeof(double));
575 for(size_t i = 0; i < dimTotal && !err; ++i)
577 err = err || cbor_value_get_double(&insideArray, &(((double*)arr)[i]));
578 err = err || cbor_value_advance_fixed(&insideArray);
581 OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
585 err = CborUnknownError;
588 case OCREP_PROP_BOOL:
589 arr = (bool*)OICMalloc(dimTotal * sizeof(bool));
590 for(size_t i = 0; i < dimTotal && !err; ++i)
592 err = err || cbor_value_get_boolean(&insideArray, &(((bool*)arr)[i]));
593 err = err || cbor_value_advance_fixed(&insideArray);
596 OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
600 err = CborUnknownError;
603 case OCREP_PROP_STRING:
604 arr = (char**)OICMalloc(dimTotal * sizeof(char*));
605 for(size_t i = 0; i < dimTotal && !err; ++i)
607 err = err || cbor_value_dup_text_string(&insideArray, &tempStr, &len, NULL);
608 ((char**) arr)[i] = tempStr;
609 err = err || cbor_value_advance(&insideArray);
612 OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
616 err = CborUnknownError;
619 case OCREP_PROP_OBJECT:
620 arr = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
621 for(size_t i = 0; i < dimTotal && !err; ++i)
624 err = err || OCParseSingleRepPayload(&pl, &insideArray);
625 ((OCRepPayload**)arr)[i] = pl;
626 err = err || cbor_value_advance(&insideArray);
629 OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions))
633 err = CborUnknownError;
637 OC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
638 err = CborUnknownError;
645 static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repParent)
647 *outPayload = OCRepPayloadCreate();
648 OCRepPayload* curPayload = *outPayload;
652 return CborErrorOutOfMemory;
657 err = err || cbor_value_map_find_value(repParent, OC_RSRVD_HREF, &curVal);
658 if(cbor_value_is_valid(&curVal))
660 err = err || cbor_value_dup_text_string(&curVal, &curPayload->uri, &len,
664 err = err || cbor_value_map_find_value(repParent, OC_RSRVD_PROPERTY, &curVal);
665 if(cbor_value_is_valid(&curVal))
667 CborValue insidePropArray;
668 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE,
671 if(cbor_value_is_array(&insidePropArray))
674 err = err || cbor_value_enter_container(&insidePropArray, &rtArray);
676 while(!err && cbor_value_is_valid(&rtArray))
679 err = err || cbor_value_dup_text_string(&rtArray, &curRt, &len, NULL);
680 err = err || cbor_value_advance(&rtArray);
681 OCRepPayloadAddResourceTypeAsOwner(curPayload, curRt);
684 err = err || cbor_value_leave_container(&insidePropArray, &rtArray);
687 err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &insidePropArray);
689 if(cbor_value_is_array(&insidePropArray))
692 err = err || cbor_value_enter_container(&insidePropArray, &ifArray);
694 while(!err && cbor_value_is_valid(&ifArray))
697 err = err || cbor_value_dup_text_string(&ifArray, &curIf, &len, NULL);
698 err = err || cbor_value_advance(&ifArray);
699 OCRepPayloadAddInterfaceAsOwner(curPayload, curIf);
702 err = err || cbor_value_leave_container(&insidePropArray, &ifArray);
705 err = err || cbor_value_map_find_value(repParent, OC_RSRVD_REPRESENTATION, &curVal);
706 if(cbor_value_is_map(&curVal))
709 err = err || cbor_value_enter_container(&curVal, &repMap);
711 while(!err && cbor_value_is_valid(&repMap))
714 err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
716 err = err || cbor_value_advance(&repMap);
719 bool boolval = false;
721 double doubleval = 0;
724 switch(cbor_value_get_type(&repMap))
727 OCRepPayloadSetNull(curPayload, name);
729 case CborIntegerType:
730 err = err || cbor_value_get_int64(&repMap, &intval);
731 OCRepPayloadSetPropInt(curPayload, name, intval);
734 err = err || cbor_value_get_double(&repMap, &doubleval);
735 OCRepPayloadSetPropDouble(curPayload, name, doubleval);
737 case CborBooleanType:
738 err = err || cbor_value_get_boolean(&repMap, &boolval);
739 OCRepPayloadSetPropBool(curPayload, name, boolval);
741 case CborTextStringType:
742 err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
743 OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
746 err = err || OCParseSingleRepPayload(&pl, &repMap);
747 OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
750 err = err || OCParseArray(curPayload, name, &repMap);
753 OC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
757 err = err || cbor_value_advance(&repMap);
760 err = err || cbor_value_leave_container(&curVal, &repMap);
765 OCRepPayloadDestroy(*outPayload);
771 static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* arrayVal)
775 OCRepPayload* rootPayload = NULL;
776 OCRepPayload* curPayload = NULL;
777 OCRepPayload* temp = NULL;
778 while(!err && cbor_value_is_map(arrayVal))
780 err = err || OCParseSingleRepPayload(&temp, arrayVal);
782 if(rootPayload == NULL)
789 curPayload->next = temp;
790 curPayload = curPayload->next;
794 err = err || cbor_value_advance(arrayVal);
797 OCRepPayloadDestroy(rootPayload);
798 OC_LOG_V(ERROR, TAG, PCF("CBOR error in ParseRepPayload"));
799 return OC_STACK_MALFORMED_RESPONSE;
803 *outPayload = (OCPayload*)rootPayload;
808 static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal)
811 if(cbor_value_is_map(arrayVal))
815 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
816 char* tempStr = NULL;
821 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_NONCE, &curVal);
822 err = err || cbor_value_get_uint64(&curVal, &seqNum);
825 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TTL, &curVal);
826 err = err || cbor_value_get_uint64(&curVal, &maxAge);
829 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TRIGGER, &curVal);
830 err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
831 trigger = convertTriggerStringToEnum(tempStr);
835 // Resource type name
836 err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_RESOURCE_TYPE, &curVal);
837 if(cbor_value_is_valid(&curVal))
839 err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
842 err = err || cbor_value_advance(arrayVal);
846 *outPayload = (OCPayload*)OCPresencePayloadCreate(seqNum, maxAge, trigger, tempStr);
852 OCPayloadDestroy(*outPayload);
853 OC_LOG_V(ERROR, TAG, PCF("CBOR error Parse Presence Payload"));
854 return OC_STACK_MALFORMED_RESPONSE;
859 return OC_STACK_NO_MEMORY;
866 OC_LOG(ERROR, TAG, PCF("Root presence node was not a map"));
867 return OC_STACK_MALFORMED_RESPONSE;