| /* |
| * |
| * Copyright (c) 2017 Nest Labs, Inc. |
| * All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include <Weave/Support/CodeUtils.h> |
| #include <Weave/Support/logging/WeaveLogging.h> |
| #include <Weave/Support/SerializationUtils.h> |
| |
| namespace nl { |
| |
| using namespace nl::Weave::TLV; |
| |
| // |
| // Some notes on memory management. |
| // |
| // No dynamic memory allocation is necessary for serializing a structure, |
| // but it is REQUIRED for de-serializing. If your platform needs to |
| // de-serialize, you can: |
| // |
| // (1) Pass TLVReaderToDeserializedData() and |
| // TLVReaderToDeserializedDataHelper() a MemoryManagement |
| // structure with any implementations of malloc(), free(), |
| // and realloc() you choose, OR |
| // |
| // (2) Pass no MemoryManagement at all, in which case a default |
| // MemoryManagement will be used. |
| // |
| // If option (2) is chosen, you must turn on |
| // WEAVE_CONFIG_SERIALIZATION_USE_MALLOC, |
| // and the stdlib versions of malloc(), free(), and realloc() will be |
| // used. Otherwise the unsupported_*() functions will be used, which |
| // do nothing except log an error. |
| // |
| // The assumption is that de-serialization will likely be performed |
| // only on resource-rich platforms where dynamic memory allocation is |
| // supported. |
| // |
| |
| #if WEAVE_CONFIG_SERIALIZATION_USE_MALLOC |
| #if HAVE_MALLOC && HAVE_FREE && HAVE_REALLOC |
| static MemoryManagement sDefaultMemoryManagement = { malloc, free, realloc }; |
| #else // HAVE_MALLOC && HAVE_FREE && HAVE_REALLOC |
| #error "Implementations of malloc, free, and realloc must be present in order to use stdlib memory management." |
| #endif // HAVE_MALLOC && HAVE_FREE && HAVE_REALLOC |
| #else // WEAVE_CONFIG_SERIALIZATION_USE_MALLOC |
| static void *unsupported_malloc(size_t size) |
| { |
| WeaveLogError(Support, "malloc() not supported"); |
| return NULL; |
| } |
| |
| static void unsupported_free(void *ptr) |
| { |
| WeaveLogError(Support, "free() not supported"); |
| } |
| |
| static void *unsupported_realloc(void *ptr, size_t size) |
| { |
| WeaveLogError(Support, "realloc() not supported"); |
| return NULL; |
| } |
| |
| static MemoryManagement sDefaultMemoryManagement = { unsupported_malloc, unsupported_free, unsupported_realloc }; |
| #endif // WEAVE_CONFIG_SERIALIZATION_USE_MALLOC |
| |
| static WEAVE_ERROR WriteArrayData(TLVWriter &aWriter, |
| void *aStructureData, |
| const FieldDescriptor * aFieldPtr); |
| |
| static WEAVE_ERROR WriteDataForType(TLVWriter &aWriter, |
| void *aStructureData, |
| const FieldDescriptor *&aFieldPtr, |
| SerializedFieldType aType, |
| bool aInArray); |
| |
| static WEAVE_ERROR ReadArrayData(TLVReader &aReader, |
| void *aStructureData, |
| const FieldDescriptor * aFieldPtr, |
| SerializationContext *aContext = NULL); |
| |
| static WEAVE_ERROR ReadDataForType(TLVReader &aReader, |
| void *aStructureData, |
| const FieldDescriptor *&aFieldPtr, |
| SerializedFieldType aType, |
| bool aInArray, |
| SerializationContext *aContext = NULL); |
| |
| static WEAVE_ERROR CheckForEndOfTLV(TLVReader &aReader, bool &aEndOfTLV); |
| |
| static WEAVE_ERROR DeallocateDeserializedArray(void *aArrayData, |
| const SchemaFieldDescriptor *aFieldDescriptors, |
| SerializationContext *aContext = NULL); |
| |
| #if WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING |
| static int32_t sIndentationLevel = 0; |
| #define LogReadWrite(aFormat, ...) WeaveLogDetail(Support, "%*s" aFormat, sIndentationLevel, "", __VA_ARGS__) |
| #define LogReadWriteStartContainer(aFormat, ...) do { LogReadWrite(aFormat, __VA_ARGS__); sIndentationLevel += 2; } while (0); |
| #define LogReadWriteEndContainer(aFormat, ...) do { sIndentationLevel -= 2; LogReadWrite(aFormat, __VA_ARGS__); } while (0); |
| #else // WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING |
| #define LogReadWrite(aFormat, ...) |
| #define LogReadWriteStartContainer(aFormat, ...) |
| #define LogReadWriteEndContainer(aFormat, ...) |
| #endif // WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING |
| |
| static bool IsValidFieldType(SerializedFieldType aType) |
| { |
| return (aType <= SerializedFieldTypeArray); |
| } |
| |
| const static uint8_t sElementSize[] = |
| { |
| sizeof(bool), //SerializedFieldTypeBoolean |
| sizeof(uint8_t), //SerializedFieldTypeUInt8, |
| sizeof(uint16_t), //SerializedFieldTypeUInt16, |
| sizeof(uint32_t), //SerializedFieldTypeUInt32, |
| sizeof(uint64_t), //SerializedFieldTypeUInt64, |
| sizeof(int8_t), //SerializedFieldTypeInt8, |
| sizeof(int16_t), //SerializedFieldTypeInt16, |
| sizeof(int32_t), //SerializedFieldTypeInt32, |
| sizeof(int64_t), //SerializedFieldTypeInt64, |
| sizeof(float), //SerializedFieldTypeFloatingPoint32, |
| sizeof(double), //SerializedFieldTypeFloatingPoint64, |
| sizeof(char *), //SerializedFieldTypeUTF8String, |
| sizeof(SerializedByteString), //SerializedFieldTypeByteString, |
| sizeof(void *), //SerializedFieldTypeStructure, |
| sizeof(void *) //SerializedFieldTypeArray, |
| }; |
| |
| static WEAVE_ERROR GetArrayElementSize(uint32_t &aOutSize, const FieldDescriptor * aFieldPtr, SerializedFieldType aType) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| VerifyOrExit(aFieldPtr != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| if (aFieldPtr->mNestedFieldDescriptors) |
| { |
| VerifyOrExit(aType == SerializedFieldTypeStructure, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| LogReadWrite("%s element is a structure", __FUNCTION__); |
| aOutSize = aFieldPtr->mNestedFieldDescriptors->mSize; |
| } |
| else |
| { |
| LogReadWrite("%s element is a primitive size", __FUNCTION__); |
| aOutSize = sElementSize[aType]; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * A writer function that writes an array structure. |
| * |
| * @param aWriter[in] The writer to use for writing out the structure |
| * |
| * @param aStructureData[in] A pointer to the c-structure data to write based on the FieldDescriptor |
| * |
| * @param aFieldPtr[in] FieldDescriptor to describe the array c struct + TLV |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that mey be returned from the aWriter. |
| * |
| */ |
| WEAVE_ERROR WriteArrayData(TLVWriter &aWriter, void *aStructureData, const FieldDescriptor * aFieldPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const bool writingInArray = true; |
| SerializedFieldType type; |
| ArrayLengthAndBuffer *array; |
| const FieldDescriptor *fieldPtr = aFieldPtr; |
| uint32_t elementSize = 0; |
| |
| // aStructureData should be pointing to the wrapped length and buffer structure |
| array = static_cast<ArrayLengthAndBuffer *>(aStructureData); |
| |
| // the type of the array is next in the FieldDescriptors list |
| fieldPtr++; |
| |
| // Error check to see that this returns a valid type |
| type = fieldPtr->GetType(); |
| VerifyOrExit(IsValidFieldType(type), err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| err = GetArrayElementSize(elementSize, fieldPtr, type); |
| LogReadWrite("%s elementSize %d", "W", elementSize); |
| |
| for (uint32_t idx = 0; idx < array->mNumElements; idx++) |
| { |
| // Increment based on type |
| aFieldPtr = fieldPtr; |
| |
| LogReadWrite("%s aStructureData 0x%x array 0x%x array->mNumElements %d array->mElementBuffer 0x%x idx %d idx * elementSize 0x%x", "W", aStructureData, array, array->mNumElements, array->mElementBuffer, idx, idx * elementSize); |
| |
| err = WriteDataForType(aWriter, static_cast<char *>(array->mElementBuffer) + idx * elementSize, aFieldPtr, type, writingInArray); |
| SuccessOrExit(err); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * A writer function to check whether data is nullable/nullified before |
| * writing to the TLV. |
| * |
| * @param aWriter[in] The writer to use for writing out the structure |
| * |
| * @param aStructureData[in] A pointer to the c-structure data to read |
| * |
| * @param aFieldPtr[inout] FieldDescriptor to describe the fields and |
| * TLV tag. The function will increment |
| * the pointer s.t. it will point to the |
| * next element in the FieldDescriptor array |
| * |
| * @param aType[in] The SerializedFieldType of the field |
| * |
| * @param aIsNullified[in] The TLV tag will be nullified if this is true. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other TLV errors while writing. |
| * |
| */ |
| WEAVE_ERROR WriteNullableDataForType(TLVWriter &aWriter, void *aStructureData, const FieldDescriptor *&aFieldPtr, SerializedFieldType aType, bool aIsNullified) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| if (aIsNullified) |
| { |
| LogReadWrite("%s nullified", "W"); |
| |
| err = aWriter.PutNull(ContextTag(aFieldPtr->mTVDContextTag)); |
| SuccessOrExit(err); |
| |
| aFieldPtr++; |
| } |
| else |
| { |
| err = WriteDataForType(aWriter, aStructureData, aFieldPtr, aType, false); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * A writer function write a specific entry into the TLV based on structure data. |
| * |
| * @param aWriter[in] The writer to use for writing out the structure |
| * |
| * @param aStructureData[in] A pointer to the c-structure data to write |
| * |
| * @param aFieldPtr[inout] FieldDescriptor to describe the fields and |
| * TLV tag. The function will increment |
| * the pointer s.t. it will point to the |
| * next element in the FieldDescritor array |
| * |
| * @param aType[in] The SerializedFieldType of the field |
| * |
| * @param aInArray[in] True if we're writing an array (use anonymous tag) |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that mey be returned from the aWriter. |
| * |
| */ |
| WEAVE_ERROR WriteDataForType(TLVWriter &aWriter, void *aStructureData, const FieldDescriptor *&aFieldPtr, SerializedFieldType aType, bool aInArray) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| TLVType containerType; |
| |
| uint64_t tag = aInArray ? AnonymousTag : ContextTag(aFieldPtr->mTVDContextTag); |
| |
| LogReadWrite("%s aStructureData 0x%x", "W", aStructureData); |
| |
| switch (aType) |
| { |
| case SerializedFieldTypeBoolean: |
| { |
| bool v = *static_cast<bool *>(aStructureData); |
| |
| LogReadWrite("%s boolean '%s'", "W", v ? "true" : "false"); |
| |
| err = aWriter.PutBoolean(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeUInt8: |
| { |
| uint8_t v = *static_cast<uint8_t *>(aStructureData); |
| |
| LogReadWrite("%s uint8 %u", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeUInt16: |
| { |
| uint16_t v = *static_cast<uint16_t *>(aStructureData); |
| |
| LogReadWrite("%s uint16 %u", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeUInt32: |
| { |
| uint32_t v = *static_cast<uint32_t *>(aStructureData); |
| |
| LogReadWrite("%s uint32 %u", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeUInt64: |
| { |
| uint64_t v = *static_cast<uint64_t *>(aStructureData); |
| |
| LogReadWrite("%s uint64 %llu", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeInt8: |
| { |
| int8_t v = *static_cast<int8_t *>(aStructureData); |
| |
| LogReadWrite("%s int8 %d", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeInt16: |
| { |
| int16_t v = *static_cast<int16_t *>(aStructureData); |
| |
| LogReadWrite("%s int16 %d", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeInt32: |
| { |
| int32_t v = *static_cast<int32_t *>(aStructureData); |
| |
| LogReadWrite("%s int32 %d", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeInt64: |
| { |
| int64_t v = *static_cast<int64_t *>(aStructureData); |
| |
| LogReadWrite("%s int64 %d", "W", v); |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeFloatingPoint32: |
| { |
| float v = *static_cast<float *>(aStructureData); |
| |
| #if WEAVE_CONFIG_SERIALIZATION_LOG_FLOATS |
| LogReadWrite("%s float %f", "W", v); |
| #endif |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeFloatingPoint64: |
| { |
| double v = *static_cast<double *>(aStructureData); |
| |
| #if WEAVE_CONFIG_SERIALIZATION_LOG_FLOATS |
| LogReadWrite("%s double %f", "W", v); |
| #endif |
| |
| err = aWriter.Put(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeUTF8String: |
| { |
| const char *v = *static_cast<const char**>(aStructureData); |
| |
| LogReadWrite("%s utf8string '%s'", "W", v); |
| |
| err = aWriter.PutString(tag, v); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeByteString: |
| { |
| SerializedByteString v = *static_cast<SerializedByteString *>(aStructureData); |
| |
| LogReadWrite("%s bytestring len: %u", "W", v.mLen); |
| |
| err = aWriter.PutBytes(tag, v.mBuf, v.mLen); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| // We can hit this case when we have an array of structures. |
| case SerializedFieldTypeStructure: |
| { |
| err = aWriter.StartContainer(tag, |
| kTLVType_Structure, |
| containerType); |
| SuccessOrExit(err); |
| |
| LogReadWriteStartContainer("%s Structure Start", "W"); |
| |
| err = SerializedDataToTLVWriter(aWriter, aStructureData, aFieldPtr->mNestedFieldDescriptors); |
| SuccessOrExit(err); |
| |
| LogReadWriteEndContainer("%s Structure End", "W"); |
| |
| err = aWriter.EndContainer(containerType); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeArray: |
| { |
| err = aWriter.StartContainer(tag, |
| kTLVType_Array, |
| containerType); |
| SuccessOrExit(err); |
| |
| LogReadWriteStartContainer("%s Array Start", "W"); |
| |
| err = WriteArrayData(aWriter, aStructureData, aFieldPtr); |
| if (err == WEAVE_END_OF_TLV) |
| { |
| err = WEAVE_NO_ERROR; |
| } |
| SuccessOrExit(err); |
| |
| LogReadWriteEndContainer("%s Array End", "W"); |
| |
| err = aWriter.EndContainer(containerType); |
| SuccessOrExit(err); |
| |
| // Skip over the elements. |
| aFieldPtr++; |
| |
| break; |
| } |
| |
| default: |
| { |
| err = WEAVE_ERROR_INVALID_ARGUMENT; |
| break; |
| } |
| } |
| aFieldPtr++; |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * A reader function that reads an array structure. |
| * |
| * @param aReader[in] The reader to use for reading in the structure |
| * |
| * @param aStructureData[in] A pointer to the c-structure data to read based on the FieldDescriptor |
| * |
| * @param aFieldPtr[in] FieldDescriptor to describe the array c struct + TLV |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that mey be returned from the aWriter. |
| * |
| */ |
| WEAVE_ERROR ReadArrayData(TLVReader &aReader, void *aStructureData, const FieldDescriptor * aFieldPtr, SerializationContext *aContext) |
| { |
| #if WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const bool readingOutArray = true; |
| SerializedFieldType type; |
| ArrayLengthAndBuffer *array; |
| const FieldDescriptor *fieldPtr = aFieldPtr; |
| size_t count = 0; |
| char *outputBuffer = NULL; |
| size_t outputBufferNumItems = 0; |
| size_t outputBufferNumResizes = 0; |
| MemoryManagement *memMgmt = NULL; |
| uint32_t elementSize = 0; |
| bool endOfTLV = false; |
| |
| if ((aContext == NULL) || !(aContext->memMgmt.mem_alloc && aContext->memMgmt.mem_free && aContext->memMgmt.mem_realloc)) |
| { |
| memMgmt = &sDefaultMemoryManagement; |
| } |
| else |
| { |
| memMgmt = &aContext->memMgmt; |
| } |
| |
| // aStructureData should be pointing to the wrapped length and buffer structure |
| array = static_cast<ArrayLengthAndBuffer *>(aStructureData); |
| |
| // Initialize. |
| array->mNumElements = 0; |
| array->mElementBuffer = NULL; |
| |
| // the type of the array is next in the FieldDescriptors list |
| fieldPtr++; |
| |
| // Error check to see that this returns a valid type |
| type = fieldPtr->GetType(); |
| VerifyOrExit(IsValidFieldType(type), err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| err = GetArrayElementSize(elementSize, fieldPtr, type); |
| LogReadWrite("%s elementSize %d", "R", elementSize); |
| |
| VerifyOrExit(array && (elementSize > 0), err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| // Check to see whether there are any elements to read in. |
| err = CheckForEndOfTLV(aReader, endOfTLV); |
| SuccessOrExit(err); |
| VerifyOrExit(endOfTLV == false, LogReadWrite("%s array contains no elements", "R")); |
| |
| // Read in each element. |
| while (err == WEAVE_NO_ERROR) |
| { |
| // See whether the output buffer needs to be resized. |
| if (count >= outputBufferNumItems) |
| { |
| outputBufferNumItems = (1 << ++outputBufferNumResizes); |
| outputBuffer = (char *)memMgmt->mem_realloc((void *)outputBuffer, outputBufferNumItems*elementSize); |
| VerifyOrExit(outputBuffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| LogReadWrite("%s allocating array memory at 0x%x", "R", outputBuffer); |
| } |
| |
| // Increment based on type |
| aFieldPtr = fieldPtr; |
| |
| LogReadWrite("%s aStructureData 0x%x array 0x%x count %d outputBuffer 0x%x count*elementSize 0x%x", "R", aStructureData, array, count, outputBuffer, count, count*elementSize); |
| |
| err = ReadDataForType(aReader, outputBuffer + count*elementSize, aFieldPtr, type, readingOutArray, aContext); |
| if (err == WEAVE_END_OF_TLV) |
| { |
| count++; |
| |
| array->mNumElements = count; |
| array->mElementBuffer = outputBuffer; |
| err = WEAVE_NO_ERROR; |
| break; |
| } |
| |
| count++; |
| } |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| if (outputBuffer != NULL) |
| { |
| memMgmt->mem_free(outputBuffer); |
| } |
| } |
| |
| return err; |
| #else // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| return WEAVE_ERROR_NOT_IMPLEMENTED; |
| #endif // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| } |
| |
| /** |
| * @brief |
| * A reader function to see whether the next element in a TLVReader is the end of TLV. |
| * |
| * @param aReader[in] The reader |
| * |
| * @param aEndOfTLV[inout] A bool set to true if the next element in the reader is |
| * the end of TLV, false otherwise |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that may be returned from the aReader. |
| * |
| */ |
| static WEAVE_ERROR CheckForEndOfTLV(TLVReader &aReader, bool &aEndOfTLV) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| TLVReader reader; |
| |
| // Initialize. |
| aEndOfTLV = false; |
| |
| // Initialize a new reader, at aReader's position. |
| reader.Init(aReader); |
| |
| // Position it the next element. |
| err = reader.Next(); |
| VerifyOrExit(err == WEAVE_NO_ERROR || err == WEAVE_END_OF_TLV, ); |
| |
| // If err was WEAVE_END_OF_TLV, we've the end of TLV and we can |
| // safely suppress the error. |
| if (err == WEAVE_END_OF_TLV) |
| { |
| aEndOfTLV = true; |
| err = WEAVE_NO_ERROR; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * A reader function to check whether data is nullable/nullified before |
| * reading from the TLV. |
| * |
| * @param aReader[in] The reader to use for reading in the structure |
| * |
| * @param aStructureData[in] A pointer to the c-structure data to read |
| * |
| * @param aFieldPtr[inout] FieldDescriptor to describe the fields and |
| * TLV tag. The function will increment |
| * the pointer s.t. it will point to the |
| * next element in the FieldDescriptor array |
| * |
| * @param aType[in] The SerializedFieldType of the field |
| * |
| * @param aIsNullified[out] Set to indicate that a field is nullified. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other TLV errors while writing. |
| * |
| */ |
| WEAVE_ERROR ReadNullableDataForType(TLVReader &aReader, void *aStructureData, const FieldDescriptor *&aFieldPtr, SerializedFieldType aType, bool &aIsNullified, SerializationContext *aContext) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| if ((aFieldPtr->IsNullable()) && (aReader.GetType() == kTLVType_Null)) |
| { |
| aIsNullified = true; |
| aFieldPtr++; |
| err = aReader.Next(); |
| LogReadWrite("%s nullified", "R"); |
| } |
| else |
| { |
| aIsNullified = false; |
| err = ReadDataForType(aReader, aStructureData, aFieldPtr, aType, false, aContext); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * A reader function to read a specific entry from the TLV based on structure data. |
| * |
| * @param aReader[in] The reader to use for reading in the structure |
| * |
| * @param aStructureData[in] A pointer to the c-structure data to read |
| * |
| * @param aFieldPtr[inout] FieldDescriptor to describe the fields and |
| * TLV tag. The function will increment |
| * the pointer s.t. it will point to the |
| * next element in the FieldDescritor array |
| * |
| * @param aType[in] The SerializedFieldType of the field |
| * |
| * @param aInArray[in] True if we're reading an array (use anonymous tag) |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that mey be returned from the aReader. |
| * |
| */ |
| WEAVE_ERROR ReadDataForType(TLVReader &aReader, void *aStructureData, const FieldDescriptor *&aFieldPtr, SerializedFieldType aType, bool aInArray, SerializationContext *aContext) |
| { |
| #if WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| TLVType containerType; |
| MemoryManagement *memMgmt = NULL; |
| |
| if ((aContext == NULL) || !(aContext->memMgmt.mem_alloc && aContext->memMgmt.mem_free && aContext->memMgmt.mem_realloc)) |
| { |
| memMgmt = &sDefaultMemoryManagement; |
| } |
| else |
| { |
| memMgmt = &aContext->memMgmt; |
| } |
| |
| LogReadWrite("%s aStructureData 0x%x", "R", aStructureData); |
| |
| switch (aType) |
| { |
| case SerializedFieldTypeBoolean: |
| { |
| bool v = false; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s boolean '%s'", "R", v ? "true" : "false"); |
| |
| *static_cast<bool *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeUInt8: |
| { |
| uint8_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s uint8 %d", "R", v); |
| |
| *static_cast<uint8_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeUInt16: |
| { |
| uint16_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s unt16 %u", "R", v); |
| |
| *static_cast<uint16_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeUInt32: |
| { |
| uint32_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s uint32 %u", "R", v); |
| |
| *static_cast<uint32_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeUInt64: |
| { |
| uint64_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s uint64 %llu", "R", v); |
| |
| *static_cast<uint64_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeInt8: |
| { |
| int8_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s int8 %d", "R", v); |
| |
| *static_cast<int8_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeInt16: |
| { |
| int16_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s int16 %d", "R", v); |
| |
| *static_cast<int16_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeInt32: |
| { |
| int32_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s int32 %d", "R", v); |
| |
| *static_cast<int32_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeInt64: |
| { |
| int64_t v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s int64 %d", "R", v); |
| |
| *static_cast<int8_t *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeFloatingPoint32: |
| { |
| double v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| #if WEAVE_CONFIG_SERIALIZATION_LOG_FLOATS |
| LogReadWrite("%s float %f", "R", v); |
| #endif |
| |
| *static_cast<float *>(aStructureData) = (float)v; |
| break; |
| } |
| |
| case SerializedFieldTypeFloatingPoint64: |
| { |
| double v = 0; |
| err = aReader.Get(v); |
| SuccessOrExit(err); |
| |
| #if WEAVE_CONFIG_SERIALIZATION_LOG_FLOATS |
| LogReadWrite("%s double %f", "R", v); |
| #endif |
| |
| *static_cast<double *>(aStructureData) = v; |
| break; |
| } |
| |
| case SerializedFieldTypeUTF8String: |
| { |
| char *dst = NULL; |
| // TLV Strings are not null terminated |
| uint32_t length = aReader.GetLength() + 1; |
| |
| dst = (char *)memMgmt->mem_alloc(length); |
| VerifyOrExit(dst != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = aReader.GetString(dst, length); |
| SuccessOrExit(err); |
| |
| LogReadWrite("%s utf8string '%s' allocating %d bytes at %p", "R", dst, length, dst); |
| *static_cast<char**>(aStructureData) = dst; |
| break; |
| } |
| |
| case SerializedFieldTypeByteString: |
| { |
| SerializedByteString byteString; |
| byteString.mLen = aReader.GetLength(); |
| |
| byteString.mBuf = static_cast<uint8_t *>(memMgmt->mem_alloc(byteString.mLen)); |
| VerifyOrExit(byteString.mBuf != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| aReader.GetBytes(byteString.mBuf, byteString.mLen); |
| |
| LogReadWrite("%s bytestring allocated %d bytes at %p", "R", byteString.mLen, byteString.mBuf); |
| *static_cast<SerializedByteString *>(aStructureData) = byteString; |
| break; |
| } |
| |
| // We can hit this case when we have an array of structures. |
| case SerializedFieldTypeStructure: |
| err = aReader.EnterContainer(containerType); |
| SuccessOrExit(err); |
| VerifyOrExit(aReader.GetContainerType() == nl::Weave::TLV::kTLVType_Structure, err = WEAVE_ERROR_WRONG_TLV_TYPE); |
| |
| err = aReader.Next(); |
| if (err == WEAVE_END_OF_TLV) |
| err = WEAVE_NO_ERROR; |
| SuccessOrExit(err); |
| |
| LogReadWriteStartContainer("%s Structure Start", "R"); |
| |
| err = TLVReaderToDeserializedData(aReader, aStructureData, aFieldPtr->mNestedFieldDescriptors, aContext); |
| if (err == WEAVE_END_OF_TLV) |
| { |
| err = WEAVE_NO_ERROR; |
| } |
| SuccessOrExit(err); |
| |
| LogReadWriteEndContainer("%s Structure End", "R"); |
| |
| err = aReader.ExitContainer(containerType); |
| break; |
| case SerializedFieldTypeArray: |
| { |
| err = aReader.EnterContainer(containerType); |
| SuccessOrExit(err); |
| VerifyOrExit(aReader.GetContainerType() == nl::Weave::TLV::kTLVType_Array, err = WEAVE_ERROR_WRONG_TLV_TYPE); |
| |
| err = aReader.Next(); |
| if (err == WEAVE_END_OF_TLV) |
| err = WEAVE_NO_ERROR; |
| SuccessOrExit(err); |
| |
| LogReadWriteStartContainer("%s Array Start", "R"); |
| |
| err = ReadArrayData(aReader, aStructureData, aFieldPtr, aContext); |
| SuccessOrExit(err); |
| |
| LogReadWriteEndContainer("%s Array End", "R"); |
| |
| err = aReader.ExitContainer(containerType); |
| |
| // Skip over elements. |
| aFieldPtr++; |
| |
| break; |
| } |
| default: |
| err = WEAVE_ERROR_INVALID_ARGUMENT; |
| break; |
| } |
| aFieldPtr++; |
| err = aReader.Next(); |
| exit: |
| return err; |
| #else // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| return WEAVE_ERROR_NOT_IMPLEMENTED; |
| #endif // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| } |
| |
| /** |
| * @brief |
| * A helper function to find the location of the nullified fields array |
| * located at the end of the C struct. |
| * |
| * The __nullified_fields__ member of the C struct is expected to be located |
| * directly after the last member described by the array of FieldDescriptors. |
| * It is not in the list of field descriptors, as it's meant to be a hidden |
| * utility for creators and consumers of nullable events. This struct member |
| * does not exist for events with no nullable fields, however by construction |
| * of setters and getters, no out of bounds accesses should occur. |
| * |
| * @param aStructureData[in] A pointer to the c-struct |
| * |
| * @param aFieldDescriptors[in] SchemaFieldDescriptors to describe the c struct |
| * |
| * @param aNullifiedFields[out] A pointer to __nullified_fields__ member of |
| * the c struct |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval #WEAVE_ERROR_INVALID_ARGUMENT If the field descriptor pointer is NULL. |
| * |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If the format of the field descriptors |
| * doesn't match expectation. |
| * |
| * |
| */ |
| static WEAVE_ERROR FindNullifiedFieldsArray(void *aStructureData, const SchemaFieldDescriptor *aSchemaDescriptor, uint8_t *&aNullifiedFields) |
| { |
| uint32_t offset; |
| WEAVE_ERROR err; |
| const FieldDescriptor *lastFieldDescriptor = &(aSchemaDescriptor->mFields[aSchemaDescriptor->mNumFieldDescriptorElements - 1]); |
| |
| err = GetArrayElementSize(offset, lastFieldDescriptor, lastFieldDescriptor->GetType()); |
| SuccessOrExit(err); |
| |
| aNullifiedFields = static_cast<uint8_t *>(aStructureData) + lastFieldDescriptor->mOffset + offset; |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * A writer function to convert a data structure into a TLV structure. Uses |
| * a SchemaFieldDescriptor to interpret the data structure and write to the TLV. |
| * |
| * @param aWriter[in] The writer to use for writing out the structure |
| * |
| * @param aStructureData[in] A pointer to the c-structure data to write based on the SchemaFieldDescriptor |
| * |
| * @param aFieldDescriptors[in] SchemaFieldDescriptors to describe the c struct + TLV |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that mey be returned from the aWriter. |
| * |
| */ |
| WEAVE_ERROR SerializedDataToTLVWriter(TLVWriter &aWriter, void *aStructureData, const SchemaFieldDescriptor *aFieldDescriptors) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const FieldDescriptor *fieldPtr = aFieldDescriptors->mFields; |
| const FieldDescriptor *endFieldPtr = &(aFieldDescriptors->mFields[aFieldDescriptors->mNumFieldDescriptorElements]); |
| int nullifiedBitIdx = 0; |
| uint8_t *nullifiedFields = NULL; |
| |
| err = FindNullifiedFieldsArray(aStructureData, aFieldDescriptors, nullifiedFields); |
| SuccessOrExit(err); |
| |
| while (fieldPtr < endFieldPtr) |
| { |
| bool aIsNullified = fieldPtr->IsNullable() && |
| GET_FIELD_NULLIFIED_BIT(nullifiedFields, nullifiedBitIdx); |
| |
| if (fieldPtr->IsNullable()) |
| { |
| nullifiedBitIdx++; |
| } |
| |
| err = WriteNullableDataForType(aWriter, |
| static_cast<char *>(aStructureData) + fieldPtr->mOffset, |
| fieldPtr, |
| fieldPtr->GetType(), |
| aIsNullified); |
| SuccessOrExit(err); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| |
| /** |
| * @brief |
| * A wrapper writer function that surrounds the SerializedDataToTLVWriter with a container. |
| * Also splits up an StructureSchemaPointerPair into structure data and descriptors to pass through. |
| * |
| * @param aWriter[in] The writer to use for writing out the structure |
| * |
| * @param aAppData[in] StructureSchemaPointerPair that contains a pointer to |
| * structure data and field descriptors. void* due to prototype |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that mey be returned from the aWriter. |
| * |
| */ |
| WEAVE_ERROR SerializedDataToTLVWriterHelper(TLVWriter &aWriter, uint8_t aDataTag, void *aAppData) |
| { |
| StructureSchemaPointerPair *structureSchemaPair = static_cast<StructureSchemaPointerPair *>(aAppData); |
| const bool inArray = false; |
| FieldDescriptor descriptor = { structureSchemaPair->mFieldSchema, |
| 0, |
| static_cast<uint8_t>(SerializedFieldTypeStructure), |
| aDataTag }; |
| const FieldDescriptor * pDescriptor = & descriptor; |
| |
| #if WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING |
| sIndentationLevel = 0; |
| #endif |
| |
| return WriteDataForType(aWriter, structureSchemaPair->mStructureData, pDescriptor, SerializedFieldTypeStructure, inArray); |
| } |
| |
| /** |
| * @brief |
| * A reader function to convert TLV into a C-struct. Uses |
| * a SchemaFieldDescriptor to interpret the data structure. |
| * |
| * It must be robust both to encoutering unknown fields and to not |
| * encountering an expected field. |
| * |
| * @param aReader[in] The reader to use for reading in the data |
| * |
| * @param aStructureData[in] A pointer to the destination c-structure data into which we'll read |
| * based on the SchemaFieldDescriptor |
| * |
| * @param aFieldDescriptors[in] SchemaFieldDescriptors to describe the c struct + TLV |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that may be returned from the aReader. |
| * |
| */ |
| WEAVE_ERROR TLVReaderToDeserializedData(nl::Weave::TLV::TLVReader &aReader, |
| void *aStructureData, |
| const SchemaFieldDescriptor *aFieldDescriptors, |
| SerializationContext *aContext) |
| { |
| #if WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const FieldDescriptor *fieldPtr = aFieldDescriptors->mFields; |
| const FieldDescriptor *endFieldPtr = &(aFieldDescriptors->mFields[aFieldDescriptors->mNumFieldDescriptorElements]); |
| int nullifiedBitIdx = 0; |
| uint8_t *nullifiedFields = NULL; |
| |
| err = FindNullifiedFieldsArray(aStructureData, aFieldDescriptors, nullifiedFields); |
| SuccessOrExit(err); |
| |
| // while there are remaining fields to be parsed |
| while (fieldPtr < endFieldPtr) |
| { |
| // Tentatively searches for the next schema field matching the TLV tag in head. |
| const FieldDescriptor *searchFieldPtr = fieldPtr; |
| int searchNullifiedBitIdx = nullifiedBitIdx; |
| while (searchFieldPtr < endFieldPtr |
| && TagNumFromTag(aReader.GetTag()) != searchFieldPtr->mTVDContextTag) |
| { |
| // Sets any nullable skipped fields to NULL |
| if (searchFieldPtr->IsNullable()) |
| { |
| SET_FIELD_NULLIFIED_BIT(nullifiedFields, searchNullifiedBitIdx); |
| searchNullifiedBitIdx++; |
| } |
| |
| searchFieldPtr++; |
| } |
| |
| // If schema found for TLV tag |
| if (searchFieldPtr != endFieldPtr) |
| { |
| // Commit to found schema |
| fieldPtr = searchFieldPtr; |
| nullifiedBitIdx = searchNullifiedBitIdx; |
| |
| bool isNullified = false; |
| bool isNullable = fieldPtr->IsNullable(); |
| err = ReadNullableDataForType(aReader, |
| static_cast<char *>(aStructureData) + fieldPtr->mOffset, |
| fieldPtr, |
| fieldPtr->GetType(), |
| isNullified, |
| aContext); |
| |
| if (isNullable) |
| { |
| if (isNullified) |
| { |
| SET_FIELD_NULLIFIED_BIT(nullifiedFields, nullifiedBitIdx); |
| } |
| else |
| { |
| CLEAR_FIELD_NULLIFIED_BIT(nullifiedFields, nullifiedBitIdx); |
| } |
| |
| nullifiedBitIdx++; |
| } |
| |
| if (err == WEAVE_END_OF_TLV) |
| { |
| err = WEAVE_NO_ERROR; |
| break; |
| } |
| SuccessOrExit(err); |
| } |
| else |
| { |
| // If schema not found, move TLV forward to skip unknown field. |
| err = aReader.Next(); |
| if (err == WEAVE_END_OF_TLV) |
| { |
| err = WEAVE_NO_ERROR; |
| break; |
| } |
| } |
| } |
| |
| // Sets any unparsed field (TLV ended prematurely) to NULL |
| while (fieldPtr < endFieldPtr) |
| { |
| if (fieldPtr->IsNullable()) |
| { |
| SET_FIELD_NULLIFIED_BIT(nullifiedFields, nullifiedBitIdx); |
| nullifiedBitIdx++; |
| } |
| fieldPtr++; |
| } |
| |
| exit: |
| return err; |
| #else // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| return WEAVE_ERROR_NOT_IMPLEMENTED; |
| #endif // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| } |
| |
| /** |
| * @brief |
| * A wrapper reader function that surrounds the TLVReaderToDeserializedData with a container. |
| * Also splits up an StructureSchemaPointerPair into structure data and descriptors to pass through. |
| * |
| * @param aReader[in] The reader to use for writing out the structure |
| * |
| * @param aProfileId[in] Unused for the moment |
| * |
| * @param aStructureType[in] Unused for the moment |
| * |
| * @param aAppData[in] StructureSchemaPointerPair that contains a pointer to |
| * structure data and field descriptors. void* due to prototype |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval other Other errors that mey be returned from the aReader. |
| * |
| */ |
| WEAVE_ERROR TLVReaderToDeserializedDataHelper(nl::Weave::TLV::TLVReader &aReader, |
| uint8_t aDataTag, |
| void *aAppData, |
| SerializationContext *aContext) |
| { |
| #if WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| StructureSchemaPointerPair *structureSchemaPair = static_cast<StructureSchemaPointerPair *>(aAppData); |
| const bool inArray = false; |
| FieldDescriptor descriptor = { structureSchemaPair->mFieldSchema, |
| 0, |
| static_cast<uint8_t>(SerializedFieldTypeStructure), |
| aDataTag }; |
| const FieldDescriptor * pDescriptor = & descriptor; |
| |
| #if WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING |
| sIndentationLevel = 0; |
| #endif |
| |
| err = ReadDataForType(aReader, structureSchemaPair->mStructureData, pDescriptor, SerializedFieldTypeStructure, inArray, aContext); |
| if (err == WEAVE_END_OF_TLV) |
| { |
| err = WEAVE_NO_ERROR; |
| } |
| |
| return err; |
| #else // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| return WEAVE_ERROR_NOT_IMPLEMENTED; |
| #endif // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| } |
| |
| WEAVE_ERROR DeallocateDeserializedArray(void *aArrayData, |
| const SchemaFieldDescriptor *aFieldDescriptors, |
| SerializationContext *aContext/* = NULL*/) |
| { |
| #if WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| MemoryManagement *memMgmt = NULL; |
| ArrayLengthAndBuffer *array = NULL; |
| |
| // aStructureData should be pointing to the wrapped length and buffer structure |
| array = static_cast<ArrayLengthAndBuffer *>(aArrayData); |
| |
| if ((aContext == NULL) || !(aContext->memMgmt.mem_alloc && aContext->memMgmt.mem_free && aContext->memMgmt.mem_realloc)) |
| { |
| memMgmt = &sDefaultMemoryManagement; |
| } |
| else |
| { |
| memMgmt = &aContext->memMgmt; |
| } |
| |
| if (aFieldDescriptors == NULL) |
| { |
| LogReadWrite("%s Freeing array of primitive type at 0x%x", "R", array->mElementBuffer); |
| |
| // The elements are of a primitive type, we can free the array now. |
| memMgmt->mem_free(array->mElementBuffer); |
| } |
| else |
| { |
| // The elements are structures, and we need to deallocate each one. |
| for (uint32_t i = 0; i < array->mNumElements; i++) |
| { |
| char *element = static_cast<char *>(array->mElementBuffer) + i*aFieldDescriptors->mSize; |
| err = DeallocateDeserializedStructure(element, aFieldDescriptors, aContext); |
| SuccessOrExit(err); |
| } |
| |
| LogReadWrite("%s Freeing array of structures at 0x%x", "R", array->mElementBuffer); |
| |
| // Free the array now. |
| memMgmt->mem_free(array->mElementBuffer); |
| } |
| |
| exit: |
| return err; |
| #else // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| return WEAVE_ERROR_NOT_IMPLEMENTED; |
| #endif // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| } |
| |
| WEAVE_ERROR DeallocateDeserializedStructure(void *aStructureData, |
| const SchemaFieldDescriptor *aFieldDescriptors, |
| SerializationContext *aContext/* = NULL*/) |
| { |
| #if WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const FieldDescriptor *fieldPtr = aFieldDescriptors->mFields; |
| const FieldDescriptor *endFieldPtr = &(aFieldDescriptors->mFields[aFieldDescriptors->mNumFieldDescriptorElements]); |
| MemoryManagement *memMgmt = NULL; |
| |
| if ((aContext == NULL) || !(aContext->memMgmt.mem_alloc && aContext->memMgmt.mem_free && aContext->memMgmt.mem_realloc)) |
| { |
| memMgmt = &sDefaultMemoryManagement; |
| } |
| else |
| { |
| memMgmt = &aContext->memMgmt; |
| } |
| |
| while (fieldPtr < endFieldPtr) |
| { |
| char *currentFieldData = static_cast<char *>(aStructureData) + fieldPtr->mOffset; |
| |
| switch (fieldPtr->GetType()) |
| { |
| case SerializedFieldTypeStructure: |
| { |
| err = DeallocateDeserializedStructure(currentFieldData, |
| fieldPtr->mNestedFieldDescriptors, |
| aContext); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeArray: |
| { |
| // fieldPtr is telling us we have an array, but the |
| // elements reside at the next field. Increment |
| // fieldPtr to get us to the elements, but leave |
| // currentFieldData where it is. |
| fieldPtr++; |
| |
| err = DeallocateDeserializedArray(currentFieldData, |
| fieldPtr->mNestedFieldDescriptors, |
| aContext); |
| SuccessOrExit(err); |
| break; |
| } |
| |
| case SerializedFieldTypeUTF8String: |
| { |
| char *str = *((char **)currentFieldData); |
| |
| LogReadWrite("%s Freeing UTF8String '%s' at 0x%x", "R", str, str); |
| |
| // Go ahead and free it here. |
| memMgmt->mem_free(str); |
| break; |
| } |
| |
| default: |
| { |
| // A primitive type, doesn't need to be deallocated. |
| break; |
| } |
| } |
| |
| fieldPtr++; |
| } |
| |
| exit: |
| if (err == WEAVE_END_OF_TLV) |
| { |
| err = WEAVE_NO_ERROR; |
| } |
| return err; |
| #else // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| return WEAVE_ERROR_NOT_IMPLEMENTED; |
| #endif // WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION |
| } |
| |
| } // nl |
