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 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
22 #include "ocpayload.h"
25 #include "oic_malloc.h"
26 #include "oic_string.h"
27 #include "ocstackinternal.h"
28 #include "ocresource.h"
30 #include "rdpayload.h"
32 #define TAG "OIC_RI_PAYLOAD"
34 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
36 void OCPayloadDestroy(OCPayload* payload)
45 case PAYLOAD_TYPE_REPRESENTATION:
46 OCRepPayloadDestroy((OCRepPayload*)payload);
48 case PAYLOAD_TYPE_DISCOVERY:
49 OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload);
51 case PAYLOAD_TYPE_DEVICE:
52 OCDevicePayloadDestroy((OCDevicePayload*)payload);
54 case PAYLOAD_TYPE_PLATFORM:
55 OCPlatformPayloadDestroy((OCPlatformPayload*)payload);
57 case PAYLOAD_TYPE_PRESENCE:
58 OCPresencePayloadDestroy((OCPresencePayload*)payload);
60 case PAYLOAD_TYPE_SECURITY:
61 OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
64 OCRDPayloadDestroy((OCRDPayload*)payload);
67 OIC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
72 OCRepPayload* OCRepPayloadCreate()
74 OCRepPayload* payload = (OCRepPayload*)OICCalloc(1, sizeof(OCRepPayload));
81 payload->base.type = PAYLOAD_TYPE_REPRESENTATION;
86 void OCRepPayloadAppend(OCRepPayload* parent, OCRepPayload* child)
95 parent = parent->next;
102 static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, const char* name)
104 if (!payload || !name)
109 OCRepPayloadValue* val = payload->values;
112 if (0 == strcmp(val->name, name))
122 static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
124 if (!dest || !source)
129 size_t dimTotal = calcDimTotal(source->arr.dimensions);
130 switch(source->arr.type)
133 dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
134 memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
136 case OCREP_PROP_DOUBLE:
137 dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
138 memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
140 case OCREP_PROP_BOOL:
141 dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
142 memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
144 case OCREP_PROP_STRING:
145 dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
146 for(size_t i = 0; i < dimTotal; ++i)
148 dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
151 case OCREP_PROP_ARRAY:
152 dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
153 for(size_t i = 0; i < dimTotal; ++i)
155 dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
159 OIC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
164 static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
166 if (!source || !dest)
173 case OCREP_PROP_STRING:
174 dest->str = OICStrdup(source->str);
176 case OCREP_PROP_OBJECT:
177 dest->obj = OCRepPayloadClone(source->obj);
179 case OCREP_PROP_ARRAY:
180 OCCopyPropertyValueArray(dest, source);
183 // Nothing to do for the trivially copyable types.
188 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
195 if (val->type == OCREP_PROP_STRING)
199 else if (val->type == OCREP_PROP_BYTE_STRING)
201 OICFree(val->ocByteStr.bytes);
203 else if (val->type == OCREP_PROP_OBJECT)
205 OCRepPayloadDestroy(val->obj);
207 else if (val->type == OCREP_PROP_ARRAY)
209 size_t dimTotal = calcDimTotal(val->arr.dimensions);
210 switch(val->arr.type)
213 case OCREP_PROP_DOUBLE:
214 case OCREP_PROP_BOOL:
215 // Since this is a union, iArray will
216 // point to all of the above
217 OICFree(val->arr.iArray);
219 case OCREP_PROP_STRING:
220 for(size_t i = 0; i< dimTotal; ++i)
222 OICFree(val->arr.strArray[i]);
224 OICFree(val->arr.strArray);
226 case OCREP_PROP_BYTE_STRING:
227 for (size_t i = 0; i< dimTotal; ++i)
229 OICFree(val->arr.ocByteStrArray[i].bytes);
231 OICFree(val->arr.ocByteStrArray);
233 case OCREP_PROP_OBJECT:
234 for(size_t i = 0; i< dimTotal; ++i)
236 OCRepPayloadDestroy(val->arr.objArray[i]);
238 OICFree(val->arr.objArray);
240 case OCREP_PROP_NULL:
241 case OCREP_PROP_ARRAY:
242 OIC_LOG_V(ERROR, TAG, "FreeRepPayloadValueContents: Illegal type\
243 inside an array: %d", val->arr.type);
249 static void OCFreeRepPayloadValue(OCRepPayloadValue* val)
257 OCFreeRepPayloadValueContents(val);
258 OCFreeRepPayloadValue(val->next);
261 static OCRepPayloadValue* OCRepPayloadValueClone (OCRepPayloadValue* source)
268 OCRepPayloadValue *sourceIter = source;
269 OCRepPayloadValue *destIter = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
275 OCRepPayloadValue *headOfClone = destIter;
277 // Copy payload type and non pointer types in union.
278 *destIter = *sourceIter;
279 destIter->name = OICStrdup (sourceIter->name);
280 OCCopyPropertyValue (destIter, sourceIter);
282 sourceIter = sourceIter->next;
286 destIter->next = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
289 OCFreeRepPayloadValue (headOfClone);
293 *(destIter->next) = *sourceIter;
294 destIter->next->name = OICStrdup (sourceIter->name);
295 OCCopyPropertyValue (destIter->next, sourceIter);
297 sourceIter = sourceIter->next;
298 destIter = destIter->next;
303 static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, const char* name,
304 OCRepPayloadPropType type)
306 if (!payload || !name)
311 OCRepPayloadValue* val = payload->values;
314 payload->values = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
315 if (!payload->values)
319 payload->values->name = OICStrdup(name);
320 if (!payload->values->name)
322 OICFree(payload->values);
323 payload->values = NULL;
326 payload->values->type =type;
327 return payload->values;
332 if (0 == strcmp(val->name, name))
334 OCFreeRepPayloadValueContents(val);
338 else if (val->next == NULL)
340 val->next = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
345 val->next->name = OICStrdup(name);
346 if (!val->next->name)
352 val->next->type =type;
359 OIC_LOG(ERROR, TAG, "FindAndSetValue reached point after while loop, pointer corruption?");
363 bool OCRepPayloadAddResourceType(OCRepPayload* payload, const char* resourceType)
365 return OCRepPayloadAddResourceTypeAsOwner(payload, OICStrdup(resourceType));
368 bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceType)
370 if (!payload || !resourceType)
377 OCStringLL* cur = payload->types;
382 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
389 cur->next->value = resourceType;
394 payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
399 payload->types->value = resourceType;
404 bool OCRepPayloadAddInterface(OCRepPayload* payload, const char* interface)
406 return OCRepPayloadAddInterfaceAsOwner(payload, OICStrdup(interface));
409 bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
411 if (!payload || !interface)
416 if (payload->interfaces)
418 OCStringLL* cur = payload->interfaces;
423 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
429 cur->next->value = interface;
434 payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
435 if (!payload->interfaces)
439 payload->interfaces->value = interface;
444 bool OCRepPayloadSetUri(OCRepPayload* payload, const char* uri)
450 OICFree(payload->uri);
451 payload->uri = OICStrdup(uri);
452 return payload->uri != NULL;
455 bool OCRepPayloadIsNull(const OCRepPayload* payload, const char* name)
457 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
464 return val->type == OCREP_PROP_NULL;
467 static bool OCRepPayloadSetProp(OCRepPayload* payload, const char* name,
468 void* value, OCRepPayloadPropType type)
470 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, type);
478 val->i = *(int64_t*)value;
480 case OCREP_PROP_DOUBLE:
481 val->d = *(double*)value;
483 case OCREP_PROP_BOOL:
484 val->b = *(bool*)value;
486 case OCREP_PROP_OBJECT:
487 val->obj = (OCRepPayload*)value;
489 case OCREP_PROP_STRING:
490 val->str = (char*)value;
491 return val->str != NULL;
492 case OCREP_PROP_BYTE_STRING:
493 val->ocByteStr = *(OCByteString*)value;
495 case OCREP_PROP_NULL:
497 case OCREP_PROP_ARRAY:
505 bool OCRepPayloadSetNull(OCRepPayload* payload, const char* name)
507 return OCRepPayloadSetProp(payload, name, NULL, OCREP_PROP_NULL);
510 bool OCRepPayloadSetPropInt(OCRepPayload* payload,
511 const char* name, int64_t value)
513 return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_INT);
516 bool OCRepPayloadGetPropInt(const OCRepPayload* payload, const char* name, int64_t* value)
518 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
520 if (!val || val->type != OCREP_PROP_INT)
529 bool OCRepPayloadSetPropDouble(OCRepPayload* payload,
530 const char* name, double value)
532 return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_DOUBLE);
535 bool OCRepPayloadGetPropDouble(const OCRepPayload* payload, const char* name, double* value)
537 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
539 if (!val || val->type != OCREP_PROP_DOUBLE)
548 bool OCRepPayloadSetPropString(OCRepPayload* payload, const char* name, const char* value)
550 char* temp = OICStrdup(value);
551 bool b = OCRepPayloadSetPropStringAsOwner(payload, name, temp);
560 bool OCRepPayloadSetPropStringAsOwner(OCRepPayload* payload, const char* name, char* value)
562 return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_STRING);
565 bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, char** value)
567 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
569 if (!val || val->type != OCREP_PROP_STRING)
574 *value = OICStrdup(val->str);
575 return *value != NULL;
578 bool OCRepPayloadSetPropByteString(OCRepPayload* payload, const char* name, OCByteString value)
580 if (!value.bytes || !value.len)
585 OCByteString ocByteStr = {
586 .bytes = (uint8_t*)OICMalloc(value.len * sizeof(uint8_t)),
589 if (!ocByteStr.bytes)
593 memcpy(ocByteStr.bytes, value.bytes, ocByteStr.len);
595 bool b = OCRepPayloadSetPropByteStringAsOwner(payload, name, &ocByteStr);
599 OICFree(ocByteStr.bytes);
604 bool OCRepPayloadSetPropByteStringAsOwner(OCRepPayload* payload, const char* name, OCByteString* value)
606 return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_BYTE_STRING);
609 bool OCRepPayloadGetPropByteString(const OCRepPayload* payload, const char* name, OCByteString* value)
611 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
613 if (!val || val->type != OCREP_PROP_BYTE_STRING)
623 value->bytes = (uint8_t*)OICMalloc(val->ocByteStr.len * sizeof(uint8_t));
628 value->len = val->ocByteStr.len;
629 memcpy(value->bytes, val->ocByteStr.bytes, value->len);
634 bool OCRepPayloadSetPropBool(OCRepPayload* payload,
635 const char* name, bool value)
637 return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_BOOL);
640 bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool* value)
642 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
644 if (!val || val->type != OCREP_PROP_BOOL)
653 bool OCRepPayloadSetPropObject(OCRepPayload* payload, const char* name, const OCRepPayload* value)
655 OCRepPayload* temp = OCRepPayloadClone(value);
656 bool b = OCRepPayloadSetPropObjectAsOwner(payload, name, temp);
660 OCRepPayloadDestroy(temp);
665 bool OCRepPayloadSetPropObjectAsOwner(OCRepPayload* payload, const char* name, OCRepPayload* value)
667 return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_OBJECT);
670 bool OCRepPayloadGetPropObject(const OCRepPayload* payload, const char* name, OCRepPayload** value)
672 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
674 if (!val || val->type != OCREP_PROP_OBJECT)
679 *value = OCRepPayloadClone(val->obj);
680 return *value != NULL;
683 size_t calcDimTotal(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
685 if (dimensions[0] == 0)
691 for(uint8_t i = 0; i < MAX_REP_ARRAY_DEPTH && dimensions[i] != 0; ++i)
693 total *= dimensions[i];
699 bool OCRepPayloadSetByteStringArrayAsOwner(OCRepPayload* payload, const char* name,
700 OCByteString* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
702 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
709 val->arr.type = OCREP_PROP_BYTE_STRING;
710 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
711 val->arr.ocByteStrArray = array;
716 bool OCRepPayloadSetByteStringArray(OCRepPayload* payload, const char* name,
717 const OCByteString* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
724 size_t dimTotal = calcDimTotal(dimensions);
730 OCByteString* newArray = (OCByteString*)OICCalloc(dimTotal, sizeof(OCByteString));
737 for (size_t i = 0; i < dimTotal; ++i)
739 newArray[i].bytes = (uint8_t*)OICMalloc(array[i].len * sizeof(uint8_t));
740 if (NULL == newArray[i].bytes)
742 for (size_t j = 0; j < i; ++j)
744 OICFree(newArray[j].bytes);
750 newArray[i].len = array[i].len;
751 memcpy(newArray[i].bytes, array[i].bytes, newArray[i].len);
754 bool b = OCRepPayloadSetByteStringArrayAsOwner(payload, name, newArray, dimensions);
757 for (size_t i = 0; i < dimTotal; ++i)
759 OICFree(newArray[i].bytes);
767 bool OCRepPayloadGetByteStringArray(const OCRepPayload* payload, const char* name,
768 OCByteString** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
770 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
772 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BYTE_STRING
773 || !val->arr.ocByteStrArray)
778 size_t dimTotal = calcDimTotal(val->arr.dimensions);
784 *array = (OCByteString*)OICCalloc(dimTotal, sizeof(OCByteString));
790 for (size_t i = 0; i < dimTotal; ++i)
792 OCByteString* tmp = &(*array)[i];
793 tmp->bytes = (uint8_t*)OICMalloc(val->arr.ocByteStrArray[i].len * sizeof(uint8_t));
794 if (NULL == tmp->bytes)
796 for (size_t j = 0; j < i; ++j)
798 OCByteString* tmp = &(*array)[j];
806 tmp->len = val->arr.ocByteStrArray[i].len;
807 memcpy(tmp->bytes, val->arr.ocByteStrArray[i].bytes, tmp->len);
810 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
815 bool OCRepPayloadSetIntArrayAsOwner(OCRepPayload* payload, const char* name,
816 int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
818 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
825 val->arr.type = OCREP_PROP_INT;
826 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
827 val->arr.iArray = array;
832 bool OCRepPayloadSetIntArray(OCRepPayload* payload, const char* name,
833 const int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
835 size_t dimTotal = calcDimTotal(dimensions);
841 int64_t* newArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
848 memcpy(newArray, array, dimTotal * sizeof(int64_t));
851 bool b = OCRepPayloadSetIntArrayAsOwner(payload, name, newArray, dimensions);
859 bool OCRepPayloadGetIntArray(const OCRepPayload* payload, const char* name,
860 int64_t** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
862 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
864 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
870 size_t dimTotal = calcDimTotal(val->arr.dimensions);
875 *array = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
881 memcpy(*array, val->arr.iArray, dimTotal * sizeof(int64_t));
882 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
886 bool OCRepPayloadSetDoubleArrayAsOwner(OCRepPayload* payload, const char* name,
887 double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
889 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
896 val->arr.type = OCREP_PROP_DOUBLE;
897 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
898 val->arr.dArray = array;
902 bool OCRepPayloadSetDoubleArray(OCRepPayload* payload, const char* name,
903 const double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
905 size_t dimTotal = calcDimTotal(dimensions);
911 double* newArray = (double*)OICMalloc(dimTotal * sizeof(double));
918 memcpy(newArray, array, dimTotal * sizeof(double));
920 bool b = OCRepPayloadSetDoubleArrayAsOwner(payload, name, newArray, dimensions);
928 bool OCRepPayloadGetDoubleArray(const OCRepPayload* payload, const char* name,
929 double** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
931 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
933 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_DOUBLE
939 size_t dimTotal = calcDimTotal(val->arr.dimensions);
944 *array = (double*)OICMalloc(dimTotal * sizeof(double));
950 memcpy(*array, val->arr.dArray, dimTotal * sizeof(double));
951 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
955 bool OCRepPayloadSetStringArrayAsOwner(OCRepPayload* payload, const char* name,
956 char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
958 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
965 val->arr.type = OCREP_PROP_STRING;
966 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
967 val->arr.strArray = array;
971 bool OCRepPayloadSetStringArray(OCRepPayload* payload, const char* name,
972 const char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
974 size_t dimTotal = calcDimTotal(dimensions);
980 char** newArray = (char**)OICMalloc(dimTotal * sizeof(char*));
987 for(size_t i = 0; i < dimTotal; ++i)
989 newArray[i] = OICStrdup(array[i]);
992 bool b = OCRepPayloadSetStringArrayAsOwner(payload, name, newArray, dimensions);
996 for(size_t i = 0; i < dimTotal; ++i)
998 OICFree(newArray[i]);
1005 bool OCRepPayloadGetStringArray(const OCRepPayload* payload, const char* name,
1006 char*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1008 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1010 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
1011 || !val->arr.strArray)
1016 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1021 *array = (char**)OICMalloc(dimTotal * sizeof(char*));
1027 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1029 for(size_t i = 0; i < dimTotal; ++i)
1031 (*array)[i] = OICStrdup(val->arr.strArray[i]);
1038 bool OCRepPayloadSetBoolArrayAsOwner(OCRepPayload* payload, const char* name,
1039 bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1042 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
1049 val->arr.type = OCREP_PROP_BOOL;
1050 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1051 val->arr.bArray = array;
1055 bool OCRepPayloadSetBoolArray(OCRepPayload* payload, const char* name,
1056 const bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1058 size_t dimTotal = calcDimTotal(dimensions);
1064 bool* newArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
1071 memcpy(newArray, array, dimTotal * sizeof(bool));
1074 bool b = OCRepPayloadSetBoolArrayAsOwner(payload, name, newArray, dimensions);
1082 bool OCRepPayloadGetBoolArray(const OCRepPayload* payload, const char* name,
1083 bool** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1085 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1087 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
1088 || !val->arr.bArray)
1093 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1098 *array = (bool*)OICMalloc(dimTotal * sizeof(bool));
1104 memcpy(*array, val->arr.bArray, dimTotal * sizeof(bool));
1105 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1109 bool OCRepPayloadSetPropObjectArrayAsOwner(OCRepPayload* payload, const char* name,
1110 OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1112 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
1119 val->arr.type = OCREP_PROP_OBJECT;
1120 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1121 val->arr.objArray = array;
1126 bool OCRepPayloadSetPropObjectArray(OCRepPayload* payload, const char* name,
1127 const OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1129 size_t dimTotal = calcDimTotal(dimensions);
1135 OCRepPayload** newArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
1142 for(size_t i = 0; i < dimTotal; ++i)
1144 newArray[i] = OCRepPayloadClone(array[i]);
1147 bool b = OCRepPayloadSetPropObjectArrayAsOwner(payload, name, newArray, dimensions);
1151 for(size_t i = 0; i < dimTotal; ++i)
1153 OCRepPayloadDestroy(newArray[i]);
1160 bool OCRepPayloadGetPropObjectArray(const OCRepPayload* payload, const char* name,
1161 OCRepPayload*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1163 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1165 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
1166 || !val->arr.objArray)
1171 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1176 *array = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
1182 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1184 for(size_t i = 0; i < dimTotal; ++i)
1186 (*array)[i] = OCRepPayloadClone(val->arr.objArray[i]);
1192 void OCFreeOCStringLL(OCStringLL* ll)
1199 OCFreeOCStringLL(ll->next);
1204 OCStringLL* CloneOCStringLL (OCStringLL* ll)
1211 OCStringLL *sourceIter = ll;
1213 OCStringLL *destIter = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1218 destIter->value = OICStrdup (sourceIter->value);
1220 OCStringLL *headOfClone = destIter;
1222 sourceIter = sourceIter->next;
1226 destIter->next = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1227 if (!destIter->next)
1229 OCFreeOCStringLL (headOfClone);
1232 destIter->next->value = OICStrdup (sourceIter->value);
1234 destIter = destIter->next;
1235 sourceIter = sourceIter->next;
1240 OCRepPayload* OCRepPayloadClone (const OCRepPayload* payload)
1247 OCRepPayload *clone = OCRepPayloadCreate();
1254 clone->uri = OICStrdup (payload->uri);
1255 clone->types = CloneOCStringLL (payload->types);
1256 clone->interfaces = CloneOCStringLL (payload->interfaces);
1257 clone->values = OCRepPayloadValueClone (payload->values);
1263 void OCRepPayloadDestroy(OCRepPayload* payload)
1270 OICFree(payload->uri);
1271 OCFreeOCStringLL(payload->types);
1272 OCFreeOCStringLL(payload->interfaces);
1273 OCFreeRepPayloadValue(payload->values);
1274 OCRepPayloadDestroy(payload->next);
1278 OCDiscoveryPayload* OCDiscoveryPayloadCreate()
1280 OCDiscoveryPayload* payload = (OCDiscoveryPayload*)OICCalloc(1, sizeof(OCDiscoveryPayload));
1287 payload->base.type = PAYLOAD_TYPE_DISCOVERY;
1292 //TODO : Remove this once all cbor changes land.
1293 OCSecurityPayload* OCSecurityPayloadCreate(const char* securityData)
1295 OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1302 payload->base.type = PAYLOAD_TYPE_SECURITY;
1303 payload->securityData = OICStrdup(securityData);
1308 // TODO : To convert this to OCSecurityPayloadCreate once all cbor changes land.
1309 OCSecurityPayload* OCSecurityPayloadCBORCreate(const uint8_t* securityData, size_t size)
1311 OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1318 payload->base.type = PAYLOAD_TYPE_SECURITY;
1319 payload->securityData1 = (uint8_t *)OICCalloc(1, size);
1320 if (!payload->securityData1)
1325 memcpy(payload->securityData1, (uint8_t *)securityData, size);
1326 payload->payloadSize = size;
1331 void OCSecurityPayloadDestroy(OCSecurityPayload* payload)
1337 // Remove this once all cbor changes land.
1338 OICFree(payload->securityData);
1339 // OICFree(payload->securityData1);
1343 size_t OCDiscoveryPayloadGetResourceCount(OCDiscoveryPayload* payload)
1346 OCResourcePayload* p = payload->resources;
1355 OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, size_t index)
1358 OCResourcePayload* p = payload->resources;
1371 static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
1373 OCResourcePayload* pl = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1379 pl->uri = OICStrdup(res->uri);
1383 OCDiscoveryResourceDestroy(pl);
1388 OCResourceType* typePtr = res->rsrcType;
1390 if (typePtr != NULL)
1392 pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1395 OCDiscoveryResourceDestroy(pl);
1398 pl->types->value = OICStrdup(typePtr->resourcetypename);
1399 if (!pl->types->value)
1401 OCDiscoveryResourceDestroy(pl);
1405 OCStringLL* cur = pl->types;
1406 typePtr = typePtr->next;
1409 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1412 OCDiscoveryResourceDestroy(pl);
1415 cur->next->value = OICStrdup(typePtr->resourcetypename);
1416 if (!cur->next->value)
1418 OCDiscoveryResourceDestroy(pl);
1422 typePtr = typePtr->next;
1427 OCResourceInterface* ifPtr = res->rsrcInterface;
1430 pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1431 if (!pl->interfaces)
1433 OCDiscoveryResourceDestroy(pl);
1436 pl->interfaces->value = OICStrdup(ifPtr->name);
1437 if (!pl->interfaces->value)
1439 OCDiscoveryResourceDestroy(pl);
1443 OCStringLL* cur = pl->interfaces;
1444 ifPtr = ifPtr->next;
1447 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1450 OCDiscoveryResourceDestroy(pl);
1453 cur->next->value = OICStrdup(ifPtr->name);
1454 if (!cur->next->value)
1456 OCDiscoveryResourceDestroy(pl);
1460 ifPtr = ifPtr->next;
1464 pl->bitmap = res->resourceProperties & (OC_OBSERVABLE | OC_DISCOVERABLE);
1465 pl->secure = (res->resourceProperties & OC_SECURE) != 0;
1471 void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
1474 OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
1477 bool OCResourcePayloadAddStringLL(OCStringLL **stringLL, const char *value)
1479 char *dup = OICStrdup(value);
1480 VERIFY_PARAM_NON_NULL(TAG, dup, "Failed copying string");
1481 VERIFY_PARAM_NON_NULL(TAG, value, "Invalid Parameters");
1485 *stringLL = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
1486 VERIFY_PARAM_NON_NULL(TAG, dup, "Failed allocating memory");
1487 (*stringLL)->value = dup;
1492 OCStringLL *temp = *stringLL;
1497 temp->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
1498 VERIFY_PARAM_NON_NULL(TAG, temp->next, "Failed allocating memory");
1499 temp->next->value = dup;
1507 void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res)
1514 if (!payload->resources)
1516 payload->resources = res;
1520 OCResourcePayload* p = payload->resources;
1529 void OCDiscoveryResourceDestroy(OCResourcePayload* payload)
1536 OICFree(payload->uri);
1537 OCFreeOCStringLL(payload->types);
1538 OCFreeOCStringLL(payload->interfaces);
1539 OCDiscoveryResourceDestroy(payload->next);
1543 void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
1549 OICFree(payload->sid);
1550 OCDiscoveryResourceDestroy(payload->resources);
1554 OCDevicePayload* OCDevicePayloadCreate(const char* sid, const char* dname,
1555 const OCStringLL *types, const char* specVer, const char* dmVer)
1558 OCDevicePayload* payload = (OCDevicePayload*)OICCalloc(1, sizeof(OCDevicePayload));
1565 payload->base.type = PAYLOAD_TYPE_DEVICE;
1566 payload->sid = OICStrdup(sid);
1567 if (sid && !payload->sid)
1572 payload->deviceName = OICStrdup(dname);
1573 if (dname && !payload->deviceName)
1578 payload->specVersion = OICStrdup(specVer);
1579 if (specVer && !payload->specVersion)
1584 payload->dataModelVersion = OICStrdup(dmVer);
1585 if (dmVer && !payload->dataModelVersion)
1590 payload->types = CloneOCStringLL((OCStringLL *)types);
1591 if (types && !payload->types)
1599 OCDevicePayloadDestroy((OCDevicePayload*)payload);
1603 void OCDevicePayloadDestroy(OCDevicePayload* payload)
1610 OICFree(payload->sid);
1611 OICFree(payload->deviceName);
1612 OICFree(payload->specVersion);
1613 OICFree(payload->dataModelVersion);
1614 OCFreeOCStringLL(payload->types);
1618 static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
1620 if (!platformInfo || !target)
1625 target->info.platformID = OICStrdup(platformInfo->platformID);
1626 target->info.manufacturerName = OICStrdup(platformInfo->manufacturerName);
1627 target->info.manufacturerUrl = OICStrdup(platformInfo->manufacturerUrl);
1628 target->info.modelNumber = OICStrdup(platformInfo->modelNumber);
1629 target->info.dateOfManufacture = OICStrdup(platformInfo->dateOfManufacture);
1630 target->info.platformVersion = OICStrdup(platformInfo->platformVersion);
1631 target->info.operatingSystemVersion = OICStrdup(platformInfo->operatingSystemVersion);
1632 target->info.hardwareVersion = OICStrdup(platformInfo->hardwareVersion);
1633 target->info.firmwareVersion = OICStrdup(platformInfo->firmwareVersion);
1634 target->info.supportUrl = OICStrdup(platformInfo->supportUrl);
1635 target->info.systemTime = OICStrdup(platformInfo->systemTime);
1638 OCPlatformPayload* OCPlatformPayloadCreateAsOwner(OCPlatformInfo* platformInfo)
1640 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
1646 payload->base.type = PAYLOAD_TYPE_PLATFORM;
1648 payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1649 if (!payload->interfaces)
1653 payload->interfaces->value = OICStrdup(OC_RSRVD_INTERFACE_READ);
1654 payload->rt = OICStrdup(OC_RSRVD_RESOURCE_TYPE_PLATFORM);
1655 payload->info = *platformInfo;
1660 OCPlatformPayload* OCPlatformPayloadCreate(const OCPlatformInfo* platformInfo)
1662 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
1669 payload->base.type = PAYLOAD_TYPE_PLATFORM;
1671 payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1672 if (!payload->interfaces)
1676 payload->interfaces->value = OICStrdup(OC_RSRVD_INTERFACE_READ);
1677 payload->rt = OICStrdup(OC_RSRVD_RESOURCE_TYPE_PLATFORM);
1678 OCCopyPlatformInfo(platformInfo, payload);
1683 void OCPlatformInfoDestroy(OCPlatformInfo *info)
1685 OICFree(info->platformID);
1686 OICFree(info->manufacturerName);
1687 OICFree(info->manufacturerUrl);
1688 OICFree(info->modelNumber);
1689 OICFree(info->dateOfManufacture);
1690 OICFree(info->platformVersion);
1691 OICFree(info->operatingSystemVersion);
1692 OICFree(info->hardwareVersion);
1693 OICFree(info->firmwareVersion);
1694 OICFree(info->supportUrl);
1695 OICFree(info->systemTime);
1698 void OCPlatformPayloadDestroy(OCPlatformPayload* payload)
1704 OICFree(payload->uri);
1705 OCPlatformInfoDestroy(&payload->info);
1706 OICFree(payload->rt);
1707 OCFreeOCStringLL(payload->interfaces);
1711 OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
1712 OCPresenceTrigger trigger, const char* resourceType)
1714 OCPresencePayload* payload = (OCPresencePayload*)OICCalloc(1, sizeof(OCPresencePayload));
1720 payload->base.type = PAYLOAD_TYPE_PRESENCE;
1721 payload->sequenceNumber = seqNum;
1722 payload->maxAge = maxAge;
1723 payload->trigger = trigger;
1724 payload->resourceType = OICStrdup(resourceType);
1728 void OCPresencePayloadDestroy(OCPresencePayload* payload)
1734 OICFree(payload->resourceType);