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);
33 static void FreeOCDiscoveryResource(OCResourcePayload* payload);
35 void OCPayloadDestroy(OCPayload* payload)
44 case PAYLOAD_TYPE_REPRESENTATION:
45 OCRepPayloadDestroy((OCRepPayload*)payload);
47 case PAYLOAD_TYPE_DISCOVERY:
48 OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload);
50 case PAYLOAD_TYPE_DEVICE:
51 OCDevicePayloadDestroy((OCDevicePayload*)payload);
53 case PAYLOAD_TYPE_PLATFORM:
54 OCPlatformPayloadDestroy((OCPlatformPayload*)payload);
56 case PAYLOAD_TYPE_PRESENCE:
57 OCPresencePayloadDestroy((OCPresencePayload*)payload);
59 case PAYLOAD_TYPE_SECURITY:
60 OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
63 OC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
68 OCRepPayload* OCRepPayloadCreate()
70 OCRepPayload* payload = (OCRepPayload*)OICCalloc(1, sizeof(OCRepPayload));
77 payload->base.type = PAYLOAD_TYPE_REPRESENTATION;
82 void OCRepPayloadAppend(OCRepPayload* parent, OCRepPayload* child)
91 parent = parent->next;
98 static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, const char* name)
100 if(!payload || !name)
105 OCRepPayloadValue* val = payload->values;
108 if(0 == strcmp(val->name, name))
119 static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
121 size_t dimTotal = calcDimTotal(source->arr.dimensions);
122 switch(source->arr.type)
125 dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
126 memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
128 case OCREP_PROP_DOUBLE:
129 dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
130 memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
132 case OCREP_PROP_BOOL:
133 dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
134 memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
136 case OCREP_PROP_STRING:
137 dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
138 for(size_t i = 0; i < dimTotal; ++i)
140 dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
143 case OCREP_PROP_ARRAY:
144 dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
145 for(size_t i = 0; i < dimTotal; ++i)
147 dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
151 OC_LOG(ERROR, TAG, PCF("CopyPropertyValueArray invalid type"));
156 static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
158 if (!source || !dest)
165 case OCREP_PROP_STRING:
166 dest->str = OICStrdup(source->str);
168 case OCREP_PROP_OBJECT:
169 dest->obj = OCRepPayloadClone(source->obj);
171 case OCREP_PROP_ARRAY:
172 OCCopyPropertyValueArray(dest, source);
175 // Nothing to do for the trivially copyable types.
180 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
187 if(val->type == OCREP_PROP_STRING)
191 else if (val->type == OCREP_PROP_OBJECT)
193 OCRepPayloadDestroy(val->obj);
195 else if (val->type == OCREP_PROP_ARRAY)
197 size_t dimTotal = calcDimTotal(val->arr.dimensions);
198 switch(val->arr.type)
201 case OCREP_PROP_DOUBLE:
202 case OCREP_PROP_BOOL:
203 // Since this is a union, iArray will
204 // point to all of the above
205 OICFree(val->arr.iArray);
207 case OCREP_PROP_STRING:
208 for(size_t i = 0; i< dimTotal;++i)
210 OICFree(val->arr.strArray[i]);
212 OICFree(val->arr.strArray);
214 case OCREP_PROP_OBJECT:
215 for(size_t i = 0; i< dimTotal;++i)
217 OCRepPayloadDestroy(val->arr.objArray[i]);
219 OICFree(val->arr.objArray);
221 case OCREP_PROP_NULL:
222 case OCREP_PROP_ARRAY:
223 OC_LOG_V(ERROR, TAG, "FreeRepPayloadValueContents: Illegal type\
224 inside an array: %d", val->arr.type);
230 static void OCFreeRepPayloadValue(OCRepPayloadValue* val)
238 OCFreeRepPayloadValueContents(val);
239 OCFreeRepPayloadValue(val->next);
242 static OCRepPayloadValue* OCRepPayloadValueClone (OCRepPayloadValue* source)
249 OCRepPayloadValue *sourceIter = source;
250 OCRepPayloadValue *destIter = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
256 OCRepPayloadValue *headOfClone = destIter;
258 // Copy payload type and non pointer types in union.
259 *destIter = *sourceIter;
260 destIter->name = OICStrdup (sourceIter->name);
261 OCCopyPropertyValue (destIter, sourceIter);
263 sourceIter = sourceIter->next;
267 destIter->next = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
270 OCFreeRepPayloadValue (headOfClone);
274 *(destIter->next) = *sourceIter;
275 destIter->next->name = OICStrdup (sourceIter->name);
276 OCCopyPropertyValue (destIter->next, sourceIter);
278 sourceIter = sourceIter->next;
279 destIter = destIter->next;
284 static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, const char* name,
285 OCRepPayloadPropType type)
287 if(!payload || !name)
292 OCRepPayloadValue* val = payload->values;
295 payload->values = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
300 payload->values->name = OICStrdup(name);
301 if(!payload->values->name)
303 OICFree(payload->values);
304 payload->values = NULL;
307 payload->values->type =type;
308 return payload->values;
313 if(0 == strcmp(val->name, name))
315 OCFreeRepPayloadValueContents(val);
319 else if(val->next == NULL)
321 val->next = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
326 val->next->name = OICStrdup(name);
333 val->next->type =type;
340 OC_LOG(ERROR, TAG, PCF("FindAndSetValue reached point after while loop, pointer corruption?"));
344 bool OCRepPayloadAddResourceType(OCRepPayload* payload, const char* resourceType)
346 return OCRepPayloadAddResourceTypeAsOwner(payload, OICStrdup(resourceType));
349 bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceType)
351 if(!payload || !resourceType)
358 OCStringLL* cur = payload->types;
363 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
370 cur->next->value = resourceType;
375 payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
380 payload->types->value = resourceType;
385 bool OCRepPayloadAddInterface(OCRepPayload* payload, const char* interface)
387 return OCRepPayloadAddInterfaceAsOwner(payload, OICStrdup(interface));
390 bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
392 if(!payload || !interface)
397 if(payload->interfaces)
399 OCStringLL* cur = payload->interfaces;
404 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
410 cur->next->value = interface;
415 payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
416 if(!payload->interfaces)
420 payload->interfaces->value = interface;
425 bool OCRepPayloadSetUri(OCRepPayload* payload, const char* uri)
432 payload->uri = OICStrdup(uri);
433 return payload->uri != NULL;
436 bool OCRepPayloadIsNull(const OCRepPayload* payload, const char* name)
438 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
445 return val->type == OCREP_PROP_NULL;
448 bool OCRepPayloadSetNull(OCRepPayload* payload, const char* name)
450 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_NULL);
454 bool OCRepPayloadSetPropInt(OCRepPayload* payload,
455 const char* name, int64_t value)
457 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_INT);
468 bool OCRepPayloadGetPropInt(const OCRepPayload* payload, const char* name, int64_t* value)
470 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
472 if(!val || val->type != OCREP_PROP_INT)
481 bool OCRepPayloadSetPropDouble(OCRepPayload* payload,
482 const char* name, double value)
484 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_DOUBLE);
495 bool OCRepPayloadGetPropDouble(const OCRepPayload* payload, const char* name, double* value)
497 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
499 if(!val || val->type != OCREP_PROP_DOUBLE)
508 bool OCRepPayloadSetPropString(OCRepPayload* payload, const char* name, const char* value)
510 char* temp = OICStrdup(value);
511 bool b = OCRepPayloadSetPropStringAsOwner(payload, name, temp);
520 bool OCRepPayloadSetPropStringAsOwner(OCRepPayload* payload, const char* name, char* value)
522 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_STRING);
530 return val->str != NULL;
533 bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, const char** value)
535 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
537 if(!val || val->type != OCREP_PROP_STRING)
542 *value = OICStrdup(val->str);
543 return *value != NULL;
546 bool OCRepPayloadSetPropBool(OCRepPayload* payload,
547 const char* name, bool value)
549 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_BOOL);
560 bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool* value)
562 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
564 if(!val || val->type != OCREP_PROP_BOOL)
573 bool OCRepPayloadSetPropObject(OCRepPayload* payload, const char* name, const OCRepPayload* value)
575 OCRepPayload* temp = OCRepPayloadClone(value);
576 bool b = OCRepPayloadSetPropObjectAsOwner(payload, name, temp);
580 OCRepPayloadDestroy(temp);
585 bool OCRepPayloadSetPropObjectAsOwner(OCRepPayload* payload, const char* name, OCRepPayload* value)
587 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_OBJECT);
598 bool OCRepPayloadGetPropObject(const OCRepPayload* payload, const char* name, OCRepPayload** value)
600 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
602 if(!val || val->type != OCREP_PROP_OBJECT)
607 *value = OCRepPayloadClone(val->obj);
608 return *value != NULL;
611 size_t calcDimTotal(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
613 if(dimensions[0] == 0)
619 for(uint8_t i = 0; i < MAX_REP_ARRAY_DEPTH && dimensions[i] != 0; ++i)
621 total *= dimensions[i];
626 bool OCRepPayloadSetIntArrayAsOwner(OCRepPayload* payload, const char* name,
627 int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
629 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
636 val->arr.type = OCREP_PROP_INT;
637 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
638 val->arr.iArray = array;
643 bool OCRepPayloadSetIntArray(OCRepPayload* payload, const char* name,
644 const int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
646 size_t dimTotal = calcDimTotal(dimensions);
652 int64_t* newArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
659 memcpy(newArray, array, dimTotal * sizeof(int64_t));
662 bool b = OCRepPayloadSetIntArrayAsOwner(payload, name, newArray, dimensions);
670 bool OCRepPayloadGetIntArray(const OCRepPayload* payload, const char* name,
671 int64_t** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
673 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
675 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
681 size_t dimTotal = calcDimTotal(val->arr.dimensions);
686 *array = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
692 memcpy(*array, val->arr.iArray, dimTotal * sizeof(int64_t));
693 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
697 bool OCRepPayloadSetDoubleArrayAsOwner(OCRepPayload* payload, const char* name,
698 double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
700 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
707 val->arr.type = OCREP_PROP_DOUBLE;
708 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
709 val->arr.dArray = array;
713 bool OCRepPayloadSetDoubleArray(OCRepPayload* payload, const char* name,
714 const double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
716 size_t dimTotal = calcDimTotal(dimensions);
722 double* newArray = (double*)OICMalloc(dimTotal * sizeof(double));
729 memcpy(newArray, array, dimTotal * sizeof(double));
731 bool b = OCRepPayloadSetDoubleArrayAsOwner(payload, name, newArray, dimensions);
739 bool OCRepPayloadGetDoubleArray(const OCRepPayload* payload, const char* name,
740 double** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
742 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
744 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_DOUBLE
750 size_t dimTotal = calcDimTotal(val->arr.dimensions);
755 *array = (double*)OICMalloc(dimTotal * sizeof(double));
761 memcpy(*array, val->arr.dArray, dimTotal * sizeof(double));
762 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
766 bool OCRepPayloadSetStringArrayAsOwner(OCRepPayload* payload, const char* name,
767 char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
769 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
776 val->arr.type = OCREP_PROP_STRING;
777 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
778 val->arr.strArray = array;
782 bool OCRepPayloadSetStringArray(OCRepPayload* payload, const char* name,
783 const char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
785 size_t dimTotal = calcDimTotal(dimensions);
791 char** newArray = (char**)OICMalloc(dimTotal * sizeof(char*));
798 for(size_t i = 0; i < dimTotal; ++i)
800 newArray[i] = OICStrdup(array[i]);
803 bool b = OCRepPayloadSetStringArrayAsOwner(payload, name, newArray, dimensions);
807 for(size_t i = 0; i < dimTotal; ++i)
809 OICFree(newArray[i]);
816 bool OCRepPayloadGetStringArray(const OCRepPayload* payload, const char* name,
817 char*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
819 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
821 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
822 || !val->arr.strArray)
827 size_t dimTotal = calcDimTotal(val->arr.dimensions);
832 *array = (char**)OICMalloc(dimTotal * sizeof(char*));
838 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
840 for(size_t i = 0; i < dimTotal; ++i)
842 (*array)[i] = OICStrdup(val->arr.strArray[i]);
849 bool OCRepPayloadSetBoolArrayAsOwner(OCRepPayload* payload, const char* name,
850 bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
853 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
860 val->arr.type = OCREP_PROP_BOOL;
861 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
862 val->arr.bArray = array;
866 bool OCRepPayloadSetBoolArray(OCRepPayload* payload, const char* name,
867 const bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
869 size_t dimTotal = calcDimTotal(dimensions);
875 bool* newArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
882 memcpy(newArray, array, dimTotal * sizeof(bool));
885 bool b = OCRepPayloadSetBoolArrayAsOwner(payload, name, newArray, dimensions);
893 bool OCRepPayloadGetBoolArray(const OCRepPayload* payload, const char* name,
894 bool** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
896 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
898 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
904 size_t dimTotal = calcDimTotal(val->arr.dimensions);
909 *array = (bool*)OICMalloc(dimTotal * sizeof(bool));
915 memcpy(*array, val->arr.bArray, dimTotal * sizeof(bool));
916 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
920 bool OCRepPayloadSetPropObjectArrayAsOwner(OCRepPayload* payload, const char* name,
921 OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
923 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
930 val->arr.type = OCREP_PROP_OBJECT;
931 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
932 val->arr.objArray = array;
937 bool OCRepPayloadSetPropObjectArray(OCRepPayload* payload, const char* name,
938 const OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
940 size_t dimTotal = calcDimTotal(dimensions);
946 OCRepPayload** newArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
953 for(size_t i = 0; i < dimTotal; ++i)
955 newArray[i] = OCRepPayloadClone(array[i]);
958 bool b = OCRepPayloadSetPropObjectArrayAsOwner(payload, name, newArray, dimensions);
962 for(size_t i = 0; i < dimTotal; ++i)
964 OCRepPayloadDestroy(newArray[i]);
971 bool OCRepPayloadGetPropObjectArray(const OCRepPayload* payload, const char* name,
972 OCRepPayload*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
974 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
976 if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
977 || !val->arr.objArray)
982 size_t dimTotal = calcDimTotal(val->arr.dimensions);
987 *array = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
993 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
995 for(size_t i = 0; i < dimTotal; ++i)
997 (*array)[i] = OCRepPayloadClone(val->arr.objArray[i]);
1003 void OCFreeOCStringLL(OCStringLL* ll)
1010 OCFreeOCStringLL(ll->next);
1015 OCStringLL* CloneOCStringLL (OCStringLL* ll)
1022 OCStringLL *sourceIter = ll;
1024 OCStringLL *destIter = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1029 destIter->value = OICStrdup (sourceIter->value);
1031 OCStringLL *headOfClone = destIter;
1033 sourceIter = sourceIter->next;
1037 destIter->next = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1038 if (!destIter->next)
1040 OCFreeOCStringLL (headOfClone);
1043 destIter->next->value = OICStrdup (sourceIter->value);
1045 destIter = destIter->next;
1046 sourceIter = sourceIter->next;
1051 OCRepPayload* OCRepPayloadClone (const OCRepPayload* payload)
1058 OCRepPayload *clone = OCRepPayloadCreate();
1065 clone->uri = OICStrdup (payload->uri);
1066 clone->types = CloneOCStringLL (payload->types);
1067 clone->interfaces = CloneOCStringLL (payload->interfaces);
1068 clone->values = OCRepPayloadValueClone (payload->values);
1074 void OCRepPayloadDestroy(OCRepPayload* payload)
1081 OICFree(payload->uri);
1082 OCFreeOCStringLL(payload->types);
1083 OCFreeOCStringLL(payload->interfaces);
1084 OCFreeRepPayloadValue(payload->values);
1085 OCRepPayloadDestroy(payload->next);
1089 OCDiscoveryPayload* OCDiscoveryPayloadCreate()
1091 OCDiscoveryPayload* payload = (OCDiscoveryPayload*)OICCalloc(1, sizeof(OCDiscoveryPayload));
1098 payload->base.type = PAYLOAD_TYPE_DISCOVERY;
1103 OCSecurityPayload* OCSecurityPayloadCreate(const char* securityData)
1105 OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1112 payload->base.type = PAYLOAD_TYPE_SECURITY;
1113 payload->securityData = OICStrdup(securityData);
1118 void OCSecurityPayloadDestroy(OCSecurityPayload* payload)
1125 OICFree(payload->securityData);
1129 size_t OCDiscoveryPayloadGetResourceCount(OCDiscoveryPayload* payload)
1132 OCResourcePayload* p = payload->resources;
1141 OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, size_t index)
1144 OCResourcePayload* p = payload->resources;
1157 static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
1159 OCResourcePayload* pl = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1165 pl->uri = OICStrdup(res->uri);
1166 pl->sid = (uint8_t*)OICCalloc(1, UUID_SIZE);
1167 if(!pl->uri || ! pl->sid)
1169 FreeOCDiscoveryResource(pl);
1172 memcpy(pl->sid, OCGetServerInstanceID(), UUID_SIZE);
1175 OCResourceType* typePtr = res->rsrcType;
1179 pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1182 FreeOCDiscoveryResource(pl);
1185 pl->types->value = OICStrdup(typePtr->resourcetypename);
1186 if(!pl->types->value)
1188 FreeOCDiscoveryResource(pl);
1192 OCStringLL* cur = pl->types;
1193 typePtr = typePtr->next;
1196 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1199 FreeOCDiscoveryResource(pl);
1202 cur->next->value = OICStrdup(typePtr->resourcetypename);
1203 if(!cur->next->value)
1205 FreeOCDiscoveryResource(pl);
1209 typePtr = typePtr->next;
1214 OCResourceInterface* ifPtr = res->rsrcInterface;
1217 pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1220 FreeOCDiscoveryResource(pl);
1223 pl->interfaces->value = OICStrdup(ifPtr->name);
1224 if(!pl->interfaces->value)
1226 FreeOCDiscoveryResource(pl);
1230 OCStringLL* cur = pl->interfaces;
1231 ifPtr = ifPtr->next;
1234 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1237 FreeOCDiscoveryResource(pl);
1240 cur->next->value = OICStrdup(ifPtr->name);
1241 if(!cur->next->value)
1243 FreeOCDiscoveryResource(pl);
1247 ifPtr = ifPtr->next;
1251 pl->bitmap = res->resourceProperties & (OC_OBSERVABLE | OC_DISCOVERABLE);
1252 pl->secure = (res->resourceProperties & OC_SECURE) != 0;
1258 void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
1261 OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
1264 void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res)
1266 if(!payload->resources)
1268 payload->resources = res;
1272 OCResourcePayload* p = payload->resources;
1281 static void FreeOCDiscoveryResource(OCResourcePayload* payload)
1288 OICFree(payload->uri);
1289 OICFree(payload->sid);
1290 OCFreeOCStringLL(payload->types);
1291 OCFreeOCStringLL(payload->interfaces);
1292 FreeOCDiscoveryResource(payload->next);
1296 void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
1303 FreeOCDiscoveryResource(payload->resources);
1307 OCDevicePayload* OCDevicePayloadCreate(const char* uri, const uint8_t* sid, const char* dname,
1308 const char* specVer, const char* dmVer)
1311 OCDevicePayload* payload = (OCDevicePayload*)OICCalloc(1, sizeof(OCDevicePayload));
1318 payload->base.type = PAYLOAD_TYPE_DEVICE;
1320 payload->uri = OICStrdup(uri);
1321 if(uri && !payload->uri)
1328 payload->sid = (uint8_t*)OICMalloc(UUID_SIZE);
1333 memcpy(payload->sid, sid, UUID_SIZE);
1336 payload->deviceName = OICStrdup(dname);
1337 if(dname && !payload->deviceName)
1342 payload->specVersion = OICStrdup(specVer);
1343 if(specVer && !payload->specVersion)
1348 payload->dataModelVersion = OICStrdup(dmVer);
1349 if(dmVer && !payload->dataModelVersion)
1357 OCDevicePayloadDestroy((OCDevicePayload*)payload);
1361 void OCDevicePayloadDestroy(OCDevicePayload* payload)
1368 OICFree(payload->uri);
1369 OICFree(payload->sid);
1370 OICFree(payload->deviceName);
1371 OICFree(payload->specVersion);
1372 OICFree(payload->dataModelVersion);
1376 static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
1378 target->info.platformID = OICStrdup(platformInfo->platformID);
1379 target->info.manufacturerName = OICStrdup(platformInfo->manufacturerName);
1380 target->info.manufacturerUrl = OICStrdup(platformInfo->manufacturerUrl);
1381 target->info.modelNumber = OICStrdup(platformInfo->modelNumber);
1382 target->info.dateOfManufacture = OICStrdup(platformInfo->dateOfManufacture);
1383 target->info.platformVersion = OICStrdup(platformInfo->platformVersion);
1384 target->info.operatingSystemVersion = OICStrdup(platformInfo->operatingSystemVersion);
1385 target->info.hardwareVersion = OICStrdup(platformInfo->hardwareVersion);
1386 target->info.firmwareVersion = OICStrdup(platformInfo->firmwareVersion);
1387 target->info.supportUrl = OICStrdup(platformInfo->supportUrl);
1388 target->info.systemTime = OICStrdup(platformInfo->systemTime);
1391 OCPlatformPayload* OCPlatformPayloadCreateAsOwner(char* uri, OCPlatformInfo* platformInfo)
1393 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
1399 payload->base.type = PAYLOAD_TYPE_PLATFORM;
1401 payload->info = *platformInfo;
1406 OCPlatformPayload* OCPlatformPayloadCreate(const char* uri, const OCPlatformInfo* platformInfo)
1408 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
1415 payload->base.type = PAYLOAD_TYPE_PLATFORM;
1416 payload->uri = OICStrdup(uri);
1417 OCCopyPlatformInfo(platformInfo, payload);
1422 void OCPlatformPayloadDestroy(OCPlatformPayload* payload)
1428 OICFree(payload->uri);
1429 OICFree(payload->info.platformID);
1430 OICFree(payload->info.manufacturerName);
1431 OICFree(payload->info.manufacturerUrl);
1432 OICFree(payload->info.modelNumber);
1433 OICFree(payload->info.dateOfManufacture);
1434 OICFree(payload->info.platformVersion);
1435 OICFree(payload->info.operatingSystemVersion);
1436 OICFree(payload->info.hardwareVersion);
1437 OICFree(payload->info.firmwareVersion);
1438 OICFree(payload->info.supportUrl);
1439 OICFree(payload->info.systemTime);
1443 OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
1444 OCPresenceTrigger trigger, const char* resourceType)
1446 OCPresencePayload* payload = (OCPresencePayload*)OICCalloc(1, sizeof(OCPresencePayload));
1452 payload->base.type = PAYLOAD_TYPE_PRESENCE;
1453 payload->sequenceNumber = seqNum;
1454 payload->maxAge = maxAge;
1455 payload->trigger = trigger;
1456 payload->resourceType = OICStrdup(resourceType);
1460 void OCPresencePayloadDestroy(OCPresencePayload* payload)
1466 OICFree(payload->resourceType);