| /* |
| * |
| * Copyright (c) 2016 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. |
| * |
| */ |
| |
| #if HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <algorithm> |
| #include <inttypes.h> |
| #include "SpinelNCPInstance.h" |
| #include "time-utils.h" |
| #include "assert-macros.h" |
| #include <syslog.h> |
| #include <errno.h> |
| #include "socket-utils.h" |
| #include <stdexcept> |
| #include <sys/file.h> |
| #include "SuperSocket.h" |
| #include "SpinelNCPTask.h" |
| #include "SpinelNCPTaskWake.h" |
| #include "SpinelNCPTaskSendCommand.h" |
| #include "SpinelNCPTaskJoin.h" |
| #include "SpinelNCPTaskGetNetworkTopology.h" |
| #include "SpinelNCPTaskGetMsgBufferCounters.h" |
| #include "SpinelNCPThreadDataset.h" |
| #include "any-to.h" |
| #include "spinel-extra.h" |
| #include "IPv6Helpers.h" |
| |
| #define kWPANTUND_Allowlist_RssiOverrideDisabled 127 |
| #define kWPANTUND_SpinelPropValueDumpLen 8 |
| |
| using namespace nl; |
| using namespace wpantund; |
| |
| WPANTUND_DEFINE_NCPINSTANCE_PLUGIN(spinel, SpinelNCPInstance); |
| |
| void |
| SpinelNCPInstance::handle_ncp_debug_stream(const uint8_t* data_ptr, int data_len) |
| { |
| static char linebuffer[NCP_DEBUG_LINE_LENGTH_MAX + 1]; |
| static int linepos = 0; |
| while (data_len--) { |
| char nextchar = *data_ptr++; |
| |
| if ((nextchar == '\t') || (nextchar >= 32)) { |
| linebuffer[linepos++] = nextchar; |
| } |
| |
| if ( (linepos != 0) |
| && ( (nextchar == '\n') |
| || (nextchar == '\r') |
| || (linepos >= (sizeof(linebuffer) - 1)) |
| ) |
| ) |
| { |
| // flush. |
| linebuffer[linepos] = 0; |
| syslog(LOG_WARNING, "NCP => %s\n", linebuffer); |
| linepos = 0; |
| } |
| } |
| } |
| |
| static const char * |
| ot_log_level_to_string(uint8_t log_level) |
| { |
| const char *retval = "----"; |
| |
| switch (log_level) |
| { |
| case SPINEL_NCP_LOG_LEVEL_EMERG: |
| retval = "EMRG"; |
| break; |
| |
| case SPINEL_NCP_LOG_LEVEL_ALERT: |
| retval = "ALRT"; |
| break; |
| |
| case SPINEL_NCP_LOG_LEVEL_CRIT: |
| retval = "CRIT"; |
| break; |
| |
| case SPINEL_NCP_LOG_LEVEL_ERR: |
| retval = "ERR "; |
| break; |
| |
| case SPINEL_NCP_LOG_LEVEL_WARN: |
| retval = "WARN"; |
| break; |
| |
| case SPINEL_NCP_LOG_LEVEL_NOTICE: |
| retval = "NOTE"; |
| break; |
| |
| case SPINEL_NCP_LOG_LEVEL_INFO: |
| retval = "INFO"; |
| break; |
| |
| case SPINEL_NCP_LOG_LEVEL_DEBUG: |
| retval = "DEBG"; |
| break; |
| } |
| |
| return retval; |
| } |
| |
| static const char * |
| ot_log_region_to_string(unsigned int log_region) |
| { |
| const char *retval = "---------"; |
| |
| switch (log_region) |
| { |
| case SPINEL_NCP_LOG_REGION_OT_API: |
| retval = "-API-----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_MLE: |
| retval = "-MLE-----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_COAP: |
| retval = "-COAP----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_ARP: |
| retval = "-ARP-----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_NET_DATA: |
| retval = "-N-DATA--"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_ICMP: |
| retval = "-ICMP----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_IP6: |
| retval = "-IP6-----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_MAC: |
| retval = "-MAC-----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_MEM: |
| retval = "-MEM-----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_NCP: |
| retval = "-NCP-----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_MESH_COP: |
| retval = "-MESH-CP-"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_NET_DIAG: |
| retval = "-DIAG----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_PLATFORM: |
| retval = "-PLAT----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_CORE: |
| retval = "-CORE----"; |
| break; |
| |
| case SPINEL_NCP_LOG_REGION_OT_UTIL: |
| retval = "-UTIL----"; |
| break; |
| } |
| |
| return retval; |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_log_stream(const uint8_t *data_in, int data_len) |
| { |
| spinel_ssize_t len; |
| char prefix_string[NCP_DEBUG_LINE_LENGTH_MAX + 1]; |
| const char *log_string; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UTF8_S, |
| &log_string |
| ); |
| require(len >= 0, bail); |
| |
| data_in += len; |
| data_len -= len; |
| |
| prefix_string[0] = 0; |
| |
| if ((data_len > 0) && mCapabilities.count(SPINEL_CAP_OPENTHREAD_LOG_METADATA)) { |
| uint8_t log_level; |
| unsigned int log_region; |
| uint64_t log_timestamp; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| ( |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_UINT_PACKED_S |
| ), |
| &log_level, |
| &log_region |
| ); |
| require(len >= 0, bail); |
| |
| data_in += len; |
| data_len -= len; |
| |
| if (data_len >= sizeof(log_timestamp)) { |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT64_S, |
| &log_timestamp |
| ); |
| require(len >= 0, bail); |
| |
| snprintf( |
| prefix_string, |
| sizeof(prefix_string), |
| "[%013llu][%s]%s: ", |
| static_cast<unsigned long long>(log_timestamp), |
| ot_log_level_to_string(log_level), |
| ot_log_region_to_string(log_region) |
| ); |
| } else { |
| snprintf( |
| prefix_string, |
| sizeof(prefix_string), |
| "[%s]%s: ", |
| ot_log_level_to_string(log_level), |
| ot_log_region_to_string(log_region) |
| ); |
| } |
| } |
| |
| syslog(LOG_WARNING, "NCP => %s%s\n", prefix_string, log_string); |
| |
| bail: |
| return; |
| } |
| |
| void |
| SpinelNCPInstance::start_new_task(const boost::shared_ptr<SpinelNCPTask> &task) |
| { |
| if (ncp_state_is_detached_from_ncp(get_ncp_state())) { |
| task->finish(kWPANTUNDStatus_InvalidWhenDisabled); |
| } else if (PT_SCHEDULE(task->process_event(EVENT_STARTING_TASK))) { |
| |
| if (ncp_state_is_sleeping(get_ncp_state()) |
| && (dynamic_cast<const SpinelNCPTaskWake*>(task.get()) == NULL) |
| ) { |
| if (can_set_ncp_power() |
| || !mCapabilities.count(SPINEL_CAP_MCU_POWER_STATE) |
| ){ |
| start_new_task(boost::shared_ptr<SpinelNCPTask>(new SpinelNCPTaskWake(this, NilReturn()))); |
| } |
| } |
| |
| mTaskQueue.push_back(task); |
| } |
| } |
| |
| int |
| nl::wpantund::spinel_status_to_wpantund_status(int spinel_status) |
| { |
| wpantund_status_t ret; |
| switch (spinel_status) { |
| case SPINEL_STATUS_ALREADY: |
| ret = kWPANTUNDStatus_Already; |
| break; |
| case SPINEL_STATUS_BUSY: |
| ret = kWPANTUNDStatus_Busy; |
| break; |
| case SPINEL_STATUS_IN_PROGRESS: |
| ret = kWPANTUNDStatus_InProgress; |
| break; |
| case SPINEL_STATUS_JOIN_FAILURE: |
| ret = kWPANTUNDStatus_JoinFailedUnknown; |
| break; |
| case SPINEL_STATUS_JOIN_INCOMPATIBLE: |
| ret = kWPANTUNDStatus_JoinFailedAtScan; |
| break; |
| case SPINEL_STATUS_JOIN_SECURITY: |
| ret = kWPANTUNDStatus_JoinFailedAtAuthenticate; |
| break; |
| case SPINEL_STATUS_OK: |
| ret = kWPANTUNDStatus_Ok; |
| break; |
| case SPINEL_STATUS_PROP_NOT_FOUND: |
| ret = kWPANTUNDStatus_PropertyNotFound; |
| break; |
| case SPINEL_STATUS_INVALID_ARGUMENT: |
| ret = kWPANTUNDStatus_NCP_InvalidArgument; |
| break; |
| case SPINEL_STATUS_INVALID_STATE: |
| ret = kWPANTUNDStatus_InvalidForCurrentState; |
| break; |
| |
| default: |
| ret = WPANTUND_NCPERROR_TO_STATUS(spinel_status); |
| break; |
| } |
| |
| return ret; |
| } |
| |
| int |
| nl::wpantund::peek_ncp_callback_status(int event, va_list args) |
| { |
| int ret = 0; |
| |
| if (EVENT_NCP_PROP_VALUE_IS == event) { |
| va_list tmp; |
| va_copy(tmp, args); |
| unsigned int key = va_arg(tmp, unsigned int); |
| if (SPINEL_PROP_LAST_STATUS == key) { |
| const uint8_t* spinel_data_ptr = va_arg(tmp, const uint8_t*); |
| spinel_size_t spinel_data_len = va_arg(tmp, spinel_size_t); |
| |
| if (spinel_datatype_unpack(spinel_data_ptr, spinel_data_len, "i", &ret) <= 0) { |
| ret = SPINEL_STATUS_PARSE_ERROR; |
| } |
| } |
| va_end(tmp); |
| } else if (EVENT_NCP_RESET == event) { |
| va_list tmp; |
| va_copy(tmp, args); |
| ret = va_arg(tmp, int); |
| va_end(tmp); |
| } |
| |
| return ret; |
| } |
| |
| SpinelNCPInstance::SpinelNCPInstance(const Settings& settings) : |
| NCPInstanceBase(settings), mControlInterface(this), mVendorCustom(this) |
| { |
| mInboundFrameDataLen = 0; |
| mInboundFrameDataPtr = NULL; |
| mInboundFrameDataType = 0; |
| mInboundFrameHDLCCRC = 0; |
| mInboundFrameSize = 0; |
| mInboundHeader = 0; |
| mIsCommissioned = false; |
| mFilterRLOCAddresses = true; |
| mFilterALOCAddresses = true; |
| mTickleOnHostDidWake = false; |
| mIsPcapInProgress = false; |
| mLastHeader = 0; |
| mLastTID = 0; |
| mNetworkKeyIndex = 0; |
| mOutboundBufferEscapedLen = 0; |
| mOutboundBufferLen = 0; |
| mOutboundBufferSent = 0; |
| mOutboundBufferType = 0; |
| #if WPANTUND_NCP_RESET_EXPECTED_ON_START |
| mResetIsExpected = true; |
| #else |
| mResetIsExpected = false; |
| #endif |
| mSetSteeringDataWhenJoinable = false; |
| mSubPTIndex = 0; |
| mTXPower = 0; |
| mThreadMode = 0; |
| mXPANIDWasExplicitlySet = false; |
| mChannelManagerNewChannel = 0; |
| mMacFilterFixedRssi = -100; |
| mSupportedChannelMask = 0; |
| mPreferredChannelMask = 0; |
| mJoinerDiscernerBitLength = 0; |
| mCommissionerEnergyScanResult.clear(); |
| mCommissionerPanIdConflictResult.clear(); |
| |
| mSettings.clear(); |
| |
| regsiter_all_get_handlers(); |
| regsiter_all_set_handlers(); |
| regsiter_all_insert_handlers(); |
| regsiter_all_remove_handlers(); |
| |
| memset(mSteeringDataAddress, 0xff, sizeof(mSteeringDataAddress)); |
| |
| if (!settings.empty()) { |
| int status; |
| Settings::const_iterator iter; |
| |
| for(iter = settings.begin(); iter != settings.end(); iter++) { |
| if (!NCPInstanceBase::setup_property_supported_by_class(iter->first)) { |
| status = static_cast<NCPControlInterface&>(get_control_interface()) |
| .property_set_value(iter->first, iter->second); |
| |
| if (status != 0 && status != kWPANTUNDStatus_InProgress) { |
| syslog(LOG_WARNING, "Attempt to set property \"%s\" failed with err %s", iter->first.c_str(), wpantund_status_to_cstr(status)); |
| } |
| } |
| } |
| } |
| } |
| |
| SpinelNCPInstance::~SpinelNCPInstance() |
| { |
| } |
| |
| std::string |
| SpinelNCPInstance::thread_mode_to_string(uint8_t mode) |
| { |
| char c_string[400]; |
| |
| snprintf( |
| c_string, |
| sizeof(c_string), |
| "RxOnWhenIdle:%s FTD:%s FullNetData:%s SecDataReq:%s", |
| ((mode & SPINEL_THREAD_MODE_RX_ON_WHEN_IDLE) != 0) ? "yes" : "no", |
| ((mode & SPINEL_THREAD_MODE_FULL_THREAD_DEV) != 0) ? "yes" : "no", |
| ((mode & SPINEL_THREAD_MODE_FULL_NETWORK_DATA) != 0) ? "yes" : "no", |
| ((mode & SPINEL_THREAD_MODE_SECURE_DATA_REQUEST) != 0) ? "yes" : "no" |
| ); |
| |
| return c_string; |
| } |
| |
| uint8_t |
| SpinelNCPInstance::get_thread_mode(void) |
| { |
| return mThreadMode; |
| } |
| |
| bool |
| SpinelNCPInstance::setup_property_supported_by_class(const std::string& prop_name) |
| { |
| return NCPInstanceBase::setup_property_supported_by_class(prop_name); |
| } |
| |
| SpinelNCPControlInterface& |
| SpinelNCPInstance::get_control_interface() |
| { |
| return mControlInterface; |
| } |
| |
| std::set<std::string> |
| SpinelNCPInstance::get_supported_property_keys()const |
| { |
| std::set<std::string> properties (NCPInstanceBase::get_supported_property_keys()); |
| |
| properties.insert(kWPANTUNDProperty_ConfigNCPDriverName); |
| properties.insert(kWPANTUNDProperty_NCPChannel); |
| properties.insert(kWPANTUNDProperty_NCPChannelMask); |
| properties.insert(kWPANTUNDProperty_NCPPreferredChannelMask); |
| properties.insert(kWPANTUNDProperty_NCPFrequency); |
| properties.insert(kWPANTUNDProperty_NCPRSSI); |
| properties.insert(kWPANTUNDProperty_NCPExtendedAddress); |
| properties.insert(kWPANTUNDProperty_NCPCCAFailureRate); |
| properties.insert(kWPANTUNDProperty_NCPCapabilities); |
| |
| if (mCapabilities.count(SPINEL_CAP_ROLE_SLEEPY)) { |
| properties.insert(kWPANTUNDProperty_NCPSleepyPollInterval); |
| } |
| |
| properties.insert(kWPANTUNDProperty_ThreadRLOC16); |
| properties.insert(kWPANTUNDProperty_ThreadDeviceMode); |
| properties.insert(kWPANTUNDProperty_ThreadRouterID); |
| properties.insert(kWPANTUNDProperty_ThreadLeaderAddress); |
| properties.insert(kWPANTUNDProperty_ThreadLeaderRouterID); |
| properties.insert(kWPANTUNDProperty_ThreadLeaderWeight); |
| properties.insert(kWPANTUNDProperty_ThreadLeaderLocalWeight); |
| properties.insert(kWPANTUNDProperty_ThreadNetworkData); |
| properties.insert(kWPANTUNDProperty_ThreadNetworkDataVersion); |
| properties.insert(kWPANTUNDProperty_ThreadStableNetworkData); |
| properties.insert(kWPANTUNDProperty_ThreadStableNetworkDataVersion); |
| properties.insert(kWPANTUNDProperty_ThreadLeaderNetworkData); |
| properties.insert(kWPANTUNDProperty_ThreadStableLeaderNetworkData); |
| properties.insert(kWPANTUNDProperty_ThreadChildTable); |
| properties.insert(kWPANTUNDProperty_ThreadChildTableAddresses); |
| properties.insert(kWPANTUNDProperty_ThreadNeighborTable); |
| properties.insert(kWPANTUNDProperty_ThreadChildTimeout); |
| properties.insert(kWPANTUNDProperty_ThreadRouterTable); |
| properties.insert(kWPANTUNDProperty_ThreadParent); |
| properties.insert(kWPANTUNDProperty_ThreadOffMeshRoutes); |
| properties.insert(kWPANTUNDProperty_NetworkPartitionId); |
| properties.insert(kWPANTUNDProperty_ThreadRouterUpgradeThreshold); |
| properties.insert(kWPANTUNDProperty_ThreadRouterDowngradeThreshold); |
| properties.insert(kWPANTUNDProperty_ThreadActiveDataset); |
| properties.insert(kWPANTUNDProperty_ThreadPendingDataset); |
| properties.insert(kWPANTUNDProperty_ThreadAddressCacheTable); |
| properties.insert(kWPANTUNDProperty_OpenThreadSupportedRadioLinks); |
| |
| if (mCapabilities.count(SPINEL_CAP_NET_THREAD_1_2)) { |
| properties.insert(kWPANTUNDProperty_ThreadDomainName); |
| properties.insert(kWPANTUNDProperty_ThreadBackboneRouterPrimary); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_BACKBONE_ROUTER)) { |
| properties.insert(kWPANTUNDProperty_ThreadBackboneRouterLocalState); |
| properties.insert(kWPANTUNDProperty_ThreadBackboneRouterLocalConfig); |
| properties.insert(kWPANTUNDProperty_ThreadBackboneRouterLocalJitter); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_ERROR_RATE_TRACKING)) { |
| properties.insert(kWPANTUNDProperty_ThreadNeighborTableErrorRates); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_MULTI_RADIO)) { |
| properties.insert(kWPANTUNDProperty_OpenThreadNeighborTableMultiRadioInfo); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_DUA)) { |
| properties.insert(kWPANTUNDProperty_ThreadDUAInterfaceIdentifier); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_COMMISSIONER)) { |
| properties.insert(kWPANTUNDProperty_CommissionerState); |
| properties.insert(kWPANTUNDProperty_CommissionerProvisioningUrl); |
| properties.insert(kWPANTUNDProperty_CommissionerSessionId); |
| properties.insert(kWPANTUNDProperty_CommissionerJoiners); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_JOINER)) { |
| properties.insert(kWPANTUNDProperty_JoinerState); |
| properties.insert(kWPANTUNDProperty_JoinerDiscernerValue); |
| properties.insert(kWPANTUNDProperty_JoinerDiscernerBitLength); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_POSIX)) { |
| properties.insert(kWPANTUNDProperty_POSIXAppRCPVersion); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_COUNTERS)) { |
| properties.insert(kWPANTUNDProperty_NCPCounterAllMac); |
| properties.insert(kWPANTUNDProperty_NCPCounter_TX_IP_SEC_TOTAL); |
| properties.insert(kWPANTUNDProperty_NCPCounter_TX_IP_INSEC_TOTAL); |
| properties.insert(kWPANTUNDProperty_NCPCounter_TX_IP_DROPPED); |
| properties.insert(kWPANTUNDProperty_NCPCounter_RX_IP_SEC_TOTAL); |
| properties.insert(kWPANTUNDProperty_NCPCounter_RX_IP_INSEC_TOTAL); |
| properties.insert(kWPANTUNDProperty_NCPCounter_RX_IP_DROPPED); |
| properties.insert(kWPANTUNDProperty_NCPCounter_TX_SPINEL_TOTAL); |
| properties.insert(kWPANTUNDProperty_NCPCounter_RX_SPINEL_TOTAL); |
| properties.insert(kWPANTUNDProperty_NCPCounter_RX_SPINEL_ERR); |
| properties.insert(kWPANTUNDProperty_NCPCounterThreadMle); |
| properties.insert(kWPANTUNDProperty_NCPCounterAllIPv6); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_MAC_ALLOWLIST)) { |
| properties.insert(kWPANTUNDProperty_MACAllowlistEnabled); |
| properties.insert(kWPANTUNDProperty_MACAllowlistEntries); |
| properties.insert(kWPANTUNDProperty_MACDenylistEnabled); |
| properties.insert(kWPANTUNDProperty_MACDenylistEntries); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_JAM_DETECT)) { |
| properties.insert(kWPANTUNDProperty_JamDetectionStatus); |
| properties.insert(kWPANTUNDProperty_JamDetectionEnable); |
| properties.insert(kWPANTUNDProperty_JamDetectionRssiThreshold); |
| properties.insert(kWPANTUNDProperty_JamDetectionWindow); |
| properties.insert(kWPANTUNDProperty_JamDetectionBusyPeriod); |
| properties.insert(kWPANTUNDProperty_JamDetectionDebugHistoryBitmap); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_CHANNEL_MONITOR)) { |
| properties.insert(kWPANTUNDProperty_ChannelMonitorSampleInterval); |
| properties.insert(kWPANTUNDProperty_ChannelMonitorRssiThreshold); |
| properties.insert(kWPANTUNDProperty_ChannelMonitorSampleWindow); |
| properties.insert(kWPANTUNDProperty_ChannelMonitorSampleCount); |
| properties.insert(kWPANTUNDProperty_ChannelMonitorChannelQuality); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_CHANNEL_MANAGER)) { |
| properties.insert(kWPANTUNDProperty_ChannelManagerNewChannel); |
| properties.insert(kWPANTUNDProperty_ChannelManagerDelay); |
| properties.insert(kWPANTUNDProperty_ChannelManagerAutoSelectEnabled); |
| properties.insert(kWPANTUNDProperty_ChannelManagerAutoSelectInterval); |
| properties.insert(kWPANTUNDProperty_ChannelManagerSupportedChannelMask); |
| properties.insert(kWPANTUNDProperty_ChannelManagerFavoredChannelMask); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_TMF_PROXY)) { |
| properties.insert(kWPANTUNDProperty_TmfProxyEnabled); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_NEST_LEGACY_INTERFACE)) { |
| properties.insert(kWPANTUNDProperty_NestLabs_LegacyMeshLocalPrefix); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_TIME_SYNC)) { |
| properties.insert(kWPANTUNDProperty_TimeSync_NetworkTime); |
| properties.insert(kWPANTUNDProperty_TimeSync_Period); |
| properties.insert(kWPANTUNDProperty_TimeSync_XtalThreshold); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_SERVICE)) { |
| properties.insert(kWPANTUNDProperty_ThreadServices); |
| properties.insert(kWPANTUNDProperty_ThreadLeaderServices); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_CSL_RECEIVER)) { |
| properties.insert(kWPANTUNDProperty_ThreadCslPeriod); |
| properties.insert(kWPANTUNDProperty_ThreadCslTimeout); |
| properties.insert(kWPANTUNDProperty_ThreadCslChannel); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_RADIO_COEX)) { |
| properties.insert(kWPANTUNDProperty_NCPCoexEnable); |
| properties.insert(kWPANTUNDProperty_NCPCoexMetrics); |
| } |
| |
| if (mCapabilities.count(SPINEL_CAP_OPENTHREAD_LOG_METADATA)) { |
| properties.insert(kWPANTUNDProperty_OpenThreadLogTimestampBase); |
| } |
| |
| { |
| const std::set<std::string> vendor_props(mVendorCustom.get_supported_property_keys()); |
| properties.insert(vendor_props.begin(), vendor_props.end()); |
| } |
| |
| return properties; |
| } |
| |
| cms_t |
| SpinelNCPInstance::get_ms_to_next_event(void) |
| { |
| cms_t cms = NCPInstanceBase::get_ms_to_next_event(); |
| |
| if (ncp_state_is_detached_from_ncp(get_ncp_state())) { |
| return CMS_DISTANT_FUTURE; |
| } |
| |
| // If the control protothread hasn't even started, set cms to zero. |
| if (0 == mControlPT.lc) { |
| cms = 0; |
| } |
| |
| if (!mTaskQueue.empty()) { |
| int tmp_cms = mTaskQueue.front()->get_ms_to_next_event(); |
| if (tmp_cms < cms) { |
| cms = tmp_cms; |
| } |
| } |
| |
| if (cms > mVendorCustom.get_ms_to_next_event()) { |
| cms = mVendorCustom.get_ms_to_next_event(); |
| } |
| |
| if (cms < 0) { |
| cms = 0; |
| } |
| |
| return cms; |
| } |
| |
| static void |
| convert_rloc16_to_router_id(CallbackWithStatusArg1 cb, int status, const boost::any& value) |
| { |
| uint8_t router_id = 0; |
| |
| if (status == kWPANTUNDStatus_Ok) { |
| uint16_t rloc16 = any_to_int(value); |
| router_id = rloc16 >> 10; |
| } |
| cb(status, router_id); |
| } |
| |
| |
| |
| static int |
| unpack_commissioner_state(const uint8_t *data_in, spinel_size_t data_len, boost::any& value) |
| { |
| spinel_ssize_t len; |
| uint8_t state; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT8_S, |
| &state |
| ); |
| |
| if (len > 0) { |
| switch (state) { |
| case SPINEL_MESHCOP_COMMISSIONER_STATE_DISABLED: |
| value = std::string(kWPANTUNDCommissionerState_Disabled); |
| break; |
| case SPINEL_MESHCOP_COMMISSIONER_STATE_PETITION: |
| value = std::string(kWPANTUNDCommissionerState_Petition); |
| break; |
| case SPINEL_MESHCOP_COMMISSIONER_STATE_ACTIVE: |
| value = std::string(kWPANTUNDCommissionerState_Active); |
| break; |
| default: |
| ret = kWPANTUNDStatus_Failure; |
| break; |
| } |
| } else { |
| ret = kWPANTUNDStatus_Failure; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_commissioner_joiners(const uint8_t *data_in, spinel_size_t data_len, boost::any &value) |
| { |
| spinel_ssize_t len; |
| std::list<std::string> result; |
| char c_string[300]; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| while (data_len > 0) { |
| const uint8_t *joiner_info_in; |
| spinel_size_t joiner_info_len; |
| uint32_t joiner_timeout; |
| const char *joiner_pskd; |
| const spinel_eui64_t *joiner_eui64 = NULL; |
| uint8_t discerner_bit_len; |
| uint64_t discerner_value; |
| bool any_joiner = false; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_DATA_WLEN_S // Joiner Info struct (empty or EUI64 or Discerner) |
| SPINEL_DATATYPE_UINT32_S |
| SPINEL_DATATYPE_UTF8_S |
| ), |
| &joiner_info_in, &joiner_info_len, |
| &joiner_timeout, |
| &joiner_pskd |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| switch (joiner_info_len) |
| { |
| case 0: |
| any_joiner = true; |
| break; |
| |
| case sizeof(spinel_eui64_t): |
| joiner_eui64 = (const spinel_eui64_t *)joiner_info_in; |
| break; |
| |
| default: |
| len = spinel_datatype_unpack( |
| joiner_info_in, |
| joiner_info_len, |
| ( |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_UINT64_S |
| ), |
| &discerner_bit_len, |
| &discerner_value |
| ); |
| joiner_eui64 = NULL; |
| break; |
| } |
| |
| if (any_joiner) { |
| snprintf(c_string, sizeof(c_string), "any joiner, psk:%s, timeout:%.2f", joiner_pskd, joiner_timeout/1000.0); |
| |
| } else if (joiner_eui64 != NULL) { |
| snprintf(c_string, sizeof(c_string), "eui64:%02X%02X%02X%02X%02X%02X%02X%02X, psk:%s, timeout:%.2f", |
| joiner_eui64->bytes[0], joiner_eui64->bytes[1], joiner_eui64->bytes[2], joiner_eui64->bytes[3], |
| joiner_eui64->bytes[4], joiner_eui64->bytes[5], joiner_eui64->bytes[6], joiner_eui64->bytes[7], |
| joiner_pskd, joiner_timeout/1000.0); |
| |
| } else { |
| snprintf(c_string, sizeof(c_string), "discerner:%" PRIu64 ", bit-len:%d, psk:%s, timeout:%.2f", |
| discerner_value, discerner_bit_len, joiner_pskd, joiner_timeout/1000.0); |
| } |
| |
| result.push_back(std::string(c_string)); |
| } |
| |
| value = result; |
| |
| bail: |
| return ret; |
| } |
| |
| |
| static int |
| unpack_channel_mask(const uint8_t *data_in, spinel_size_t data_len, boost::any& value) |
| { |
| spinel_ssize_t len; |
| uint32_t channel_mask = 0; |
| uint8_t channel = 0xff; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| while (data_len > 0) |
| { |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT8_S, |
| &channel |
| ); |
| |
| if ((len <= 0) || (channel >= 32)) { |
| ret = kWPANTUNDStatus_Failure; |
| break; |
| } |
| |
| channel_mask |= (1U << channel); |
| |
| data_in += len; |
| data_len -= len; |
| } |
| |
| if (ret == kWPANTUNDStatus_Ok) { |
| value = channel_mask; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_mac_allowlist_entries(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| spinel_ssize_t len; |
| ValueMap entry; |
| std::list<ValueMap> result_as_val_map; |
| std::list<std::string> result_as_string; |
| const spinel_eui64_t *eui64 = NULL; |
| int8_t rssi = 0; |
| |
| int ret = kWPANTUNDStatus_Ok; |
| |
| while (data_len > 0) |
| { |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_EUI64_S // Extended address |
| SPINEL_DATATYPE_INT8_S // Rssi |
| ), |
| &eui64, |
| &rssi |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| if (as_val_map) { |
| entry.clear(); |
| entry[kWPANTUNDValueMapKey_Allowlist_ExtAddress] = Data(eui64->bytes, sizeof(spinel_eui64_t)); |
| |
| if (rssi != kWPANTUND_Allowlist_RssiOverrideDisabled) { |
| entry[kWPANTUNDValueMapKey_Allowlist_Rssi] = rssi; |
| } |
| |
| result_as_val_map.push_back(entry); |
| |
| } else { |
| char c_string[500]; |
| int index; |
| |
| index = snprintf(c_string, sizeof(c_string), "%02X%02X%02X%02X%02X%02X%02X%02X", |
| eui64->bytes[0], eui64->bytes[1], eui64->bytes[2], eui64->bytes[3], |
| eui64->bytes[4], eui64->bytes[5], eui64->bytes[6], eui64->bytes[7]); |
| |
| if (rssi != kWPANTUND_Allowlist_RssiOverrideDisabled) { |
| if (index >= 0 && index < sizeof(c_string)) { |
| snprintf(c_string + index, sizeof(c_string) - index, " fixed-rssi:%d", rssi); |
| } |
| } |
| |
| result_as_string.push_back(std::string(c_string)); |
| } |
| |
| data_len -= len; |
| data_in += len; |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_mac_denylist_entries(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| spinel_ssize_t len; |
| ValueMap entry; |
| std::list<ValueMap> result_as_val_map; |
| std::list<std::string> result_as_string; |
| const spinel_eui64_t *eui64 = NULL; |
| |
| int ret = kWPANTUNDStatus_Ok; |
| |
| while (data_len > 0) |
| { |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_EUI64_S // Extended address |
| ), |
| &eui64 |
| ); |
| |
| if (len <= 0) |
| { |
| ret = kWPANTUNDStatus_Failure; |
| break; |
| } |
| |
| if (as_val_map) { |
| entry.clear(); |
| entry[kWPANTUNDValueMapKey_Allowlist_ExtAddress] = Data(eui64->bytes, sizeof(spinel_eui64_t)); |
| result_as_val_map.push_back(entry); |
| |
| } else { |
| char c_string[500]; |
| int index; |
| |
| index = snprintf(c_string, sizeof(c_string), "%02X%02X%02X%02X%02X%02X%02X%02X", |
| eui64->bytes[0], eui64->bytes[1], eui64->bytes[2], eui64->bytes[3], |
| eui64->bytes[4], eui64->bytes[5], eui64->bytes[6], eui64->bytes[7]); |
| |
| result_as_string.push_back(std::string(c_string)); |
| } |
| |
| data_len -= len; |
| data_in += len; |
| } |
| |
| if (ret == kWPANTUNDStatus_Ok) { |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_channel_occupancy(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| std::list<std::string> result_as_string; |
| std::list<ValueMap> result_as_val_map; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| while (data_len > 0) |
| { |
| spinel_ssize_t len; |
| uint8_t channel; |
| uint16_t quality; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_UINT8_S // Channel |
| SPINEL_DATATYPE_UINT16_S // Quality |
| ), |
| &channel, |
| &quality |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| if (!as_val_map) { |
| char c_string[100]; |
| |
| snprintf(c_string, sizeof(c_string), "ch %d (0x%04x) %.2f%% busy ", channel, quality, |
| static_cast<double>(quality) * 100.0 / 0xffff); |
| |
| result_as_string.push_back(std::string(c_string)); |
| } else { |
| ValueMap entry; |
| |
| entry[kWPANTUNDValueMapKey_ChannelMonitor_Channel] = boost::any((int)channel); |
| entry[kWPANTUNDValueMapKey_ChannelMonitor_Quality] = boost::any((int)quality); |
| result_as_val_map.push_back(entry); |
| } |
| |
| data_in += len; |
| data_len -= len; |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_ncp_counters_all_mac(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| std::list<std::string> result_as_string; |
| ValueMap result_as_val_map; |
| int ret = kWPANTUNDStatus_Ok; |
| spinel_ssize_t len; |
| |
| const char *tx_counter_names[] = { |
| kWPANTUNDValueMapKey_Counter_TxTotal, |
| kWPANTUNDValueMapKey_Counter_TxUnicast, |
| kWPANTUNDValueMapKey_Counter_TxBroadcast, |
| kWPANTUNDValueMapKey_Counter_TxAckRequested, |
| kWPANTUNDValueMapKey_Counter_TxAcked, |
| kWPANTUNDValueMapKey_Counter_TxNoAckRequested, |
| kWPANTUNDValueMapKey_Counter_TxData, |
| kWPANTUNDValueMapKey_Counter_TxDataPoll, |
| kWPANTUNDValueMapKey_Counter_TxBeacon, |
| kWPANTUNDValueMapKey_Counter_TxBeaconRequest, |
| kWPANTUNDValueMapKey_Counter_TxOther, |
| kWPANTUNDValueMapKey_Counter_TxRetry, |
| kWPANTUNDValueMapKey_Counter_TxErrCca, |
| kWPANTUNDValueMapKey_Counter_TxErrAbort, |
| kWPANTUNDValueMapKey_Counter_TxErrBusyChannel, |
| NULL |
| }; |
| |
| const char *rx_counter_names[] = { |
| kWPANTUNDValueMapKey_Counter_RxTotal, |
| kWPANTUNDValueMapKey_Counter_RxUnicast, |
| kWPANTUNDValueMapKey_Counter_RxBroadcast, |
| kWPANTUNDValueMapKey_Counter_RxData, |
| kWPANTUNDValueMapKey_Counter_RxDataPoll, |
| kWPANTUNDValueMapKey_Counter_RxBeacon, |
| kWPANTUNDValueMapKey_Counter_RxBeaconRequest, |
| kWPANTUNDValueMapKey_Counter_RxOther, |
| kWPANTUNDValueMapKey_Counter_RxAddressFiltered, |
| kWPANTUNDValueMapKey_Counter_RxDestAddrFiltered, |
| kWPANTUNDValueMapKey_Counter_RxDuplicated, |
| kWPANTUNDValueMapKey_Counter_RxErrNoFrame, |
| kWPANTUNDValueMapKey_Counter_RxErrUnknownNeighbor, |
| kWPANTUNDValueMapKey_Counter_RxErrInvalidSrcAddr, |
| kWPANTUNDValueMapKey_Counter_RxErrSec, |
| kWPANTUNDValueMapKey_Counter_RxErrFcs, |
| kWPANTUNDValueMapKey_Counter_RxErrOther, |
| NULL |
| }; |
| |
| for (int struct_index = 0; struct_index < 2; struct_index++) |
| { |
| const char **counter_names; |
| const uint8_t *struct_in = NULL; |
| unsigned int struct_len = 0; |
| spinel_size_t len; |
| |
| counter_names = (struct_index == 0) ? tx_counter_names : rx_counter_names; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_DATA_WLEN_S, |
| &struct_in, |
| &struct_len |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| while (*counter_names != NULL) { |
| uint32_t counter_value; |
| |
| len = spinel_datatype_unpack( |
| struct_in, |
| struct_len, |
| SPINEL_DATATYPE_UINT32_S, |
| &counter_value |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| struct_in += len; |
| struct_len -= len; |
| |
| if (!as_val_map) { |
| char c_string[200]; |
| snprintf(c_string, sizeof(c_string), "%-20s = %d", *counter_names, counter_value); |
| result_as_string.push_back(std::string(c_string)); |
| } else { |
| result_as_val_map[*counter_names] = counter_value; |
| } |
| |
| counter_names++; |
| } |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_ncp_counters_mle(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| std::list<std::string> result_as_string; |
| ValueMap result_as_val_map; |
| int ret = kWPANTUNDStatus_Ok; |
| spinel_ssize_t len; |
| |
| const char *mle_counter_names[] = { |
| kWPANTUNDValueMapKey_MleCounter_DisabledRole, |
| kWPANTUNDValueMapKey_MleCounter_DetachedRole, |
| kWPANTUNDValueMapKey_MleCounter_ChildRole, |
| kWPANTUNDValueMapKey_MleCounter_RouterRole, |
| kWPANTUNDValueMapKey_MleCounter_LeaderRole, |
| kWPANTUNDValueMapKey_MleCounter_AttachAttempts, |
| kWPANTUNDValueMapKey_MleCounter_PartitionIdChanges, |
| kWPANTUNDValueMapKey_MleCounter_BetterPartitionAttaches, |
| kWPANTUNDValueMapKey_MleCounter_ParentChanges, |
| NULL |
| }; |
| |
| const char **counter_names = mle_counter_names; |
| |
| while (*counter_names != NULL) { |
| uint16_t counter_value; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT16_S, |
| &counter_value |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| if (!as_val_map) { |
| char c_string[200]; |
| snprintf(c_string, sizeof(c_string), "%-20s = %d", *counter_names, counter_value); |
| result_as_string.push_back(std::string(c_string)); |
| } else { |
| result_as_val_map[*counter_names] = counter_value; |
| } |
| |
| counter_names++; |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_ncp_counters_ipv6(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| std::list<std::string> result_as_string; |
| ValueMap result_as_val_map; |
| int ret = kWPANTUNDStatus_Ok; |
| spinel_ssize_t len; |
| |
| const char *tx_counter_names[] = { |
| kWPANTUNDValueMapKey_IPv6Counter_TxSuccess, |
| kWPANTUNDValueMapKey_IPv6Counter_TxFailure, |
| NULL |
| }; |
| |
| const char *rx_counter_names[] = { |
| kWPANTUNDValueMapKey_IPv6Counter_RxSuccess, |
| kWPANTUNDValueMapKey_IPv6Counter_RxFailure, |
| NULL |
| }; |
| |
| for (int struct_index = 0; struct_index < 2; struct_index++) |
| { |
| const char **counter_names; |
| const uint8_t *struct_in = NULL; |
| unsigned int struct_len = 0; |
| spinel_size_t len; |
| |
| counter_names = (struct_index == 0) ? tx_counter_names : rx_counter_names; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_DATA_WLEN_S, |
| &struct_in, |
| &struct_len |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| while (*counter_names != NULL) { |
| uint32_t counter_value; |
| |
| len = spinel_datatype_unpack( |
| struct_in, |
| struct_len, |
| SPINEL_DATATYPE_UINT32_S, |
| &counter_value |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| struct_in += len; |
| struct_len -= len; |
| |
| if (!as_val_map) { |
| char c_string[200]; |
| snprintf(c_string, sizeof(c_string), "%-20s = %d", *counter_names, counter_value); |
| result_as_string.push_back(std::string(c_string)); |
| } else { |
| result_as_val_map[*counter_names] = counter_value; |
| } |
| |
| counter_names++; |
| } |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_coex_metrics(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| std::list<std::string> result_as_string; |
| ValueMap result_as_val_map; |
| int ret = kWPANTUNDStatus_Ok; |
| spinel_ssize_t len; |
| bool stopped; |
| uint32_t num_grant_glitch; |
| |
| const char *tx_coex_metrics_names[] = { |
| kWPANTUNDValueMapKey_CoexMetrics_NumTxRequest, |
| kWPANTUNDValueMapKey_CoexMetrics_NumTxGrantImmediate, |
| kWPANTUNDValueMapKey_CoexMetrics_NumTxGrantWait, |
| kWPANTUNDValueMapKey_CoexMetrics_NumTxGrantWaitActivated, |
| kWPANTUNDValueMapKey_CoexMetrics_NumTxGrantWaitTimeout, |
| kWPANTUNDValueMapKey_CoexMetrics_NumTxGrantDeactivatedDuringRequest, |
| kWPANTUNDValueMapKey_CoexMetrics_NumTxDelayedGrant, |
| kWPANTUNDValueMapKey_CoexMetrics_AvgTxRequestToGrantTime, |
| NULL |
| }; |
| |
| const char *rx_coex_metrics_names[] = { |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxRequest, |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxGrantImmediate, |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxGrantWait, |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxGrantWaitActivated, |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxGrantWaitTimeout, |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxGrantDeactivatedDuringRequest, |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxDelayedGrant, |
| kWPANTUNDValueMapKey_CoexMetrics_AvgRxRequestToGrantTime, |
| kWPANTUNDValueMapKey_CoexMetrics_NumRxGrantNone, |
| NULL |
| }; |
| |
| for (int index = 0; index < 2; index++) |
| { |
| const char **counter_names; |
| const uint8_t *struct_in = NULL; |
| unsigned int struct_len = 0; |
| spinel_size_t len; |
| |
| counter_names = (index == 0) ? tx_coex_metrics_names : rx_coex_metrics_names; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_DATA_WLEN_S, |
| &struct_in, |
| &struct_len |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| while (*counter_names != NULL) { |
| uint32_t counter_value; |
| |
| len = spinel_datatype_unpack( |
| struct_in, |
| struct_len, |
| SPINEL_DATATYPE_UINT32_S, |
| &counter_value |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| struct_in += len; |
| struct_len -= len; |
| |
| if (!as_val_map) { |
| char c_string[200]; |
| snprintf(c_string, sizeof(c_string), "%-20s = %u", *counter_names, counter_value); |
| result_as_string.push_back(std::string(c_string)); |
| } else { |
| result_as_val_map[*counter_names] = counter_value; |
| } |
| |
| counter_names++; |
| } |
| } |
| |
| len = spinel_datatype_unpack(data_in, data_len, SPINEL_DATATYPE_BOOL_S, &stopped); |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| data_in += len; |
| data_len -= len; |
| |
| len = spinel_datatype_unpack(data_in, data_len, SPINEL_DATATYPE_UINT32_S, &num_grant_glitch); |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| data_in += len; |
| data_len -= len; |
| |
| if (!as_val_map) { |
| char c_string[200]; |
| snprintf(c_string, sizeof(c_string), "%-20s = %u", kWPANTUNDValueMapKey_CoexMetrics_Stopped, stopped); |
| result_as_string.push_back(std::string(c_string)); |
| |
| snprintf(c_string, sizeof(c_string), "%-20s = %u", kWPANTUNDValueMapKey_CoexMetrics_NumGrantGlitch, num_grant_glitch); |
| result_as_string.push_back(std::string(c_string)); |
| } else { |
| result_as_val_map[kWPANTUNDValueMapKey_CoexMetrics_Stopped] = stopped; |
| result_as_val_map[kWPANTUNDValueMapKey_CoexMetrics_NumGrantGlitch] = num_grant_glitch; |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| |
| static int |
| unpack_mcu_power_state(const uint8_t *data_in, spinel_size_t data_len, boost::any& value) |
| { |
| spinel_ssize_t len; |
| uint8_t power_state; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT8_S, |
| &power_state |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| switch (power_state) |
| { |
| case SPINEL_MCU_POWER_STATE_ON: |
| value = std::string(kWPANTUNDNCPMCUPowerState_On); |
| break; |
| |
| case SPINEL_MCU_POWER_STATE_LOW_POWER: |
| value = std::string(kWPANTUNDNCPMCUPowerState_LowPower); |
| break; |
| |
| case SPINEL_MCU_POWER_STATE_OFF: |
| value = std::string(kWPANTUNDNCPMCUPowerState_Off); |
| break; |
| |
| default: |
| value = std::string("unknown"); |
| break; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_parent_info(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| std::string result_as_string; |
| ValueMap result_as_val_map; |
| int ret = kWPANTUNDStatus_Ok; |
| spinel_ssize_t len; |
| const spinel_eui64_t *eui64 = NULL; |
| uint16_t rloc16; |
| uint32_t age; |
| int8_t average_rssi; |
| int8_t last_rssi; |
| uint8_t lqin; |
| uint8_t lqout; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| ( |
| SPINEL_DATATYPE_EUI64_S // EUI64 Address |
| SPINEL_DATATYPE_UINT16_S // Rloc16 |
| SPINEL_DATATYPE_UINT32_S // Age |
| SPINEL_DATATYPE_INT8_S // Average RSSI |
| SPINEL_DATATYPE_INT8_S // Last RSSI |
| SPINEL_DATATYPE_UINT8_S // LinkQuality In |
| SPINEL_DATATYPE_UINT8_S // LinkQuality Out |
| ), |
| &eui64, |
| &rloc16, |
| &age, |
| &average_rssi, |
| &last_rssi, |
| &lqin, |
| &lqout |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| if (!as_val_map) { |
| char c_string[200]; |
| |
| snprintf(c_string, sizeof(c_string), |
| "%02X%02X%02X%02X%02X%02X%02X%02X, " |
| "RLOC16:%04x, " |
| "Age:%u, " |
| "AveRssi:%d, " |
| "LastRssi:%d, " |
| "LQIn:%d, " |
| "LQOut:%d", |
| eui64->bytes[0], eui64->bytes[1], eui64->bytes[2], eui64->bytes[3], |
| eui64->bytes[4], eui64->bytes[5], eui64->bytes[6], eui64->bytes[7], |
| rloc16, |
| age, |
| average_rssi, |
| last_rssi, |
| lqin, |
| lqout |
| ); |
| |
| value = std::string(c_string); |
| |
| } else { |
| ValueMap map; |
| uint64_t ext_addr; |
| |
| ext_addr = (uint64_t) eui64->bytes[7]; |
| ext_addr |= (uint64_t) eui64->bytes[6] << 8; |
| ext_addr |= (uint64_t) eui64->bytes[5] << 16; |
| ext_addr |= (uint64_t) eui64->bytes[4] << 24; |
| ext_addr |= (uint64_t) eui64->bytes[3] << 32; |
| ext_addr |= (uint64_t) eui64->bytes[2] << 40; |
| ext_addr |= (uint64_t) eui64->bytes[1] << 48; |
| ext_addr |= (uint64_t) eui64->bytes[0] << 56; |
| |
| map[kWPANTUNDValueMapKey_NetworkTopology_ExtAddress] = boost::any(ext_addr); |
| map[kWPANTUNDValueMapKey_NetworkTopology_RLOC16] = boost::any(rloc16); |
| map[kWPANTUNDValueMapKey_NetworkTopology_Age] = boost::any(age); |
| map[kWPANTUNDValueMapKey_NetworkTopology_AverageRssi] = boost::any(average_rssi); |
| map[kWPANTUNDValueMapKey_NetworkTopology_LastRssi] = boost::any(last_rssi); |
| map[kWPANTUNDValueMapKey_NetworkTopology_LinkQualityIn] = boost::any(lqin); |
| |
| value = map; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static const char * |
| cache_table_entry_state_to_string(uint8_t state) |
| { |
| const char *str; |
| |
| switch (state) |
| { |
| case SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED: |
| str = kWPANTUNDCacheTableEntryState_Cached; |
| break; |
| case SPINEL_ADDRESS_CACHE_ENTRY_STATE_SNOOPED: |
| str = kWPANTUNDCacheTableEntryState_Snooped; |
| break; |
| case SPINEL_ADDRESS_CACHE_ENTRY_STATE_QUERY: |
| str = kWPANTUNDCacheTableEntryState_Query; |
| break; |
| case SPINEL_ADDRESS_CACHE_ENTRY_STATE_RETRY_QUERY: |
| str = kWPANTUNDCacheTableEntryState_RetryQuery; |
| break; |
| default: |
| str = "unknown"; |
| break; |
| } |
| |
| return str; |
| } |
| |
| static int |
| unpack_address_cache_table(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| std::list<std::string> result_as_string; |
| std::list<ValueMap> result_as_val_map; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| while (data_len > 0) |
| { |
| spinel_ssize_t len; |
| struct in6_addr *target_address = NULL; |
| uint16_t target_rloc16; |
| uint8_t age; |
| uint8_t state; |
| bool valid_last_trans; |
| uint32_t last_trans_time; |
| struct in6_addr *ml_eid = NULL; |
| bool can_evict; |
| uint16_t timeout; |
| uint16_t retry_delay; |
| const uint8_t *cached_struct_in = NULL; |
| unsigned int cached_struct_len = 0; |
| const uint8_t *other_struct_in = NULL; |
| unsigned int other_struct_len = 0; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_IPv6ADDR_S // Target address |
| SPINEL_DATATYPE_UINT16_S // RLOC16 |
| SPINEL_DATATYPE_UINT8_S // Age |
| SPINEL_DATATYPE_UINT8_S // State |
| SPINEL_DATATYPE_DATA_WLEN_S // Cached struct info |
| SPINEL_DATATYPE_DATA_WLEN_S // Other struct info |
| ), |
| &target_address, |
| &target_rloc16, |
| &age, |
| &state, |
| &cached_struct_in, &cached_struct_len, |
| &other_struct_in, &other_struct_len |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| if (state == SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED) { |
| |
| len = spinel_datatype_unpack( |
| cached_struct_in, |
| cached_struct_len, |
| ( |
| SPINEL_DATATYPE_BOOL_S // Is Last Transaction Time valid? |
| SPINEL_DATATYPE_UINT32_S // Last Transaction Time |
| SPINEL_DATATYPE_IPv6ADDR_S // Mesh-local EID |
| ), |
| &valid_last_trans, |
| &last_trans_time, |
| &ml_eid |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| } else { |
| |
| len = spinel_datatype_unpack( |
| other_struct_in, |
| other_struct_len, |
| ( |
| SPINEL_DATATYPE_BOOL_S // Can evict? |
| SPINEL_DATATYPE_UINT16_S // Timeout |
| SPINEL_DATATYPE_UINT16_S // Retry delay |
| ), |
| &can_evict, |
| &timeout, |
| &retry_delay |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| } |
| |
| if (!as_val_map) { |
| char c_string[500]; |
| int index = 0; |
| |
| index += snprintf( |
| c_string + index, sizeof(c_string) - index, |
| "%s -> 0x%04x, Age:%d, State:%s", |
| in6_addr_to_string(*target_address).c_str(), |
| target_rloc16, |
| age, |
| cache_table_entry_state_to_string(state) |
| ); |
| |
| if (state == SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED) { |
| if (valid_last_trans) { |
| index += snprintf( |
| c_string + index, sizeof(c_string) - index, |
| ", LastTrans:%u, ML-EID:%s", |
| last_trans_time, |
| in6_addr_to_string(*ml_eid).c_str() |
| ); |
| } |
| } else { |
| index += snprintf( |
| c_string + index, sizeof(c_string) - index, |
| ", CanEvict:%s, Timeout:%d, RetryDelay:%d", |
| can_evict ? "yes" : "no", |
| timeout, |
| retry_delay |
| ); |
| } |
| |
| result_as_string.push_back(std::string(c_string)); |
| |
| } else { |
| ValueMap entry; |
| |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_Address] = boost::any(in6_addr_to_string(*target_address)); |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_RLOC16] = boost::any(target_rloc16); |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_Age] = boost::any(age); |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_State] = boost::any(std::string(cache_table_entry_state_to_string(state))); |
| |
| if (state == SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED) { |
| if (valid_last_trans) { |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_LastTrans] = boost::any(last_trans_time); |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_MeshLocalEID] = boost::any(in6_addr_to_string(*ml_eid)); |
| } |
| } else { |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_CanEvict] = boost::any(can_evict); |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_Timeout] = boost::any(timeout); |
| entry[kWPANTUNDValueMapKey_AddressCacheTable_RetryDelay] = boost::any(retry_delay); |
| } |
| |
| result_as_val_map.push_back(entry); |
| } |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map; |
| } else { |
| value = result_as_string; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_supported_radio_links(const uint8_t *data_in, spinel_size_t data_len, boost::any &value) |
| { |
| std::list<std::string> result; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| while (data_len > 0) { |
| spinel_ssize_t len; |
| unsigned int value; |
| |
| len = spinel_packed_uint_decode(data_in, data_len, &value); |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| result.push_back(std::string(spinel_radio_link_to_cstr(value))); |
| } |
| |
| value = result; |
| |
| bail: |
| return ret; |
| } |
| static int |
| unpack_neighbor_table_multi_radio_info(const uint8_t *data_in, spinel_size_t data_len, boost::any &value) |
| { |
| int ret = kWPANTUNDStatus_Ok; |
| std::list<std::string> result; |
| char c_string[200]; |
| int index; |
| |
| while (data_len > 0) { |
| spinel_ssize_t len = 0; |
| const uint8_t *entry_data; |
| spinel_size_t entry_len; |
| const spinel_eui64_t *eui64 = NULL; |
| uint16_t rloc16; |
| bool first_radio; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_DATA_WLEN_S, |
| &entry_data, |
| &entry_len |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| data_in += len; |
| data_len -= len; |
| |
| // Parse the entry_data (which contains info about a neighbor) |
| |
| len = spinel_datatype_unpack( |
| entry_data, |
| entry_len, |
| ( |
| SPINEL_DATATYPE_EUI64_S // EUI64 Address |
| SPINEL_DATATYPE_UINT16_S // Rloc16 |
| ), |
| &eui64, |
| &rloc16 |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| index = 0; |
| |
| index += snprintf(c_string + index, sizeof(c_string) - index, |
| "%02X%02X%02X%02X%02X%02X%02X%02X, RLOC16:%04x, Radios:[", |
| eui64->bytes[0], eui64->bytes[1], eui64->bytes[2], eui64->bytes[3], |
| eui64->bytes[4], eui64->bytes[5], eui64->bytes[6], eui64->bytes[7], |
| rloc16 |
| ); |
| |
| require_action(index < sizeof(c_string), bail, ret = kWPANTUNDStatus_Failure); |
| |
| entry_data += len; |
| entry_len -= len; |
| |
| first_radio = true; |
| |
| while (entry_len > 0) { |
| const uint8_t *struct_data; |
| spinel_size_t struct_len; |
| unsigned int radio; |
| uint8_t preference; |
| |
| len = spinel_datatype_unpack( |
| entry_data, |
| entry_len, |
| SPINEL_DATATYPE_DATA_WLEN_S, |
| &struct_data, |
| &struct_len |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| entry_data += len; |
| entry_len -= len; |
| |
| // Parse struct_data (contains info about a supported radio link type) |
| |
| len = spinel_datatype_unpack( |
| struct_data, |
| struct_len, |
| ( |
| SPINEL_DATATYPE_UINT_PACKED_S // Radio link |
| SPINEL_DATATYPE_UINT8_S // Preference |
| ), |
| &radio, |
| &preference |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| struct_data += len; |
| struct_len -= len; |
| |
| index += snprintf(c_string + index, sizeof(c_string) - index, |
| "%s%s(%d)", |
| first_radio ? "" : ", ", |
| spinel_radio_link_to_cstr(radio), |
| preference |
| ); |
| |
| require_action(index < sizeof(c_string), bail, ret = kWPANTUNDStatus_Failure); |
| first_radio = false; |
| } |
| |
| index += snprintf(c_string + index, sizeof(c_string) - index, "]"); |
| require_action(index < sizeof(c_string), bail, ret = kWPANTUNDStatus_Failure); |
| |
| result.push_back(std::string(c_string)); |
| } |
| |
| value = result; |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_mesh_local_prefix(const uint8_t *data_in, spinel_size_t data_len, boost::any &value) |
| { |
| spinel_ssize_t len; |
| struct in6_addr *addr; |
| uint8_t prefix_len; |
| int ret = kWPANTUNDStatus_Failure; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| ( |
| SPINEL_DATATYPE_IPv6ADDR_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| &addr, |
| &prefix_len |
| ); |
| |
| if (len > 0) |
| { |
| char str[10]; |
| snprintf(str, sizeof(str), "/%d", prefix_len); |
| |
| value = boost::any(in6_addr_to_string(*addr) + std::string(str)); |
| ret = kWPANTUNDStatus_Ok; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_dataset(const uint8_t *data_in, spinel_size_t data_len, boost::any &value, bool as_val_map) |
| { |
| int ret = kWPANTUNDStatus_Ok; |
| ThreadDataset dataset; |
| ValueMap map; |
| std::list<std::string> list; |
| |
| ret = dataset.set_from_spinel_frame(data_in, data_len); |
| require_noerr(ret, bail); |
| |
| if (as_val_map) { |
| dataset.convert_to_valuemap(map); |
| value = map; |
| } else { |
| dataset.convert_to_string_list(list); |
| value = list; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_server_leader_services_as_any(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| int ret = kWPANTUNDStatus_Ok; |
| spinel_ssize_t len; |
| uint8_t service_id; |
| uint32_t enterprise_number; |
| const uint8_t *service_data; |
| spinel_size_t service_data_len; |
| bool stable; |
| const uint8_t *server_data; |
| spinel_size_t server_data_len; |
| uint16_t rloc16; |
| int num_service = 0; |
| char c_string[500]; |
| |
| std::list<ValueMap> result_as_val_map_list; |
| std::list<std::string> result_as_string_list; |
| |
| while (data_len > 0) { |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_UINT8_S // Service ID |
| SPINEL_DATATYPE_UINT32_S // Enterprise Number |
| SPINEL_DATATYPE_DATA_WLEN_S // Service Data |
| SPINEL_DATATYPE_BOOL_S // stable |
| SPINEL_DATATYPE_DATA_WLEN_S // Server Data |
| SPINEL_DATATYPE_UINT16_S // RLOC |
| ), |
| &service_id, |
| &enterprise_number, |
| &service_data, |
| &service_data_len, |
| &stable, |
| &server_data, |
| &server_data_len, |
| &rloc16 |
| ); |
| |
| if (len <= 0) { |
| break; |
| } |
| |
| if (as_val_map) { |
| ValueMap result_as_val_map; |
| result_as_val_map[kWPANTUNDValueMapKey_Service_ServiceId] = service_id; |
| result_as_val_map[kWPANTUNDValueMapKey_Service_EnterpriseNumber] = enterprise_number; |
| result_as_val_map[kWPANTUNDValueMapKey_Service_ServiceData] = Data(service_data, service_data_len); |
| result_as_val_map[kWPANTUNDValueMapKey_Service_Stable] = stable; |
| result_as_val_map[kWPANTUNDValueMapKey_Service_ServerData] = Data(server_data, server_data_len); |
| result_as_val_map[kWPANTUNDValueMapKey_Service_RLOC16] = rloc16; |
| result_as_val_map_list.push_back(result_as_val_map); |
| } else { |
| snprintf(c_string, sizeof(c_string), "ServiceId:%01x, EnterpriseNumber:%u, Stable:%d, RLOC16:%04x", service_id, enterprise_number, stable, rloc16); |
| result_as_string_list.push_back(std::string(c_string)); |
| } |
| |
| num_service++; |
| |
| data_in += len; |
| data_len -= len; |
| } |
| |
| if (as_val_map) { |
| value = result_as_val_map_list; |
| } else { |
| value = result_as_string_list; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_mcu_dua_interface_identifier(const uint8_t *data_in, spinel_size_t data_len, boost::any& value) |
| { |
| std::string buff; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| if (data_len == 0) |
| { |
| // When data_len == 0 an empty string will be returned. |
| value = buff; |
| } |
| else if (data_len == 8) |
| { |
| buff = std::string(data_len*2,0); |
| buff.resize(2 * data_len + 1); |
| |
| encode_data_into_string(data_in, data_len, &buff[0], buff.capacity(), 0); |
| value = buff; |
| } |
| else |
| { |
| ret = kWPANTUNDStatus_InvalidArgument; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_meshcop_joiner_state(const uint8_t *data_in, spinel_size_t data_len, boost::any &value) |
| { |
| spinel_ssize_t len; |
| uint8_t joiner_state; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT8_S, |
| &joiner_state |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| switch (joiner_state) { |
| case SPINEL_MESHCOP_JOINER_STATE_IDLE: |
| value = std::string(kWPANTUNDThreadJoinerState_Idle); |
| break; |
| |
| case SPINEL_MESHCOP_JOINER_STATE_DISCOVER: |
| value = std::string(kWPANTUNDThreadJoinerState_Discover); |
| break; |
| |
| case SPINEL_MESHCOP_JOINER_STATE_CONNECTING: |
| value = std::string(kWPANTUNDThreadJoinerState_Connecting); |
| break; |
| |
| case SPINEL_MESHCOP_JOINER_STATE_CONNECTED: |
| value = std::string(kWPANTUNDThreadJoinerState_Connected); |
| break; |
| |
| case SPINEL_MESHCOP_JOINER_STATE_ENTRUST: |
| value = std::string(kWPANTUNDThreadJoinerState_Entrust); |
| break; |
| |
| case SPINEL_MESHCOP_JOINER_STATE_JOINED: |
| value = std::string(kWPANTUNDThreadJoinerState_Joined); |
| break; |
| |
| default: |
| value = std::string("unknown"); |
| break; |
| } |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_meshcop_joiner_discerner_value(const uint8_t *data_in, spinel_size_t data_len, boost::any &value) |
| { |
| spinel_ssize_t len; |
| uint8_t discerner_len; |
| uint64_t discerner_value = 0; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT8_S, |
| &discerner_len |
| ); |
| |
| require_action(len > 0, bail, ret = kWPANTUNDStatus_Failure); |
| |
| if (discerner_len != 0) { |
| data_in += len; |
| data_len -= len; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT64_S, |
| &discerner_value |
| ); |
| } |
| |
| value = discerner_value; |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_thread_network_time_spinel(const uint8_t *data_in, spinel_size_t data_len, uint64_t &time, int8_t &time_sync_status) |
| { |
| return spinel_datatype_unpack( |
| data_in, |
| data_len, |
| ( |
| SPINEL_DATATYPE_UINT64_S // time |
| SPINEL_DATATYPE_INT8_S // time sync status |
| ), |
| &time, |
| &time_sync_status |
| ); |
| } |
| |
| static int |
| unpack_thread_network_time_as_string(const uint8_t *data_in, spinel_size_t data_len, std::string &result) |
| { |
| spinel_ssize_t len; |
| uint64_t time; |
| int8_t time_sync_status; |
| char c_string[500]; |
| int ret = kWPANTUNDStatus_Failure; |
| |
| len = unpack_thread_network_time_spinel(data_in, data_len, time, time_sync_status); |
| |
| if (len > 0) |
| { |
| ret = kWPANTUNDStatus_Ok; |
| snprintf(c_string, sizeof(c_string), "ThreadNetworkTime: %" PRIu64 ", TimeSyncStatus:%d", time, time_sync_status); |
| result.assign(c_string); |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_thread_network_time_as_valmap(const uint8_t *data_in, spinel_size_t data_len, ValueMap &result) |
| { |
| spinel_ssize_t len; |
| ValueMap entry; |
| uint64_t time; |
| int8_t time_sync_status; |
| int ret = kWPANTUNDStatus_Failure; |
| |
| len = unpack_thread_network_time_spinel(data_in, data_len, time, time_sync_status); |
| |
| if (len > 0) |
| { |
| ret = kWPANTUNDStatus_Ok; |
| result.clear(); |
| result[kWPANTUNDValueMapKey_TimeSync_Time] = time; |
| result[kWPANTUNDValueMapKey_TimeSync_Status] = time_sync_status; |
| #if APPEND_NETWORK_TIME_RECEIVED_MONOTONIC_TIMESTAMP |
| result[kWPANTUNDValueMapKey_TimeSync_ReceivedMonoTimeUs] = time_get_monotonic_us(); |
| #endif // APPEND_NETWORK_TIME_RECEIVED_MONOTONIC_TIMESTAMP |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_thread_network_time_as_any(const uint8_t *data_in, spinel_size_t data_len, boost::any& value, bool as_val_map) |
| { |
| ValueMap result_as_val_map; |
| std::list<ValueMap> result_as_val_map_list; |
| std::string result_as_string; |
| std::list<std::string> result_as_string_list; |
| int ret; |
| |
| if (as_val_map) |
| { |
| ret = unpack_thread_network_time_as_valmap(data_in, data_len, result_as_val_map); |
| |
| if (ret == kWPANTUNDStatus_Ok) |
| { |
| result_as_val_map_list.push_back(result_as_val_map); |
| value = result_as_val_map_list; |
| } |
| } |
| else |
| { |
| ret = unpack_thread_network_time_as_string(data_in, data_len, result_as_string); |
| |
| if (ret == kWPANTUNDStatus_Ok) |
| { |
| result_as_string_list.push_back(result_as_string); |
| value = result_as_string_list; |
| } |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_link_metrics_as_val_map(const uint8_t *data_in, spinel_size_t data_len, ValueMap &val_map) |
| { |
| spinel_ssize_t len; |
| uint8_t metric_type; |
| uint8_t *metric_ptr = NULL; |
| uint32_t metric_len = 0; |
| int ret = kWPANTUNDStatus_Failure; |
| |
| while (data_len > 0) { |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| ( |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_DATA_S |
| ) |
| ), |
| &metric_type, |
| &metric_ptr, |
| &metric_len |
| ); |
| |
| require(len >= 0, bail); |
| data_in += len; |
| data_len -= len; |
| |
| switch (metric_type) { |
| case SPINEL_THREAD_LINK_METRIC_PDU_COUNT: |
| val_map[kWPANTUNDValueMapKey_LinkMetrics_PDUCount] = *reinterpret_cast<uint32_t*>(metric_ptr); |
| break; |
| case SPINEL_THREAD_LINK_METRIC_LQI: |
| val_map[kWPANTUNDValueMapKey_LinkMetrics_LQI] = static_cast<uint32_t>(*reinterpret_cast<uint8_t*>(metric_ptr)); |
| break; |
| case SPINEL_THREAD_LINK_METRIC_LINK_MARGIN: |
| val_map[kWPANTUNDValueMapKey_LinkMetrics_LinkMargin] = static_cast<uint32_t>(*reinterpret_cast<uint8_t*>(metric_ptr)); |
| break; |
| case SPINEL_THREAD_LINK_METRIC_RSSI: |
| val_map[kWPANTUNDValueMapKey_LinkMetrics_RSSI] = *reinterpret_cast<int8_t*>(metric_ptr); |
| break; |
| default: |
| goto bail; |
| } |
| } |
| |
| ret = kWPANTUNDStatus_Ok; |
| |
| bail: |
| return ret; |
| } |
| |
| static int |
| unpack_backbone_router_primary(const uint8_t *data_in, spinel_size_t data_len, boost::any& value) |
| { |
| spinel_ssize_t len; |
| char c_string[300]; |
| int ret = kWPANTUNDStatus_Ok; |
| uint16_t server = 0; |
| uint16_t delay = 0; |
| uint32_t timeout = 0; |
| uint8_t seqno = 0; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| ( |
| SPINEL_DATATYPE_UINT16_S |
| SPINEL_DATATYPE_UINT16_S |
| SPINEL_DATATYPE_UINT32_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| &server, |
| &delay, |
| &timeout, |
| &seqno |
| ); |
| |
| if (len > 0) { |
| snprintf(c_string, sizeof(c_string), "server16 = 0x%04X, seqno = %hu, delay = %hu secs, timeout = %u secs", |
| server, (uint16_t)seqno, delay, timeout); |
| |
| value = std::string(c_string); |
| } else { |
| ret = kWPANTUNDStatus_Failure; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_backbone_router_config(const uint8_t *data_in, spinel_size_t data_len, boost::any& value) |
| { |
| spinel_ssize_t len; |
| char c_string[300]; |
| int ret = kWPANTUNDStatus_Ok; |
| uint16_t delay = 0; |
| uint32_t timeout = 0; |
| uint8_t seqno = 0; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| ( |
| SPINEL_DATATYPE_UINT16_S |
| SPINEL_DATATYPE_UINT32_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| &delay, |
| &timeout, |
| &seqno |
| ); |
| |
| if (len > 0) { |
| snprintf(c_string, sizeof(c_string), "seqno = %hu, delay = %hu secs, timeout = %u secs", |
| (uint16_t)seqno, delay, timeout); |
| |
| value = std::string(c_string); |
| } else { |
| ret = kWPANTUNDStatus_Failure; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| unpack_backbone_router_state(const uint8_t *data_in, spinel_size_t data_len, boost::any& value) |
| { |
| spinel_ssize_t len; |
| uint8_t state; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| len = spinel_datatype_unpack( |
| data_in, |
| data_len, |
| SPINEL_DATATYPE_UINT8_S, |
| &state |
| ); |
| |
| if (len > 0) { |
| switch (state) { |
| case SPINEL_THREAD_BACKBONE_ROUTER_STATE_DISABLED: |
| value = std::string(kWPANTUNDThreadBackboneRouterState_Disabled); |
| break; |
| case SPINEL_THREAD_BACKBONE_ROUTER_STATE_SECONDARY: |
| value = std::string(kWPANTUNDThreadBackboneRouterState_Secondary); |
| break; |
| case SPINEL_THREAD_BACKBONE_ROUTER_STATE_PRIMARY: |
| value = std::string(kWPANTUNDThreadBackboneRouterState_Primary); |
| break; |
| default: |
| ret = kWPANTUNDStatus_Failure; |
| break; |
| } |
| } else { |
| ret = kWPANTUNDStatus_Failure; |
| } |
| |
| return ret; |
| } |
| |
| void |
| SpinelNCPInstance::get_dataset_command_help(std::list<std::string> &list) |
| { |
| list.clear(); |
| list.push_back("List of valid commands:"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_Erase "`: Erase the local Dataset (all fields are un-set)"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_GetActive "`: Get the NCP's Active Operational Dataset and populate the local Dataset from it"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_SetActive "`: Set the NCP's Active Operational Dataset from the current local Dataset"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_SendMgmtGetActive "`: Send MGMT_GET_ACTIVE meshcop command requesting TLVs in current local Dataset"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_SendMgmtSetActive "`: Send MGMT_SET_ACTIVE meshcop command along with the current local Dataset"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_GetPending "`: Get the NCP's Pending Operational Dataset and populate the local DataSet from it"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_SetPending "`: Set the NCP's Pending Operational Dataset from the current local Dataset"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_SendMgmtGetPending "`: Send MGMT_GET_PENDING meshcop command requesting TLVs in the current local Dataset"); |
| list.push_back(" - `" kWPANTUNDDatasetCommand_SendMgmtSetPending "`: Send MGMT_SET_PENDING meshcop command along with the current local Dataset"); |
| } |
| |
| int |
| SpinelNCPInstance::unpack_and_set_local_dataset(const uint8_t *data_in, spinel_size_t data_len) |
| { |
| return mLocalDataset.set_from_spinel_frame(data_in, data_len); |
| } |
| |
| void |
| SpinelNCPInstance::perform_dataset_command(const std::string &command, CallbackWithStatus cb) |
| { |
| if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_Erase)) { |
| mLocalDataset.clear(); |
| cb(kWPANTUNDStatus_Ok); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_GetActive)) { |
| get_spinel_prop_with_unpacker( |
| boost::bind(cb, _1), |
| SPINEL_PROP_THREAD_ACTIVE_DATASET, |
| boost::bind(&SpinelNCPInstance::unpack_and_set_local_dataset, this, _1, _2)); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_SetActive)) { |
| Data frame; |
| mLocalDataset.convert_to_spinel_frame(frame); |
| set_spinel_prop(frame, cb, SPINEL_PROP_THREAD_ACTIVE_DATASET, SPINEL_DATATYPE_DATA_C); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_SendMgmtGetActive)) { |
| Data frame; |
| mLocalDataset.convert_to_spinel_frame(frame, /* include_values */ false); |
| set_spinel_prop(frame, cb, SPINEL_PROP_THREAD_MGMT_GET_ACTIVE_DATASET, SPINEL_DATATYPE_DATA_C); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_SendMgmtSetActive)) { |
| Data frame; |
| mLocalDataset.convert_to_spinel_frame(frame); |
| set_spinel_prop(frame, cb, SPINEL_PROP_THREAD_MGMT_SET_ACTIVE_DATASET, SPINEL_DATATYPE_DATA_C); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_GetPending)) { |
| get_spinel_prop_with_unpacker( |
| boost::bind(cb, _1), |
| SPINEL_PROP_THREAD_PENDING_DATASET, |
| boost::bind(&SpinelNCPInstance::unpack_and_set_local_dataset, this, _1, _2)); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_SetPending)) { |
| Data frame; |
| mLocalDataset.convert_to_spinel_frame(frame); |
| set_spinel_prop(frame, cb, SPINEL_PROP_THREAD_PENDING_DATASET, SPINEL_DATATYPE_DATA_C); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_SendMgmtGetPending)) { |
| Data frame; |
| mLocalDataset.convert_to_spinel_frame(frame, /* include_values */ false); |
| set_spinel_prop(frame, cb, SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET, SPINEL_DATATYPE_DATA_C); |
| |
| } else if (strcaseequal(command.c_str(), kWPANTUNDDatasetCommand_SendMgmtSetPending)) { |
| Data frame; |
| mLocalDataset.convert_to_spinel_frame(frame); |
| set_spinel_prop(frame, cb, SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET, SPINEL_DATATYPE_DATA_C); |
| |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::update_node_type(NodeType new_node_type) |
| { |
| if (mNodeType != new_node_type) { |
| syslog( |
| LOG_NOTICE, |
| "Node type change: \"%s\" -> \"%s\"", |
| node_type_to_string(mNodeType).c_str(), |
| node_type_to_string(new_node_type).c_str() |
| ); |
| |
| mNodeType = new_node_type; |
| signal_property_changed(kWPANTUNDProperty_NetworkNodeType, node_type_to_string(mNodeType)); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::update_link_local_address(struct in6_addr *addr) |
| { |
| if (NULL != addr |
| && (0 != memcmp(mNCPLinkLocalAddress.s6_addr, addr->s6_addr, sizeof(mNCPLinkLocalAddress))) |
| ) { |
| memcpy((void*)mNCPLinkLocalAddress.s6_addr, (void*)addr->s6_addr, sizeof(mNCPLinkLocalAddress)); |
| signal_property_changed(kWPANTUNDProperty_IPv6LinkLocalAddress, in6_addr_to_string(*addr)); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::update_mesh_local_address(struct in6_addr *addr) |
| { |
| if (addr |
| && buffer_is_nonzero(addr->s6_addr, 8) |
| && (0 != memcmp(mNCPMeshLocalAddress.s6_addr, addr->s6_addr, sizeof(mNCPMeshLocalAddress))) |
| ) { |
| memcpy((void*)mNCPMeshLocalAddress.s6_addr, (void*)addr->s6_addr, sizeof(mNCPMeshLocalAddress)); |
| signal_property_changed(kWPANTUNDProperty_IPv6MeshLocalAddress, in6_addr_to_string(*addr)); |
| |
| // If mesh-local prefix gets changed we go through the |
| // list of IPv6 addresses and filter/remove any previously |
| // added RLOC addresses. |
| filter_addresses(); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::update_mesh_local_prefix(struct in6_addr *addr) |
| { |
| if (addr |
| && buffer_is_nonzero(addr->s6_addr, 8) |
| && (0 != memcmp(mNCPV6Prefix, addr, sizeof(mNCPV6Prefix))) |
| ) { |
| memcpy((void*)mNCPV6Prefix, (void*)addr, sizeof(mNCPV6Prefix)); |
| struct in6_addr prefix_addr (mNCPMeshLocalAddress); |
| // Zero out the lower 64 bits. |
| memset(prefix_addr.s6_addr+8, 0, 8); |
| signal_property_changed(kWPANTUNDProperty_IPv6MeshLocalPrefix, in6_addr_to_string(prefix_addr) + "/64"); |
| |
| // If mesh-local prefix gets changed we go through the |
| // list of IPv6 addresses and filter/remove any previously |
| // added RLOC addresses. |
| filter_addresses(); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Property Get Handlers |
| |
| void |
| SpinelNCPInstance::get_spinel_prop(CallbackWithStatusArg1 cb, spinel_prop_key_t prop_key, |
| const std::string &reply_format) |
| { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, prop_key)) |
| .set_reply_format(reply_format) |
| .finish() |
| ); |
| } |
| |
| void |
| SpinelNCPInstance::get_spinel_prop_with_unpacker(CallbackWithStatusArg1 cb, spinel_prop_key_t prop_key, |
| ReplyUnpacker unpacker) |
| { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, prop_key)) |
| .set_reply_unpacker(unpacker) |
| .finish() |
| ); |
| } |
| |
| void SpinelNCPInstance::check_capability_prop_get(CallbackWithStatusArg1 cb, const std::string &prop_name, |
| unsigned int capability, PropGetHandler handler) |
| { |
| if (mCapabilities.count(capability)) { |
| handler(cb, prop_name); |
| } else { |
| char error_msg[200]; |
| snprintf(error_msg, sizeof(error_msg), |
| "Capability %s (required for \"%s\") is not supported by NCP", spinel_capability_to_cstr(capability), |
| prop_name.c_str()); |
| cb(kWPANTUNDStatus_FeatureNotSupported, std::string(error_msg)); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::register_get_handler(const char *prop_name, PropGetHandler handler) |
| { |
| NCPInstanceBase::register_prop_get_handler(prop_name, handler); |
| } |
| |
| void |
| SpinelNCPInstance::register_get_handler_capability(const char *prop_name, unsigned int capability, |
| PropGetHandler handler) |
| { |
| register_get_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::check_capability_prop_get, this, _1, _2, capability, handler)); |
| } |
| |
| void |
| SpinelNCPInstance::register_get_handler_spinel_simple(const char *prop_name, spinel_prop_key_t prop_key, |
| const char *reply_format) |
| { |
| register_get_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::get_spinel_prop, this, _1, prop_key, std::string(reply_format))); |
| } |
| |
| void |
| SpinelNCPInstance::register_get_handler_spinel_unpacker(const char *prop_name, spinel_prop_key_t prop_key, |
| ReplyUnpacker unpacker) |
| { |
| register_get_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::get_spinel_prop_with_unpacker, this, _1, prop_key, unpacker)); |
| } |
| |
| void |
| SpinelNCPInstance::register_get_handler_capability_spinel_simple(const char *prop_name, unsigned int capability, |
| spinel_prop_key_t prop_key, const char *reply_format) |
| { |
| register_get_handler_capability( |
| prop_name, |
| capability, |
| boost::bind(&SpinelNCPInstance::get_spinel_prop, this, _1, prop_key, std::string(reply_format))); |
| } |
| |
| void |
| SpinelNCPInstance::register_get_handler_capability_spinel_unpacker(const char *prop_name, unsigned int capability, |
| spinel_prop_key_t prop_key, ReplyUnpacker unpacker) |
| { |
| register_get_handler_capability( |
| prop_name, |
| capability, |
| boost::bind(&SpinelNCPInstance::get_spinel_prop_with_unpacker, this, _1, prop_key, unpacker)); |
| } |
| |
| void |
| SpinelNCPInstance::regsiter_all_get_handlers(void) |
| { |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties associated with a spinel property with simple packing format |
| |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NCPCCAThreshold, |
| SPINEL_PROP_PHY_CCA_THRESHOLD, SPINEL_DATATYPE_INT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NCPTXPower, |
| SPINEL_PROP_PHY_TX_POWER, SPINEL_DATATYPE_INT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NCPFrequency, |
| SPINEL_PROP_PHY_FREQ, SPINEL_DATATYPE_INT32_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NetworkKey, |
| SPINEL_PROP_NET_MASTER_KEY, SPINEL_DATATYPE_DATA_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NetworkPSKc, |
| SPINEL_PROP_NET_PSKC, SPINEL_DATATYPE_DATA_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NCPExtendedAddress, |
| SPINEL_PROP_MAC_EXTENDED_ADDR, SPINEL_DATATYPE_EUI64_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NetworkKeyIndex, |
| SPINEL_PROP_NET_KEY_SEQUENCE_COUNTER, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NetworkKeySwitchGuardTime, |
| SPINEL_PROP_NET_KEY_SWITCH_GUARDTIME, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NetworkRole, |
| SPINEL_PROP_NET_ROLE, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NetworkPartitionId, |
| SPINEL_PROP_NET_PARTITION_ID, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadRouterUpgradeThreshold, |
| SPINEL_PROP_THREAD_ROUTER_UPGRADE_THRESHOLD, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadRouterDowngradeThreshold, |
| SPINEL_PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NCPRSSI, |
| SPINEL_PROP_PHY_RSSI, SPINEL_DATATYPE_INT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadRLOC16, |
| SPINEL_PROP_THREAD_RLOC16, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadRouterSelectionJitter, |
| SPINEL_PROP_THREAD_ROUTER_SELECTION_JITTER, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadLeaderAddress, |
| SPINEL_PROP_THREAD_LEADER_ADDR, SPINEL_DATATYPE_IPv6ADDR_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadLeaderRouterID, |
| SPINEL_PROP_THREAD_LEADER_RID, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadLeaderWeight, |
| SPINEL_PROP_THREAD_LEADER_WEIGHT, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadLeaderLocalWeight, |
| SPINEL_PROP_THREAD_LOCAL_LEADER_WEIGHT, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadNetworkData, |
| SPINEL_PROP_THREAD_NETWORK_DATA, SPINEL_DATATYPE_DATA_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadNetworkDataVersion, |
| SPINEL_PROP_THREAD_NETWORK_DATA_VERSION, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadStableNetworkData, |
| SPINEL_PROP_THREAD_STABLE_NETWORK_DATA, SPINEL_DATATYPE_DATA_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadLeaderNetworkData, |
| SPINEL_PROP_THREAD_LEADER_NETWORK_DATA, SPINEL_DATATYPE_DATA_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadStableLeaderNetworkData, |
| SPINEL_PROP_THREAD_STABLE_LEADER_NETWORK_DATA, SPINEL_DATATYPE_DATA_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadStableNetworkDataVersion, |
| SPINEL_PROP_THREAD_STABLE_NETWORK_DATA_VERSION, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadRouterRoleEnabled, |
| SPINEL_PROP_THREAD_ROUTER_ROLE_ENABLED, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadDeviceMode, |
| SPINEL_PROP_THREAD_MODE, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_OpenThreadDebugTestAssert, |
| SPINEL_PROP_DEBUG_TEST_ASSERT, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_OpenThreadDebugTestWatchdog, |
| SPINEL_PROP_DEBUG_TEST_WATCHDOG, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_TmfProxyEnabled, |
| SPINEL_PROP_THREAD_TMF_PROXY_ENABLED, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_NCPCCAFailureRate, |
| SPINEL_PROP_MAC_CCA_FAILURE_RATE, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_ThreadChildTimeout, |
| SPINEL_PROP_THREAD_CHILD_TIMEOUT, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_OpenThreadLogLevel, |
| SPINEL_PROP_DEBUG_NCP_LOG_LEVEL, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_OpenThreadLogTimestampBase, |
| SPINEL_PROP_DEBUG_LOG_TIMESTAMP_BASE, SPINEL_DATATYPE_UINT64_S); |
| register_get_handler_spinel_simple( |
| kWPANTUNDProperty_OpenThreadTrelTestModeEnable, |
| SPINEL_PROP_DEBUG_TREL_TEST_MODE_ENABLE, SPINEL_DATATYPE_BOOL_S); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties requiring capability check and associated with a spinel property |
| // with simple packing format |
| |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPSleepyPollInterval, |
| SPINEL_CAP_ROLE_SLEEPY, |
| SPINEL_PROP_MAC_DATA_POLL_PERIOD, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_CommissionerProvisioningUrl, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_PROVISIONING_URL, SPINEL_DATATYPE_UTF8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_CommissionerSessionId, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_SESSION_ID, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_MACAllowlistEnabled, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_ALLOWLIST_ENABLED, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_MACDenylistEnabled, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_DENYLIST_ENABLED, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_JamDetectionStatus, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECTED, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_JamDetectionEnable, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_ENABLE, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_JamDetectionRssiThreshold, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_RSSI_THRESHOLD, SPINEL_DATATYPE_INT8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_JamDetectionWindow, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_WINDOW, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_JamDetectionBusyPeriod, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_BUSY, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_JamDetectionDebugHistoryBitmap, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_HISTORY_BITMAP, SPINEL_DATATYPE_UINT64_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChildSupervisionInterval, |
| SPINEL_CAP_CHILD_SUPERVISION, |
| SPINEL_PROP_CHILD_SUPERVISION_INTERVAL, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChildSupervisionCheckTimeout, |
| SPINEL_CAP_CHILD_SUPERVISION, |
| SPINEL_PROP_CHILD_SUPERVISION_CHECK_TIMEOUT, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelMonitorSampleInterval, |
| SPINEL_CAP_CHANNEL_MONITOR, |
| SPINEL_PROP_CHANNEL_MONITOR_SAMPLE_INTERVAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelMonitorRssiThreshold, |
| SPINEL_CAP_CHANNEL_MONITOR, |
| SPINEL_PROP_CHANNEL_MONITOR_RSSI_THRESHOLD, SPINEL_DATATYPE_INT8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelMonitorSampleWindow, |
| SPINEL_CAP_CHANNEL_MONITOR, |
| SPINEL_PROP_CHANNEL_MONITOR_SAMPLE_WINDOW, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelMonitorSampleCount, |
| SPINEL_CAP_CHANNEL_MONITOR, |
| SPINEL_PROP_CHANNEL_MONITOR_SAMPLE_COUNT, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelManagerNewChannel, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_NEW_CHANNEL, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelManagerDelay, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_DELAY, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelManagerAutoSelectEnabled, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_ENABLED, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelManagerAutoSelectInterval, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_INTERVAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ChannelManagerChannelSelect, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_CHANNEL_SELECT, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NestLabs_LegacyMeshLocalPrefix, |
| SPINEL_CAP_NEST_LEGACY_INTERFACE, |
| SPINEL_PROP_NEST_LEGACY_ULA_PREFIX, SPINEL_DATATYPE_DATA_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_TimeSync_Period, |
| SPINEL_CAP_TIME_SYNC, |
| SPINEL_PROP_TIME_SYNC_PERIOD, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_TimeSync_XtalThreshold, |
| SPINEL_CAP_TIME_SYNC, |
| SPINEL_PROP_TIME_SYNC_XTAL_THRESHOLD, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_UNICAST, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_UNICAST, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_BROADCAST, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_BROADCAST, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_ACK_REQ, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_ACK_REQ, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_ACKED, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_ACKED, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_NO_ACK_REQ, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_NO_ACK_REQ, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_DATA, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_DATA, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_DATA_POLL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_DATA_POLL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_BEACON, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_BEACON, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_BEACON_REQ, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_BEACON_REQ, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_OTHER, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_OTHER, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_PKT_RETRY, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_PKT_RETRY, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_ERR_CCA, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_ERR_CCA, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_ERR_ABORT, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_ERR_ABORT, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_UNICAST, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_UNICAST, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_BROADCAST, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_BROADCAST, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_DATA, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_DATA, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_DATA_POLL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_DATA_POLL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_BEACON, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_BEACON, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_BEACON_REQ, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_BEACON_REQ, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_OTHER, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_OTHER, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_FILT_WL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_FILT_WL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_PKT_FILT_DA, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_PKT_FILT_DA, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_ERR_EMPTY, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_ERR_EMPTY, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_ERR_UKWN_NBR, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_ERR_UKWN_NBR, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_ERR_NVLD_SADDR, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_ERR_NVLD_SADDR, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_ERR_SECURITY, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_ERR_SECURITY, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_ERR_BAD_FCS, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_ERR_BAD_FCS, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_ERR_OTHER, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_ERR_OTHER, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_IP_SEC_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_IP_SEC_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_IP_INSEC_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_IP_INSEC_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_IP_DROPPED, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_IP_DROPPED, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_IP_SEC_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_IP_SEC_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_IP_INSEC_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_IP_INSEC_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_IP_DROPPED, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_IP_DROPPED, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_TX_SPINEL_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_TX_SPINEL_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_SPINEL_TOTAL, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_SPINEL_TOTAL, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_RX_SPINEL_ERR, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RX_SPINEL_ERR, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_IP_TX_SUCCESS, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_IP_TX_SUCCESS, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_IP_RX_SUCCESS, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_IP_RX_SUCCESS, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_IP_TX_FAILURE, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_IP_TX_FAILURE, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCounter_IP_RX_FAILURE, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_IP_RX_FAILURE, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_POSIXAppRCPVersion, |
| SPINEL_CAP_POSIX, |
| SPINEL_PROP_RCP_VERSION, SPINEL_DATATYPE_UTF8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_OpenThreadSLAACEnabled, |
| SPINEL_CAP_SLAAC, |
| SPINEL_PROP_SLAAC_ENABLED, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_NCPCoexEnable, |
| SPINEL_CAP_RADIO_COEX, |
| SPINEL_PROP_RADIO_COEX_ENABLE, SPINEL_DATATYPE_BOOL_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ThreadDomainName, |
| SPINEL_CAP_NET_THREAD_1_2, |
| SPINEL_PROP_THREAD_DOMAIN_NAME, SPINEL_DATATYPE_UTF8_S); |
| |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ThreadCslPeriod, |
| SPINEL_CAP_THREAD_CSL_RECEIVER, |
| SPINEL_PROP_THREAD_CSL_PERIOD, SPINEL_DATATYPE_UINT16_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ThreadCslTimeout, |
| SPINEL_CAP_THREAD_CSL_RECEIVER, |
| SPINEL_PROP_THREAD_CSL_TIMEOUT, SPINEL_DATATYPE_UINT32_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ThreadCslChannel, |
| SPINEL_CAP_THREAD_CSL_RECEIVER, |
| SPINEL_PROP_THREAD_CSL_CHANNEL, SPINEL_DATATYPE_UINT8_S); |
| register_get_handler_capability_spinel_simple( |
| kWPANTUNDProperty_ThreadBackboneRouterLocalJitter, |
| SPINEL_CAP_THREAD_BACKBONE_ROUTER, |
| SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTRATION_JITTER, SPINEL_DATATYPE_UINT8_S); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties associated with a spinel property using an unpacker |
| |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_NCPChannelMask, |
| SPINEL_PROP_PHY_CHAN_SUPPORTED, unpack_channel_mask); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_NCPPreferredChannelMask, |
| SPINEL_PROP_PHY_CHAN_PREFERRED, unpack_channel_mask); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadActiveDataset, |
| SPINEL_PROP_THREAD_ACTIVE_DATASET, boost::bind(unpack_dataset, _1, _2, _3, /* as_val_map */ false)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadActiveDatasetAsValMap, |
| SPINEL_PROP_THREAD_ACTIVE_DATASET, boost::bind(unpack_dataset, _1, _2, _3, /* as_val_map */ true)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadPendingDataset, |
| SPINEL_PROP_THREAD_PENDING_DATASET, boost::bind(unpack_dataset, _1, _2, _3, /* as_val_map */ false)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadPendingDatasetAsValMap, |
| SPINEL_PROP_THREAD_PENDING_DATASET, boost::bind(unpack_dataset, _1, _2, _3, /* as_val_map */ true)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadParent, |
| SPINEL_PROP_THREAD_PARENT, |
| boost::bind(unpack_parent_info, _1, _2, _3, /* as_val_map */ false)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadParentAsValMap, |
| SPINEL_PROP_THREAD_PARENT, |
| boost::bind(unpack_parent_info, _1, _2, _3, /* as_val_map */ true)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadAddressCacheTable, |
| SPINEL_PROP_THREAD_ADDRESS_CACHE_TABLE, |
| boost::bind(unpack_address_cache_table, _1, _2, _3, /* as_val_map */ false)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_ThreadAddressCacheTableAsValMap, |
| SPINEL_PROP_THREAD_ADDRESS_CACHE_TABLE, |
| boost::bind(unpack_address_cache_table, _1, _2, _3, /* as_val_map */ true)); |
| register_get_handler_spinel_unpacker( |
| kWPANTUNDProperty_OpenThreadSupportedRadioLinks, |
| SPINEL_PROP_SUPPORTED_RADIO_LINKS, |
| unpack_supported_radio_links); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties requiring capability check and associated with a spinel property |
| // using an unpacker |
| |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPMCUPowerState, |
| SPINEL_CAP_MCU_POWER_STATE, |
| SPINEL_PROP_MCU_POWER_STATE, unpack_mcu_power_state); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_JoinerState, |
| SPINEL_CAP_THREAD_JOINER, |
| SPINEL_PROP_MESHCOP_JOINER_STATE, unpack_meshcop_joiner_state); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_JoinerDiscernerValue, |
| SPINEL_CAP_THREAD_JOINER, |
| SPINEL_PROP_MESHCOP_JOINER_DISCERNER, unpack_meshcop_joiner_discerner_value); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_CommissionerState, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_STATE, unpack_commissioner_state); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_CommissionerJoiners, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS, unpack_commissioner_joiners); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_MACAllowlistEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_ALLOWLIST, boost::bind(unpack_mac_allowlist_entries, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_MACAllowlistEntriesAsValMap, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_ALLOWLIST, boost::bind(unpack_mac_allowlist_entries, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_MACDenylistEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_DENYLIST, boost::bind(unpack_mac_denylist_entries, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_MACDenylistEntriesAsValMap, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_DENYLIST, boost::bind(unpack_mac_denylist_entries, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_MACFilterEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_FIXED_RSS, boost::bind(unpack_mac_allowlist_entries, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_MACFilterEntriesAsValMap, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_FIXED_RSS, boost::bind(unpack_mac_allowlist_entries, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ChannelMonitorChannelQuality, |
| SPINEL_CAP_CHANNEL_MONITOR, |
| SPINEL_PROP_CHANNEL_MONITOR_CHANNEL_OCCUPANCY, boost::bind(unpack_channel_occupancy, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ChannelMonitorChannelQualityAsValMap, |
| SPINEL_CAP_CHANNEL_MONITOR, |
| SPINEL_PROP_CHANNEL_MONITOR_CHANNEL_OCCUPANCY, boost::bind(unpack_channel_occupancy, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ChannelManagerSupportedChannelMask, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_SUPPORTED_CHANNELS, unpack_channel_mask); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ChannelManagerFavoredChannelMask, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_FAVORED_CHANNELS, unpack_channel_mask); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCounterAllMac, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_ALL_MAC_COUNTERS, boost::bind(unpack_ncp_counters_all_mac, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCounterAllMacAsValMap, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_ALL_MAC_COUNTERS, boost::bind(unpack_ncp_counters_all_mac, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCounterThreadMle, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_MLE_COUNTERS, boost::bind(unpack_ncp_counters_mle, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCounterThreadMleAsValMap, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_MLE_COUNTERS, boost::bind(unpack_ncp_counters_mle, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCounterAllIPv6, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_ALL_IP_COUNTERS, boost::bind(unpack_ncp_counters_ipv6, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCounterAllIPv6AsValMap, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_ALL_IP_COUNTERS, boost::bind(unpack_ncp_counters_ipv6, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_TimeSync_NetworkTime, |
| SPINEL_CAP_TIME_SYNC, |
| SPINEL_PROP_THREAD_NETWORK_TIME, boost::bind(unpack_thread_network_time_as_any, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_TimeSync_NetworkTimeAsValMap, |
| SPINEL_CAP_TIME_SYNC, |
| SPINEL_PROP_THREAD_NETWORK_TIME, boost::bind(unpack_thread_network_time_as_any, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ThreadLeaderServices, |
| SPINEL_CAP_THREAD_SERVICE, |
| SPINEL_PROP_SERVER_LEADER_SERVICES, boost::bind(unpack_server_leader_services_as_any, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ThreadLeaderServicesAsValMap, |
| SPINEL_CAP_THREAD_SERVICE, |
| SPINEL_PROP_SERVER_LEADER_SERVICES, boost::bind(unpack_server_leader_services_as_any, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCoexMetrics, |
| SPINEL_CAP_RADIO_COEX, |
| SPINEL_PROP_RADIO_COEX_METRICS, boost::bind(unpack_coex_metrics, _1, _2, _3, false)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_NCPCoexMetricsAsValMap, |
| SPINEL_CAP_RADIO_COEX, |
| SPINEL_PROP_RADIO_COEX_METRICS, boost::bind(unpack_coex_metrics, _1, _2, _3, true)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_OpenThreadNeighborTableMultiRadioInfo, |
| SPINEL_CAP_MULTI_RADIO, |
| SPINEL_PROP_NEIGHBOR_TABLE_MULTI_RADIO_INFO, boost::bind(unpack_neighbor_table_multi_radio_info, _1, _2, _3)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ThreadDUAInterfaceIdentifier, |
| SPINEL_CAP_DUA, |
| SPINEL_PROP_THREAD_DUA_ID, unpack_mcu_dua_interface_identifier); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ThreadBackboneRouterPrimary, |
| SPINEL_CAP_NET_THREAD_1_2, |
| SPINEL_PROP_THREAD_BACKBONE_ROUTER_PRIMARY, boost::bind(unpack_backbone_router_primary, _1, _2, _3)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ThreadBackboneRouterLocalState, |
| SPINEL_CAP_THREAD_BACKBONE_ROUTER, |
| SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_STATE, boost::bind(unpack_backbone_router_state, _1, _2, _3)); |
| register_get_handler_capability_spinel_unpacker( |
| kWPANTUNDProperty_ThreadBackboneRouterLocalConfig, |
| SPINEL_CAP_THREAD_BACKBONE_ROUTER, |
| SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_CONFIG, boost::bind(unpack_backbone_router_config, _1, _2, _3)); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties with a dedicated handler method |
| |
| register_get_handler( |
| kWPANTUNDProperty_ConfigNCPDriverName, |
| boost::bind(&SpinelNCPInstance::get_prop_ConfigNCPDriverName, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_NCPCapabilities, |
| boost::bind(&SpinelNCPInstance::get_prop_NCPCapabilities, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_NetworkIsCommissioned, |
| boost::bind(&SpinelNCPInstance::get_prop_NetworkIsCommissioned, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadRouterID, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadRouterID, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadConfigFilterRLOCAddresses, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadConfigFilterRLOCAddresses, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadConfigFilterALOCAddresses, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadConfigFilterALOCAddresses, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_IPv6MeshLocalPrefix, |
| boost::bind(&SpinelNCPInstance::get_prop_IPv6MeshLocalPrefix, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_IPv6MeshLocalAddress, |
| boost::bind(&SpinelNCPInstance::get_prop_IPv6MeshLocalAddress, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_IPv6LinkLocalAddress, |
| boost::bind(&SpinelNCPInstance::get_prop_IPv6LinkLocalAddress, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadChildTable, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadChildTable, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadChildTableAsValMap, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadChildTableAsValMap, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadChildTableAddresses, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadChildTableAddresses, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadNeighborTable, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadNeighborTable, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadNeighborTableAsValMap, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadNeighborTableAsValMap, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadRouterTable, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadRouterTable, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_ThreadRouterTableAsValMap, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadRouterTableAsValMap, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_OpenThreadMsgBufferCounters, |
| boost::bind(&SpinelNCPInstance::get_prop_OpenThreadMsgBufferCounters, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_OpenThreadMsgBufferCountersAsString, |
| boost::bind(&SpinelNCPInstance::get_prop_OpenThreadMsgBufferCountersAsString, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_OpenThreadSteeringDataSetWhenJoinable, |
| boost::bind(&SpinelNCPInstance::get_prop_OpenThreadSteeringDataSetWhenJoinable, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_OpenThreadSteeringDataAddress, |
| boost::bind(&SpinelNCPInstance::get_prop_OpenThreadSteeringDataAddress, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetActiveTimestamp, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetActiveTimestamp, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetPendingTimestamp, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetPendingTimestamp, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetMasterKey, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetMasterKey, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetNetworkName, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetNetworkName, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetExtendedPanId, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetExtendedPanId, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetMeshLocalPrefix, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetMeshLocalPrefix, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetDelay, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetDelay, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetPanId, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetPanId, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetChannel, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetChannel, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetPSKc, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetPSKc, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetChannelMaskPage0, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetChannelMaskPage0, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetSecPolicyKeyRotation, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetSecPolicyKeyRotation, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetSecPolicyFlags, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetSecPolicyFlags, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetRawTlvs, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetRawTlvs, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetDestIpAddress, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetDestIpAddress, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetAllFileds, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetAllFileds, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetAllFileds_AltString, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetAllFileds, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetAllFiledsAsValMap, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetAllFiledsAsValMap, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DatasetCommand, |
| boost::bind(&SpinelNCPInstance::get_prop_DatasetCommand, this, _1)); |
| register_get_handler( |
| kWPANTUNDProperty_DaemonTickleOnHostDidWake, |
| boost::bind(&SpinelNCPInstance::get_prop_DaemonTickleOnHostDidWake, this, _1)); |
| |
| // Properties requiring capability check with a dedicated handler method |
| |
| register_get_handler_capability( |
| kWPANTUNDProperty_JoinerDiscernerBitLength, |
| SPINEL_CAP_THREAD_JOINER, |
| boost::bind(&SpinelNCPInstance::get_prop_JoinerDiscernerBitLength, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDProperty_CommissionerEnergyScanResult, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| boost::bind(&SpinelNCPInstance::get_prop_CommissionerEnergyScanResult, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDProperty_CommissionerPanIdConflictResult, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| boost::bind(&SpinelNCPInstance::get_prop_CommissionerPanIdConflictResult, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDCommissionerLinkMetricsQueryResult, |
| SPINEL_CAP_THREAD_LINK_METRICS, |
| boost::bind(&SpinelNCPInstance::get_prop_LinkMetricsQueryResult, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDCommissionerLinkMetricsMgmtResponse, |
| SPINEL_CAP_THREAD_LINK_METRICS, |
| boost::bind(&SpinelNCPInstance::get_prop_LinkMetricsMgmtResponse, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDCommissionerLinkMetricsLastEnhAckIe, |
| SPINEL_CAP_THREAD_LINK_METRICS, |
| boost::bind(&SpinelNCPInstance::get_prop_LinkMetricsLastEnhAckIe, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDProperty_ThreadMlrResponse, |
| SPINEL_CAP_NET_THREAD_1_2, |
| boost::bind(&SpinelNCPInstance::get_prop_MulticastListenerRegistrationResponse, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDProperty_ThreadNeighborTableErrorRates, |
| SPINEL_CAP_ERROR_RATE_TRACKING, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadNeighborTableErrorRates, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDProperty_ThreadNeighborTableErrorRatesAsValMap, |
| SPINEL_CAP_ERROR_RATE_TRACKING, |
| boost::bind(&SpinelNCPInstance::get_prop_ThreadNeighborTableErrorRatesAsValMap, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDProperty_POSIXAppRCPVersionCached, |
| SPINEL_CAP_POSIX, |
| boost::bind(&SpinelNCPInstance::get_prop_POSIXAppRCPVersionCached, this, _1)); |
| register_get_handler_capability( |
| kWPANTUNDProperty_MACFilterFixedRssi, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| boost::bind(&SpinelNCPInstance::get_prop_MACFilterFixedRssi, this, _1)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ConfigNCPDriverName(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(std::string("spinel"))); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_NCPCapabilities(CallbackWithStatusArg1 cb) |
| { |
| std::list<std::string> capability_list; |
| std::set<unsigned int>::iterator iter; |
| |
| for (iter = mCapabilities.begin(); iter != mCapabilities.end(); iter++) { |
| char str[200]; |
| snprintf(str, sizeof(str), "%s (%d)", spinel_capability_to_cstr(*iter), *iter); |
| capability_list.push_back(std::string(str)); |
| } |
| |
| cb(kWPANTUNDStatus_Ok, boost::any(capability_list)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_NetworkIsCommissioned(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mIsCommissioned)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadRouterID(CallbackWithStatusArg1 cb) |
| { |
| get_spinel_prop(boost::bind(convert_rloc16_to_router_id, cb, _1, _2), SPINEL_PROP_THREAD_RLOC16, |
| SPINEL_DATATYPE_UINT16_S); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadConfigFilterRLOCAddresses(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mFilterRLOCAddresses)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadConfigFilterALOCAddresses(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mFilterALOCAddresses)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_JoinerDiscernerBitLength(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mJoinerDiscernerBitLength)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_CommissionerEnergyScanResult(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mCommissionerEnergyScanResult)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_CommissionerPanIdConflictResult(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mCommissionerPanIdConflictResult)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_IPv6MeshLocalPrefix(CallbackWithStatusArg1 cb) |
| { |
| if (!buffer_is_nonzero(mNCPV6Prefix, sizeof(mNCPV6Prefix))) { |
| get_spinel_prop_with_unpacker(cb, SPINEL_PROP_IPV6_ML_PREFIX, unpack_mesh_local_prefix); |
| } else { |
| struct in6_addr addr = mNCPMeshLocalAddress; |
| memset(addr.s6_addr + 8, 0, 8); |
| cb(kWPANTUNDStatus_Ok, boost::any(in6_addr_to_string(addr) + "/64")); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_IPv6MeshLocalAddress(CallbackWithStatusArg1 cb) |
| { |
| if (!buffer_is_nonzero(mNCPV6Prefix, sizeof(mNCPV6Prefix))) { |
| get_spinel_prop(cb, SPINEL_PROP_IPV6_ML_ADDR, SPINEL_DATATYPE_IPv6ADDR_S); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(in6_addr_to_string(mNCPMeshLocalAddress))); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_IPv6LinkLocalAddress(CallbackWithStatusArg1 cb) |
| { |
| if (!IN6_IS_ADDR_LINKLOCAL(&mNCPLinkLocalAddress)) { |
| get_spinel_prop(cb, SPINEL_PROP_IPV6_LL_ADDR, SPINEL_DATATYPE_IPv6ADDR_S); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(in6_addr_to_string(mNCPLinkLocalAddress))); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_LinkMetricsQueryResult(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLinkMetricsQueryResult)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_LinkMetricsMgmtResponse(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLinkMetricsMgmtResponse)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_LinkMetricsLastEnhAckIe(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLinkMetricsLastEnhAckIe)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_MulticastListenerRegistrationResponse(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mMulticastListenerRegistrationResponse)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadChildTable(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kChildTable, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_StringArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadChildTableAsValMap(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kChildTable, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_ValueMapArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadChildTableAddresses(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kChildTableAddresses, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_StringArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadNeighborTable(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kNeighborTable, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_StringArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadNeighborTableAsValMap(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kNeighborTable, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_ValueMapArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadNeighborTableErrorRates(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kNeighborTableErrorRates, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_StringArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadNeighborTableErrorRatesAsValMap(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kNeighborTableErrorRates, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_ValueMapArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadRouterTable(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kRouterTable, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_StringArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_ThreadRouterTableAsValMap(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetNetworkTopology( |
| this, |
| cb, |
| SpinelNCPTaskGetNetworkTopology::kRouterTable, |
| SpinelNCPTaskGetNetworkTopology::kResultFormat_ValueMapArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_OpenThreadMsgBufferCounters(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetMsgBufferCounters( |
| this, |
| cb, |
| SpinelNCPTaskGetMsgBufferCounters::kResultFormat_StringArray |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_OpenThreadMsgBufferCountersAsString(CallbackWithStatusArg1 cb) |
| { |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskGetMsgBufferCounters( |
| this, |
| cb, |
| SpinelNCPTaskGetMsgBufferCounters::kResultFormat_String |
| ) |
| )); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_OpenThreadSteeringDataSetWhenJoinable(CallbackWithStatusArg1 cb) |
| { |
| cb(0, boost::any(mSetSteeringDataWhenJoinable)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_OpenThreadSteeringDataAddress(CallbackWithStatusArg1 cb) |
| { |
| cb(0, boost::any(nl::Data(mSteeringDataAddress, sizeof(mSteeringDataAddress)))); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetActiveTimestamp(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mActiveTimestamp.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mActiveTimestamp.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetPendingTimestamp(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mPendingTimestamp.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mPendingTimestamp.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetMasterKey(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mMasterKey.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mMasterKey.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetNetworkName(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mNetworkName.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mNetworkName.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetExtendedPanId(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mExtendedPanId.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mExtendedPanId.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetMeshLocalPrefix(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mMeshLocalPrefix.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(in6_addr_to_string(mLocalDataset.mMeshLocalPrefix.get()))); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetDelay(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mDelay.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mDelay.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetPanId(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mPanId.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mPanId.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetChannel(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mChannel.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mChannel.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetPSKc(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mPSKc.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mPSKc.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetChannelMaskPage0(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mChannelMaskPage0.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mChannelMaskPage0.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetSecPolicyKeyRotation(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mSecurityPolicy.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mSecurityPolicy.get().mKeyRotationTime)); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetSecPolicyFlags(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mSecurityPolicy.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mSecurityPolicy.get().mFlags)); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetRawTlvs(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mRawTlvs.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(mLocalDataset.mRawTlvs.get())); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetDestIpAddress(CallbackWithStatusArg1 cb) |
| { |
| if (mLocalDataset.mDestIpAddress.has_value()) { |
| cb(kWPANTUNDStatus_Ok, boost::any(in6_addr_to_string(mLocalDataset.mDestIpAddress.get()))); |
| } else { |
| cb(kWPANTUNDStatus_Ok, boost::any(Data())); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetAllFileds(CallbackWithStatusArg1 cb) |
| { |
| std::list<std::string> list; |
| mLocalDataset.convert_to_string_list(list); |
| cb(kWPANTUNDStatus_Ok, boost::any(list)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetAllFiledsAsValMap(CallbackWithStatusArg1 cb) |
| { |
| ValueMap map; |
| mLocalDataset.convert_to_valuemap(map); |
| cb(kWPANTUNDStatus_Ok, boost::any(map)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DatasetCommand(CallbackWithStatusArg1 cb) |
| { |
| std::list<std::string> help_string; |
| get_dataset_command_help(help_string); |
| cb(kWPANTUNDStatus_Ok, boost::any(help_string)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_DaemonTickleOnHostDidWake(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mTickleOnHostDidWake)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_POSIXAppRCPVersionCached(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mRcpVersion)); |
| } |
| |
| void |
| SpinelNCPInstance::get_prop_MACFilterFixedRssi(CallbackWithStatusArg1 cb) |
| { |
| cb(kWPANTUNDStatus_Ok, boost::any(mMacFilterFixedRssi)); |
| } |
| |
| void |
| SpinelNCPInstance::property_get_value( |
| const std::string& key, |
| CallbackWithStatusArg1 cb |
| ) { |
| if (!is_initializing_ncp()) { |
| syslog(LOG_INFO, "property_get_value: key: \"%s\"", key.c_str()); |
| } |
| |
| if (mVendorCustom.is_property_key_supported(key)) { |
| mVendorCustom.property_get_value(key, cb); |
| } else { |
| NCPInstanceBase::property_get_value(key, cb); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Property Set Handlers |
| |
| void |
| SpinelNCPInstance::set_spinel_prop( |
| const boost::any &value, CallbackWithStatus cb, spinel_prop_key_t prop_key, char pack_type, unsigned int capability, |
| bool save_in_settings, const std::string &prop_name) |
| { |
| Data command = SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_NULL_S), prop_key); |
| int status = SpinelAppendAny(command, value, pack_type); |
| |
| if (status != kWPANTUNDStatus_Ok) { |
| cb(status); |
| } else { |
| |
| if (save_in_settings) { |
| mSettings[prop_name] = SettingsEntry(command, capability); |
| } |
| |
| if (!capability || mCapabilities.count(capability)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(command) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_FeatureNotSupported); |
| } |
| } |
| } |
| |
| void |
| SpinelNCPInstance::convert_value_prop_set(const boost::any &value, CallbackWithStatus cb, const std::string &prop_name, |
| ValueConverter converter, PropUpdateHandler handler) |
| { |
| boost::any converted_value; |
| int status = converter(value, converted_value); |
| |
| if (status == kWPANTUNDStatus_Ok) { |
| handler(converted_value, cb, prop_name); |
| } else { |
| cb(status); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::register_set_handler(const char *prop_name, PropUpdateHandler handler, ValueConverter converter) |
| { |
| if (converter.empty()) { |
| NCPInstanceBase::register_prop_set_handler(prop_name, handler); |
| } else { |
| |
| // If a `converter` function is given, use `convert_value_prop_set` |
| // which converts the value using the `converter` then passing the |
| // converted value to the original `handler`. |
| NCPInstanceBase::register_prop_set_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::convert_value_prop_set, _1, _2, _3, converter, handler)); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::register_set_handler_spinel(const char *prop_name, spinel_prop_key_t prop_key, char pack_type, |
| ValueConverter converter) |
| { |
| register_set_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::set_spinel_prop, this, _1, _2, prop_key, pack_type, 0, false, _3), |
| converter); |
| } |
| |
| void |
| SpinelNCPInstance::register_set_handler_spinel_persist(const char *prop_name, spinel_prop_key_t prop_key, |
| char pack_type, ValueConverter converter) |
| { |
| register_set_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::set_spinel_prop, this, _1, _2, prop_key, pack_type, 0, true, _3), |
| converter); |
| } |
| |
| void |
| SpinelNCPInstance::register_set_handler_capability_spinel(const char *prop_name, unsigned int capability, |
| spinel_prop_key_t prop_key, char pack_type, ValueConverter converter) |
| { |
| register_set_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::set_spinel_prop, this, _1, _2, prop_key, pack_type, capability, false, _3), |
| converter); |
| } |
| |
| void |
| SpinelNCPInstance::register_set_handler_capability_spinel_persist(const char *prop_name, unsigned int capability, |
| spinel_prop_key_t prop_key, char pack_type, ValueConverter converter) |
| { |
| register_set_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::set_spinel_prop, this, _1, _2, prop_key, pack_type, capability, true, _3), |
| converter); |
| } |
| |
| void |
| SpinelNCPInstance::regsiter_all_set_handlers(void) |
| { |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties associated with a spinel property |
| |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NCPChannel, |
| SPINEL_PROP_PHY_CHAN, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NetworkPANID, |
| SPINEL_PROP_MAC_15_4_PANID, SPINEL_DATATYPE_UINT16_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NetworkPSKc, |
| SPINEL_PROP_NET_PSKC, SPINEL_DATATYPE_DATA_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NetworkPartitionId, |
| SPINEL_PROP_NET_PARTITION_ID, SPINEL_DATATYPE_UINT32_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NCPMACAddress, |
| SPINEL_PROP_MAC_15_4_LADDR, SPINEL_DATATYPE_EUI64_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NCPExtendedAddress, |
| SPINEL_PROP_MAC_EXTENDED_ADDR, SPINEL_DATATYPE_EUI64_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NetworkKeyIndex, |
| SPINEL_PROP_NET_KEY_SEQUENCE_COUNTER, SPINEL_DATATYPE_UINT32_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NetworkKeySwitchGuardTime, |
| SPINEL_PROP_NET_KEY_SWITCH_GUARDTIME, SPINEL_DATATYPE_UINT32_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NetworkName, |
| SPINEL_PROP_NET_NETWORK_NAME, SPINEL_DATATYPE_UTF8_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_NetworkRole, |
| SPINEL_PROP_NET_ROLE, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_ThreadPreferredRouterID, |
| SPINEL_PROP_THREAD_PREFERRED_ROUTER_ID, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_ThreadRouterRoleEnabled, |
| SPINEL_PROP_THREAD_ROUTER_ROLE_ENABLED, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_ThreadRouterSelectionJitter, |
| SPINEL_PROP_THREAD_ROUTER_SELECTION_JITTER, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_ThreadRouterUpgradeThreshold, |
| SPINEL_PROP_THREAD_ROUTER_UPGRADE_THRESHOLD, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_ThreadRouterDowngradeThreshold, |
| SPINEL_PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_spinel( |
| kWPANTUNDProperty_OpenThreadTrelTestModeEnable, |
| SPINEL_PROP_DEBUG_TREL_TEST_MODE_ENABLE, SPINEL_DATATYPE_BOOL_C); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties requiring persistence (saving in settings) and associated with a |
| // spinel property |
| |
| register_set_handler_spinel_persist( |
| kWPANTUNDProperty_NCPCCAThreshold, |
| SPINEL_PROP_PHY_CCA_THRESHOLD, SPINEL_DATATYPE_INT8_C); |
| register_set_handler_spinel_persist( |
| kWPANTUNDProperty_NCPTXPower, |
| SPINEL_PROP_PHY_TX_POWER, SPINEL_DATATYPE_INT8_C); |
| register_set_handler_spinel_persist( |
| kWPANTUNDProperty_ThreadChildTimeout, |
| SPINEL_PROP_THREAD_CHILD_TIMEOUT, SPINEL_DATATYPE_UINT32_C); |
| register_set_handler_spinel_persist( |
| kWPANTUNDProperty_ThreadDeviceMode, |
| SPINEL_PROP_THREAD_MODE, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_spinel_persist( |
| kWPANTUNDProperty_OpenThreadLogLevel, |
| SPINEL_PROP_DEBUG_NCP_LOG_LEVEL, SPINEL_DATATYPE_UINT8_C); |
| |
| // Properties with a `ValueConverter` |
| register_set_handler_spinel_persist( |
| kWPANTUNDProperty_NCPChannelMask, |
| SPINEL_PROP_PHY_CHAN_SUPPORTED, SPINEL_DATATYPE_DATA_C, |
| &SpinelNCPInstance::convert_value_channel_mask); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties requiring capability check and associated with a spinel property |
| |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_MACAllowlistEnabled, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_ALLOWLIST_ENABLED, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_MACDenylistEnabled, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| SPINEL_PROP_MAC_DENYLIST_ENABLED, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_CommissionerProvisioningUrl, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_PROVISIONING_URL, SPINEL_DATATYPE_UTF8_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_CommissionerSendMgmtGet, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_MGMT_GET, SPINEL_DATATYPE_DATA_WLEN_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_CommissionerSendMgmtSet, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_MGMT_SET, SPINEL_DATATYPE_DATA_WLEN_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ChannelManagerChannelSelect, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_CHANNEL_SELECT, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_TimeSync_Period, |
| SPINEL_CAP_TIME_SYNC, |
| SPINEL_PROP_TIME_SYNC_PERIOD, SPINEL_DATATYPE_UINT16_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_TimeSync_XtalThreshold, |
| SPINEL_CAP_TIME_SYNC, |
| SPINEL_PROP_TIME_SYNC_XTAL_THRESHOLD, SPINEL_DATATYPE_UINT16_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_OpenThreadLogTimestampBase, |
| SPINEL_CAP_OPENTHREAD_LOG_METADATA, |
| SPINEL_PROP_DEBUG_LOG_TIMESTAMP_BASE, SPINEL_DATATYPE_UINT64_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadDomainName, |
| SPINEL_CAP_NET_THREAD_1_2, |
| SPINEL_PROP_THREAD_DOMAIN_NAME, |
| SPINEL_DATATYPE_UTF8_C); |
| |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadCslPeriod, |
| SPINEL_CAP_THREAD_CSL_RECEIVER, |
| SPINEL_PROP_THREAD_CSL_PERIOD, SPINEL_DATATYPE_UINT16_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadCslTimeout, |
| SPINEL_CAP_THREAD_CSL_RECEIVER, |
| SPINEL_PROP_THREAD_CSL_TIMEOUT, SPINEL_DATATYPE_UINT32_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadCslChannel, |
| SPINEL_CAP_THREAD_CSL_RECEIVER, |
| SPINEL_PROP_THREAD_CSL_CHANNEL, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadBackboneRouterLocalJitter, |
| SPINEL_CAP_THREAD_BACKBONE_ROUTER, |
| SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTRATION_JITTER, SPINEL_DATATYPE_UINT8_C); |
| |
| // Properties with a `ValueConverter` |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_CommissionerState, |
| SPINEL_CAP_THREAD_COMMISSIONER, |
| SPINEL_PROP_MESHCOP_COMMISSIONER_STATE, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_CommissionerState); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_NCPCounterAllReset, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_RESET, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_counter_reset); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_NCPCounterAllMac, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_ALL_MAC_COUNTERS, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_counter_reset); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_NCPCounterThreadMle, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_MLE_COUNTERS, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_counter_reset); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_NCPCounterAllIPv6, |
| SPINEL_CAP_COUNTERS, |
| SPINEL_PROP_CNTR_ALL_IP_COUNTERS, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_counter_reset); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadDUAInterfaceIdentifier, |
| SPINEL_CAP_DUA, |
| SPINEL_PROP_THREAD_DUA_ID, SPINEL_DATATYPE_DATA_C, |
| &SpinelNCPInstance::convert_value_dua_interface_identifier); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadBackboneRouterLocalState, |
| SPINEL_CAP_THREAD_BACKBONE_ROUTER, |
| SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_STATE, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_BackboneRouterState); |
| register_set_handler_capability_spinel( |
| kWPANTUNDProperty_ThreadBackboneRouterLocalRegister, |
| SPINEL_CAP_THREAD_BACKBONE_ROUTER, |
| SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTER, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_BackboneRouterRegister); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties requiring capability check and persistence (saving in settings), |
| // and associated with a spinel property |
| |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_NCPSleepyPollInterval, |
| SPINEL_CAP_ROLE_SLEEPY, |
| SPINEL_PROP_MAC_DATA_POLL_PERIOD, SPINEL_DATATYPE_UINT32_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_TmfProxyEnabled, |
| SPINEL_CAP_THREAD_TMF_PROXY, |
| SPINEL_PROP_THREAD_TMF_PROXY_ENABLED, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_JamDetectionEnable, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_ENABLE, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_JamDetectionRssiThreshold, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_RSSI_THRESHOLD, SPINEL_DATATYPE_INT8_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_JamDetectionWindow, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_WINDOW, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_JamDetectionBusyPeriod, |
| SPINEL_CAP_JAM_DETECT, |
| SPINEL_PROP_JAM_DETECT_BUSY, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_NestLabs_LegacyMeshLocalPrefix, |
| SPINEL_CAP_NEST_LEGACY_INTERFACE, |
| SPINEL_PROP_NEST_LEGACY_ULA_PREFIX, SPINEL_DATATYPE_DATA_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChildSupervisionInterval, |
| SPINEL_CAP_CHILD_SUPERVISION, |
| SPINEL_PROP_CHILD_SUPERVISION_INTERVAL, SPINEL_DATATYPE_UINT16_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChildSupervisionCheckTimeout, |
| SPINEL_CAP_CHILD_SUPERVISION, |
| SPINEL_PROP_CHILD_SUPERVISION_CHECK_TIMEOUT, SPINEL_DATATYPE_UINT16_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChannelManagerNewChannel, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_NEW_CHANNEL, SPINEL_DATATYPE_UINT8_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChannelManagerDelay, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_DELAY, SPINEL_DATATYPE_UINT16_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChannelManagerAutoSelectEnabled, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_ENABLED, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChannelManagerAutoSelectInterval, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_INTERVAL, SPINEL_DATATYPE_UINT32_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_OpenThreadSLAACEnabled, |
| SPINEL_CAP_SLAAC, |
| SPINEL_PROP_SLAAC_ENABLED, SPINEL_DATATYPE_BOOL_C); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_NCPCoexEnable, |
| SPINEL_CAP_RADIO_COEX, |
| SPINEL_PROP_RADIO_COEX_ENABLE, SPINEL_DATATYPE_BOOL_C); |
| |
| // Properties with a `ValueConverter` |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_NCPMCUPowerState, |
| SPINEL_PROP_MCU_POWER_STATE, |
| SPINEL_PROP_MCU_POWER_STATE, SPINEL_DATATYPE_UINT8_C, |
| &SpinelNCPInstance::convert_value_NCPMCUPowerState); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChannelManagerSupportedChannelMask, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_SUPPORTED_CHANNELS, SPINEL_DATATYPE_DATA_C, |
| &SpinelNCPInstance::convert_value_channel_mask); |
| register_set_handler_capability_spinel_persist( |
| kWPANTUNDProperty_ChannelManagerFavoredChannelMask, |
| SPINEL_CAP_CHANNEL_MANAGER, |
| SPINEL_PROP_CHANNEL_MANAGER_FAVORED_CHANNELS, SPINEL_DATATYPE_DATA_C, |
| &SpinelNCPInstance::convert_value_channel_mask); |
| |
| // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| // Properties with a dedicated handler method |
| |
| register_set_handler( |
| kWPANTUNDProperty_NetworkKey, |
| boost::bind(&SpinelNCPInstance::set_prop_NetworkKey, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_InterfaceUp, |
| boost::bind(&SpinelNCPInstance::set_prop_InterfaceUp, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_NetworkXPANID, |
| boost::bind(&SpinelNCPInstance::set_prop_NetworkXPANID, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_IPv6MeshLocalPrefix, |
| boost::bind(&SpinelNCPInstance::set_prop_IPv6MeshLocalPrefix, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_ThreadConfigFilterRLOCAddresses, |
| boost::bind(&SpinelNCPInstance::set_prop_ThreadConfigFilterRLOCAddresses, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_ThreadConfigFilterALOCAddresses, |
| boost::bind(&SpinelNCPInstance::set_prop_ThreadConfigFilterALOCAddresses, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_OpenThreadSteeringDataSetWhenJoinable, |
| boost::bind(&SpinelNCPInstance::set_prop_OpenThreadSteeringDataSetWhenJoinable, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_OpenThreadSteeringDataAddress, |
| boost::bind(&SpinelNCPInstance::set_prop_OpenThreadSteeringDataAddress, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_TmfProxyStream, |
| boost::bind(&SpinelNCPInstance::set_prop_TmfProxyStream, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_UdpForwardStream, |
| boost::bind(&SpinelNCPInstance::set_prop_UdpForwardStream, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetActiveTimestamp, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetActiveTimestamp, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetPendingTimestamp, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetPendingTimestamp, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetMasterKey, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetMasterKey, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetNetworkName, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetNetworkName, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetExtendedPanId, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetExtendedPanId, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetMeshLocalPrefix, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetMeshLocalPrefix, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetDelay, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetDelay, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetPanId, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetPanId, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetChannel, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetChannel, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetPSKc, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetPSKc, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetChannelMaskPage0, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetChannelMaskPage0, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetSecPolicyKeyRotation, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetSecPolicyKeyRotation, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetSecPolicyFlags, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetSecPolicyFlags, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetRawTlvs, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetRawTlvs, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetDestIpAddress, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetDestIpAddress, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DatasetCommand, |
| boost::bind(&SpinelNCPInstance::set_prop_DatasetCommand, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_DaemonTickleOnHostDidWake, |
| boost::bind(&SpinelNCPInstance::set_prop_DaemonTickleOnHostDidWake, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_MACFilterFixedRssi, |
| boost::bind(&SpinelNCPInstance::set_prop_MACFilterFixedRssi, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_JoinerDiscernerBitLength, |
| boost::bind(&SpinelNCPInstance::set_prop_JoinerDiscernerBitLength, this, _1, _2)); |
| register_set_handler( |
| kWPANTUNDProperty_JoinerDiscernerValue, |
| boost::bind(&SpinelNCPInstance::set_prop_JoinerDiscernerValue, this, _1, _2)); |
| } |
| |
| int |
| SpinelNCPInstance::convert_value_NCPMCUPowerState(const boost::any &value, boost::any &value_out) |
| { |
| int ret = kWPANTUNDStatus_Ok; |
| std::string str = any_to_string(value); |
| |
| if (strcaseequal(str.c_str(), kWPANTUNDNCPMCUPowerState_On)) { |
| value_out = static_cast<uint8_t>(SPINEL_MCU_POWER_STATE_ON); |
| } else if (strcaseequal(str.c_str(), kWPANTUNDNCPMCUPowerState_LowPower) || strcaseequal(str.c_str(), "lp")) { |
| value_out = static_cast<uint8_t>(SPINEL_MCU_POWER_STATE_LOW_POWER); |
| } else if (strcaseequal(str.c_str(), "kWPANTUNDNCPMCUPowerState_Off")) { |
| value_out = static_cast<uint8_t>(SPINEL_MCU_POWER_STATE_OFF); |
| } else { |
| ret = kWPANTUNDStatus_InvalidArgument; |
| } |
| |
| return ret; |
| } |
| |
| int |
| SpinelNCPInstance::convert_value_channel_mask(const boost::any &value, boost::any &value_out) |
| { |
| uint32_t channel_mask = any_to_int(value); |
| Data mask_array(32); |
| |
| mask_array.clear(); |
| for (uint8_t channel = 0; channel < 32; channel++) { |
| if (channel_mask & (1U << channel)) { |
| mask_array.push_back(channel); |
| } |
| } |
| |
| value_out = mask_array; |
| return kWPANTUNDStatus_Ok; |
| } |
| |
| int |
| SpinelNCPInstance::convert_value_counter_reset(const boost::any &value, boost::any &value_out) |
| { |
| // When reseting all/subset of counters, the value written to |
| // related spinel property does not matter, so we just write |
| // value `1`. |
| |
| (void)value; |
| value_out = 1; |
| return kWPANTUNDStatus_Ok; |
| } |
| |
| int |
| SpinelNCPInstance::convert_value_CommissionerState(const boost::any &value, boost::any &value_out) |
| { |
| int ret = kWPANTUNDStatus_Ok; |
| std::string state_str = any_to_string(value); |
| const char *str = state_str.c_str(); |
| |
| if (strcaseequal(str, kWPANTUNDCommissionerState_Disabled) || strcaseequal(str, "stop") || strcaseequal(str, "off") |
| || strcaseequal(str, "0") || strcaseequal(str, "false") |
| ) { |
| value_out = static_cast<uint8_t>(SPINEL_MESHCOP_COMMISSIONER_STATE_DISABLED); |
| |
| } else if (strcaseequal(str, kWPANTUNDCommissionerState_Active) || strcaseequal(str, "start") || |
| strcaseequal(str, "on") || strcaseequal(str, "1") || strcaseequal(str, "true") |
| ) { |
| value_out = static_cast<uint8_t>(SPINEL_MESHCOP_COMMISSIONER_STATE_ACTIVE); |
| |
| } else { |
| ret = kWPANTUNDStatus_InvalidArgument; |
| } |
| |
| return ret; |
| } |
| |
| int |
| SpinelNCPInstance::convert_value_dua_interface_identifier(const boost::any &value, boost::any &value_out) |
| { |
| std::string state_str = any_to_string(value); |
| Data data; |
| int ret = kWPANTUNDStatus_Ok; |
| |
| if (state_str.length() == 16) |
| { |
| data.resize(8); |
| parse_string_into_data(data.data(), data.size(), state_str.c_str()); |
| } |
| else if (state_str.length() != 0) |
| { |
| ret = kWPANTUNDStatus_InvalidArgument; |
| } |
| else |
| { |
| // Intentionally leave empty data when state_str.length() == 0 |
| } |
| |
| value_out = data; |
| return ret; |
| } |
| |
| int |
| SpinelNCPInstance::convert_value_BackboneRouterState(const boost::any &value, boost::any &value_out) |
| { |
| int ret = kWPANTUNDStatus_Ok; |
| std::string state_str = any_to_string(value); |
| const char *str = state_str.c_str(); |
| |
| if (strcaseequal(str, kWPANTUNDThreadBackboneRouterState_Disabled) || strcaseequal(str, "stop") || strcaseequal(str, "off") |
| || strcaseequal(str, "0") || strcaseequal(str, "false") || strcaseequal(str, "disable") |
| ) { |
| value_out = static_cast<uint8_t>(SPINEL_THREAD_BACKBONE_ROUTER_STATE_DISABLED); |
| |
| } else if (strcaseequal(str, kWPANTUNDThreadBackboneRouterState_Primary) || strcaseequal(str, "start") || |
| strcaseequal(str, "on") || strcaseequal(str, "1") || strcaseequal(str, "true") || strcaseequal(str, "enable") |
| ) { |
| value_out = static_cast<uint8_t>(SPINEL_THREAD_BACKBONE_ROUTER_STATE_PRIMARY); |
| |
| } else { |
| ret = kWPANTUNDStatus_InvalidArgument; |
| } |
| |
| return ret; |
| } |
| |
| int |
| SpinelNCPInstance::convert_value_BackboneRouterRegister(const boost::any &value, boost::any &value_out) |
| { |
| // The value written to related spinel property does not matter, |
| // so we just write value `1`. |
| |
| (void)value; |
| value_out = 1; |
| return kWPANTUNDStatus_Ok; |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_NetworkKey(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data network_key = any_to_data(value); |
| |
| if (!ncp_state_is_joining_or_joined(get_ncp_state())) { |
| mNetworkKey = network_key; |
| if (mNetworkKeyIndex == 0) { |
| mNetworkKeyIndex = 1; |
| } |
| } |
| |
| if (get_ncp_state() == CREDENTIALS_NEEDED) { |
| ValueMap options; |
| options[kWPANTUNDProperty_NetworkKey] = value; |
| start_new_task(boost::shared_ptr<SpinelNCPTask>( |
| new SpinelNCPTaskJoin( |
| this, |
| boost::bind(cb,_1), |
| options |
| ) |
| )); |
| } else { |
| set_spinel_prop(value, cb, SPINEL_PROP_NET_MASTER_KEY, SPINEL_DATATYPE_DATA_C); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_InterfaceUp(const boost::any &value, CallbackWithStatus cb) |
| { |
| bool isup = any_to_bool(value); |
| |
| if (isup) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_BOOL_S), |
| SPINEL_PROP_NET_IF_UP, |
| true |
| )) |
| .add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_BOOL_S), |
| SPINEL_PROP_NET_STACK_UP, |
| true |
| )) |
| .finish() |
| ); |
| } else { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_BOOL_S), |
| SPINEL_PROP_NET_STACK_UP, |
| false |
| )) |
| .add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_BOOL_S), |
| SPINEL_PROP_NET_IF_UP, |
| false |
| )) |
| .finish() |
| ); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_NetworkXPANID(const boost::any &value, CallbackWithStatus cb) |
| { |
| mXPANIDWasExplicitlySet = true; |
| set_spinel_prop(value, cb, SPINEL_PROP_NET_XPANID, SPINEL_DATATYPE_DATA_C); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_IPv6MeshLocalPrefix(const boost::any &value, CallbackWithStatus cb) |
| { |
| struct in6_addr addr = any_to_ipv6(value); |
| |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_IPv6ADDR_S SPINEL_DATATYPE_UINT8_S), |
| SPINEL_PROP_IPV6_ML_PREFIX, |
| &addr, |
| 64 |
| )) |
| .finish() |
| ); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_ThreadConfigFilterRLOCAddresses(const boost::any &value, CallbackWithStatus cb) |
| { |
| mFilterRLOCAddresses = any_to_bool(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_ThreadConfigFilterALOCAddresses(const boost::any &value, CallbackWithStatus cb) |
| { |
| mFilterALOCAddresses = any_to_bool(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_OpenThreadSteeringDataSetWhenJoinable(const boost::any &value, CallbackWithStatus cb) |
| { |
| mSetSteeringDataWhenJoinable = any_to_bool(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_OpenThreadSteeringDataAddress(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data address = any_to_data(value); |
| wpantund_status_t status = kWPANTUNDStatus_Ok; |
| |
| if (address.size() != sizeof(mSteeringDataAddress)) { |
| status = kWPANTUNDStatus_InvalidArgument; |
| } else { |
| memcpy(mSteeringDataAddress, address.data(), sizeof(mSteeringDataAddress)); |
| } |
| |
| cb (status); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_TmfProxyStream(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data packet = any_to_data(value); |
| |
| if (packet.size() > sizeof(uint16_t)*2) { |
| uint16_t port = (packet[packet.size() - sizeof(port)] << 8 | packet[packet.size() - sizeof(port) + 1]); |
| uint16_t locator = (packet[packet.size() - sizeof(locator) - sizeof(port)] << 8 | |
| packet[packet.size() - sizeof(locator) - sizeof(port) + 1]); |
| |
| packet.resize(packet.size() - sizeof(locator) - sizeof(port)); |
| |
| Data command = SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET( |
| SPINEL_DATATYPE_DATA_WLEN_S |
| SPINEL_DATATYPE_UINT16_S |
| SPINEL_DATATYPE_UINT16_S |
| ), |
| SPINEL_PROP_THREAD_TMF_PROXY_STREAM, |
| packet.data(), |
| packet.size(), |
| locator, |
| port |
| ); |
| |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(command) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_UdpForwardStream(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data packet = any_to_data(value); |
| |
| if (packet.size() > sizeof(uint16_t) * 2 + sizeof(in6_addr)) { |
| in6_addr peer_addr; |
| const size_t payload_len = packet.size() - sizeof(uint16_t) * 2 - sizeof(struct in6_addr); |
| size_t i = payload_len; |
| const uint16_t peer_port = (packet[i] << 8 | packet[i + 1]); |
| i += sizeof(uint16_t); |
| memcpy(peer_addr.s6_addr, &packet[i], sizeof(peer_addr)); |
| i += sizeof(peer_addr); |
| const uint16_t sock_port = (packet[i] << 8 | packet[i + 1]); |
| |
| Data command = SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET( |
| SPINEL_DATATYPE_DATA_WLEN_S |
| SPINEL_DATATYPE_UINT16_S // Peer port |
| SPINEL_DATATYPE_IPv6ADDR_S // Peer address |
| SPINEL_DATATYPE_UINT16_S // Sock port |
| ), |
| SPINEL_PROP_THREAD_UDP_FORWARD_STREAM, |
| packet.data(), |
| payload_len, |
| peer_port, |
| &peer_addr, |
| sock_port |
| ); |
| |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(command) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetActiveTimestamp(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mActiveTimestamp = any_to_uint64(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetPendingTimestamp(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mPendingTimestamp = any_to_uint64(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetMasterKey(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data master_key = any_to_data(value); |
| |
| if (master_key.size() == NCP_NETWORK_KEY_SIZE) { |
| mLocalDataset.mMasterKey = master_key; |
| cb(kWPANTUNDStatus_Ok); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetNetworkName(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mNetworkName = any_to_string(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetExtendedPanId(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data xpanid = any_to_data(value); |
| |
| if (xpanid.size() == sizeof(spinel_net_xpanid_t)) { |
| mLocalDataset.mExtendedPanId = any_to_data(value); |
| cb(kWPANTUNDStatus_Ok); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetMeshLocalPrefix(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mMeshLocalPrefix = any_to_ipv6(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetDelay(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mDelay = static_cast<uint32_t>(any_to_int(value)); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetPanId(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mPanId = static_cast<uint16_t>(any_to_int(value)); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetChannel(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mChannel = static_cast<uint8_t>(any_to_int(value)); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetPSKc(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data pskc = any_to_data(value); |
| |
| if (pskc.size() <= sizeof(spinel_net_pskc_t)) { |
| mLocalDataset.mPSKc = any_to_data(value); |
| cb(kWPANTUNDStatus_Ok); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetChannelMaskPage0(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mChannelMaskPage0 = static_cast<uint32_t>(any_to_int(value)); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetSecPolicyKeyRotation(const boost::any &value, CallbackWithStatus cb) |
| { |
| ThreadDataset::SecurityPolicy policy = mLocalDataset.mSecurityPolicy.get(); |
| policy.mKeyRotationTime = static_cast<uint16_t>(any_to_int(value)); |
| mLocalDataset.mSecurityPolicy = policy; |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetSecPolicyFlags(const boost::any &value, CallbackWithStatus cb) |
| { |
| ThreadDataset::SecurityPolicy policy = mLocalDataset.mSecurityPolicy.get(); |
| policy.mFlags = static_cast<uint8_t>(any_to_int(value)); |
| mLocalDataset.mSecurityPolicy = policy; |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetRawTlvs(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mRawTlvs = any_to_data(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetDestIpAddress(const boost::any &value, CallbackWithStatus cb) |
| { |
| mLocalDataset.mDestIpAddress = any_to_ipv6(value); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DatasetCommand(const boost::any &value, CallbackWithStatus cb) |
| { |
| perform_dataset_command(any_to_string(value), cb); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_DaemonTickleOnHostDidWake(const boost::any &value, CallbackWithStatus cb) |
| { |
| mTickleOnHostDidWake = any_to_bool(value); |
| syslog(LOG_INFO, "TickleOnHostDidWake is %sabled", mTickleOnHostDidWake ? "en" : "dis"); |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_MACFilterFixedRssi(const boost::any &value, CallbackWithStatus cb) |
| { |
| if (mCapabilities.count(SPINEL_CAP_MAC_ALLOWLIST)) { |
| mMacFilterFixedRssi = static_cast<int8_t>(any_to_int(value)); |
| cb(kWPANTUNDStatus_Ok); |
| } else { |
| cb(kWPANTUNDStatus_FeatureNotSupported); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_JoinerDiscernerBitLength(const boost::any &value, CallbackWithStatus cb) |
| { |
| if (mCapabilities.count(SPINEL_CAP_THREAD_JOINER)) { |
| mJoinerDiscernerBitLength = static_cast<uint8_t>(any_to_int(value)); |
| |
| // Setting Discerner length to zero is to clear any previous set Discerner value |
| if (mJoinerDiscernerBitLength == 0) { |
| |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_UINT8_S), |
| SPINEL_PROP_MESHCOP_JOINER_DISCERNER, |
| mJoinerDiscernerBitLength |
| )) |
| .finish() |
| ); |
| |
| } else { |
| cb(kWPANTUNDStatus_Ok); |
| } |
| |
| } else { |
| cb(kWPANTUNDStatus_FeatureNotSupported); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::set_prop_JoinerDiscernerValue(const boost::any &value, CallbackWithStatus cb) |
| { |
| if (mCapabilities.count(SPINEL_CAP_THREAD_JOINER)) { |
| uint64_t discerner_value = any_to_uint64(value); |
| |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET( |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_UINT64_S |
| ), |
| SPINEL_PROP_MESHCOP_JOINER_DISCERNER, |
| mJoinerDiscernerBitLength, |
| discerner_value |
| )) |
| .finish() |
| ); |
| |
| } else { |
| cb(kWPANTUNDStatus_FeatureNotSupported); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::property_set_value( |
| const std::string& key, |
| const boost::any& value, |
| CallbackWithStatus cb |
| ) { |
| syslog(LOG_INFO, "property_set_value: key: \"%s\"", key.c_str()); |
| |
| // If we are disabled, then the only property we |
| // are allowed to set is kWPANTUNDProperty_DaemonEnabled. |
| if (!mEnabled && !strcaseequal(key.c_str(), kWPANTUNDProperty_DaemonEnabled)) { |
| cb(kWPANTUNDStatus_InvalidWhenDisabled); |
| return; |
| } |
| |
| try { |
| if (mVendorCustom.is_property_key_supported(key)) { |
| mVendorCustom.property_set_value(key, value, cb); |
| |
| } else { |
| NCPInstanceBase::property_set_value(key, value, cb); |
| } |
| |
| } catch (const boost::bad_any_cast &x) { |
| // We will get a bad_any_cast exception if the property is of |
| // the wrong type. |
| syslog(LOG_ERR,"property_set_value: Bad type for property \"%s\" (%s)", key.c_str(), x.what()); |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } catch (const std::invalid_argument &x) { |
| // We will get a bad_any_cast exception if the property is of |
| // the wrong type. |
| syslog(LOG_ERR,"property_set_value: Invalid argument for property \"%s\" (%s)", key.c_str(), x.what()); |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Property Insert Handlers |
| |
| void |
| SpinelNCPInstance::check_capability_prop_update(const boost::any &value, CallbackWithStatus cb, |
| const std::string &prop_name, unsigned int capability, PropUpdateHandler handler) |
| { |
| if (mCapabilities.count(capability)) { |
| handler(value, cb, prop_name); |
| } else { |
| cb(kWPANTUNDStatus_FeatureNotSupported); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::register_insert_handler(const char *prop_name, PropUpdateHandler handler) |
| { |
| NCPInstanceBase::register_prop_insert_handler(prop_name, handler); |
| } |
| |
| void |
| SpinelNCPInstance::register_insert_handler_capability(const char *prop_name, unsigned int capability, |
| PropUpdateHandler handler) |
| { |
| register_insert_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::check_capability_prop_update, this, _1, _2, _3, capability, handler)); |
| } |
| |
| void |
| SpinelNCPInstance::regsiter_all_insert_handlers(void) |
| { |
| register_insert_handler_capability( |
| kWPANTUNDProperty_MACAllowlistEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| boost::bind(&SpinelNCPInstance::insert_prop_MACAllowlistEntries, this, _1, _2)); |
| register_insert_handler_capability( |
| kWPANTUNDProperty_MACDenylistEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| boost::bind(&SpinelNCPInstance::insert_prop_MACDenylistEntries, this, _1, _2)); |
| register_insert_handler_capability( |
| kWPANTUNDProperty_MACFilterEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| boost::bind(&SpinelNCPInstance::insert_prop_MACFilterEntries, this, _1, _2)); |
| } |
| |
| void |
| SpinelNCPInstance::insert_prop_MACAllowlistEntries(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data ext_address = any_to_data(value); |
| int8_t rssi = kWPANTUND_Allowlist_RssiOverrideDisabled; |
| |
| if (ext_address.size() == sizeof(spinel_eui64_t)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT(SPINEL_DATATYPE_EUI64_S SPINEL_DATATYPE_INT8_S), |
| SPINEL_PROP_MAC_ALLOWLIST, |
| ext_address.data(), |
| rssi |
| ) |
| ) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::insert_prop_MACDenylistEntries(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data ext_address = any_to_data(value); |
| int8_t rssi = kWPANTUND_Allowlist_RssiOverrideDisabled; |
| |
| if (ext_address.size() == sizeof(spinel_eui64_t)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT(SPINEL_DATATYPE_EUI64_S SPINEL_DATATYPE_INT8_S), |
| SPINEL_PROP_MAC_DENYLIST, |
| ext_address.data(), |
| rssi |
| ) |
| ) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::insert_prop_MACFilterEntries(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data ext_address = any_to_data(value); |
| |
| if (ext_address.size() == sizeof(spinel_eui64_t)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT(SPINEL_DATATYPE_EUI64_S SPINEL_DATATYPE_INT8_S), |
| SPINEL_PROP_MAC_FIXED_RSS, |
| ext_address.data(), |
| mMacFilterFixedRssi |
| ) |
| ) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::property_insert_value(const std::string &key, const boost::any &value, CallbackWithStatus cb) |
| { |
| syslog(LOG_INFO, "property_insert_value: key: \"%s\"", key.c_str()); |
| |
| if (!mEnabled) { |
| cb(kWPANTUNDStatus_InvalidWhenDisabled); |
| return; |
| } |
| |
| try { |
| if (mVendorCustom.is_property_key_supported(key)) { |
| mVendorCustom.property_insert_value(key, value, cb); |
| |
| } else { |
| NCPInstanceBase::property_insert_value(key, value, cb); |
| } |
| } catch (const boost::bad_any_cast &x) { |
| // We will get a bad_any_cast exception if the property is of |
| // the wrong type. |
| syslog(LOG_ERR,"property_insert_value: Bad type for property \"%s\" (%s)", key.c_str(), x.what()); |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } catch (const std::invalid_argument &x) { |
| // We will get a bad_any_cast exception if the property is of |
| // the wrong type. |
| syslog(LOG_ERR,"property_insert_value: Invalid argument for property \"%s\" (%s)", key.c_str(), x.what()); |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Property Remove Handlers |
| |
| void |
| SpinelNCPInstance::register_remove_handler(const char *prop_name, PropUpdateHandler handler) |
| { |
| NCPInstanceBase::register_prop_remove_handler(prop_name, handler); |
| } |
| |
| void |
| SpinelNCPInstance::register_remove_handler_capability(const char *prop_name, unsigned int capability, |
| PropUpdateHandler handler) |
| { |
| register_remove_handler( |
| prop_name, |
| boost::bind(&SpinelNCPInstance::check_capability_prop_update, this, _1, _2, _3, capability, handler)); |
| } |
| |
| void |
| SpinelNCPInstance::regsiter_all_remove_handlers(void) |
| { |
| register_remove_handler_capability( |
| kWPANTUNDProperty_MACAllowlistEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| boost::bind(&SpinelNCPInstance::remove_prop_MACAllowlistEntries, this, _1, _2)); |
| register_remove_handler_capability( |
| kWPANTUNDProperty_MACDenylistEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| boost::bind(&SpinelNCPInstance::remove_prop_MACDenylistEntries, this, _1, _2)); |
| register_remove_handler_capability( |
| kWPANTUNDProperty_MACFilterEntries, |
| SPINEL_CAP_MAC_ALLOWLIST, |
| boost::bind(&SpinelNCPInstance::remove_prop_MACFilterEntries, this, _1, _2)); |
| } |
| |
| void |
| SpinelNCPInstance::remove_prop_MACAllowlistEntries(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data ext_address = any_to_data(value); |
| |
| if (ext_address.size() == sizeof(spinel_eui64_t)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE(SPINEL_DATATYPE_EUI64_S), |
| SPINEL_PROP_MAC_ALLOWLIST, |
| ext_address.data() |
| ) |
| ) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::remove_prop_MACDenylistEntries(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data ext_address = any_to_data(value); |
| |
| if (ext_address.size() == sizeof(spinel_eui64_t)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE(SPINEL_DATATYPE_EUI64_S), |
| SPINEL_PROP_MAC_DENYLIST, |
| ext_address.data() |
| ) |
| ) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::remove_prop_MACFilterEntries(const boost::any &value, CallbackWithStatus cb) |
| { |
| Data ext_address = any_to_data(value); |
| |
| if (ext_address.size() == sizeof(spinel_eui64_t)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .set_callback(cb) |
| .add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE(SPINEL_DATATYPE_EUI64_S), |
| SPINEL_PROP_MAC_FIXED_RSS, |
| ext_address.data() |
| ) |
| ) |
| .finish() |
| ); |
| } else { |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::property_remove_value(const std::string &key, const boost::any &value, CallbackWithStatus cb) |
| { |
| syslog(LOG_INFO, "property_remove_value: key: \"%s\"", key.c_str()); |
| |
| try { |
| if (mVendorCustom.is_property_key_supported(key)) { |
| mVendorCustom.property_remove_value(key, value, cb); |
| |
| } else { |
| NCPInstanceBase::property_remove_value(key, value, cb); |
| } |
| |
| } catch (const boost::bad_any_cast &x) { |
| // We will get a bad_any_cast exception if the property is of |
| // the wrong type. |
| syslog(LOG_ERR,"property_remove_value: Bad type for property \"%s\" (%s)", key.c_str(), x.what()); |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } catch (const std::invalid_argument &x) { |
| // We will get a bad_any_cast exception if the property is of |
| // the wrong type. |
| syslog(LOG_ERR,"property_remove_value: Invalid argument for property \"%s\" (%s)", key.c_str(), x.what()); |
| cb(kWPANTUNDStatus_InvalidArgument); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::reset_tasks(wpantund_status_t status) |
| { |
| NCPInstanceBase::reset_tasks(status); |
| while(!mTaskQueue.empty()) { |
| mTaskQueue.front()->finish(status); |
| mTaskQueue.pop_front(); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_spinel_value_is_ON_MESH_NETS(const uint8_t *value_data_ptr, spinel_size_t value_data_len) |
| { |
| std::multimap<IPv6Prefix, OnMeshPrefixEntry>::iterator iter; |
| std::multimap<IPv6Prefix, OnMeshPrefixEntry> on_mesh_prefixes(mOnMeshPrefixes); |
| int num_prefix = 0; |
| |
| while (value_data_len > 0) { |
| spinel_ssize_t len = 0; |
| struct in6_addr *prefix_addr = NULL; |
| uint8_t prefix_len = 0; |
| bool stable = false; |
| uint8_t flags = 0; |
| uint8_t flags_extended = 0; |
| uint16_t mesh_nets_flags = 0; |
| bool is_local = false; |
| uint16_t rloc16 = 0; |
| |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_IPv6ADDR_S // Prefix |
| SPINEL_DATATYPE_UINT8_S // Prefix length (in bits) |
| SPINEL_DATATYPE_BOOL_S // stable |
| SPINEL_DATATYPE_UINT8_S // flags |
| SPINEL_DATATYPE_BOOL_S // is_local |
| SPINEL_DATATYPE_UINT16_S // RLOC16 |
| SPINEL_DATATYPE_UINT8_S // flags extended |
| ), |
| &prefix_addr, |
| &prefix_len, |
| &stable, |
| &flags, |
| &is_local, |
| &rloc16, |
| &flags_extended |
| ); |
| |
| if (len <= 0) { |
| break; |
| } |
| |
| mesh_nets_flags = (flags_extended << 8) | flags; |
| |
| syslog( |
| LOG_INFO, |
| "[-NCP-]: On-mesh net [%d] \"%s/%d\" stable:%s local:%s flags:%s, rloc16:0x%04x", |
| num_prefix, |
| in6_addr_to_string(*prefix_addr).c_str(), |
| prefix_len, |
| stable ? "yes" : "no", |
| is_local ? "yes" : "no", |
| on_mesh_prefix_flags_to_string(mesh_nets_flags).c_str(), |
| rloc16 |
| ); |
| |
| num_prefix++; |
| |
| if (!is_local) { |
| |
| // Go through the `on_mesh_prefixes` list (which is the copy of mOnMeshPrefixes) |
| // and check if this entry is already on the list, if so remove it. |
| |
| IPv6Prefix prefix(*prefix_addr, prefix_len); |
| OnMeshPrefixEntry entry(kOriginThreadNCP, mesh_nets_flags, stable, rloc16); |
| |
| iter = on_mesh_prefixes.lower_bound(prefix); |
| |
| if (iter != on_mesh_prefixes.end()) { |
| std::multimap<IPv6Prefix, OnMeshPrefixEntry>::iterator upper_iter = on_mesh_prefixes.upper_bound(prefix); |
| |
| for (; iter != upper_iter; ++iter) { |
| if (iter->second == entry) { |
| on_mesh_prefixes.erase(iter); |
| break; |
| } |
| } |
| } |
| |
| on_mesh_prefix_was_added(kOriginThreadNCP, *prefix_addr, prefix_len, mesh_nets_flags, stable, rloc16); |
| } |
| |
| value_data_ptr += len; |
| value_data_len -= len; |
| } |
| |
| // Since this was the whole list, we need to remove any prefixes |
| // which originated from NCP that that weren't in the new list. |
| |
| for (iter = on_mesh_prefixes.begin(); iter != on_mesh_prefixes.end(); ++iter) { |
| if (iter->second.is_from_ncp()) { |
| on_mesh_prefix_was_removed( |
| kOriginThreadNCP, |
| iter->first.get_prefix(), |
| iter->first.get_length(), |
| iter->second.get_flags(), |
| iter->second.is_stable(), |
| iter->second.get_rloc() |
| ); |
| } |
| } |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_spinel_value_is_OFF_MESH_ROUTES(const uint8_t* value_data_ptr, spinel_size_t value_data_len) |
| { |
| std::multimap<IPv6Prefix, OffMeshRouteEntry>::iterator iter; |
| std::multimap<IPv6Prefix, OffMeshRouteEntry> off_mesh_routes(mOffMeshRoutes); |
| int num_routes = 0; |
| |
| while (value_data_len > 0) { |
| spinel_ssize_t len; |
| struct in6_addr *route_prefix = NULL; |
| uint8_t prefix_len; |
| bool is_stable; |
| uint8_t flags; |
| bool is_local; |
| bool next_hop_is_this_device; |
| uint16_t rloc16; |
| RoutePreference preference; |
| |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_IPv6ADDR_S // Route Prefix |
| SPINEL_DATATYPE_UINT8_S // Prefix Length (in bits) |
| SPINEL_DATATYPE_BOOL_S // isStable |
| SPINEL_DATATYPE_UINT8_S // Flags |
| SPINEL_DATATYPE_BOOL_S // IsLocal |
| SPINEL_DATATYPE_BOOL_S // NextHopIsThisDevice |
| SPINEL_DATATYPE_UINT16_S // RLOC16 |
| ), |
| &route_prefix, |
| &prefix_len, |
| &is_stable, |
| &flags, |
| &is_local, |
| &next_hop_is_this_device, |
| &rloc16 |
| ); |
| |
| if (len <= 0) { |
| break; |
| } |
| |
| preference = convert_flags_to_route_preference(flags); |
| |
| syslog(LOG_INFO, "[-NCP-]: Off-mesh route [%d] \"%s/%d\" stable:%s local:%s preference:%s, next_hop_is_this_device:%s, rloc16:0x%0x", |
| num_routes, in6_addr_to_string(*route_prefix).c_str(), prefix_len, is_stable ? "yes" : "no", |
| is_local ? "yes" : "no", NCPControlInterface::external_route_priority_to_string(preference).c_str(), |
| next_hop_is_this_device ? "yes" : "no", rloc16); |
| |
| num_routes++; |
| |
| if (!is_local) { |
| |
| // Go through the `off_mesh_routes` list (which is the copy of mOffMeshRoutes) |
| // and check if this entry is already on the list, if so remove it. |
| |
| IPv6Prefix route(*route_prefix, prefix_len); |
| OffMeshRouteEntry entry(kOriginThreadNCP, preference, is_stable, rloc16, next_hop_is_this_device); |
| iter = off_mesh_routes.lower_bound(route); |
| |
| if (iter != off_mesh_routes.end()) { |
| std::multimap<IPv6Prefix, OffMeshRouteEntry>::iterator upper_iter = off_mesh_routes.upper_bound(route); |
| |
| for (; iter != upper_iter; ++iter) { |
| if (iter->second == entry) { |
| off_mesh_routes.erase(iter); |
| break; |
| } |
| } |
| } |
| |
| route_was_added(kOriginThreadNCP, *route_prefix, prefix_len, preference, is_stable, rloc16, |
| next_hop_is_this_device); |
| } |
| |
| value_data_ptr += len; |
| value_data_len -= len; |
| } |
| |
| // Since this was the whole list, we need to remove any routes |
| // which originated from NCP that that weren't in the new list. |
| |
| for (iter = off_mesh_routes.begin(); iter != off_mesh_routes.end(); ++iter) { |
| if (iter->second.is_from_ncp()) { |
| route_was_removed(kOriginThreadNCP, iter->first.get_prefix(), iter->first.get_length(), |
| iter->second.get_preference(), iter->second.is_stable(), iter->second.get_rloc()); |
| } |
| } |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_spinel_value_is_SERVICES(const uint8_t* value_data_ptr, spinel_size_t value_data_len) |
| { |
| uint32_t enterprise_number; |
| const uint8_t *service_data_ptr = NULL; |
| spinel_size_t service_data_len = 0; |
| bool stable = false; |
| const uint8_t *server_data_ptr = NULL; |
| spinel_size_t server_data_len = 0; |
| uint16_t rloc16; |
| int num_services = 0; |
| spinel_ssize_t len; |
| |
| std::vector<ServiceEntry> entries(mServiceEntries); |
| std::vector<ServiceEntry>::iterator iter; |
| |
| while (value_data_len > 0) { |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_STRUCT_S( |
| SPINEL_DATATYPE_UINT32_S // Enterprise Number |
| SPINEL_DATATYPE_DATA_WLEN_S // Service Data |
| SPINEL_DATATYPE_BOOL_S // stable |
| SPINEL_DATATYPE_DATA_WLEN_S // Server Data |
| SPINEL_DATATYPE_UINT16_S // RLOC |
| ), |
| &enterprise_number, |
| &service_data_ptr, |
| &service_data_len, |
| &stable, |
| &server_data_ptr, |
| &server_data_len, |
| &rloc16 |
| ); |
| |
| if (len <= 0) { |
| break; |
| } |
| |
| syslog(LOG_INFO, "[-NCP-]: Service [%d] enterprise_number:%u stable:%s RLOC16:%04x", |
| num_services, enterprise_number, stable ? "yes" : "no", rloc16); |
| |
| Data service_data(service_data_ptr, service_data_len); |
| Data server_data(server_data_ptr, server_data_len); |
| |
| ServiceEntry entry(kOriginThreadNCP, enterprise_number, service_data, stable, server_data); |
| |
| iter = std::find(entries.begin(), entries.end(), entry); |
| if (iter != entries.end()) { |
| entries.erase(iter); |
| } |
| |
| service_was_added(kOriginThreadNCP, enterprise_number, service_data, stable, server_data); |
| |
| value_data_ptr += len; |
| value_data_len -= len; |
| num_services += 1; |
| } |
| |
| for (iter = entries.begin(); iter != entries.end(); ++iter) { |
| if (iter->is_from_ncp()) { |
| service_was_removed(kOriginThreadNCP, iter->get_enterprise_number(), iter->get_service_data()); |
| } |
| } |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_spinel_value_is(spinel_prop_key_t key, const uint8_t* value_data_ptr, spinel_size_t value_data_len) |
| { |
| const uint8_t *original_value_data_ptr = value_data_ptr; |
| spinel_size_t original_value_data_len = value_data_len; |
| |
| if (key == SPINEL_PROP_LAST_STATUS) { |
| spinel_status_t status = SPINEL_STATUS_OK; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "i", &status); |
| syslog(LOG_INFO, "[-NCP-]: Last status (%s, %d)", spinel_status_to_cstr(status), status); |
| if ((status >= SPINEL_STATUS_RESET__BEGIN) && (status <= SPINEL_STATUS_RESET__END)) { |
| syslog(LOG_NOTICE, "[-NCP-]: NCP was reset (%s, %d)", spinel_status_to_cstr(status), status); |
| process_event(EVENT_NCP_RESET, status); |
| if (!mResetIsExpected && (mDriverState == NORMAL_OPERATION)) { |
| wpantund_status_t wstatus = kWPANTUNDStatus_NCP_Reset; |
| switch(status) { |
| case SPINEL_STATUS_RESET_CRASH: |
| case SPINEL_STATUS_RESET_FAULT: |
| case SPINEL_STATUS_RESET_ASSERT: |
| case SPINEL_STATUS_RESET_WATCHDOG: |
| case SPINEL_STATUS_RESET_OTHER: |
| wstatus = kWPANTUNDStatus_NCP_Crashed; |
| break; |
| default: |
| break; |
| } |
| reset_tasks(wstatus); |
| } |
| |
| if (mDriverState == NORMAL_OPERATION) { |
| reinitialize_ncp(); |
| } |
| mResetIsExpected = false; |
| return; |
| } else if ((status >= SPINEL_STATUS_JOIN__BEGIN) && (status <= SPINEL_STATUS_JOIN__END)) { |
| if (status == SPINEL_STATUS_JOIN_SUCCESS) { |
| change_ncp_state(COMMISSIONED); |
| } |
| else { |
| change_ncp_state(CREDENTIALS_NEEDED); |
| } |
| } else if (status == SPINEL_STATUS_INVALID_COMMAND) { |
| syslog(LOG_NOTICE, "[-NCP-]: COMMAND NOT RECOGNIZED"); |
| } |
| } else if (key == SPINEL_PROP_NCP_VERSION) { |
| const char* ncp_version = NULL; |
| spinel_ssize_t len = spinel_datatype_unpack(value_data_ptr, value_data_len, "U", &ncp_version); |
| if ((len <= 0) || (ncp_version == NULL)) { |
| syslog(LOG_CRIT, "[-NCP-]: Got a corrupted NCP version"); |
| // TODO: Properly handle NCP Misbehavior |
| change_ncp_state(FAULT); |
| } else { |
| set_ncp_version_string(ncp_version); |
| } |
| |
| } else if (key == SPINEL_PROP_INTERFACE_TYPE) { |
| unsigned int interface_type = 0; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "i", &interface_type); |
| |
| if (interface_type != SPINEL_PROTOCOL_TYPE_THREAD) { |
| syslog(LOG_CRIT, "[-NCP-]: NCP is using unsupported protocol type (%d)", interface_type); |
| change_ncp_state(FAULT); |
| } |
| |
| } else if (key == SPINEL_PROP_PROTOCOL_VERSION) { |
| unsigned int protocol_version_major = 0; |
| unsigned int protocol_version_minor = 0; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "ii", &protocol_version_major, &protocol_version_minor); |
| |
| if (protocol_version_major != SPINEL_PROTOCOL_VERSION_THREAD_MAJOR) { |
| syslog(LOG_CRIT, "[-NCP-]: NCP is using unsupported protocol version (NCP:%d, wpantund:%d)", protocol_version_major, SPINEL_PROTOCOL_VERSION_THREAD_MAJOR); |
| change_ncp_state(FAULT); |
| } |
| |
| if (protocol_version_minor != SPINEL_PROTOCOL_VERSION_THREAD_MINOR) { |
| syslog(LOG_WARNING, "[-NCP-]: NCP is using different protocol minor version (NCP:%d, wpantund:%d)", protocol_version_minor, SPINEL_PROTOCOL_VERSION_THREAD_MINOR); |
| } |
| |
| } else if (key == SPINEL_PROP_CAPS) { |
| const uint8_t* data_ptr = value_data_ptr; |
| spinel_size_t data_len = value_data_len; |
| std::set<unsigned int> capabilities; |
| |
| while(data_len != 0) { |
| unsigned int value = 0; |
| spinel_ssize_t parse_len = spinel_datatype_unpack(data_ptr, data_len, SPINEL_DATATYPE_UINT_PACKED_S, &value); |
| if (parse_len <= 0) { |
| syslog(LOG_WARNING, "[-NCP-]: Capability Parse failure"); |
| break; |
| } |
| capabilities.insert(value); |
| syslog(LOG_INFO, "[-NCP-]: Capability (%s, %d)", spinel_capability_to_cstr(value), value); |
| |
| data_ptr += parse_len; |
| data_len -= parse_len; |
| } |
| |
| if (capabilities != mCapabilities) { |
| mCapabilities = capabilities; |
| } |
| |
| } else if (key == SPINEL_PROP_NET_NETWORK_NAME) { |
| const char* value = NULL; |
| spinel_ssize_t len = spinel_datatype_unpack(value_data_ptr, value_data_len, "U", &value); |
| |
| if ((len <= 0) || (value == NULL)) { |
| syslog(LOG_CRIT, "[-NCP-]: Got a corrupted NCP version"); |
| // TODO: Properly handle NCP Misbehavior |
| change_ncp_state(FAULT); |
| } else { |
| syslog(LOG_INFO, "[-NCP-]: Network name \"%s\"", value); |
| if (mCurrentNetworkInstance.name != value) { |
| mCurrentNetworkInstance.name = value; |
| signal_property_changed(kWPANTUNDProperty_NetworkName, mCurrentNetworkInstance.name); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_MCU_POWER_STATE) { |
| uint8_t power_state = 0; |
| spinel_ssize_t len = 0; |
| |
| len = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT8_S, &power_state); |
| |
| if (len > 0) { |
| syslog(LOG_INFO, "[-NCP-]: MCU power state \"%s\" (%d)", |
| spinel_mcu_power_state_to_cstr(static_cast<spinel_mcu_power_state_t>(power_state)), power_state); |
| |
| switch (get_ncp_state()) { |
| case OFFLINE: |
| case COMMISSIONED: |
| if (power_state == SPINEL_MCU_POWER_STATE_LOW_POWER) { |
| change_ncp_state(DEEP_SLEEP); |
| } |
| break; |
| |
| case DEEP_SLEEP: |
| if (power_state == SPINEL_MCU_POWER_STATE_ON) { |
| change_ncp_state(mIsCommissioned ? COMMISSIONED : OFFLINE); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_IPV6_LL_ADDR) { |
| struct in6_addr *addr = NULL; |
| |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "6", &addr); |
| if (addr != NULL) { |
| syslog(LOG_INFO, "[-NCP-]: Link-local IPv6 address \"%s\"", in6_addr_to_string(*addr).c_str()); |
| } |
| update_link_local_address(addr); |
| |
| } else if (key == SPINEL_PROP_IPV6_ML_ADDR) { |
| struct in6_addr *addr = NULL; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "6", &addr); |
| if (addr != NULL) { |
| syslog(LOG_INFO, "[-NCP-]: Mesh-local IPv6 address \"%s\"", in6_addr_to_string(*addr).c_str()); |
| } |
| update_mesh_local_address(addr); |
| |
| } else if (key == SPINEL_PROP_IPV6_ML_PREFIX) { |
| struct in6_addr *addr = NULL; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "6", &addr); |
| if (addr != NULL) { |
| syslog(LOG_INFO, "[-NCP-]: Mesh-local prefix \"%s\"", (in6_addr_to_string(*addr) + "/64").c_str()); |
| } |
| update_mesh_local_prefix(addr); |
| |
| } else if (key == SPINEL_PROP_IPV6_ADDRESS_TABLE) { |
| std::map<struct in6_addr, UnicastAddressEntry>::const_iterator iter; |
| std::map<struct in6_addr, UnicastAddressEntry> unicast_addresses(mUnicastAddresses); |
| const struct in6_addr *addr = NULL; |
| int num_address = 0; |
| |
| while (value_data_len > 0) { |
| const uint8_t *entry_ptr = NULL; |
| spinel_size_t entry_len = 0; |
| spinel_ssize_t len = 0; |
| len = spinel_datatype_unpack(value_data_ptr, value_data_len, "D.", &entry_ptr, &entry_len); |
| if (len < 1) { |
| break; |
| } |
| |
| addr = reinterpret_cast<const struct in6_addr*>(entry_ptr); |
| syslog(LOG_INFO, "[-NCP-]: IPv6 address [%d] \"%s\"", num_address, in6_addr_to_string(*addr).c_str()); |
| num_address++; |
| unicast_addresses.erase(*addr); |
| handle_ncp_spinel_value_inserted(key, entry_ptr, entry_len); |
| |
| value_data_ptr += len; |
| value_data_len -= len; |
| } |
| |
| syslog(LOG_INFO, "[-NCP-]: IPv6 address: Total %d address%s", num_address, (num_address > 1) ? "es" : ""); |
| |
| // Since this was the whole list, we need to remove the addresses |
| // which originated from NCP that that weren't in the list. |
| for (iter = unicast_addresses.begin(); iter != unicast_addresses.end(); ++iter) { |
| if (iter->second.is_from_ncp()) { |
| unicast_address_was_removed(kOriginThreadNCP, iter->first); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_IPV6_MULTICAST_ADDRESS_TABLE) { |
| std::map<struct in6_addr, MulticastAddressEntry>::const_iterator iter; |
| std::map<struct in6_addr, MulticastAddressEntry> multicast_addresses(mMulticastAddresses); |
| const struct in6_addr *addr = NULL; |
| int num_address = 0; |
| |
| while (value_data_len > 0) { |
| const uint8_t *entry_ptr = NULL; |
| spinel_size_t entry_len = 0; |
| spinel_ssize_t len = 0; |
| len = spinel_datatype_unpack(value_data_ptr, value_data_len, "D.", &entry_ptr, &entry_len); |
| if (len < 1) { |
| break; |
| } |
| |
| addr = reinterpret_cast<const struct in6_addr*>(entry_ptr); |
| syslog(LOG_INFO, "[-NCP-]: Multicast IPv6 address [%d] \"%s\"", num_address, in6_addr_to_string(*addr).c_str()); |
| num_address++; |
| multicast_addresses.erase(*addr); |
| handle_ncp_spinel_value_inserted(key, entry_ptr, entry_len); |
| |
| value_data_ptr += len; |
| value_data_len -= len; |
| } |
| |
| // Since this was the whole list, we need to remove the addresses |
| // which originated from NCP that that weren't in the list. |
| for (iter = multicast_addresses.begin(); iter != multicast_addresses.end(); ++iter) { |
| if (iter->second.is_from_ncp()) { |
| multicast_address_was_left(kOriginThreadNCP, iter->first); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_HWADDR) { |
| nl::Data hwaddr(value_data_ptr, value_data_len); |
| if (value_data_len == sizeof(mMACHardwareAddress)) { |
| set_mac_hardware_address(value_data_ptr); |
| } |
| |
| } else if (key == SPINEL_PROP_MAC_15_4_LADDR) { |
| nl::Data hwaddr(value_data_ptr, value_data_len); |
| if (value_data_len == sizeof(mMACAddress)) { |
| set_mac_address(value_data_ptr); |
| } |
| |
| } else if (key == SPINEL_PROP_MAC_15_4_PANID) { |
| uint16_t panid; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT16_S, &panid); |
| syslog(LOG_INFO, "[-NCP-]: PANID 0x%04X", panid); |
| if (panid != mCurrentNetworkInstance.panid) { |
| mCurrentNetworkInstance.panid = panid; |
| signal_property_changed(kWPANTUNDProperty_NetworkPANID, panid); |
| } |
| |
| } else if (key == SPINEL_PROP_NET_XPANID) { |
| nl::Data xpanid(value_data_ptr, value_data_len); |
| char cstr_buf[200]; |
| encode_data_into_string(value_data_ptr, value_data_len, cstr_buf, sizeof(cstr_buf), 0); |
| syslog(LOG_INFO, "[-NCP-] XPANID 0x%s", cstr_buf); |
| |
| if ((value_data_len == 8) && 0 != memcmp(xpanid.data(), mCurrentNetworkInstance.xpanid, 8)) { |
| memcpy(mCurrentNetworkInstance.xpanid, xpanid.data(), 8); |
| signal_property_changed(kWPANTUNDProperty_NetworkXPANID, xpanid); |
| } |
| |
| } else if (key == SPINEL_PROP_NET_PSKC) { |
| nl::Data network_pskc(value_data_ptr, value_data_len); |
| if (network_pskc != mNetworkPSKc) { |
| mNetworkPSKc = network_pskc; |
| signal_property_changed(kWPANTUNDProperty_NetworkPSKc, mNetworkPSKc); |
| } |
| |
| } else if (key == SPINEL_PROP_NET_MASTER_KEY) { |
| nl::Data network_key(value_data_ptr, value_data_len); |
| if (ncp_state_is_joining_or_joined(get_ncp_state())) { |
| if (network_key != mNetworkKey) { |
| mNetworkKey = network_key; |
| signal_property_changed(kWPANTUNDProperty_NetworkKey, mNetworkKey); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_NET_KEY_SEQUENCE_COUNTER) { |
| uint32_t network_key_index = 0; |
| spinel_ssize_t ret; |
| |
| ret = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT32_S, &network_key_index); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| if ((ret > 0) && (network_key_index != mNetworkKeyIndex)) { |
| mNetworkKeyIndex = network_key_index; |
| signal_property_changed(kWPANTUNDProperty_NetworkKeyIndex, mNetworkKeyIndex); |
| } |
| |
| } else if (key == SPINEL_PROP_PHY_CHAN) { |
| unsigned int value = 0; |
| spinel_ssize_t ret; |
| |
| ret = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT_PACKED_S, &value); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| if (ret > 0) { |
| syslog(LOG_INFO, "[-NCP-]: Channel %d", value); |
| if (value != mCurrentNetworkInstance.channel) { |
| mCurrentNetworkInstance.channel = value; |
| signal_property_changed(kWPANTUNDProperty_NCPChannel, mCurrentNetworkInstance.channel); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_PHY_CHAN_SUPPORTED) { |
| boost::any mask_value; |
| int ret = unpack_channel_mask(value_data_ptr, value_data_len, mask_value); |
| |
| if (ret == kWPANTUNDStatus_Ok) { |
| mSupportedChannelMask = any_to_int(mask_value); |
| syslog(LOG_INFO, "[-NCP-]: Supported Channel Mask 0x%x", mSupportedChannelMask); |
| } |
| |
| } else if (key == SPINEL_PROP_PHY_CHAN_PREFERRED) { |
| boost::any mask_value; |
| int ret = unpack_channel_mask(value_data_ptr, value_data_len, mask_value); |
| |
| if (ret == kWPANTUNDStatus_Ok) { |
| mPreferredChannelMask = any_to_int(mask_value); |
| syslog(LOG_INFO, "[-NCP-]: Preferred Channel Mask 0x%x", mPreferredChannelMask); |
| } |
| |
| } else if (key == SPINEL_PROP_PHY_TX_POWER) { |
| int8_t value = 0; |
| spinel_ssize_t ret; |
| |
| ret = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_INT8_S, &value); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| if (ret > 0) { |
| syslog(LOG_INFO, "[-NCP-]: Tx power %d", value); |
| if (value != mTXPower) { |
| mTXPower = value; |
| signal_property_changed(kWPANTUNDProperty_NCPTXPower, mTXPower); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_STREAM_DEBUG) { |
| handle_ncp_debug_stream(value_data_ptr, value_data_len); |
| |
| } else if (key == SPINEL_PROP_STREAM_LOG) { |
| handle_ncp_log_stream(value_data_ptr, value_data_len); |
| |
| } else if (key == SPINEL_PROP_NET_ROLE) { |
| uint8_t value = 0; |
| spinel_ssize_t ret; |
| |
| ret = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT8_S, &value); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| if (ret > 0) { |
| syslog(LOG_INFO, "[-NCP-]: Net Role \"%s\" (%d)", spinel_net_role_to_cstr(value), value); |
| |
| if (ncp_state_is_joining_or_joined(get_ncp_state()) |
| && (value != SPINEL_NET_ROLE_DETACHED) |
| && (value != SPINEL_NET_ROLE_DISABLED) |
| ) { |
| change_ncp_state(ASSOCIATED); |
| } |
| |
| if (value == SPINEL_NET_ROLE_CHILD) { |
| if ((mThreadMode & SPINEL_THREAD_MODE_RX_ON_WHEN_IDLE) != 0) { |
| update_node_type(END_DEVICE); |
| } else { |
| update_node_type(SLEEPY_END_DEVICE); |
| } |
| |
| } else if (value == SPINEL_NET_ROLE_ROUTER) { |
| update_node_type(ROUTER); |
| |
| } else if (value == SPINEL_NET_ROLE_LEADER) { |
| update_node_type(LEADER); |
| |
| } else if (value == SPINEL_NET_ROLE_DETACHED || value == SPINEL_NET_ROLE_DISABLED) { |
| update_node_type(UNKNOWN); |
| if (ncp_state_is_associated(get_ncp_state())) { |
| change_ncp_state(ISOLATED); |
| } |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_MODE) { |
| uint8_t value = mThreadMode; |
| spinel_ssize_t ret; |
| |
| ret = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT8_S, &value); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| if (ret > 0) { |
| syslog(LOG_INFO, "[-NCP-]: Thread Mode \"%s\" (0x%02x)", thread_mode_to_string(value).c_str(), value); |
| mThreadMode = value; |
| |
| switch (get_ncp_state()) |
| { |
| case ISOLATED: |
| if ((mThreadMode & SPINEL_THREAD_MODE_RX_ON_WHEN_IDLE) != 0) { |
| change_ncp_state(ASSOCIATING); |
| } |
| break; |
| |
| case ASSOCIATING: |
| if (mIsCommissioned && ((mThreadMode & SPINEL_THREAD_MODE_RX_ON_WHEN_IDLE) == 0)) { |
| change_ncp_state(ISOLATED); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| switch (mNodeType) |
| { |
| case END_DEVICE: |
| case SLEEPY_END_DEVICE: |
| if ((mThreadMode & SPINEL_THREAD_MODE_RX_ON_WHEN_IDLE) != 0) { |
| update_node_type(END_DEVICE); |
| } else { |
| update_node_type(SLEEPY_END_DEVICE); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_NET_SAVED) { |
| bool is_commissioned = false; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_BOOL_S, &is_commissioned); |
| syslog(LOG_INFO, "[-NCP-]: NetSaved (NCP is commissioned?) \"%s\" ", is_commissioned ? "yes" : "no"); |
| mIsCommissioned = is_commissioned; |
| if (mIsCommissioned && (get_ncp_state() == OFFLINE)) { |
| change_ncp_state(COMMISSIONED); |
| } else if (!mIsCommissioned && (get_ncp_state() == COMMISSIONED)) { |
| change_ncp_state(OFFLINE); |
| } |
| |
| } else if (key == SPINEL_PROP_NET_STACK_UP) { |
| bool is_stack_up = false; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_BOOL_S, &is_stack_up); |
| syslog(LOG_INFO, "[-NCP-]: Stack is %sup", is_stack_up ? "" : "not "); |
| |
| if (is_stack_up) { |
| if (!ncp_state_is_joining_or_joined(get_ncp_state())) { |
| if (mIsCommissioned && ((mThreadMode & SPINEL_THREAD_MODE_RX_ON_WHEN_IDLE) == 0)) { |
| change_ncp_state(ISOLATED); |
| } else { |
| change_ncp_state(ASSOCIATING); |
| } |
| } |
| } else { |
| if (!ncp_state_is_joining(get_ncp_state())) { |
| change_ncp_state(mIsCommissioned ? COMMISSIONED : OFFLINE); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_NET_IF_UP) { |
| bool is_if_up = false; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_BOOL_S, &is_if_up); |
| syslog(LOG_INFO, "[-NCP-]: Interface is %sup", is_if_up ? "" : "not "); |
| |
| if (ncp_state_is_interface_up(get_ncp_state()) && !is_if_up) { |
| change_ncp_state(mIsCommissioned ? COMMISSIONED : OFFLINE); |
| } |
| |
| } else if (key == SPINEL_PROP_MESHCOP_COMMISSIONER_STATE) { |
| boost::any value; |
| int status; |
| status = unpack_commissioner_state(value_data_ptr, value_data_len, value); |
| if (status == kWPANTUNDStatus_Ok) { |
| syslog(LOG_INFO, "[-NCP-]: Thread Commissioner state is \"%s\"", any_to_string(value).c_str()); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_ON_MESH_NETS) { |
| handle_ncp_spinel_value_is_ON_MESH_NETS(value_data_ptr, value_data_len); |
| |
| } else if (key == SPINEL_PROP_THREAD_OFF_MESH_ROUTES) { |
| handle_ncp_spinel_value_is_OFF_MESH_ROUTES(value_data_ptr, value_data_len); |
| |
| } else if (key == SPINEL_PROP_SERVER_SERVICES) { |
| handle_ncp_spinel_value_is_SERVICES(value_data_ptr, value_data_len); |
| |
| } else if (key == SPINEL_PROP_THREAD_ASSISTING_PORTS) { |
| bool is_assisting = (value_data_len != 0); |
| uint16_t assisting_port(0); |
| |
| if (is_assisting) { |
| int i; |
| syslog(LOG_NOTICE, "Network is joinable"); |
| while (value_data_len > 0) { |
| i = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT16_S, &assisting_port); |
| if (i <= 0) { |
| break; |
| } |
| syslog(LOG_NOTICE, "Assisting on port %d", assisting_port); |
| value_data_ptr += i; |
| value_data_len -= i; |
| } |
| } else { |
| syslog(LOG_NOTICE, "Network is not joinable"); |
| } |
| |
| } else if (key == SPINEL_PROP_JAM_DETECTED) { |
| bool jamDetected = false; |
| |
| spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_BOOL_S, &jamDetected); |
| signal_property_changed(kWPANTUNDProperty_JamDetectionStatus, jamDetected); |
| |
| if (jamDetected) { |
| syslog(LOG_NOTICE, "Signal jamming is detected"); |
| } else { |
| syslog(LOG_NOTICE, "Signal jamming cleared"); |
| } |
| |
| } else if (key == SPINEL_PROP_CHANNEL_MANAGER_NEW_CHANNEL) { |
| uint8_t new_channel = 0; |
| spinel_ssize_t len; |
| |
| len = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT8_S, &new_channel); |
| |
| if ((len >= 0) && (new_channel != mChannelManagerNewChannel)) { |
| mChannelManagerNewChannel = new_channel; |
| signal_property_changed(kWPANTUNDProperty_ChannelManagerNewChannel, new_channel); |
| syslog(LOG_INFO, "[-NCP-]: ChannelManager about to switch to new channel %d", new_channel); |
| } |
| |
| } else if (key == SPINEL_PROP_STREAM_RAW) { |
| if (mPcapManager.is_enabled()) { |
| const uint8_t* frame_ptr(NULL); |
| unsigned int frame_len(0); |
| const uint8_t* meta_ptr(NULL); |
| unsigned int meta_len(0); |
| spinel_ssize_t ret; |
| PcapPacket packet; |
| uint16_t flags = 0; |
| |
| packet.set_timestamp().set_dlt(PCAP_DLT_IEEE802_15_4); |
| |
| // Unpack the packet. |
| ret = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_DATA_WLEN_S SPINEL_DATATYPE_DATA_S, |
| &frame_ptr, |
| &frame_len, |
| &meta_ptr, |
| &meta_len |
| ); |
| |
| require(ret > 0, bail); |
| |
| // Unpack the metadata. |
| ret = spinel_datatype_unpack( |
| meta_ptr, |
| meta_len, |
| SPINEL_DATATYPE_INT8_S // RSSI/TXPower |
| SPINEL_DATATYPE_INT8_S // Noise Floor |
| SPINEL_DATATYPE_UINT16_S, // Flags |
| NULL, // Ignore RSSI/TXPower |
| NULL, // Ignore Noise Floor |
| &flags |
| ); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| if ((flags & SPINEL_MD_FLAG_TX) == SPINEL_MD_FLAG_TX) |
| { |
| // Ignore FCS for transmitted packets |
| frame_len -= 2; |
| packet.set_dlt(PCAP_DLT_IEEE802_15_4_NOFCS); |
| } |
| |
| mPcapManager.push_packet( |
| packet |
| .append_ppi_field(PCAP_PPI_TYPE_SPINEL, meta_ptr, meta_len) |
| .append_payload(frame_ptr, frame_len) |
| ); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_TMF_PROXY_STREAM) { |
| const uint8_t* frame_ptr(NULL); |
| unsigned int frame_len(0); |
| uint16_t locator = 0; |
| uint16_t port = 0; |
| spinel_ssize_t ret; |
| Data data; |
| |
| ret = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_DATA_S SPINEL_DATATYPE_UINT16_S SPINEL_DATATYPE_UINT16_S, |
| &frame_ptr, |
| &frame_len, |
| &locator, |
| &port |
| ); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| // Analyze the packet to determine if it should be dropped. |
| if ((ret > 0)) { |
| // append frame |
| data.append(frame_ptr, frame_len); |
| // pack the locator in big endian. |
| data.push_back(locator >> 8); |
| data.push_back(locator & 0xff); |
| // pack the port in big endian. |
| data.push_back(port >> 8); |
| data.push_back(port & 0xff); |
| signal_property_changed(kWPANTUNDProperty_TmfProxyStream, data); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_UDP_FORWARD_STREAM) { |
| const uint8_t* frame_ptr(NULL); |
| unsigned int frame_len(0); |
| uint16_t peer_port = 0; |
| in6_addr *peer_addr; |
| uint16_t sock_port = 0; |
| spinel_ssize_t ret; |
| Data data; |
| |
| ret = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_DATA_S |
| SPINEL_DATATYPE_UINT16_S // Peer port |
| SPINEL_DATATYPE_IPv6ADDR_S // Peer address |
| SPINEL_DATATYPE_UINT16_S, // Sock port |
| &frame_ptr, |
| &frame_len, |
| &peer_port, |
| &peer_addr, |
| &sock_port |
| ); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| // Analyze the packet to determine if it should be dropped. |
| if (ret > 0) { |
| // append frame |
| data.append(frame_ptr, frame_len); |
| // pack the locator in big endian. |
| data.push_back(peer_port >> 8); |
| data.push_back(peer_port & 0xff); |
| data.append(peer_addr->s6_addr, sizeof(*peer_addr)); |
| // pack the port in big endian. |
| data.push_back(sock_port >> 8); |
| data.push_back(sock_port & 0xff); |
| signal_property_changed(kWPANTUNDProperty_UdpForwardStream, data); |
| } |
| |
| } else if ((key == SPINEL_PROP_STREAM_NET) || (key == SPINEL_PROP_STREAM_NET_INSECURE)) { |
| const uint8_t* frame_ptr(NULL); |
| unsigned int frame_len(0); |
| spinel_ssize_t ret; |
| uint8_t frame_data_type = FRAME_TYPE_DATA; |
| |
| if (SPINEL_PROP_STREAM_NET_INSECURE == key) { |
| frame_data_type = FRAME_TYPE_INSECURE_DATA; |
| } |
| |
| ret = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_DATA_S SPINEL_DATATYPE_DATA_S, |
| &frame_ptr, |
| &frame_len, |
| NULL, |
| NULL |
| ); |
| |
| __ASSERT_MACROS_check(ret > 0); |
| |
| // Analyze the packet to determine if it should be dropped. |
| if ((ret > 0) && should_forward_hostbound_frame(&frame_data_type, frame_ptr, frame_len)) { |
| if (static_cast<bool>(mLegacyInterface) && (frame_data_type == FRAME_TYPE_LEGACY_DATA)) { |
| handle_alt_ipv6_from_ncp(frame_ptr, frame_len); |
| } else { |
| handle_normal_ipv6_from_ncp(frame_ptr, frame_len); |
| } |
| } |
| } else if (key == SPINEL_PROP_THREAD_CHILD_TABLE) { |
| SpinelNCPTaskGetNetworkTopology::Table child_table; |
| SpinelNCPTaskGetNetworkTopology::Table::iterator it; |
| int num_children = 0; |
| |
| SpinelNCPTaskGetNetworkTopology::parse_child_table(value_data_ptr, value_data_len, child_table); |
| |
| for (it = child_table.begin(); it != child_table.end(); it++) |
| { |
| num_children++; |
| syslog(LOG_INFO, "[-NCP-] Child: %02d %s", num_children, it->get_as_string().c_str()); |
| } |
| syslog(LOG_INFO, "[-NCP-] Child: Total %d child%s", num_children, (num_children > 1) ? "ren" : ""); |
| |
| } else if (key == SPINEL_PROP_THREAD_NEIGHBOR_TABLE) { |
| SpinelNCPTaskGetNetworkTopology::Table neigh_table; |
| SpinelNCPTaskGetNetworkTopology::Table::iterator it; |
| int num_neighbor = 0; |
| |
| SpinelNCPTaskGetNetworkTopology::parse_neighbor_table(value_data_ptr, value_data_len, neigh_table); |
| |
| for (it = neigh_table.begin(); it != neigh_table.end(); it++) |
| { |
| num_neighbor++; |
| syslog(LOG_INFO, "[-NCP-] Neighbor: %02d %s", num_neighbor, it->get_as_string().c_str()); |
| } |
| syslog(LOG_INFO, "[-NCP-] Neighbor: Total %d neighbor%s", num_neighbor, (num_neighbor > 1) ? "s" : ""); |
| |
| } else if (key == SPINEL_PROP_THREAD_NEIGHBOR_TABLE_ERROR_RATES) { |
| SpinelNCPTaskGetNetworkTopology::Table neigh_table; |
| SpinelNCPTaskGetNetworkTopology::Table::iterator it; |
| int num_neighbor = 0; |
| |
| SpinelNCPTaskGetNetworkTopology::prase_neighbor_error_rates_table(value_data_ptr, value_data_len, neigh_table); |
| |
| for (it = neigh_table.begin(); it != neigh_table.end(); it++) |
| { |
| num_neighbor++; |
| syslog(LOG_INFO, "[-NCP-] Neighbor: %02d %s", num_neighbor, it->get_as_string().c_str()); |
| } |
| syslog(LOG_INFO, "[-NCP-] Neighbor: Total %d neighbor%s", num_neighbor, (num_neighbor > 1) ? "s" : ""); |
| |
| } else if (key == SPINEL_PROP_THREAD_ROUTER_TABLE) { |
| SpinelNCPTaskGetNetworkTopology::Table router_table; |
| SpinelNCPTaskGetNetworkTopology::Table::iterator it; |
| int num_router = 0; |
| |
| SpinelNCPTaskGetNetworkTopology::parse_router_table(value_data_ptr, value_data_len, router_table); |
| |
| for (it = router_table.begin(); it != router_table.end(); it++) |
| { |
| num_router++; |
| syslog(LOG_INFO, "[-NCP-] Router: %02d %s", num_router, it->get_as_string().c_str()); |
| } |
| syslog(LOG_INFO, "[-NCP-] Router: Total %d router%s", num_router, (num_router > 1) ? "s" : ""); |
| |
| |
| } else if (key == SPINEL_PROP_THREAD_ADDRESS_CACHE_TABLE) { |
| boost::any value; |
| if ((unpack_address_cache_table(value_data_ptr, value_data_len, value, false) == kWPANTUNDStatus_Ok) |
| && (value.type() == typeid(std::list<std::string>)) |
| ) { |
| std::list<std::string> list = boost::any_cast<std::list<std::string> >(value); |
| int num_entries = 0; |
| |
| for (std::list<std::string>::iterator it = list.begin(); it != list.end(); it++) { |
| num_entries++; |
| syslog(LOG_INFO, "[-NCP-] AddressCache: %02d %s", num_entries, it->c_str()); |
| } |
| syslog(LOG_INFO, "[-NCP-] AddressCache: Total %d entr%s", num_entries, (num_entries > 1) ? "ies" : "y"); |
| } |
| |
| } else if (key == SPINEL_PROP_NET_PARTITION_ID) { |
| uint32_t paritition_id = 0; |
| spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UINT32_S, &paritition_id); |
| syslog(LOG_INFO, "[-NCP-] Partition id: %u (0x%x)", paritition_id, paritition_id); |
| |
| } else if (key == SPINEL_PROP_THREAD_LEADER_NETWORK_DATA) { |
| char net_data_cstr_buf[540]; |
| encode_data_into_string(value_data_ptr, value_data_len, net_data_cstr_buf, sizeof(net_data_cstr_buf), 0); |
| syslog(LOG_INFO, "[-NCP-] Leader network data: [%s]", net_data_cstr_buf); |
| |
| } else if (key == SPINEL_PROP_RCP_VERSION) { |
| const char *rcp_version = NULL; |
| spinel_ssize_t len; |
| |
| len = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_UTF8_S, &rcp_version); |
| |
| if (len > 0) { |
| mRcpVersion = std::string(rcp_version); |
| syslog(LOG_NOTICE, "[-NCP-]: RCP is running \"%s\"", rcp_version); |
| } |
| |
| } else if (key == SPINEL_PROP_SLAAC_ENABLED) { |
| bool enabled; |
| spinel_ssize_t len; |
| |
| len = spinel_datatype_unpack(value_data_ptr, value_data_len, SPINEL_DATATYPE_BOOL_S, &enabled); |
| |
| if (len > 0) { |
| syslog(LOG_NOTICE, "[-NCP-]: SLAAC %sabled", enabled ? "en" : "dis"); |
| mNCPHandlesSLAAC = enabled; |
| } |
| |
| } else if (key == SPINEL_PROP_MESHCOP_JOINER_STATE) { |
| boost::any value; |
| |
| if (unpack_meshcop_joiner_state(value_data_ptr, value_data_len, value) == kWPANTUNDStatus_Ok) { |
| syslog(LOG_NOTICE, "[-NCP-]: Joiner state \"%s\"", any_to_string(value).c_str()); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_NETWORK_TIME) { |
| ValueMap result; |
| std::string result_as_string; |
| |
| if (unpack_thread_network_time_as_valmap(value_data_ptr, value_data_len, result) == kWPANTUNDStatus_Ok) { |
| if (unpack_thread_network_time_as_string(value_data_ptr, value_data_len, result_as_string) == kWPANTUNDStatus_Ok) { |
| syslog(LOG_INFO, "[-NCP-]: Network time update: %s", result_as_string.c_str()); |
| } else { |
| syslog(LOG_WARNING, "[-NCP-]: Failed to extract network time update for logging"); |
| } |
| |
| handle_network_time_update(result); |
| } else { |
| syslog(LOG_WARNING, "[-NCP-]: Failed to unpack network time update"); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_LINK_METRICS_QUERY_RESULT) { |
| spinel_ssize_t len; |
| struct in6_addr *source = NULL; |
| std::string source_str; |
| uint8_t status; |
| std::string status_str; |
| const uint8_t *struct_in = NULL; |
| unsigned int struct_len = 0; |
| |
| mLinkMetricsQueryResult.clear(); |
| |
| // Decode source and status |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| ( |
| SPINEL_DATATYPE_IPv6ADDR_S |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_DATA_WLEN_S |
| ), |
| &source, |
| &status, |
| &struct_in, |
| &struct_len |
| ); |
| |
| require(len >= 0, bail); |
| value_data_ptr += len; |
| value_data_len -= len; |
| |
| source_str = in6_addr_to_string(*source); |
| status_str = spinel_link_metrics_status_to_cstr(status); |
| |
| mLinkMetricsQueryResult[kWPANTUNDValueMapKey_LinkMetrics_Source] = source_str; |
| mLinkMetricsQueryResult[kWPANTUNDValueMapKey_LinkMetrics_Status] = status_str; |
| |
| unpack_link_metrics_as_val_map(struct_in, struct_len, mLinkMetricsQueryResult); |
| |
| } else if (key == SPINEL_PROP_THREAD_LINK_METRICS_MGMT_RESPONSE) { |
| spinel_ssize_t len; |
| struct in6_addr *source = NULL; |
| std::string source_str; |
| uint8_t status; |
| std::string status_str; |
| |
| // Decode source and status |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| ( |
| SPINEL_DATATYPE_IPv6ADDR_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| &source, |
| &status |
| ); |
| |
| require(len >= 0, bail); |
| value_data_ptr += len; |
| value_data_len -= len; |
| |
| source_str = in6_addr_to_string(*source); |
| status_str = spinel_link_metrics_status_to_cstr(status); |
| |
| mLinkMetricsMgmtResponse[kWPANTUNDValueMapKey_LinkMetrics_Source] = source_str; |
| mLinkMetricsMgmtResponse[kWPANTUNDValueMapKey_LinkMetrics_Status] = status_str; |
| |
| syslog(LOG_INFO, "Link Metrics Mqmt Response: %s (src: %s)", status_str.c_str(), source_str.c_str()); |
| |
| } else if (key == SPINEL_PROP_THREAD_LINK_METRICS_MGMT_ENH_ACK_IE) { |
| spinel_ssize_t len; |
| uint16_t short_addr = 0; |
| const spinel_eui64_t *eui64 = NULL; |
| const uint8_t *struct_in = NULL; |
| unsigned int struct_len = 0; |
| |
| mLinkMetricsLastEnhAckIe.clear(); |
| |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| ( |
| SPINEL_DATATYPE_UINT16_S |
| SPINEL_DATATYPE_EUI64_S |
| SPINEL_DATATYPE_DATA_WLEN_S |
| ), |
| &short_addr, |
| &eui64, |
| &struct_in, |
| &struct_len |
| ); |
| |
| require(len >= 0, bail); |
| value_data_ptr += len; |
| value_data_len -= len; |
| |
| syslog(LOG_DEBUG, "Received Link Metrics Enh-ACK IE from 0x%02x", short_addr); |
| |
| unpack_link_metrics_as_val_map(value_data_ptr, value_data_len, mLinkMetricsLastEnhAckIe); |
| |
| } else if (key == SPINEL_PROP_THREAD_MLR_RESPONSE) { |
| |
| mMulticastListenerRegistrationResponse.clear(); |
| |
| spinel_ssize_t len; |
| uint8_t status; |
| uint8_t mlr_status; |
| const uint8_t *struct_in = NULL; |
| unsigned int struct_len = 0; |
| |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| ( |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| &status, |
| &mlr_status |
| ); |
| |
| require(len >= 0, bail); |
| value_data_ptr += len; |
| value_data_len -= len; |
| |
| mMulticastListenerRegistrationResponse[kWPANTUNDValueMapKey_ThreadMlrResponse_Status] = status; |
| mMulticastListenerRegistrationResponse[kWPANTUNDValueMapKey_ThreadMlrResponse_MlrStatus] = mlr_status; |
| |
| std::list<std::string> addrList; |
| |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| SPINEL_DATATYPE_DATA_WLEN_S, |
| &struct_in, |
| &struct_len |
| ); |
| |
| require(len >= 0, bail); |
| value_data_ptr += len; |
| value_data_len -= len; |
| |
| while (struct_len != 0) |
| { |
| const in6_addr * failed_addr; |
| |
| len = spinel_datatype_unpack( |
| struct_in, |
| struct_len, |
| SPINEL_DATATYPE_IPv6ADDR_S, |
| &failed_addr |
| ); |
| |
| require(len > 0, bail); |
| |
| struct_in += len; |
| struct_len -= len; |
| |
| addrList.push_back(in6_addr_to_string(*failed_addr)); |
| } |
| |
| mMulticastListenerRegistrationResponse[kWPANTUNDValueMapKey_ThreadMlrResponse_Addresses] = addrList; |
| |
| syslog(LOG_DEBUG, "Received Multicast Listener Registration Response status=%u mlr_status=%u", |
| (unsigned)status, (unsigned)mlr_status); |
| } |
| |
| bail: |
| process_event(EVENT_NCP_PROP_VALUE_IS, key, original_value_data_ptr, original_value_data_len); |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_spinel_value_inserted(spinel_prop_key_t key, const uint8_t* value_data_ptr, spinel_size_t value_data_len) |
| { |
| if (key == SPINEL_PROP_IPV6_ADDRESS_TABLE) { |
| struct in6_addr *addr = NULL; |
| uint8_t prefix_len = 0; |
| uint32_t valid_lifetime = 0xFFFFFFFF; |
| uint32_t preferred_lifetime = 0xFFFFFFFF; |
| |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "6CLL", &addr, &prefix_len, &valid_lifetime, &preferred_lifetime); |
| |
| if (addr != NULL) { |
| if (!should_filter_address(*addr, prefix_len)) { |
| unicast_address_was_added(kOriginThreadNCP, *addr, prefix_len, valid_lifetime, preferred_lifetime); |
| } |
| } |
| |
| } else if (key == SPINEL_PROP_IPV6_MULTICAST_ADDRESS_TABLE) { |
| struct in6_addr *addr = NULL; |
| |
| spinel_datatype_unpack(value_data_ptr, value_data_len, "6", &addr); |
| |
| if ((addr != NULL) && !IN6_IS_ADDR_UNSPECIFIED(addr)) { |
| multicast_address_was_joined(kOriginThreadNCP, *addr); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_CHILD_TABLE) { |
| SpinelNCPTaskGetNetworkTopology::TableEntry child_entry; |
| int status; |
| |
| status = SpinelNCPTaskGetNetworkTopology::parse_child_entry(value_data_ptr, value_data_len, child_entry); |
| |
| if (status == kWPANTUNDStatus_Ok) { |
| syslog(LOG_INFO, "[-NCP-]: ChildTable entry added: %s", child_entry.get_as_string().c_str()); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_NEIGHBOR_TABLE) { |
| SpinelNCPTaskGetNetworkTopology::TableEntry neighbor_entry; |
| int status; |
| |
| status = SpinelNCPTaskGetNetworkTopology::parse_neighbor_entry(value_data_ptr, value_data_len, neighbor_entry); |
| |
| if (status == kWPANTUNDStatus_Ok) { |
| syslog(LOG_INFO, "[-NCP-]: Neighbor(Router) entry added: %s", neighbor_entry.get_as_string().c_str()); |
| } |
| |
| } else if (key == SPINEL_PROP_MESHCOP_COMMISSIONER_ENERGY_SCAN_RESULT) { |
| spinel_ssize_t len; |
| uint32_t channel_mask; |
| const uint8_t *energy_data = NULL; |
| unsigned int energy_data_len = 0; |
| ValueMap entry; |
| |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| ( |
| SPINEL_DATATYPE_UINT32_S |
| SPINEL_DATATYPE_DATA_WLEN_S |
| ), |
| &channel_mask, |
| &energy_data, |
| &energy_data_len |
| ); |
| |
| __ASSERT_MACROS_check(len > 0); |
| |
| entry[kWPANTUNDValueMapKey_CommrEnergyScanResult_ChannelMask] = channel_mask; |
| entry[kWPANTUNDValueMapKey_CommrEnergyScanResult_Data] = Data(energy_data, energy_data_len); |
| |
| if (mCommissionerEnergyScanResult.size() == kMaxCommissionerEnergyScanResultEntries) { |
| mCommissionerEnergyScanResult.pop_front(); |
| } |
| |
| mCommissionerEnergyScanResult.push_back(entry); |
| |
| } else if (key == SPINEL_PROP_MESHCOP_COMMISSIONER_PAN_ID_CONFLICT_RESULT) { |
| spinel_ssize_t len; |
| uint16_t panid; |
| uint32_t channel_mask; |
| ValueMap entry; |
| |
| len = spinel_datatype_unpack( |
| value_data_ptr, |
| value_data_len, |
| ( |
| SPINEL_DATATYPE_UINT16_S |
| SPINEL_DATATYPE_UINT32_S |
| ), |
| &panid, |
| &channel_mask |
| ); |
| |
| __ASSERT_MACROS_check(len > 0); |
| |
| entry[kWPANTUNDValueMapKey_CommrPanIdConflict_PanId] = panid; |
| entry[kWPANTUNDValueMapKey_CommrPanIdConflict_ChannelMask] = channel_mask; |
| |
| if (mCommissionerPanIdConflictResult.size() == kMaxCommissionerPanIdConflictResultEntries) { |
| mCommissionerPanIdConflictResult.pop_front(); |
| } |
| |
| mCommissionerPanIdConflictResult.push_back(entry); |
| } |
| |
| process_event(EVENT_NCP_PROP_VALUE_INSERTED, key, value_data_ptr, value_data_len); |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_spinel_value_removed(spinel_prop_key_t key, const uint8_t* value_data_ptr, spinel_size_t value_data_len) |
| { |
| if (key == SPINEL_PROP_THREAD_CHILD_TABLE) { |
| SpinelNCPTaskGetNetworkTopology::TableEntry child_entry; |
| int status; |
| |
| status = SpinelNCPTaskGetNetworkTopology::parse_child_entry(value_data_ptr, value_data_len, child_entry); |
| |
| if (status == kWPANTUNDStatus_Ok) { |
| syslog(LOG_INFO, "[-NCP-]: ChildTable entry removed: %s", child_entry.get_as_string().c_str()); |
| } |
| |
| } else if (key == SPINEL_PROP_THREAD_NEIGHBOR_TABLE) { |
| SpinelNCPTaskGetNetworkTopology::TableEntry neighbor_entry; |
| int status; |
| |
| status = SpinelNCPTaskGetNetworkTopology::parse_neighbor_entry(value_data_ptr, value_data_len, neighbor_entry); |
| |
| if (status == kWPANTUNDStatus_Ok) { |
| syslog(LOG_INFO, "[-NCP-]: Neighbor(Router) entry removed: %s", neighbor_entry.get_as_string().c_str()); |
| } |
| |
| } |
| |
| process_event(EVENT_NCP_PROP_VALUE_REMOVED, key, value_data_ptr, value_data_len); |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_state_change(NCPState new_ncp_state, NCPState old_ncp_state) |
| { |
| NCPInstanceBase::handle_ncp_state_change(new_ncp_state, old_ncp_state); |
| |
| if ( ncp_state_is_joining_or_joined(old_ncp_state) |
| && (new_ncp_state == OFFLINE) |
| ) { |
| // Mark this as false so that if we are actually doing |
| // a pcap right now it will force the details to be updated |
| // on the NCP at the next run through the main loop. This |
| // allows us to go back to promiscuous-mode sniffing at |
| // disconnect |
| mIsPcapInProgress = false; |
| } |
| |
| if (ncp_state_is_associated(new_ncp_state) |
| && !ncp_state_is_associated(old_ncp_state) |
| ) { |
| mIsCommissioned = true; |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, SPINEL_PROP_MAC_15_4_LADDR)) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, SPINEL_PROP_IPV6_ML_ADDR)) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, SPINEL_PROP_NET_XPANID)) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, SPINEL_PROP_MAC_15_4_PANID)) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, SPINEL_PROP_PHY_CHAN)) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, SPINEL_PROP_IPV6_ADDRESS_TABLE)) |
| .finish() |
| ); |
| } else if (ncp_state_is_joining(new_ncp_state) |
| && !ncp_state_is_joining(old_ncp_state) |
| ) { |
| if (!buffer_is_nonzero(mNCPV6Prefix, 8)) { |
| start_new_task(SpinelNCPTaskSendCommand::Factory(this) |
| .add_command(SpinelPackData(SPINEL_FRAME_PACK_CMD_PROP_VALUE_GET, SPINEL_PROP_IPV6_ML_PREFIX)) |
| .finish() |
| ); |
| } |
| } |
| } |
| |
| void |
| SpinelNCPInstance::handle_ncp_spinel_callback(unsigned int command, const uint8_t* cmd_data_ptr, spinel_size_t cmd_data_len) |
| { |
| switch (command) { |
| case SPINEL_CMD_PROP_VALUE_IS: |
| case SPINEL_CMD_PROP_VALUE_INSERTED: |
| case SPINEL_CMD_PROP_VALUE_REMOVED: |
| { |
| spinel_prop_key_t key = SPINEL_PROP_LAST_STATUS; |
| uint8_t* value_data_ptr = NULL; |
| spinel_size_t value_data_len = 0; |
| spinel_ssize_t ret; |
| |
| ret = spinel_datatype_unpack(cmd_data_ptr, cmd_data_len, "CiiD", NULL, NULL, &key, &value_data_ptr, &value_data_len); |
| |
| __ASSERT_MACROS_check(ret != -1); |
| |
| if (ret == -1) { |
| break; |
| } |
| |
| switch (command) { |
| case SPINEL_CMD_PROP_VALUE_IS: |
| handle_ncp_spinel_value_is(key, value_data_ptr, value_data_len); |
| break; |
| case SPINEL_CMD_PROP_VALUE_INSERTED: |
| handle_ncp_spinel_value_inserted(key, value_data_ptr, value_data_len); |
| break; |
| case SPINEL_CMD_PROP_VALUE_REMOVED: |
| handle_ncp_spinel_value_removed(key, value_data_ptr, value_data_len); |
| break; |
| } |
| } |
| break; |
| |
| default: |
| process_event(EVENT_NCP(command), cmd_data_ptr[0], cmd_data_ptr, cmd_data_len); |
| } |
| } |
| |
| bool |
| SpinelNCPInstance::should_filter_address(const struct in6_addr &addr, uint8_t prefix_len) |
| { |
| static const uint8_t service_aloc_start = 0x10; |
| static const uint8_t service_aloc_end = 0x2F; |
| static const uint8_t rloc_bytes[] = {0x00,0x00,0x00,0xFF,0xFE,0x00}; |
| bool should_filter = false; |
| |
| if (mFilterRLOCAddresses) { |
| // Filter RLOC link-local or mesh-local addresses |
| |
| if (0 == memcmp(rloc_bytes, addr.s6_addr + 8, sizeof(rloc_bytes))) { |
| if( addr.s6_addr[ 14 ] == 0xFC ) { |
| if (addr.s6_addr[15] < service_aloc_start || addr.s6_addr[15] > service_aloc_end) |
| { |
| should_filter = mFilterALOCAddresses; |
| } |
| } else { |
| if (IN6_IS_ADDR_LINKLOCAL(&addr)) { |
| should_filter = true; |
| } |
| |
| if (buffer_is_nonzero(mNCPV6Prefix, sizeof(mNCPV6Prefix)) |
| && (0 == memcmp(mNCPV6Prefix, &addr, sizeof(mNCPV6Prefix))) |
| ) { |
| should_filter = true; |
| } |
| } |
| } |
| } |
| |
| return should_filter; |
| } |
| |
| void |
| SpinelNCPInstance::filter_addresses(void) |
| { |
| std::map<struct in6_addr, UnicastAddressEntry> unicast_addresses(mUnicastAddresses); |
| std::map<struct in6_addr, UnicastAddressEntry>::iterator iter; |
| |
| // We create a copy of mUnicastAddress map to iterate over |
| // since `mUnicastAddresses` entries can be removed while |
| // we filter and remove addresses. |
| |
| for (iter = unicast_addresses.begin(); iter != unicast_addresses.end(); ++iter) { |
| if (!iter->second.is_from_ncp()) { |
| continue; |
| } |
| |
| if (should_filter_address(iter->first, iter->second.get_prefix_len())) { |
| unicast_address_was_removed(kOriginThreadNCP, iter->first); |
| } |
| } |
| } |
| |
| void |
| SpinelNCPInstance::add_unicast_address_on_ncp(const struct in6_addr &addr, uint8_t prefix_len, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Adding address \"%s/%d\" to NCP", in6_addr_to_string(addr).c_str(), prefix_len); |
| |
| factory.set_callback(cb); |
| |
| factory.add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT( |
| SPINEL_DATATYPE_IPv6ADDR_S // Address |
| SPINEL_DATATYPE_UINT8_S // Prefix Length |
| SPINEL_DATATYPE_UINT32_S // Valid Lifetime |
| SPINEL_DATATYPE_UINT32_S // Preferred Lifetime |
| ), |
| SPINEL_PROP_IPV6_ADDRESS_TABLE, |
| &addr, |
| prefix_len, |
| UINT32_MAX, |
| UINT32_MAX |
| ) |
| ); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| void |
| SpinelNCPInstance::remove_unicast_address_on_ncp(const struct in6_addr& addr, uint8_t prefix_len, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Removing address \"%s/%d\" from NCP", in6_addr_to_string(addr).c_str(), prefix_len); |
| |
| factory.set_callback(cb); |
| |
| factory.add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE( |
| SPINEL_DATATYPE_IPv6ADDR_S // Address |
| SPINEL_DATATYPE_UINT8_S // Prefix |
| ), |
| SPINEL_PROP_IPV6_ADDRESS_TABLE, |
| &addr, |
| prefix_len |
| ) |
| ); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| void |
| SpinelNCPInstance::add_multicast_address_on_ncp(const struct in6_addr &addr, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Adding multicast address \"%s\" to NCP", in6_addr_to_string(addr).c_str()); |
| |
| factory.set_callback(cb); |
| |
| factory.add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT( |
| SPINEL_DATATYPE_IPv6ADDR_S // Address |
| ), |
| SPINEL_PROP_IPV6_MULTICAST_ADDRESS_TABLE, |
| &addr |
| ) |
| ); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| void |
| SpinelNCPInstance::remove_multicast_address_on_ncp(const struct in6_addr &addr, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Removing multicast address \"%s\" from NCP", in6_addr_to_string(addr).c_str()); |
| |
| factory.set_callback(cb); |
| |
| factory.add_command( |
| SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE( |
| SPINEL_DATATYPE_IPv6ADDR_S // Address |
| ), |
| SPINEL_PROP_IPV6_MULTICAST_ADDRESS_TABLE, |
| &addr |
| ) |
| ); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| void |
| SpinelNCPInstance::add_service_on_ncp(uint32_t enterprise_number, const Data& service_data, bool stable, |
| const Data& server_data, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Adding service with enterprise number:%u to NCP", enterprise_number); |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_SERVICE) > 0) { |
| factory.set_lock_property(SPINEL_PROP_SERVER_ALLOW_LOCAL_DATA_CHANGE); |
| factory.set_callback(cb); |
| |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT( |
| SPINEL_DATATYPE_UINT32_S // Enterprise Number |
| SPINEL_DATATYPE_DATA_WLEN_S // Service Data |
| SPINEL_DATATYPE_BOOL_S // stable |
| SPINEL_DATATYPE_DATA_WLEN_S // Server Data |
| ), |
| SPINEL_PROP_SERVER_SERVICES, |
| enterprise_number, |
| service_data.data(), |
| service_data.size(), |
| stable, |
| server_data.data(), |
| server_data.size() |
| )); |
| |
| start_new_task(factory.finish()); |
| } else { |
| syslog(LOG_ERR, "%s capability not supported", spinel_capability_to_cstr(SPINEL_CAP_THREAD_SERVICE)); |
| cb(kWPANTUNDStatus_FeatureNotSupported); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::remove_service_on_ncp(uint32_t enterprise_number, const Data& service_data, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Removing service with enterprise number:%u from NCP", enterprise_number); |
| |
| if (mCapabilities.count(SPINEL_CAP_THREAD_SERVICE) > 0) { |
| factory.set_lock_property(SPINEL_PROP_SERVER_ALLOW_LOCAL_DATA_CHANGE); |
| factory.set_callback(cb); |
| |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE( |
| SPINEL_DATATYPE_UINT32_S // Enterprise Number |
| SPINEL_DATATYPE_DATA_WLEN_S // Service Data |
| ), |
| SPINEL_PROP_SERVER_SERVICES, |
| enterprise_number, |
| service_data.data(), |
| service_data.size() |
| )); |
| |
| start_new_task(factory.finish()); |
| } else { |
| syslog(LOG_ERR, "%s capability not supported", spinel_capability_to_cstr(SPINEL_CAP_THREAD_SERVICE)); |
| cb(kWPANTUNDStatus_FeatureNotSupported); |
| } |
| } |
| |
| void |
| SpinelNCPInstance::add_on_mesh_prefix_on_ncp(const struct in6_addr &prefix, uint8_t prefix_len, uint16_t flags, |
| bool stable, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Adding on-mesh prefix \"%s/%d\" to NCP", in6_addr_to_string(prefix).c_str(), prefix_len); |
| |
| factory.set_lock_property(SPINEL_PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE); |
| factory.set_callback(cb); |
| |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT( |
| SPINEL_DATATYPE_IPv6ADDR_S |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_BOOL_S |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_BOOL_S |
| SPINEL_DATATYPE_UINT16_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| SPINEL_PROP_THREAD_ON_MESH_NETS, |
| &prefix, |
| prefix_len, |
| stable, |
| flags & 0xff, |
| false, |
| 0, |
| (flags >> 8) & 0xff |
| )); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| void |
| SpinelNCPInstance::remove_on_mesh_prefix_on_ncp(const struct in6_addr &prefix, uint8_t prefix_len, uint16_t flags, |
| bool stable, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Removing on-mesh prefix \"%s/%d\" from NCP", in6_addr_to_string(prefix).c_str(), prefix_len); |
| |
| factory.set_lock_property(SPINEL_PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE); |
| factory.set_callback(cb); |
| |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE( |
| SPINEL_DATATYPE_IPv6ADDR_S |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_BOOL_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| SPINEL_PROP_THREAD_ON_MESH_NETS, |
| &prefix, |
| prefix_len, |
| stable, |
| flags & 0xff |
| )); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| void |
| SpinelNCPInstance::add_route_on_ncp(const struct in6_addr &route, uint8_t prefix_len, RoutePreference preference, |
| bool stable, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Adding off-mesh route \"%s/%d\" with preference %s to NCP", in6_addr_to_string(route).c_str(), |
| prefix_len, NCPControlInterface::external_route_priority_to_string(preference).c_str()); |
| |
| factory.set_lock_property(SPINEL_PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE); |
| factory.set_callback(cb); |
| |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_INSERT( |
| SPINEL_DATATYPE_IPv6ADDR_S |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_BOOL_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| SPINEL_PROP_THREAD_OFF_MESH_ROUTES, |
| &route, |
| prefix_len, |
| stable, |
| convert_route_preference_to_flags(preference) |
| )); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| void |
| SpinelNCPInstance::remove_route_on_ncp(const struct in6_addr &route, uint8_t prefix_len, RoutePreference preference, |
| bool stable, CallbackWithStatus cb) |
| { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| syslog(LOG_NOTICE, "Removing off-mesh route \"%s/%d\" with preference %s from NCP", in6_addr_to_string(route).c_str(), |
| prefix_len, NCPControlInterface::external_route_priority_to_string(preference).c_str()); |
| |
| factory.set_lock_property(SPINEL_PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE); |
| factory.set_callback(cb); |
| |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_REMOVE( |
| SPINEL_DATATYPE_IPv6ADDR_S |
| SPINEL_DATATYPE_UINT8_S |
| SPINEL_DATATYPE_BOOL_S |
| SPINEL_DATATYPE_UINT8_S |
| ), |
| SPINEL_PROP_THREAD_OFF_MESH_ROUTES, |
| &route, |
| prefix_len, |
| stable, |
| convert_route_preference_to_flags(preference) |
| )); |
| |
| start_new_task(factory.finish()); |
| } |
| |
| SpinelNCPInstance::RoutePreference |
| SpinelNCPInstance::convert_flags_to_route_preference(uint8_t flags) |
| { |
| RoutePreference preference = NCPControlInterface::ROUTE_MEDIUM_PREFERENCE; |
| |
| switch (flags & SPINEL_NET_FLAG_PREFERENCE_MASK) { |
| case SPINEL_ROUTE_PREFERENCE_HIGH: |
| preference = NCPControlInterface::ROUTE_HIGH_PREFERENCE; |
| break; |
| |
| case SPINEL_ROUTE_PREFERENCE_MEDIUM: |
| preference = NCPControlInterface::ROUTE_MEDIUM_PREFERENCE; |
| break; |
| |
| case SPINEL_ROUTE_PREFERENCE_LOW: |
| preference = NCPControlInterface::ROUTE_LOW_PREFRENCE; |
| break; |
| |
| default: |
| syslog(LOG_WARNING, "Invalid RoutePreference flag 0x%02x (using MEDIUM instead)", flags); |
| break; |
| } |
| |
| return preference; |
| } |
| |
| uint8_t |
| SpinelNCPInstance::convert_route_preference_to_flags(RoutePreference preference) |
| { |
| uint8_t flags = SPINEL_ROUTE_PREFERENCE_MEDIUM; |
| |
| switch (preference) { |
| case NCPControlInterface::ROUTE_HIGH_PREFERENCE: |
| flags = SPINEL_ROUTE_PREFERENCE_HIGH; |
| break; |
| |
| case NCPControlInterface::ROUTE_MEDIUM_PREFERENCE: |
| flags = SPINEL_ROUTE_PREFERENCE_MEDIUM; |
| break; |
| |
| case NCPControlInterface::ROUTE_LOW_PREFRENCE: |
| flags = SPINEL_ROUTE_PREFERENCE_LOW; |
| break; |
| } |
| |
| return flags; |
| } |
| |
| void |
| SpinelNCPInstance::log_spinel_frame(SpinelFrameOrigin origin, const uint8_t *frame_ptr, spinel_size_t frame_len) |
| { |
| int logmask = setlogmask(0); |
| |
| setlogmask(logmask); |
| |
| if (logmask & LOG_MASK(LOG_INFO)) { |
| std::string log; |
| uint8_t header = 0; |
| unsigned int command = 0; |
| const uint8_t *cmd_payload_ptr = NULL; |
| spinel_size_t cmd_payload_len = 0; |
| spinel_ssize_t read_len; |
| uint8_t tid; |
| const char *command_str; |
| const char *origin_str = (origin == kDriverToNCP) ? "[->NCP]" : "[NCP->]"; |
| |
| read_len = spinel_datatype_unpack(frame_ptr, frame_len, "CiD", &header, &command, &cmd_payload_ptr, |
| &cmd_payload_len); |
| require_quiet(read_len > 0, bail); |
| |
| tid = SPINEL_HEADER_GET_TID(header); |
| command_str = spinel_command_to_cstr(command); |
| |
| switch (command) { |
| case SPINEL_CMD_NOOP: |
| case SPINEL_CMD_RESET: |
| case SPINEL_CMD_NET_CLEAR: |
| syslog(LOG_INFO, "%s (%d) %s", origin_str, tid, command_str); |
| break; |
| |
| case SPINEL_CMD_PROP_VALUE_GET: |
| case SPINEL_CMD_PROP_VALUE_SET: |
| case SPINEL_CMD_PROP_VALUE_INSERT: |
| case SPINEL_CMD_PROP_VALUE_REMOVE: |
| case SPINEL_CMD_PROP_VALUE_IS: |
| case SPINEL_CMD_PROP_VALUE_INSERTED: |
| case SPINEL_CMD_PROP_VALUE_REMOVED: |
| { |
| spinel_prop_key_t prop_key = SPINEL_PROP_LAST_STATUS; |
| const uint8_t *value_ptr = NULL; |
| spinel_size_t value_len = 0; |
| const char *prop_str; |
| bool skip_value_dump = false; |
| char value_dump_str[2 * kWPANTUND_SpinelPropValueDumpLen + 1]; |
| |
| read_len = spinel_datatype_unpack(cmd_payload_ptr, cmd_payload_len, "iD", &prop_key, &value_ptr, |
| &value_len); |
| require_quiet(read_len > 0, bail); |
| |
| prop_str = spinel_prop_key_to_cstr(prop_key); |
| |
| switch (prop_key) { |
| case SPINEL_PROP_STREAM_DEBUG: // Handled by `handle_ncp_debug_stream()` |
| case SPINEL_PROP_STREAM_LOG: // Handled by `handle_ncp_log_stream()` |
| case SPINEL_PROP_STREAM_NET: // Handled by `handle_normal_ipv6_from_ncp() |
| case SPINEL_PROP_STREAM_NET_INSECURE: // Handled by `handle_normal_ipv6_from_ncp() |
| // Skip logging any of above properties |
| goto bail; |
| |
| case SPINEL_PROP_NET_MASTER_KEY: |
| case SPINEL_PROP_THREAD_ACTIVE_DATASET: |
| case SPINEL_PROP_THREAD_PENDING_DATASET: |
| case SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING: |
| case SPINEL_PROP_NET_PSKC: |
| case SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS: |
| // Hide the value by skipping value dump |
| skip_value_dump = true; |
| break; |
| |
| default: |
| skip_value_dump = false; |
| encode_data_into_string(value_ptr, value_len, value_dump_str, sizeof(value_dump_str), 0); |
| break; |
| } |
| |
| if (command == SPINEL_CMD_PROP_VALUE_GET) { |
| syslog(LOG_INFO, "%s (%d) %s(%s)", origin_str, tid, command_str, prop_str); |
| } else { |
| syslog(LOG_INFO, "%s (%d) %s(%s) [%s%s]", origin_str, tid, command_str, prop_str, |
| skip_value_dump ? "-- value hidden --" : value_dump_str, |
| skip_value_dump || (value_len <= kWPANTUND_SpinelPropValueDumpLen) ? "" : "..."); |
| } |
| } |
| break; |
| |
| case SPINEL_CMD_PEEK: |
| case SPINEL_CMD_POKE: |
| case SPINEL_CMD_PEEK_RET: |
| { |
| uint32_t address = 0; |
| uint16_t count = 0; |
| read_len = spinel_datatype_unpack(cmd_payload_ptr, cmd_payload_len, "LS", &address, &count); |
| require_quiet(read_len > 0, bail); |
| syslog(LOG_INFO, "%s (%d) %s(0x%x, %d)", origin_str, tid, command_str, address, count); |
| } |
| break; |
| |
| default: |
| syslog(LOG_INFO, "%s (%d) %s(cmd_id:%d)", origin_str, tid, command_str, command); |
| break; |
| } |
| } |
| |
| bail: |
| return; |
| } |
| |
| bool |
| SpinelNCPInstance::is_busy(void) |
| { |
| return NCPInstanceBase::is_busy() |
| || !mTaskQueue.empty(); |
| } |
| |
| void |
| SpinelNCPInstance::process(void) |
| { |
| NCPInstanceBase::process(); |
| |
| mVendorCustom.process(); |
| |
| if (!is_initializing_ncp() && mTaskQueue.empty()) { |
| bool x = mPcapManager.is_enabled(); |
| |
| if (mIsPcapInProgress != x) { |
| SpinelNCPTaskSendCommand::Factory factory(this); |
| |
| mIsPcapInProgress = x; |
| |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_BOOL_S), |
| SPINEL_PROP_MAC_RAW_STREAM_ENABLED, |
| mIsPcapInProgress |
| )); |
| |
| if (mIsPcapInProgress) { |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_BOOL_S), |
| SPINEL_PROP_NET_IF_UP, |
| true |
| )); |
| if (!ncp_state_is_joining_or_joined(get_ncp_state())) { |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_UINT8_S), |
| SPINEL_PROP_MAC_PROMISCUOUS_MODE, |
| SPINEL_MAC_PROMISCUOUS_MODE_FULL |
| )); |
| } |
| } else { |
| factory.add_command(SpinelPackData( |
| SPINEL_FRAME_PACK_CMD_PROP_VALUE_SET(SPINEL_DATATYPE_UINT8_S), |
| SPINEL_PROP_MAC_PROMISCUOUS_MODE, |
| SPINEL_MAC_PROMISCUOUS_MODE_OFF |
| )); |
| } |
| |
| start_new_task(factory.finish()); |
| NCPInstanceBase::process(); |
| } |
| } |
| } |
