| /* |
| * |
| * Copyright (c) 2015-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. |
| */ |
| |
| /** |
| * @file |
| * This file implements interfaces for debugging and logging |
| * Weave TLV. |
| * |
| */ |
| |
| #ifndef __STDC_FORMAT_MACROS |
| #define __STDC_FORMAT_MACROS |
| #endif |
| |
| #include <ctype.h> |
| #include <inttypes.h> |
| #include <string.h> |
| |
| #include <Weave/Core/WeaveTLV.h> |
| #include <Weave/Core/WeaveTLVDebug.hpp> |
| #include <Weave/Core/WeaveTLVUtilities.hpp> |
| #include <Weave/Support/CodeUtils.h> |
| #include <Weave/Support/logging/WeaveLogging.h> |
| |
| namespace nl { |
| |
| namespace Weave { |
| |
| namespace TLV { |
| |
| namespace Debug { |
| |
| /** |
| * Dump the TLV element referenced by @a aReader in human-readable form using |
| * @a aWriter. |
| * |
| * @param[in] aWriter The writer to log the TLV data. |
| * @param[in] aTabs The indentation for logging the current depth into |
| * the TLV data. |
| * @param[in] aReader A read-only reference to the TLV reader containing |
| * the TLV data to log. |
| * @param[in] aDepth The current depth into the TLV data. |
| * |
| */ |
| static void DumpHandler(DumpWriter aWriter, const char *aTabs, const TLVReader &aReader, size_t aDepth) |
| { |
| const TLVType type = aReader.GetType(); |
| const uint64_t tag = aReader.GetTag(); |
| const uint32_t len = aReader.GetLength(); |
| const uint8_t *strbuf = NULL; |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| TLVReader temp; |
| TLVTagControl tagControl; |
| |
| temp.Init(aReader); |
| tagControl = static_cast<TLVTagControl>(temp.GetControlByte() & kTLVTagControlMask); |
| |
| aWriter("%zd %s", aDepth, aTabs); |
| |
| aWriter("%p, ", temp.GetReadPoint()); |
| |
| if (IsProfileTag(tag)) |
| { |
| aWriter("tag[%s]: 0x%x::0x%x::0x%x, ", DecodeTagControl(tagControl), VendorIdFromTag(tag), ProfileNumFromTag(tag), TagNumFromTag(tag)); |
| } |
| else if (IsContextTag(tag)) |
| { |
| aWriter("tag[%s]: 0x%x, ", DecodeTagControl(tagControl), (uint32_t)ContextTag(tag)); |
| } |
| else if (IsSpecialTag(tag)) |
| { |
| |
| aWriter("tag[%s]: 0x%x, ", DecodeTagControl(tagControl), tag); |
| } |
| else |
| { |
| aWriter("tag[unknown]: 0x%x, ", tag); |
| } |
| |
| aWriter("type: %s (0x%02x), ", DecodeType(type), type); |
| |
| |
| if (TLVTypeIsContainer(type)) |
| { |
| aWriter("container: "); |
| } |
| else |
| { |
| if (type == kTLVType_UTF8String || type == kTLVType_ByteString) |
| aWriter("length: %" PRIu32 ", ", len); |
| |
| aWriter("value: "); |
| |
| switch (type) { |
| |
| case kTLVType_SignedInteger: |
| int64_t sVal; |
| err = temp.Get(sVal); |
| VerifyOrExit(err == WEAVE_NO_ERROR, aWriter("Error in kTLVType_SignedInteger")); |
| aWriter("%" PRIi64, sVal); |
| break; |
| |
| case kTLVType_UnsignedInteger: |
| uint64_t uVal; |
| err = temp.Get(uVal); |
| VerifyOrExit(err == WEAVE_NO_ERROR, aWriter("Error in kTLVType_UnsignedInteger")); |
| aWriter("%" PRIu64, uVal); |
| break; |
| |
| case kTLVType_Boolean: |
| bool bVal; |
| err = temp.Get(bVal); |
| VerifyOrExit(err == WEAVE_NO_ERROR, aWriter("Error in kTLVType_Boolean")); |
| aWriter("%s", bVal ? "true" : "false"); |
| break; |
| |
| case kTLVType_FloatingPointNumber: |
| double fpVal; |
| err = temp.Get(fpVal); |
| VerifyOrExit(err == WEAVE_NO_ERROR, aWriter("Error in kTLVType_FloatingPointNumber")); |
| aWriter("%lf", fpVal); |
| break; |
| |
| case kTLVType_UTF8String: |
| err = temp.GetDataPtr(strbuf); |
| VerifyOrExit(err == WEAVE_NO_ERROR, aWriter("Error in kTLVType_UTF8String")); |
| aWriter("\"%-.*s\"", static_cast<int>(len), strbuf); |
| break; |
| |
| case kTLVType_ByteString: |
| err = temp.GetDataPtr(strbuf); |
| VerifyOrExit(err == WEAVE_NO_ERROR, aWriter("Error in kTLVType_ByteString")); |
| aWriter("%p\n", strbuf); |
| break; |
| |
| case kTLVType_Null: |
| aWriter("NULL"); |
| break; |
| |
| case kTLVType_NotSpecified: |
| aWriter("Not Specified"); |
| break; |
| |
| default: |
| aWriter("Error: Type is not primitive."); |
| break; |
| |
| } |
| } |
| |
| exit: |
| aWriter("\n"); |
| } |
| |
| /** |
| * Decode a TLV tag control with a descriptive string. |
| * |
| * @param[in] aTagControl The TLV tag control to decode and for which to return |
| * a descriptive string. |
| * |
| * @return A pointer to a NULL-terminated string describing the specified |
| * tag control on success; otherwise, NULL. |
| * |
| */ |
| const char *DecodeTagControl(const TLVTagControl aTagControl) |
| { |
| const char *retval; |
| |
| switch (aTagControl) |
| { |
| |
| case kTLVTagControl_Anonymous: |
| retval = "Anonymous"; |
| break; |
| |
| case kTLVTagControl_ContextSpecific: |
| retval = "Context Specific"; |
| break; |
| |
| case kTLVTagControl_CommonProfile_2Bytes: |
| retval = "Common Profile (2 Bytes)"; |
| break; |
| |
| case kTLVTagControl_CommonProfile_4Bytes: |
| retval = "Common Profile (4 Bytes)"; |
| break; |
| |
| case kTLVTagControl_ImplicitProfile_2Bytes: |
| retval = "Implicit Profile (2 Bytes)"; |
| break; |
| |
| case kTLVTagControl_ImplicitProfile_4Bytes: |
| retval = "Implicit Profile (4 Bytes)"; |
| break; |
| |
| case kTLVTagControl_FullyQualified_6Bytes: |
| retval = "Fully Qualified (6 Bytes)"; |
| break; |
| |
| case kTLVTagControl_FullyQualified_8Bytes: |
| retval = "Fully Qualified (8 Bytes)"; |
| break; |
| |
| default: |
| retval = NULL; |
| break; |
| |
| } |
| |
| return retval; |
| } |
| |
| /** |
| * Decode a TLV type with a descriptive string. |
| * |
| * @param[in] aType The TLV type to decode and for which to return |
| * a descriptive string. |
| * |
| * @return A pointer to a NULL-terminated string describing the specified |
| * type on success; otherwise, NULL. |
| * |
| */ |
| const char *DecodeType(const TLVType aType) |
| { |
| const char *retval; |
| |
| switch (aType) |
| { |
| |
| case kTLVType_NotSpecified: |
| retval = "Not Specified"; |
| break; |
| |
| case kTLVType_SignedInteger: |
| retval = "Signed Fixed Point"; |
| break; |
| |
| case kTLVType_UnsignedInteger: |
| retval = "Unsigned Fixed Point"; |
| break; |
| |
| case kTLVType_Boolean: |
| retval = "Boolean"; |
| break; |
| |
| case kTLVType_FloatingPointNumber: |
| retval = "Floating Point"; |
| break; |
| |
| case kTLVType_UTF8String: |
| retval = "UTF-8 String"; |
| break; |
| |
| case kTLVType_ByteString: |
| retval = "Data"; |
| break; |
| |
| case kTLVType_Null: |
| retval = "Null"; |
| break; |
| |
| case kTLVType_Structure: |
| retval = "Structure"; |
| break; |
| |
| case kTLVType_Array: |
| retval = "Array"; |
| break; |
| |
| case kTLVType_Path: |
| retval = "Path"; |
| break; |
| |
| default: |
| retval = NULL; |
| break; |
| |
| } |
| |
| return retval; |
| } |
| |
| /** |
| * Log the TLV data within the specified reader in human-readable form to |
| * the specified writer. |
| * |
| * @param[in] aWriter The writer to log the TLV data. |
| * @param[in] aReader A read-only reference to the TLV reader containing |
| * the TLV data to log. |
| * |
| * @retval #WEAVE_NO_ERROR Unconditionally. |
| * |
| */ |
| WEAVE_ERROR DumpIterator(DumpWriter aWriter, const TLVReader &aReader) |
| { |
| const char * tabs = ""; |
| const size_t depth = 0; |
| WEAVE_ERROR retval = WEAVE_NO_ERROR; |
| |
| DumpHandler(aWriter, tabs, aReader, depth); |
| |
| return retval; |
| } |
| |
| /** |
| * Log the TLV data within the specified reader in human-readable form. |
| * |
| * @param[in] aReader A read-only reference to the TLV reader containing |
| * the TLV data to log. |
| * @param[in] aDepth The current depth into the TLV data. |
| * @param[inout] aContext A pointer to the handler-specific context. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval #WEAVE_ERROR_INVALID_ARGUMENT If aContext is NULL or if |
| * aContext->mWriter is NULL. |
| * |
| */ |
| WEAVE_ERROR DumpHandler(const TLVReader &aReader, size_t aDepth, void *aContext) |
| { |
| static const char tabs[] = " "; |
| char tabbuf[48]; |
| WEAVE_ERROR retval = WEAVE_NO_ERROR; |
| DumpContext * context; |
| |
| VerifyOrExit(aContext != NULL, retval = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| context = static_cast<DumpContext *>(aContext); |
| |
| VerifyOrExit(context->mWriter != NULL, retval = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| strncpy(tabbuf, tabs, aDepth); |
| |
| tabbuf[aDepth] = 0; |
| |
| DumpHandler(context->mWriter, |
| tabbuf, |
| aReader, |
| aDepth); |
| |
| exit: |
| return retval; |
| } |
| |
| /** |
| * Dump the TLV data within the specified reader in human-readable form with |
| * the specified writer. |
| * |
| * @param[in] aReader A read-only reference to the TLV reader containing |
| * the TLV data to log. |
| * |
| * @param[in] aWriter A dump writer to log the TLV data of the TLV reader. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| */ |
| WEAVE_ERROR Dump(const TLVReader &aReader, DumpWriter aWriter) |
| { |
| void * context = NULL; |
| DumpContext dumpContext = { aWriter, context }; |
| WEAVE_ERROR retval; |
| |
| retval = Utilities::Iterate(aReader, DumpHandler, &dumpContext); |
| |
| return retval; |
| } |
| |
| } // namespace Debug |
| |
| } // namespace TLV |
| |
| } // namespace Weave |
| |
| } // namespace nl |
