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 // Required for strok_r
22 #define _POSIX_C_SOURCE 200112L
24 #include "iotivity_config.h"
26 #include "ocpayload.h"
29 #include "oic_malloc.h"
30 #include "oic_string.h"
31 #include "ocstackinternal.h"
32 #include "ocresource.h"
35 #define TAG "OIC_RI_PAYLOAD"
36 #define CSV_SEPARATOR ','
38 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
40 void OCPayloadDestroy(OCPayload* payload)
49 case PAYLOAD_TYPE_REPRESENTATION:
50 OCRepPayloadDestroy((OCRepPayload*)payload);
52 case PAYLOAD_TYPE_DISCOVERY:
53 OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload);
55 case PAYLOAD_TYPE_DEVICE:
56 OCDevicePayloadDestroy((OCDevicePayload*)payload);
58 case PAYLOAD_TYPE_PLATFORM:
59 OCPlatformPayloadDestroy((OCPlatformPayload*)payload);
61 case PAYLOAD_TYPE_PRESENCE:
62 OCPresencePayloadDestroy((OCPresencePayload*)payload);
64 case PAYLOAD_TYPE_SECURITY:
65 OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
68 OIC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
73 OCRepPayload* OCRepPayloadCreate()
75 OCRepPayload* payload = (OCRepPayload*)OICCalloc(1, sizeof(OCRepPayload));
82 payload->base.type = PAYLOAD_TYPE_REPRESENTATION;
87 void OCRepPayloadAppend(OCRepPayload* parent, OCRepPayload* child)
96 parent = parent->next;
103 static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, const char* name)
105 if (!payload || !name)
110 OCRepPayloadValue* val = payload->values;
113 if (0 == strcmp(val->name, name))
123 static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
125 if (!dest || !source)
130 size_t dimTotal = calcDimTotal(source->arr.dimensions);
131 switch(source->arr.type)
134 dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
135 VERIFY_PARAM_NON_NULL(TAG, dest->arr.iArray, "Failed allocating memory");
136 memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
138 case OCREP_PROP_DOUBLE:
139 dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
140 VERIFY_PARAM_NON_NULL(TAG, dest->arr.dArray, "Failed allocating memory");
141 memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
143 case OCREP_PROP_BOOL:
144 dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
145 VERIFY_PARAM_NON_NULL(TAG, dest->arr.bArray, "Failed allocating memory");
146 memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
148 case OCREP_PROP_STRING:
149 dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
150 VERIFY_PARAM_NON_NULL(TAG, dest->arr.strArray, "Failed allocating memory");
151 for(size_t i = 0; i < dimTotal; ++i)
153 dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
156 case OCREP_PROP_OBJECT:
157 dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
158 VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
159 for(size_t i = 0; i < dimTotal; ++i)
161 dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
164 case OCREP_PROP_ARRAY:
165 dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
166 VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
167 for(size_t i = 0; i < dimTotal; ++i)
169 dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
172 case OCREP_PROP_BYTE_STRING:
173 dest->arr.ocByteStrArray = (OCByteString*)OICMalloc(dimTotal * sizeof(OCByteString));
174 VERIFY_PARAM_NON_NULL(TAG, dest->arr.ocByteStrArray, "Failed allocating memory");
175 for (size_t i = 0; i < dimTotal; ++i)
177 OCByteStringCopy(&dest->arr.ocByteStrArray[i], &source->arr.ocByteStrArray[i]);
178 VERIFY_PARAM_NON_NULL(TAG, dest->arr.ocByteStrArray[i].bytes, "Failed allocating memory");
182 OIC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
189 static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
191 if (!source || !dest)
198 case OCREP_PROP_STRING:
199 dest->str = OICStrdup(source->str);
201 case OCREP_PROP_BYTE_STRING:
202 dest->ocByteStr.bytes = (uint8_t*)OICMalloc(source->ocByteStr.len * sizeof(uint8_t));
203 VERIFY_PARAM_NON_NULL(TAG, dest->ocByteStr.bytes, "Failed allocating memory");
204 dest->ocByteStr.len = source->ocByteStr.len;
205 memcpy(dest->ocByteStr.bytes, source->ocByteStr.bytes, dest->ocByteStr.len);
207 case OCREP_PROP_OBJECT:
208 dest->obj = OCRepPayloadClone(source->obj);
210 case OCREP_PROP_ARRAY:
211 OCCopyPropertyValueArray(dest, source);
214 // Nothing to do for the trivially copyable types.
221 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
228 if (val->type == OCREP_PROP_STRING)
232 else if (val->type == OCREP_PROP_BYTE_STRING)
234 OICFree(val->ocByteStr.bytes);
236 else if (val->type == OCREP_PROP_OBJECT)
238 OCRepPayloadDestroy(val->obj);
240 else if (val->type == OCREP_PROP_ARRAY)
242 size_t dimTotal = calcDimTotal(val->arr.dimensions);
243 switch(val->arr.type)
246 case OCREP_PROP_DOUBLE:
247 case OCREP_PROP_BOOL:
248 // Since this is a union, iArray will
249 // point to all of the above
250 OICFree(val->arr.iArray);
252 case OCREP_PROP_STRING:
253 for(size_t i = 0; i < dimTotal; ++i)
255 OICFree(val->arr.strArray[i]);
257 OICFree(val->arr.strArray);
259 case OCREP_PROP_BYTE_STRING:
260 for (size_t i = 0; i < dimTotal; ++i)
262 if (val->arr.ocByteStrArray[i].bytes)
264 OICFree(val->arr.ocByteStrArray[i].bytes);
267 OICFree(val->arr.ocByteStrArray);
269 case OCREP_PROP_OBJECT: // This case is the temporary fix for string input
270 for(size_t i = 0; i< dimTotal; ++i)
272 OCRepPayloadDestroy(val->arr.objArray[i]);
274 OICFree(val->arr.objArray);
276 case OCREP_PROP_NULL:
277 case OCREP_PROP_ARRAY:
278 OIC_LOG_V(ERROR, TAG, "FreeRepPayloadValueContents: Illegal type\
279 inside an array: %d", val->arr.type);
285 static void OCFreeRepPayloadValue(OCRepPayloadValue* val)
293 OCFreeRepPayloadValueContents(val);
294 OCFreeRepPayloadValue(val->next);
297 static OCRepPayloadValue* OCRepPayloadValueClone (OCRepPayloadValue* source)
304 OCRepPayloadValue *sourceIter = source;
305 OCRepPayloadValue *destIter = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
311 OCRepPayloadValue *headOfClone = destIter;
313 // Copy payload type and non pointer types in union.
314 *destIter = *sourceIter;
315 destIter->name = OICStrdup (sourceIter->name);
316 OCCopyPropertyValue (destIter, sourceIter);
318 sourceIter = sourceIter->next;
322 destIter->next = (OCRepPayloadValue*) OICCalloc(1, sizeof(OCRepPayloadValue));
325 OCFreeRepPayloadValue (headOfClone);
329 *(destIter->next) = *sourceIter;
330 destIter->next->name = OICStrdup (sourceIter->name);
331 OCCopyPropertyValue (destIter->next, sourceIter);
333 sourceIter = sourceIter->next;
334 destIter = destIter->next;
339 static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, const char* name,
340 OCRepPayloadPropType type)
342 if (!payload || !name)
347 OCRepPayloadValue* val = payload->values;
350 payload->values = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
351 if (!payload->values)
355 payload->values->name = OICStrdup(name);
356 if (!payload->values->name)
358 OICFree(payload->values);
359 payload->values = NULL;
362 payload->values->type =type;
363 return payload->values;
368 if (0 == strcmp(val->name, name))
370 OCFreeRepPayloadValueContents(val);
374 else if (val->next == NULL)
376 val->next = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
381 val->next->name = OICStrdup(name);
382 if (!val->next->name)
388 val->next->type =type;
395 OIC_LOG(ERROR, TAG, "FindAndSetValue reached point after while loop, pointer corruption?");
399 bool OCRepPayloadAddResourceType(OCRepPayload* payload, const char* resourceType)
401 return OCRepPayloadAddResourceTypeAsOwner(payload, OICStrdup(resourceType));
404 bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceType)
406 if (!payload || !resourceType)
413 OCStringLL* cur = payload->types;
418 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
425 cur->next->value = resourceType;
430 payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
435 payload->types->value = resourceType;
440 bool OCRepPayloadAddInterface(OCRepPayload* payload, const char* iface)
442 return OCRepPayloadAddInterfaceAsOwner(payload, OICStrdup(iface));
445 bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* iface)
447 if (!payload || !iface)
452 if (payload->interfaces)
454 OCStringLL* cur = payload->interfaces;
459 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
465 cur->next->value = iface;
470 payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
471 if (!payload->interfaces)
475 payload->interfaces->value = iface;
480 bool OCRepPayloadSetUri(OCRepPayload* payload, const char* uri)
486 OICFree(payload->uri);
487 payload->uri = OICStrdup(uri);
488 return payload->uri != NULL;
491 bool OCRepPayloadIsNull(const OCRepPayload* payload, const char* name)
493 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
500 return val->type == OCREP_PROP_NULL;
503 static bool OCRepPayloadSetProp(OCRepPayload* payload, const char* name,
504 void* value, OCRepPayloadPropType type)
506 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, type);
514 val->i = *(int64_t*)value;
516 case OCREP_PROP_DOUBLE:
517 val->d = *(double*)value;
519 case OCREP_PROP_BOOL:
520 val->b = *(bool*)value;
522 case OCREP_PROP_OBJECT:
523 val->obj = (OCRepPayload*)value;
525 case OCREP_PROP_STRING:
526 val->str = (char*)value;
527 return val->str != NULL;
528 case OCREP_PROP_BYTE_STRING:
529 val->ocByteStr = *(OCByteString*)value;
530 return val->ocByteStr.bytes != NULL;
532 case OCREP_PROP_NULL:
534 case OCREP_PROP_ARRAY:
542 bool OCRepPayloadSetNull(OCRepPayload* payload, const char* name)
544 return OCRepPayloadSetProp(payload, name, NULL, OCREP_PROP_NULL);
547 bool OCRepPayloadSetPropInt(OCRepPayload* payload,
548 const char* name, int64_t value)
550 return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_INT);
553 bool OCRepPayloadGetPropInt(const OCRepPayload* payload, const char* name, int64_t* value)
555 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
557 if (!val || val->type != OCREP_PROP_INT)
566 bool OCRepPayloadSetPropDouble(OCRepPayload* payload,
567 const char* name, double value)
569 return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_DOUBLE);
572 bool OCRepPayloadGetPropDouble(const OCRepPayload* payload, const char* name, double* value)
574 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
578 if (val->type == OCREP_PROP_DOUBLE)
583 else if (val->type == OCREP_PROP_INT)
593 bool OCRepPayloadSetPropString(OCRepPayload* payload, const char* name, const char* value)
595 char* temp = OICStrdup(value);
596 bool b = OCRepPayloadSetPropStringAsOwner(payload, name, temp);
605 bool OCRepPayloadSetPropStringAsOwner(OCRepPayload* payload, const char* name, char* value)
607 return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_STRING);
610 bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, char** value)
612 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
614 if (!val || val->type != OCREP_PROP_STRING)
619 *value = OICStrdup(val->str);
620 return *value != NULL;
623 bool OCRepPayloadSetPropByteString(OCRepPayload* payload, const char* name, OCByteString value)
625 if (!value.bytes || !value.len)
630 OCByteString ocByteStr = {NULL, 0};
631 bool b = OCByteStringCopy(&ocByteStr, &value);
635 b = OCRepPayloadSetPropByteStringAsOwner(payload, name, &ocByteStr);
639 OICFree(ocByteStr.bytes);
644 bool OCRepPayloadSetPropByteStringAsOwner(OCRepPayload* payload, const char* name, OCByteString* value)
646 return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_BYTE_STRING);
649 bool OCRepPayloadGetPropByteString(const OCRepPayload* payload, const char* name, OCByteString* value)
651 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
653 if (!val || val->type != OCREP_PROP_BYTE_STRING)
663 value->bytes = (uint8_t*)OICMalloc(val->ocByteStr.len * sizeof(uint8_t));
668 value->len = val->ocByteStr.len;
669 memcpy(value->bytes, val->ocByteStr.bytes, value->len);
674 bool OCRepPayloadSetPropBool(OCRepPayload* payload,
675 const char* name, bool value)
677 return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_BOOL);
680 bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool* value)
682 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
684 if (!val || val->type != OCREP_PROP_BOOL)
694 static char *getStringFromEncodingType(OicEncodingType_t type)
699 case OIC_ENCODING_BASE64: str = OC_RSRVD_BASE64; break;
700 case OIC_ENCODING_DER: str = OC_RSRVD_DER; break;
701 case OIC_ENCODING_PEM: str = OC_RSRVD_PEM; break;
702 case OIC_ENCODING_RAW: str = OC_RSRVD_RAW; break;
703 default: str = OC_RSRVD_UNKNOWN; break;
706 snprintf(encoding, sizeof(encoding), "%s.%s.%s", OC_OIC_SEC, OC_RSRVD_ENCODING, str);
708 return OICStrdup(encoding);
711 bool OCRepPayloadSetPropPubDataTypeAsOwner(OCRepPayload *payload, const char *name,
712 const OicSecKey_t *value)
714 if (!payload || !name || !value)
719 bool binary_field = false;
720 if (OIC_ENCODING_RAW == value->encoding || OIC_ENCODING_DER == value->encoding)
725 OCRepPayload *heplerPayload = OCRepPayloadCreate();
731 char *encoding = getStringFromEncodingType(value->encoding);
732 if (!OCRepPayloadSetPropString(heplerPayload, OC_RSRVD_ENCODING, encoding))
734 OIC_LOG_V(ERROR, TAG, "Can't set %s", OC_RSRVD_ENCODING);
737 OCByteString val = {.bytes = value->data, .len = value->len};
740 if (!OCRepPayloadSetPropByteString(heplerPayload, OC_RSRVD_DATA, val))
742 OIC_LOG_V(ERROR, TAG, "Can't set %s", OC_RSRVD_DATA);
747 if (!OCRepPayloadSetPropString(heplerPayload, OC_RSRVD_DATA, (char *)val.bytes))
749 OIC_LOG_V(ERROR, TAG, "Can't set %s", OC_RSRVD_DATA);
753 if (!OCRepPayloadSetPropObject(payload, name, (const OCRepPayload *)heplerPayload))
755 OIC_LOG_V(ERROR, TAG, "Can't set %s", name);
758 OCRepPayloadDestroy(heplerPayload);
764 bool OCRepPayloadSetPropPubDataType(OCRepPayload *payload, const char *name,
765 const OicSecKey_t *value)
767 return OCRepPayloadSetPropPubDataTypeAsOwner(payload, name, value);
770 static OicEncodingType_t getEncodingTypeFromString(char *encoding)
772 OicEncodingType_t type = OIC_ENCODING_UNKNOW;
774 char *str = strrchr(encoding, '.');
777 OIC_LOG_V(ERROR, TAG, "Can't find . in %s", encoding);
780 str++; //go to encoding itself
782 if (0 == strcmp(str, OC_RSRVD_BASE64)) type = OIC_ENCODING_BASE64;
783 else if (0 == strcmp(str, OC_RSRVD_DER)) type = OIC_ENCODING_DER;
784 else if (0 == strcmp(str, OC_RSRVD_PEM)) type = OIC_ENCODING_PEM;
785 else if (0 == strcmp(str, OC_RSRVD_RAW)) type = OIC_ENCODING_RAW;
790 bool OCRepPayloadGetPropPubDataType(const OCRepPayload *payload, const char *name, OicSecKey_t *value)
792 OCRepPayload *heplerPayload = NULL;
793 char *encoding = NULL;
796 if (!payload || !name || !value)
801 if (!OCRepPayloadGetPropObject(payload, name, &heplerPayload))
803 OIC_LOG_V(ERROR, TAG, "Can't get object with name %s", name);
807 if (!OCRepPayloadGetPropString(heplerPayload, OC_RSRVD_ENCODING, &encoding))
809 OIC_LOG_V(ERROR, TAG, "Can't get %s", OC_RSRVD_ENCODING);
813 value->encoding = getEncodingTypeFromString(encoding);
817 if (!OCRepPayloadGetPropByteString(heplerPayload, OC_RSRVD_DATA, &val))
819 if (!OCRepPayloadGetPropString(heplerPayload, OC_RSRVD_DATA, (char **)&val.bytes))
821 OIC_LOG_V(ERROR, TAG, "Can't get: %s", OC_RSRVD_DATA);
825 value->data = val.bytes;
826 value->len = strlen(val.bytes);
831 value->data = val.bytes;
832 value->len = val.len;
835 OCRepPayloadDestroy(heplerPayload);
840 bool OCRepPayloadSetPropObject(OCRepPayload* payload, const char* name, const OCRepPayload* value)
842 OCRepPayload* temp = OCRepPayloadClone(value);
843 bool b = OCRepPayloadSetPropObjectAsOwner(payload, name, temp);
847 OCRepPayloadDestroy(temp);
852 bool OCRepPayloadSetPropObjectAsOwner(OCRepPayload* payload, const char* name, OCRepPayload* value)
854 return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_OBJECT);
857 bool OCRepPayloadGetPropObject(const OCRepPayload* payload, const char* name, OCRepPayload** value)
859 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
861 if (!val || val->type != OCREP_PROP_OBJECT)
866 *value = OCRepPayloadClone(val->obj);
867 return *value != NULL;
870 size_t calcDimTotal(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
872 if (dimensions[0] == 0)
878 for(uint8_t i = 0; i < MAX_REP_ARRAY_DEPTH && dimensions[i] != 0; ++i)
880 total *= dimensions[i];
886 bool OCRepPayloadSetByteStringArrayAsOwner(OCRepPayload* payload, const char* name,
887 OCByteString* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
889 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
896 val->arr.type = OCREP_PROP_BYTE_STRING;
897 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
898 val->arr.ocByteStrArray = array;
903 bool OCRepPayloadSetByteStringArray(OCRepPayload* payload, const char* name,
904 const OCByteString* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
911 size_t dimTotal = calcDimTotal(dimensions);
917 OCByteString* newArray = (OCByteString*)OICCalloc(dimTotal, sizeof(OCByteString));
924 for (size_t i = 0; i < dimTotal; ++i)
926 newArray[i].bytes = (uint8_t*)OICMalloc(array[i].len * sizeof(uint8_t));
927 if (NULL == newArray[i].bytes)
929 for (size_t j = 0; j < i; ++j)
931 OICFree(newArray[j].bytes);
937 newArray[i].len = array[i].len;
938 memcpy(newArray[i].bytes, array[i].bytes, newArray[i].len);
941 bool b = OCRepPayloadSetByteStringArrayAsOwner(payload, name, newArray, dimensions);
944 for (size_t i = 0; i < dimTotal; ++i)
946 OICFree(newArray[i].bytes);
954 bool OCRepPayloadGetByteStringArray(const OCRepPayload* payload, const char* name,
955 OCByteString** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
957 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
959 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BYTE_STRING
960 || !val->arr.ocByteStrArray)
965 size_t dimTotal = calcDimTotal(val->arr.dimensions);
971 *array = (OCByteString*)OICCalloc(dimTotal, sizeof(OCByteString));
977 for (size_t i = 0; i < dimTotal; ++i)
979 OCByteString* tmp = &(*array)[i];
980 tmp->bytes = (uint8_t*)OICMalloc(val->arr.ocByteStrArray[i].len * sizeof(uint8_t));
981 if (NULL == tmp->bytes)
983 for (size_t j = 0; j < i; ++j)
985 OCByteString* tmp = &(*array)[j];
993 tmp->len = val->arr.ocByteStrArray[i].len;
994 memcpy(tmp->bytes, val->arr.ocByteStrArray[i].bytes, tmp->len);
997 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1002 bool OCRepPayloadSetIntArrayAsOwner(OCRepPayload* payload, const char* name,
1003 int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1005 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
1012 val->arr.type = OCREP_PROP_INT;
1013 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1014 val->arr.iArray = array;
1019 bool OCRepPayloadSetIntArray(OCRepPayload* payload, const char* name,
1020 const int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1022 size_t dimTotal = calcDimTotal(dimensions);
1028 int64_t* newArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
1035 memcpy(newArray, array, dimTotal * sizeof(int64_t));
1038 bool b = OCRepPayloadSetIntArrayAsOwner(payload, name, newArray, dimensions);
1046 bool OCRepPayloadGetIntArray(const OCRepPayload* payload, const char* name,
1047 int64_t** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1049 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1051 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
1052 || !val->arr.iArray)
1057 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1062 *array = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
1068 memcpy(*array, val->arr.iArray, dimTotal * sizeof(int64_t));
1069 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1073 bool OCRepPayloadSetDoubleArrayAsOwner(OCRepPayload* payload, const char* name,
1074 double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1076 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
1083 val->arr.type = OCREP_PROP_DOUBLE;
1084 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1085 val->arr.dArray = array;
1089 bool OCRepPayloadSetDoubleArray(OCRepPayload* payload, const char* name,
1090 const double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1092 size_t dimTotal = calcDimTotal(dimensions);
1098 double* newArray = (double*)OICMalloc(dimTotal * sizeof(double));
1105 memcpy(newArray, array, dimTotal * sizeof(double));
1107 bool b = OCRepPayloadSetDoubleArrayAsOwner(payload, name, newArray, dimensions);
1115 bool OCRepPayloadGetDoubleArray(const OCRepPayload* payload, const char* name,
1116 double** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1118 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1120 if (!val || val->type != OCREP_PROP_ARRAY ||
1121 (val->arr.type != OCREP_PROP_DOUBLE && val->arr.type != OCREP_PROP_INT)
1122 || !val->arr.dArray)
1127 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1132 *array = (double*)OICMalloc(dimTotal * sizeof(double));
1138 if (val->arr.type == OCREP_PROP_DOUBLE)
1140 memcpy(*array, val->arr.dArray, dimTotal * sizeof(double));
1144 /* need to convert from integer */
1146 for ( ; n < dimTotal; ++n)
1148 (*array)[n] = val->arr.iArray[n];
1151 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1155 bool OCRepPayloadSetStringArrayAsOwner(OCRepPayload* payload, const char* name,
1156 char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1158 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
1165 val->arr.type = OCREP_PROP_STRING;
1166 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1167 val->arr.strArray = array;
1171 bool OCRepPayloadSetStringArray(OCRepPayload* payload, const char* name,
1172 const char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1174 size_t dimTotal = calcDimTotal(dimensions);
1180 char** newArray = (char**)OICMalloc(dimTotal * sizeof(char*));
1187 for(size_t i = 0; i < dimTotal; ++i)
1189 newArray[i] = OICStrdup(array[i]);
1192 bool b = OCRepPayloadSetStringArrayAsOwner(payload, name, newArray, dimensions);
1196 for(size_t i = 0; i < dimTotal; ++i)
1198 OICFree(newArray[i]);
1205 bool OCRepPayloadGetStringArray(const OCRepPayload* payload, const char* name,
1206 char*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1208 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1210 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
1211 || !val->arr.strArray)
1216 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1221 *array = (char**)OICMalloc(dimTotal * sizeof(char*));
1227 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1229 for(size_t i = 0; i < dimTotal; ++i)
1231 (*array)[i] = OICStrdup(val->arr.strArray[i]);
1238 bool OCRepPayloadSetBoolArrayAsOwner(OCRepPayload* payload, const char* name,
1239 bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1242 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
1249 val->arr.type = OCREP_PROP_BOOL;
1250 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1251 val->arr.bArray = array;
1255 bool OCRepPayloadSetBoolArray(OCRepPayload* payload, const char* name,
1256 const bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1258 size_t dimTotal = calcDimTotal(dimensions);
1264 bool* newArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
1271 memcpy(newArray, array, dimTotal * sizeof(bool));
1274 bool b = OCRepPayloadSetBoolArrayAsOwner(payload, name, newArray, dimensions);
1282 bool OCRepPayloadGetBoolArray(const OCRepPayload* payload, const char* name,
1283 bool** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1285 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1287 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
1288 || !val->arr.bArray)
1293 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1298 *array = (bool*)OICMalloc(dimTotal * sizeof(bool));
1304 memcpy(*array, val->arr.bArray, dimTotal * sizeof(bool));
1305 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1309 bool OCRepPayloadSetPropObjectArrayAsOwner(OCRepPayload* payload, const char* name,
1310 OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1312 OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
1319 val->arr.type = OCREP_PROP_OBJECT;
1320 memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1321 val->arr.objArray = array;
1326 bool OCRepPayloadSetPropObjectArray(OCRepPayload* payload, const char* name,
1327 const OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1329 size_t dimTotal = calcDimTotal(dimensions);
1335 OCRepPayload** newArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
1342 for(size_t i = 0; i < dimTotal; ++i)
1344 newArray[i] = OCRepPayloadClone(array[i]);
1347 bool b = OCRepPayloadSetPropObjectArrayAsOwner(payload, name, newArray, dimensions);
1351 for(size_t i = 0; i < dimTotal; ++i)
1353 OCRepPayloadDestroy(newArray[i]);
1360 bool OCRepPayloadGetPropObjectArray(const OCRepPayload* payload, const char* name,
1361 OCRepPayload*** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
1363 OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
1365 if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
1366 || !val->arr.objArray)
1371 size_t dimTotal = calcDimTotal(val->arr.dimensions);
1376 *array = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
1382 memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
1384 for(size_t i = 0; i < dimTotal; ++i)
1386 (*array)[i] = OCRepPayloadClone(val->arr.objArray[i]);
1392 void OCFreeOCStringLL(OCStringLL* ll)
1399 OCFreeOCStringLL(ll->next);
1404 OCStringLL* CloneOCStringLL (OCStringLL* ll)
1411 OCStringLL *sourceIter = ll;
1413 OCStringLL *destIter = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1418 destIter->value = OICStrdup (sourceIter->value);
1420 OCStringLL *headOfClone = destIter;
1422 sourceIter = sourceIter->next;
1426 destIter->next = (OCStringLL*)OICCalloc (1, sizeof (OCStringLL));
1427 if (!destIter->next)
1429 OCFreeOCStringLL (headOfClone);
1432 destIter->next->value = OICStrdup (sourceIter->value);
1434 destIter = destIter->next;
1435 sourceIter = sourceIter->next;
1440 OCStringLL* OCCreateOCStringLL(const char* text)
1445 char *backup = NULL;
1446 OCStringLL* result = NULL;
1447 OCStringLL* iter = NULL;
1448 OCStringLL* prev = NULL;
1449 static const char delim[] = { CSV_SEPARATOR, '\0' };
1451 VERIFY_PARAM_NON_NULL(TAG, text, "Invalid parameter");
1452 backup = OICStrdup(text);
1453 VERIFY_PARAM_NON_NULL(TAG, backup, "Failed allocating memory");
1455 for (head = backup; ; head = NULL)
1457 token = (char *) strtok_r(head, delim, &tail);
1462 iter = (OCStringLL *)OICCalloc(1,sizeof(OCStringLL));
1463 VERIFY_PARAM_NON_NULL(TAG, iter, "Failed allocating memory");
1472 iter->value = OICStrdup(token);
1473 VERIFY_PARAM_NON_NULL(TAG, iter->value, "Failed allocating memory");
1482 OCFreeOCStringLL(result);
1486 char* OCCreateString(const OCStringLL* ll)
1499 for (const OCStringLL *it = ll; it; it = it->next)
1501 len += strlen(it->value) + 1;
1503 len--; // remove trailing separator (just added above)
1504 str = (char*) malloc(len + 1);
1511 const OCStringLL *it = ll;
1514 sublen = strlen(it->value);
1515 count = snprintf(pos, len + 1, "%s", it->value);
1516 if ((size_t)count < sublen)
1527 *pos = CSV_SEPARATOR;
1536 bool OCByteStringCopy(OCByteString* dest, const OCByteString* source)
1538 VERIFY_PARAM_NON_NULL(TAG, source, "Bad input");
1542 dest = (OCByteString *)OICMalloc(sizeof(OCByteString));
1543 VERIFY_PARAM_NON_NULL(TAG, dest, "Failed allocating memory");
1547 OICFree(dest->bytes);
1549 dest->bytes = (uint8_t*)OICMalloc(source->len * sizeof(uint8_t));
1550 VERIFY_PARAM_NON_NULL(TAG, dest->bytes, "Failed allocating memory");
1551 memcpy(dest->bytes, source->bytes, source->len * sizeof(uint8_t));
1552 dest->len = source->len;
1559 OICFree(dest->bytes);
1566 OCRepPayload* OCRepPayloadClone (const OCRepPayload* payload)
1573 OCRepPayload *clone = OCRepPayloadCreate();
1580 clone->uri = OICStrdup (payload->uri);
1581 clone->types = CloneOCStringLL (payload->types);
1582 clone->interfaces = CloneOCStringLL (payload->interfaces);
1583 clone->values = OCRepPayloadValueClone (payload->values);
1589 void OCRepPayloadDestroy(OCRepPayload* payload)
1596 OICFree(payload->uri);
1597 OCFreeOCStringLL(payload->types);
1598 OCFreeOCStringLL(payload->interfaces);
1599 OCFreeRepPayloadValue(payload->values);
1600 OCRepPayloadDestroy(payload->next);
1604 OCDiscoveryPayload* OCDiscoveryPayloadCreate()
1606 OCDiscoveryPayload* payload = (OCDiscoveryPayload*)OICCalloc(1, sizeof(OCDiscoveryPayload));
1613 payload->base.type = PAYLOAD_TYPE_DISCOVERY;
1618 OCSecurityPayload* OCSecurityPayloadCreate(const uint8_t* securityData, size_t size)
1620 OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1627 payload->base.type = PAYLOAD_TYPE_SECURITY;
1628 payload->securityData = (uint8_t *)OICCalloc(1, size);
1629 if (!payload->securityData)
1634 memcpy(payload->securityData, (uint8_t *)securityData, size);
1635 payload->payloadSize = size;
1640 void OCSecurityPayloadDestroy(OCSecurityPayload* payload)
1647 OICClearMemory(payload->securityData, payload->payloadSize);
1648 OICFree(payload->securityData);
1652 size_t OCDiscoveryPayloadGetResourceCount(OCDiscoveryPayload* payload)
1655 OCResourcePayload* p = payload->resources;
1664 OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, size_t index)
1667 OCResourcePayload* p = payload->resources;
1681 static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t securePort)
1683 static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t securePort,
1687 OCResourcePayload* pl = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1693 pl->uri = OICStrdup(res->uri);
1697 OCDiscoveryResourceDestroy(pl);
1702 OCResourceType* typePtr = res->rsrcType;
1704 if (typePtr != NULL)
1706 pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1709 OCDiscoveryResourceDestroy(pl);
1712 pl->types->value = OICStrdup(typePtr->resourcetypename);
1713 if (!pl->types->value)
1715 OCDiscoveryResourceDestroy(pl);
1719 OCStringLL* cur = pl->types;
1720 typePtr = typePtr->next;
1723 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1726 OCDiscoveryResourceDestroy(pl);
1729 cur->next->value = OICStrdup(typePtr->resourcetypename);
1730 if (!cur->next->value)
1732 OCDiscoveryResourceDestroy(pl);
1736 typePtr = typePtr->next;
1741 OCResourceInterface* ifPtr = res->rsrcInterface;
1744 pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1745 if (!pl->interfaces)
1747 OCDiscoveryResourceDestroy(pl);
1750 pl->interfaces->value = OICStrdup(ifPtr->name);
1751 if (!pl->interfaces->value)
1753 OCDiscoveryResourceDestroy(pl);
1757 OCStringLL* cur = pl->interfaces;
1758 ifPtr = ifPtr->next;
1761 cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1764 OCDiscoveryResourceDestroy(pl);
1767 cur->next->value = OICStrdup(ifPtr->name);
1768 if (!cur->next->value)
1770 OCDiscoveryResourceDestroy(pl);
1774 ifPtr = ifPtr->next;
1778 pl->bitmap = res->resourceProperties & (OC_OBSERVABLE | OC_DISCOVERABLE
1783 pl->secure = (res->resourceProperties & OC_SECURE) != 0;
1784 pl->port = securePort;
1786 pl->tcpPort = tcpPort;
1792 void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
1793 uint16_t securePort)
1795 OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, securePort));
1798 void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
1799 uint16_t securePort, uint16_t tcpPort)
1801 OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, securePort, tcpPort));
1805 bool OCResourcePayloadAddStringLL(OCStringLL **stringLL, const char *value)
1807 char *dup = OICStrdup(value);
1808 VERIFY_PARAM_NON_NULL(TAG, dup, "Failed copying string");
1809 VERIFY_PARAM_NON_NULL(TAG, value, "Invalid Parameters");
1813 *stringLL = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
1814 VERIFY_PARAM_NON_NULL(TAG, *stringLL, "Failed allocating memory");
1815 (*stringLL)->value = dup;
1820 OCStringLL *temp = *stringLL;
1825 temp->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
1826 VERIFY_PARAM_NON_NULL(TAG, temp->next, "Failed allocating memory");
1827 temp->next->value = dup;
1835 void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res)
1842 if (!payload->resources)
1844 payload->resources = res;
1848 OCResourcePayload* p = payload->resources;
1857 void OCDiscoveryResourceDestroy(OCResourcePayload* payload)
1864 OICFree(payload->uri);
1865 OCFreeOCStringLL(payload->types);
1866 OCFreeOCStringLL(payload->interfaces);
1867 OCDiscoveryResourceDestroy(payload->next);
1871 void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
1877 OICFree(payload->sid);
1878 OICFree(payload->baseURI);
1879 OICFree(payload->uri);
1880 OCFreeOCStringLL(payload->type);
1881 OICFree(payload->name);
1882 OCFreeOCStringLL(payload->iface);
1883 OCDiscoveryResourceDestroy(payload->resources);
1884 OCDiscoveryPayloadDestroy(payload->next);
1888 OCDevicePayload* OCDevicePayloadCreate(const char* sid, const char* dname,
1889 const OCStringLL *types, const char* specVer, const char* dmVer)
1892 OCDevicePayload* payload = (OCDevicePayload*)OICCalloc(1, sizeof(OCDevicePayload));
1899 payload->base.type = PAYLOAD_TYPE_DEVICE;
1900 payload->sid = OICStrdup(sid);
1901 if (sid && !payload->sid)
1906 payload->deviceName = OICStrdup(dname);
1907 if (dname && !payload->deviceName)
1912 payload->specVersion = OICStrdup(specVer);
1913 if (specVer && !payload->specVersion)
1918 payload->dataModelVersions = OCCreateOCStringLL(dmVer);
1919 if (!payload->dataModelVersions || (dmVer && !payload->dataModelVersions->value))
1924 OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_DEFAULT);
1925 OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_READ);
1927 payload->types = CloneOCStringLL((OCStringLL *)types);
1928 if (types && !payload->types)
1936 OCDevicePayloadDestroy((OCDevicePayload*)payload);
1940 void OCDevicePayloadDestroy(OCDevicePayload* payload)
1947 OICFree(payload->sid);
1948 OICFree(payload->deviceName);
1949 OICFree(payload->specVersion);
1950 OCFreeOCStringLL(payload->dataModelVersions);
1951 OCFreeOCStringLL(payload->types);
1952 OCFreeOCStringLL(payload->interfaces);
1956 static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
1958 if (!platformInfo || !target)
1963 target->info.platformID = OICStrdup(platformInfo->platformID);
1964 target->info.manufacturerName = OICStrdup(platformInfo->manufacturerName);
1965 target->info.manufacturerUrl = OICStrdup(platformInfo->manufacturerUrl);
1966 target->info.modelNumber = OICStrdup(platformInfo->modelNumber);
1967 target->info.dateOfManufacture = OICStrdup(platformInfo->dateOfManufacture);
1968 target->info.platformVersion = OICStrdup(platformInfo->platformVersion);
1969 target->info.operatingSystemVersion = OICStrdup(platformInfo->operatingSystemVersion);
1970 target->info.hardwareVersion = OICStrdup(platformInfo->hardwareVersion);
1971 target->info.firmwareVersion = OICStrdup(platformInfo->firmwareVersion);
1972 target->info.supportUrl = OICStrdup(platformInfo->supportUrl);
1973 target->info.systemTime = OICStrdup(platformInfo->systemTime);
1976 OCPlatformPayload* OCPlatformPayloadCreateAsOwner(OCPlatformInfo* platformInfo)
1978 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
1984 payload->base.type = PAYLOAD_TYPE_PLATFORM;
1986 payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1987 if (!payload->interfaces)
1991 payload->interfaces->value = OICStrdup(OC_RSRVD_INTERFACE_READ);
1992 payload->rt = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
1997 payload->rt->value = OICStrdup(OC_RSRVD_RESOURCE_TYPE_PLATFORM);
1998 payload->info = *platformInfo;
2003 OCPlatformPayload* OCPlatformPayloadCreate(const OCPlatformInfo* platformInfo)
2005 OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
2012 payload->base.type = PAYLOAD_TYPE_PLATFORM;
2013 OCResourcePayloadAddStringLL(&payload->rt, OC_RSRVD_RESOURCE_TYPE_PLATFORM);
2015 OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_DEFAULT);
2016 OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_READ);
2018 OCCopyPlatformInfo(platformInfo, payload);
2023 void OCPlatformInfoDestroy(OCPlatformInfo *info)
2025 OICFree(info->platformID);
2026 OICFree(info->manufacturerName);
2027 OICFree(info->manufacturerUrl);
2028 OICFree(info->modelNumber);
2029 OICFree(info->dateOfManufacture);
2030 OICFree(info->platformVersion);
2031 OICFree(info->operatingSystemVersion);
2032 OICFree(info->hardwareVersion);
2033 OICFree(info->firmwareVersion);
2034 OICFree(info->supportUrl);
2035 OICFree(info->systemTime);
2038 void OCPlatformPayloadDestroy(OCPlatformPayload* payload)
2044 OICFree(payload->uri);
2045 OCPlatformInfoDestroy(&payload->info);
2046 OCFreeOCStringLL(payload->rt);
2047 OCFreeOCStringLL(payload->interfaces);
2051 OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
2052 OCPresenceTrigger trigger, const char* resourceType)
2054 OCPresencePayload* payload = (OCPresencePayload*)OICCalloc(1, sizeof(OCPresencePayload));
2060 payload->base.type = PAYLOAD_TYPE_PRESENCE;
2061 payload->sequenceNumber = seqNum;
2062 payload->maxAge = maxAge;
2063 payload->trigger = trigger;
2064 payload->resourceType = OICStrdup(resourceType);
2068 void OCPresencePayloadDestroy(OCPresencePayload* payload)
2074 OICFree(payload->resourceType);