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"
31 #define TAG "OCPayload"
32 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
34 void OCPayloadDestroy(OCPayload* payload)
43 case PAYLOAD_TYPE_REPRESENTATION:
44 OCRepPayloadDestroy((OCRepPayload*)payload);
46 case PAYLOAD_TYPE_DISCOVERY:
47 OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload);
49 case PAYLOAD_TYPE_DEVICE:
50 OCDevicePayloadDestroy((OCDevicePayload*)payload);
52 case PAYLOAD_TYPE_PLATFORM:
53 OCPlatformPayloadDestroy((OCPlatformPayload*)payload);
55 case PAYLOAD_TYPE_PRESENCE:
56 OCPresencePayloadDestroy((OCPresencePayload*)payload);
58 case PAYLOAD_TYPE_SECURITY:
59 OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
62 OC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
67 OCRepPayload* OCRepPayloadCreate()
69 OCRepPayload* payload = (OCRepPayload*)OICCalloc(1, sizeof(OCRepPayload));
76 payload->base.type = PAYLOAD_TYPE_REPRESENTATION;
81 void OCRepPayloadAppend(OCRepPayload* parent, OCRepPayload* child)
90 parent = parent->next;
96 static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, const char* name)
103 OCRepPayloadValue* val = payload->values;
106 if(0 == strcmp(val->name, name))
117 static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
119 size_t dimTotal = calcDimTotal(source->arr.dimensions);
120 switch(source->arr.type)
123 dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
124 memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
126 case OCREP_PROP_DOUBLE:
127 dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
128 memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
130 case OCREP_PROP_BOOL:
131 dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
132 memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
134 case OCREP_PROP_STRING:
135 dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
136 for(size_t i = 0; i < dimTotal; ++i)
138 dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
141 case OCREP_PROP_ARRAY:
142 dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
143 for(size_t i = 0; i < dimTotal; ++i)
145 dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
149 OC_LOG(ERROR, TAG, PCF("CopyPropertyValueArray invalid type"));
154 static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
156 if (!source || !dest)
163 case OCREP_PROP_STRING:
164 dest->str = OICStrdup(source->str);
166 case OCREP_PROP_OBJECT:
167 dest->obj = OCRepPayloadClone(source->obj);
169 case OCREP_PROP_ARRAY:
170 OCCopyPropertyValueArray(dest, source);
173 // Nothing to do for the trivially copyable types.
178 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
185 if(val->type == OCREP_PROP_STRING)
189 else if (val->type == OCREP_PROP_OBJECT)
191 OCRepPayloadDestroy(val->obj);
193 else if (val->type == OCREP_PROP_ARRAY)
195 size_t dimTotal = calcDimTotal(val->arr.dimensions);
196 switch(val->arr.type)
199 case OCREP_PROP_DOUBLE:
200 case OCREP_PROP_BOOL:
201 // Since this is a union, iArray will
202 // point to all of the above
203 OICFree(val->arr.iArray);
205 case OCREP_PROP_STRING:
206 for(size_t i = 0; i< dimTotal;++i)
208 OICFree(val->arr.strArray[i]);
210 OICFree(val->arr.strArray);
212 case OCREP_PROP_OBJECT:
213 for(size_t i = 0; i< dimTotal;++i)
215 OCRepPayloadDestroy(val->arr.objArray[i]);
217 OICFree(val->arr.objArray);
219 case OCREP_PROP_NULL:
220 case OCREP_PROP_ARRAY:
221 OC_LOG_V(ERROR, TAG, "FreeRepPayloadValueContents: Illegal type\
222 inside an array: %d", val->arr.type);
228 static void OCFreeRepPayloadValue(OCRepPayloadValue* val)
236 OCFreeRepPayloadValueContents(val);
237 OCFreeRepPayloadValue(val->next);
240 static OCRepPayloadValue* OCRepPayloadValueClone (OCRepPayloadValue* source)
247 OCRepPayloadValue *sourceIter = source;
248 OCRepPayloadValue *destIter = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
254 OCRepPayloadValue *headOfClone = destIter;
256 // Copy payload type and non pointer types in union.
257 *destIter = *sourceIter;
258 destIter->name = OICStrdup (sourceIter->name);
259 OCCopyPropertyValue (destIter, sourceIter);
261 sourceIter = sourceIter->next;
265 destIter->next = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
268 OCFreeRepPayloadValue (headOfClone);
272 *(destIter->next) = *sourceIter;
273 destIter->next->name = OICStrdup (sourceIter->name);
274 OCCopyPropertyValue (destIter->next, sourceIter);
276 sourceIter = sourceIter->next;
277 destIter = destIter->next;
282 static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, const char* name,
283 OCRepPayloadPropType type)
285 if(!payload || !name)
290 OCRepPayloadValue* val = payload->values;
293 payload->values = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
294 payload->values->name = OICStrdup(name);
295 payload->values->type =type;
296 return payload->values;
301 if(0 == strcmp(val->name, name))
303 OCFreeRepPayloadValueContents(val);
307 else if(val->next == NULL)
309 val->next = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
310 val->next->name = OICStrdup(name);
311 val->next->type =type;
318 OC_LOG(ERROR, TAG, PCF("FindAndSetValue reached point after while loop, pointer corruption?"));
322 bool OCRepPayloadAddResourceType(OCRepPayload* payload, const char* resourceType)
324 return OCRepPayloadAddResourceTypeAsOwner(payload, OICStrdup(resourceType));
327 bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceType)
329 if(!payload || !resourceType)
336 OCStringLL* cur = payload->types;
341 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
348 cur->next->value = resourceType;
353 payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
358 payload->types->value = resourceType;
363 bool OCRepPayloadAddInterface(OCRepPayload* payload, const char* interface)
365 return OCRepPayloadAddInterfaceAsOwner(payload, OICStrdup(interface));
368 bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
370 if(!payload || !interface)
375 if(payload->interfaces)
377 OCStringLL* cur = payload->interfaces;
382 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
388 cur->next->value = interface;
393 payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
394 if(!payload->interfaces)
398 payload->interfaces->value = interface;
403 bool OCRepPayloadSetUri(OCRepPayload* payload, const char* uri)
410 payload->uri = OICStrdup(uri);
411 return payload->uri != NULL;
414 bool OCRepPayloadIsNull(const OCRepPayload* payload, const char* name)
416 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
423 return val->type == OCREP_PROP_NULL;
426 bool OCRepPayloadSetNull(OCRepPayload* payload, const char* name)
428 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_NULL);
432 bool OCRepPayloadSetPropInt(OCRepPayload* payload,
433 const char* name, int64_t value)
435 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_INT);
446 bool OCRepPayloadGetPropInt(const OCRepPayload* payload, const char* name, int64_t* value)
448 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
450 if(!val || val->type != OCREP_PROP_INT)
459 bool OCRepPayloadSetPropDouble(OCRepPayload* payload,
460 const char* name, double value)
462 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_DOUBLE);
473 bool OCRepPayloadGetPropDouble(const OCRepPayload* payload, const char* name, double* value)
475 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
477 if(!val || val->type != OCREP_PROP_DOUBLE)
486 bool OCRepPayloadSetPropString(OCRepPayload* payload, const char* name, const char* value)
488 char* temp = OICStrdup(value);
489 bool b = OCRepPayloadSetPropStringAsOwner(payload, name, temp);
498 bool OCRepPayloadSetPropStringAsOwner(OCRepPayload* payload, const char* name, char* value)
500 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_STRING);
508 return val->str != NULL;
511 bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, const char** value)
513 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
515 if(!val || val->type != OCREP_PROP_STRING)
520 *value = OICStrdup(val->str);
521 return *value != NULL;
524 bool OCRepPayloadSetPropBool(OCRepPayload* payload,
525 const char* name, bool value)
527 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_BOOL);
538 bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool* value)
540 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
542 if(!val || val->type != OCREP_PROP_BOOL)
551 bool OCRepPayloadSetPropObject(OCRepPayload* payload, const char* name, const OCRepPayload* value)
553 OCRepPayload* temp = OCRepPayloadClone(value);
554 bool b = OCRepPayloadSetPropObjectAsOwner(payload, name, temp);
558 OCRepPayloadDestroy(temp);
563 bool OCRepPayloadSetPropObjectAsOwner(OCRepPayload* payload, const char* name, OCRepPayload* value)
565 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_OBJECT);
576 bool OCRepPayloadGetPropObject(const OCRepPayload* payload, const char* name, OCRepPayload** value)
578 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
580 if(!val || val->type != OCREP_PROP_OBJECT)
585 *value = OCRepPayloadClone(val->obj);
586 return *value != NULL;
589 size_t calcDimTotal(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
591 if(dimensions[0] == 0)
597 for(uint8_t i = 0; i < MAX_REP_ARRAY_DEPTH && dimensions[i] != 0; ++i)
599 total *= dimensions[i];
604 bool OCRepPayloadSetIntArrayAsOwner(OCRepPayload* payload, const char* name,
605 int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
607 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
614 val->arr.type = OCREP_PROP_INT;
615 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
616 val->arr.iArray = array;
621 bool OCRepPayloadSetIntArray(OCRepPayload* payload, const char* name,
622 const int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
624 size_t dimTotal = calcDimTotal(dimensions);
630 int64_t* newArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
637 memcpy(newArray, array, dimTotal * sizeof(int64_t));
640 bool b = OCRepPayloadSetIntArrayAsOwner(payload, name, newArray, dimensions);
648 bool OCRepPayloadGetIntArray(const OCRepPayload* payload, const char* name,
649 int64_t** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
651 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
653 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
659 size_t dimTotal = calcDimTotal(val->arr.dimensions);
664 *array = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
670 memcpy(*array, val->arr.iArray, dimTotal * sizeof(int64_t));
671 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
675 bool OCRepPayloadSetDoubleArrayAsOwner(OCRepPayload* payload, const char* name,
676 double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
678 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
685 val->arr.type = OCREP_PROP_DOUBLE;
686 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
687 val->arr.dArray = array;
691 bool OCRepPayloadSetDoubleArray(OCRepPayload* payload, const char* name,
692 const double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
694 size_t dimTotal = calcDimTotal(dimensions);
700 double* newArray = (double*)OICMalloc(dimTotal * sizeof(double));
707 memcpy(newArray, array, dimTotal * sizeof(double));
709 bool b = OCRepPayloadSetDoubleArrayAsOwner(payload, name, newArray, dimensions);
717 bool OCRepPayloadGetDoubleArray(const OCRepPayload* payload, const char* name,
718 double** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
720 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
722 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_DOUBLE
728 size_t dimTotal = calcDimTotal(val->arr.dimensions);
733 *array = (double*)OICMalloc(dimTotal * sizeof(double));
739 memcpy(*array, val->arr.dArray, dimTotal * sizeof(double));
740 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
744 bool OCRepPayloadSetStringArrayAsOwner(OCRepPayload* payload, const char* name,
745 char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
747 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
754 val->arr.type = OCREP_PROP_STRING;
755 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
756 val->arr.strArray = array;
760 bool OCRepPayloadSetStringArray(OCRepPayload* payload, const char* name,
761 const char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
763 size_t dimTotal = calcDimTotal(dimensions);
769 char** newArray = (char**)OICMalloc(dimTotal * sizeof(char*));
776 for(size_t i = 0; i < dimTotal; ++i)
778 newArray[i] = OICStrdup(array[i]);
781 bool b = OCRepPayloadSetStringArrayAsOwner(payload, name, newArray, dimensions);
785 for(size_t i = 0; i < dimTotal; ++i)
787 OICFree(newArray[i]);
794 bool OCRepPayloadGetStringArray(const OCRepPayload* payload, const char* name,
795 char*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
797 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
799 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
800 || !val->arr.strArray)
805 size_t dimTotal = calcDimTotal(val->arr.dimensions);
810 *array = (char**)OICMalloc(dimTotal * sizeof(char*));
816 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
818 for(size_t i = 0; i < dimTotal; ++i)
820 (*array)[i] = OICStrdup(val->arr.strArray[i]);
827 bool OCRepPayloadSetBoolArrayAsOwner(OCRepPayload* payload, const char* name,
828 bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
831 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
838 val->arr.type = OCREP_PROP_BOOL;
839 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
840 val->arr.bArray = array;
844 bool OCRepPayloadSetBoolArray(OCRepPayload* payload, const char* name,
845 const bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
847 size_t dimTotal = calcDimTotal(dimensions);
853 bool* newArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
860 memcpy(newArray, array, dimTotal * sizeof(bool));
863 bool b = OCRepPayloadSetBoolArrayAsOwner(payload, name, newArray, dimensions);
871 bool OCRepPayloadGetBoolArray(const OCRepPayload* payload, const char* name,
872 bool** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
874 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
876 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
882 size_t dimTotal = calcDimTotal(val->arr.dimensions);
887 *array = (bool*)OICMalloc(dimTotal * sizeof(bool));
893 memcpy(*array, val->arr.bArray, dimTotal * sizeof(bool));
894 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
898 bool OCRepPayloadSetPropObjectArrayAsOwner(OCRepPayload* payload, const char* name,
899 OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
901 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
908 val->arr.type = OCREP_PROP_OBJECT;
909 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
910 val->arr.objArray = array;
915 bool OCRepPayloadSetPropObjectArray(OCRepPayload* payload, const char* name,
916 const OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
918 size_t dimTotal = calcDimTotal(dimensions);
924 OCRepPayload** newArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
931 for(size_t i = 0; i < dimTotal; ++i)
933 newArray[i] = OCRepPayloadClone(array[i]);
936 bool b = OCRepPayloadSetPropObjectArrayAsOwner(payload, name, newArray, dimensions);
940 for(size_t i = 0; i < dimTotal; ++i)
942 OCRepPayloadDestroy(newArray[i]);
949 bool OCRepPayloadGetPropObjectArray(const OCRepPayload* payload, const char* name,
950 OCRepPayload*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
952 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
954 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
955 || !val->arr.objArray)
960 size_t dimTotal = calcDimTotal(val->arr.dimensions);
965 *array = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
971 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
973 for(size_t i = 0; i < dimTotal; ++i)
975 (*array)[i] = OCRepPayloadClone(val->arr.objArray[i]);
981 void OCFreeOCStringLL(OCStringLL* ll)
988 OCFreeOCStringLL(ll->next);
993 OCStringLL* CloneOCStringLL (OCStringLL* ll)
1000 OCStringLL *sourceIter = ll;
1002 OCStringLL *destIter = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1007 destIter->value = OICStrdup (sourceIter->value);
1009 OCStringLL *headOfClone = destIter;
1011 sourceIter = sourceIter->next;
1015 destIter->next = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1016 if (!destIter->next)
1018 OCFreeOCStringLL (headOfClone);
1021 destIter->next->value = OICStrdup (sourceIter->value);
1023 destIter = destIter->next;
1024 sourceIter = sourceIter->next;
1029 OCRepPayload* OCRepPayloadClone (const OCRepPayload* payload)
1036 OCRepPayload *clone = OCRepPayloadCreate();
1043 clone->uri = OICStrdup (payload->uri);
1044 clone->types = CloneOCStringLL (payload->types);
1045 clone->interfaces = CloneOCStringLL (payload->interfaces);
1046 clone->values = OCRepPayloadValueClone (payload->values);
1052 void OCRepPayloadDestroy(OCRepPayload* payload)
1059 OICFree(payload->uri);
1060 OCFreeOCStringLL(payload->types);
1061 OCFreeOCStringLL(payload->interfaces);
1062 OCFreeRepPayloadValue(payload->values);
1063 OCRepPayloadDestroy(payload->next);
1067 OCDiscoveryPayload* OCDiscoveryPayloadCreate()
1069 OCDiscoveryPayload* payload = (OCDiscoveryPayload*)OICCalloc(1, sizeof(OCDiscoveryPayload));
1076 payload->base.type = PAYLOAD_TYPE_DISCOVERY;
1081 OCSecurityPayload* OCSecurityPayloadCreate(char* securityData)
1083 OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1090 payload->base.type = PAYLOAD_TYPE_SECURITY;
1091 payload->securityData = OICStrdup(securityData);
1096 void OCSecurityPayloadDestroy(OCSecurityPayload* payload)
1103 OICFree(payload->securityData);
1107 size_t OCDiscoveryPayloadGetResourceCount(OCDiscoveryPayload* payload)
1110 OCResourcePayload* p = payload->resources;
1119 OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, size_t index)
1122 OCResourcePayload* p = payload->resources;
1135 static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
1137 OCResourcePayload* pl = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1143 pl->uri = OICStrdup(res->uri);
1144 pl->sid = (uint8_t*)OICCalloc(1, UUID_SIZE);
1145 memcpy(pl->sid, OCGetServerInstanceID(), UUID_SIZE);
1148 OCResourceType* typePtr = res->rsrcType;
1152 pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1153 pl->types->value = OICStrdup(typePtr->resourcetypename);
1155 OCStringLL* cur = pl->types;
1156 typePtr = typePtr->next;
1159 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1160 cur->next->value = OICStrdup(typePtr->resourcetypename);
1162 typePtr = typePtr->next;
1167 OCResourceInterface* ifPtr = res->rsrcInterface;
1170 pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1171 pl->interfaces->value = OICStrdup(ifPtr->name);
1173 OCStringLL* cur = pl->interfaces;
1174 ifPtr = ifPtr->next;
1177 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1178 cur->next->value = OICStrdup(ifPtr->name);
1180 ifPtr = ifPtr->next;
1184 pl->bitmap = res->resourceProperties & (OC_OBSERVABLE | OC_DISCOVERABLE);
1185 pl->secure = (res->resourceProperties & OC_SECURE) != 0;
1191 void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
1194 OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
1197 void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res)
1199 if(!payload->resources)
1201 payload->resources = res;
1205 OCResourcePayload* p = payload->resources;
1214 void FreeOCDiscoveryResource(OCResourcePayload* payload)
1221 OICFree(payload->uri);
1222 OICFree(payload->sid);
1223 OCFreeOCStringLL(payload->types);
1224 OCFreeOCStringLL(payload->interfaces);
1225 FreeOCDiscoveryResource(payload->next);
1229 void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
1236 FreeOCDiscoveryResource(payload->resources);
1240 OCDevicePayload* OCDevicePayloadCreate(const char* uri, const uint8_t* sid, const char* dname,
1241 const char* specVer, const char* dmVer)
1244 OCDevicePayload* payload = (OCDevicePayload*)OICCalloc(1, sizeof(OCDevicePayload));
1251 payload->base.type = PAYLOAD_TYPE_DEVICE;
1253 payload->uri = OICStrdup(uri);
1254 if(uri && !payload->uri)
1261 payload->sid = (uint8_t*)OICMalloc(UUID_SIZE);
1266 memcpy(payload->sid, sid, UUID_SIZE);
1269 payload->deviceName = OICStrdup(dname);
1270 if(dname && !payload->deviceName)
1275 payload->specVersion = OICStrdup(specVer);
1276 if(specVer && !payload->specVersion)
1281 payload->dataModelVersion = OICStrdup(dmVer);
1282 if(dmVer && !payload->dataModelVersion)
1290 OCDevicePayloadDestroy((OCDevicePayload*)payload);
1294 void OCDevicePayloadDestroy(OCDevicePayload* payload)
1301 OICFree(payload->uri);
1302 OICFree(payload->sid);
1303 OICFree(payload->deviceName);
1304 OICFree(payload->specVersion);
1305 OICFree(payload->dataModelVersion);
1309 static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
1311 target->info.platformID = OICStrdup(platformInfo->platformID);
1312 target->info.manufacturerName = OICStrdup(platformInfo->manufacturerName);
1313 target->info.manufacturerUrl = OICStrdup(platformInfo->manufacturerUrl);
1314 target->info.modelNumber = OICStrdup(platformInfo->modelNumber);
1315 target->info.dateOfManufacture = OICStrdup(platformInfo->dateOfManufacture);
1316 target->info.platformVersion = OICStrdup(platformInfo->platformVersion);
1317 target->info.operatingSystemVersion = OICStrdup(platformInfo->operatingSystemVersion);
1318 target->info.hardwareVersion = OICStrdup(platformInfo->hardwareVersion);
1319 target->info.firmwareVersion = OICStrdup(platformInfo->firmwareVersion);
1320 target->info.supportUrl = OICStrdup(platformInfo->supportUrl);
1321 target->info.systemTime = OICStrdup(platformInfo->systemTime);
1324 OCPlatformPayload* OCPlatformPayloadCreateAsOwner(char* uri, OCPlatformInfo* platformInfo)
1326 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
1332 payload->base.type = PAYLOAD_TYPE_PLATFORM;
1334 payload->info = *platformInfo;
1339 OCPlatformPayload* OCPlatformPayloadCreate(const char* uri, const OCPlatformInfo* platformInfo)
1341 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
1348 payload->base.type = PAYLOAD_TYPE_PLATFORM;
1349 payload->uri = OICStrdup(uri);
1350 OCCopyPlatformInfo(platformInfo, payload);
1355 void OCPlatformPayloadDestroy(OCPlatformPayload* payload)
1361 OICFree(payload->uri);
1362 OICFree(payload->info.platformID);
1363 OICFree(payload->info.manufacturerName);
1364 OICFree(payload->info.manufacturerUrl);
1365 OICFree(payload->info.modelNumber);
1366 OICFree(payload->info.dateOfManufacture);
1367 OICFree(payload->info.platformVersion);
1368 OICFree(payload->info.operatingSystemVersion);
1369 OICFree(payload->info.hardwareVersion);
1370 OICFree(payload->info.firmwareVersion);
1371 OICFree(payload->info.supportUrl);
1372 OICFree(payload->info.systemTime);
1376 OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
1377 OCPresenceTrigger trigger, const char* resourceType)
1379 OCPresencePayload* payload = (OCPresencePayload*)OICCalloc(1, sizeof(OCPresencePayload));
1385 payload->base.type = PAYLOAD_TYPE_PRESENCE;
1386 payload->sequenceNumber = seqNum;
1387 payload->maxAge = maxAge;
1388 payload->trigger = trigger;
1389 payload->resourceType = OICStrdup(resourceType);
1393 void OCPresencePayloadDestroy(OCPresencePayload* payload)
1399 OICFree(payload->resourceType);