| /* |
| * |
| * Copyright (c) 2020 Project CHIP Authors |
| * Copyright (c) 2019 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 |
| * Utility functions for working with OpenThread. |
| */ |
| |
| #include "OpenThreadUtils.h" |
| |
| #include <inet/IPAddress.h> |
| #include <lib/core/CHIPEncoding.h> |
| #include <lib/support/ErrorStr.h> |
| #include <lib/support/logging/CHIPLogging.h> |
| #include <platform/internal/CHIPDeviceLayerInternal.h> |
| |
| #include <openthread/error.h> |
| |
| #include <cstdio> |
| |
| namespace chip { |
| namespace DeviceLayer { |
| namespace Internal { |
| |
| /** |
| * Map an OpenThread error into the CHIP error space. |
| */ |
| CHIP_ERROR MapOpenThreadError(otError otErr) |
| { |
| return (otErr == OT_ERROR_NONE) ? CHIP_NO_ERROR : CHIP_ERROR(ChipError::Range::kOpenThread, static_cast<unsigned int>(otErr)); |
| } |
| |
| /** |
| * Given an CHIP error value that represents an OpenThread error, returns a |
| * human-readable NULL-terminated C string describing the error. |
| * |
| * @param[in] buf Buffer into which the error string will be placed. |
| * @param[in] bufSize Size of the supplied buffer in bytes. |
| * @param[in] err The error to be described. |
| * |
| * @return true If a description string was written into the supplied buffer. |
| * @return false If the supplied error was not an OpenThread error. |
| * |
| */ |
| bool FormatOpenThreadError(char * buf, uint16_t bufSize, CHIP_ERROR err) |
| { |
| if (!err.IsRange(ChipError::Range::kOpenThread)) |
| { |
| return false; |
| } |
| |
| #if CHIP_CONFIG_SHORT_ERROR_STR |
| const char * desc = NULL; |
| #else // CHIP_CONFIG_SHORT_ERROR_STR |
| otError otErr = (otError) err.GetValue(); |
| const char * desc = otThreadErrorToString(otErr); |
| #endif // CHIP_CONFIG_SHORT_ERROR_STR |
| |
| chip::FormatError(buf, bufSize, "OpenThread", err, desc); |
| |
| return true; |
| } |
| |
| /** |
| * Register a text error formatter for OpenThread errors. |
| */ |
| void RegisterOpenThreadErrorFormatter(void) |
| { |
| static ErrorFormatter sOpenThreadErrorFormatter = { FormatOpenThreadError, NULL }; |
| |
| RegisterErrorFormatter(&sOpenThreadErrorFormatter); |
| } |
| |
| /** |
| * Log information related to a state change in the OpenThread stack. |
| * |
| * NB: This function *must* be called with the Thread stack lock held. |
| */ |
| void LogOpenThreadStateChange(otInstance * otInst, uint32_t flags) |
| { |
| #if CHIP_DETAIL_LOGGING |
| |
| #if OPENTHREAD_API_VERSION >= 126 |
| const uint32_t kParamsChanged = (OT_CHANGED_THREAD_NETWORK_NAME | OT_CHANGED_THREAD_PANID | OT_CHANGED_THREAD_EXT_PANID | |
| OT_CHANGED_THREAD_CHANNEL | OT_CHANGED_NETWORK_KEY | OT_CHANGED_PSKC); |
| #else |
| const uint32_t kParamsChanged = (OT_CHANGED_THREAD_NETWORK_NAME | OT_CHANGED_THREAD_PANID | OT_CHANGED_THREAD_EXT_PANID | |
| OT_CHANGED_THREAD_CHANNEL | OT_CHANGED_MASTER_KEY | OT_CHANGED_PSKC); |
| #endif |
| |
| static char strBuf[64]; |
| |
| ChipLogDetail(DeviceLayer, "OpenThread State Changed (Flags: 0x%08" PRIx32 ")", flags); |
| if ((flags & OT_CHANGED_THREAD_ROLE) != 0) |
| { |
| ChipLogDetail(DeviceLayer, " Device Role: %s", OpenThreadRoleToStr(otThreadGetDeviceRole(otInst))); |
| } |
| if ((flags & kParamsChanged) != 0) |
| { |
| ChipLogDetail(DeviceLayer, " Network Name: %s", otThreadGetNetworkName(otInst)); |
| ChipLogDetail(DeviceLayer, " PAN Id: 0x%04X", otLinkGetPanId(otInst)); |
| { |
| const otExtendedPanId * exPanId = otThreadGetExtendedPanId(otInst); |
| snprintf(strBuf, sizeof(strBuf), "0x%02X%02X%02X%02X%02X%02X%02X%02X", exPanId->m8[0], exPanId->m8[1], exPanId->m8[2], |
| exPanId->m8[3], exPanId->m8[4], exPanId->m8[5], exPanId->m8[6], exPanId->m8[7]); |
| ChipLogDetail(DeviceLayer, " Extended PAN Id: %s", strBuf); |
| } |
| ChipLogDetail(DeviceLayer, " Channel: %d", otLinkGetChannel(otInst)); |
| { |
| const otMeshLocalPrefix * otMeshPrefix = otThreadGetMeshLocalPrefix(otInst); |
| chip::Inet::IPAddress meshPrefix; |
| memset(meshPrefix.Addr, 0, sizeof(meshPrefix.Addr)); |
| memcpy(meshPrefix.Addr, otMeshPrefix->m8, sizeof(otMeshPrefix->m8)); |
| meshPrefix.ToString(strBuf); |
| ChipLogDetail(DeviceLayer, " Mesh Prefix: %s/64", strBuf); |
| } |
| #if CHIP_CONFIG_SECURITY_TEST_MODE |
| { |
| #if OPENTHREAD_API_VERSION >= 126 |
| const otNetworkKey * otKey = otThreadGetNetworkKey(otInst); |
| for (int i = 0; i < OT_NETWORK_KEY_SIZE; i++) |
| #else |
| const otMasterKey * otKey = otThreadGetMasterKey(otInst); |
| for (int i = 0; i < OT_MASTER_KEY_SIZE; i++) |
| #endif |
| snprintf(&strBuf[i * 2], 3, "%02X", otKey->m8[i]); |
| ChipLogDetail(DeviceLayer, " Network Key: %s", strBuf); |
| } |
| #endif // CHIP_CONFIG_SECURITY_TEST_MODE |
| } |
| if ((flags & OT_CHANGED_THREAD_PARTITION_ID) != 0) |
| { |
| ChipLogDetail(DeviceLayer, " Partition Id: 0x%" PRIX32, otThreadGetPartitionId(otInst)); |
| } |
| if ((flags & (OT_CHANGED_IP6_ADDRESS_ADDED | OT_CHANGED_IP6_ADDRESS_REMOVED)) != 0) |
| { |
| ChipLogDetail(DeviceLayer, " Thread Unicast Addresses:"); |
| for (const otNetifAddress * addr = otIp6GetUnicastAddresses(otInst); addr != NULL; addr = addr->mNext) |
| { |
| chip::Inet::IPAddress ipAddr; |
| memcpy(ipAddr.Addr, addr->mAddress.mFields.m32, sizeof(ipAddr.Addr)); |
| |
| ipAddr.ToString(strBuf); |
| |
| ChipLogDetail(DeviceLayer, " %s/%d%s%s%s", strBuf, addr->mPrefixLength, addr->mValid ? " valid" : "", |
| addr->mPreferred ? " preferred" : "", addr->mRloc ? " rloc" : ""); |
| } |
| } |
| |
| #endif // CHIP_DETAIL_LOGGING |
| } |
| |
| void LogOpenThreadPacket(const char * titleStr, otMessage * pkt) |
| { |
| #if CHIP_DETAIL_LOGGING |
| |
| char srcStr[50], destStr[50], typeBuf[20]; |
| const char * type = typeBuf; |
| Inet::IPAddress addr; |
| uint8_t headerData[44]; |
| uint16_t pktLen; |
| |
| const uint8_t & IPv6_NextHeader = headerData[6]; |
| const uint8_t * const IPv6_SrcAddr = headerData + 8; |
| const uint8_t * const IPv6_DestAddr = headerData + 24; |
| const uint8_t * const IPv6_SrcPort = headerData + 40; |
| const uint8_t * const IPv6_DestPort = headerData + 42; |
| const uint8_t & ICMPv6_Type = headerData[40]; |
| const uint8_t & ICMPv6_Code = headerData[41]; |
| |
| constexpr uint8_t kIPProto_UDP = 17; |
| constexpr uint8_t kIPProto_TCP = 6; |
| constexpr uint8_t kIPProto_ICMPv6 = 58; |
| |
| constexpr uint8_t kICMPType_EchoRequest = 128; |
| constexpr uint8_t kICMPType_EchoResponse = 129; |
| |
| pktLen = otMessageGetLength(pkt); |
| |
| if (pktLen >= sizeof(headerData)) |
| { |
| otMessageRead(pkt, 0, headerData, sizeof(headerData)); |
| |
| memcpy(addr.Addr, IPv6_SrcAddr, 16); |
| addr.ToString(srcStr); |
| |
| memcpy(addr.Addr, IPv6_DestAddr, 16); |
| addr.ToString(destStr); |
| |
| if (IPv6_NextHeader == kIPProto_UDP) |
| { |
| type = "UDP"; |
| } |
| else if (IPv6_NextHeader == kIPProto_TCP) |
| { |
| type = "TCP"; |
| } |
| else if (IPv6_NextHeader == kIPProto_ICMPv6) |
| { |
| if (ICMPv6_Type == kICMPType_EchoRequest) |
| { |
| type = "ICMPv6 Echo Request"; |
| } |
| else if (ICMPv6_Type == kICMPType_EchoResponse) |
| { |
| type = "ICMPv6 Echo Response"; |
| } |
| else |
| { |
| snprintf(typeBuf, sizeof(typeBuf), "ICMPv6 %u,%u", ICMPv6_Type, ICMPv6_Code); |
| } |
| } |
| else |
| { |
| snprintf(typeBuf, sizeof(typeBuf), "IP proto %u", IPv6_NextHeader); |
| } |
| |
| if (IPv6_NextHeader == kIPProto_UDP || IPv6_NextHeader == kIPProto_TCP) |
| { |
| snprintf(srcStr + strlen(srcStr), 13, ", port %u", Encoding::BigEndian::Get16(IPv6_SrcPort)); |
| snprintf(destStr + strlen(destStr), 13, ", port %u", Encoding::BigEndian::Get16(IPv6_DestPort)); |
| } |
| |
| ChipLogDetail(DeviceLayer, "%s: %s, len %u", titleStr, type, pktLen); |
| ChipLogDetail(DeviceLayer, " src %s", srcStr); |
| ChipLogDetail(DeviceLayer, " dest %s", destStr); |
| } |
| else |
| { |
| ChipLogDetail(DeviceLayer, "%s: %s, len %u", titleStr, "(decode error)", pktLen); |
| } |
| |
| #endif // CHIP_DETAIL_LOGGING |
| } |
| |
| bool IsOpenThreadMeshLocalAddress(otInstance * otInst, const Inet::IPAddress & addr) |
| { |
| const otMeshLocalPrefix * otMeshPrefix = otThreadGetMeshLocalPrefix(otInst); |
| |
| return otMeshPrefix != NULL && memcmp(otMeshPrefix->m8, addr.Addr, OT_MESH_LOCAL_PREFIX_SIZE) == 0; |
| } |
| |
| const char * OpenThreadRoleToStr(otDeviceRole role) |
| { |
| switch (role) |
| { |
| case OT_DEVICE_ROLE_DISABLED: |
| return "DISABLED"; |
| case OT_DEVICE_ROLE_DETACHED: |
| return "DETACHED"; |
| case OT_DEVICE_ROLE_CHILD: |
| return "CHILD"; |
| case OT_DEVICE_ROLE_ROUTER: |
| return "ROUTER"; |
| case OT_DEVICE_ROLE_LEADER: |
| return "LEADER"; |
| default: |
| return "(unknown)"; |
| } |
| } |
| |
| } // namespace Internal |
| } // namespace DeviceLayer |
| } // namespace chip |