| /* |
| * Copyright (c) 2016, The OpenThread Authors. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the |
| * names of its contributors may be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** |
| * @file |
| * This file contains definitions a spinel interface to the OpenThread stack. |
| */ |
| |
| #ifndef NCP_BASE_HPP_ |
| #define NCP_BASE_HPP_ |
| |
| #include <openthread/config.h> |
| |
| #include <openthread/ip6.h> |
| #include <openthread/message.h> |
| #include <openthread/ncp.h> |
| #include <openthread/types.h> |
| |
| #include "openthread-core-config.h" |
| #include "spinel.h" |
| #include "common/tasklet.hpp" |
| #include "ncp/ncp_buffer.hpp" |
| |
| namespace ot { |
| |
| #define NCP_COMMAND_HANDLER(name) \ |
| otError CommandHandler_##name( \ |
| uint8_t aHeader, \ |
| unsigned int aCommand, \ |
| const uint8_t *aArgPtr, \ |
| uint16_t aArgLen \ |
| ) |
| |
| |
| #define NCP_GET_PROP_HANDLER(name) \ |
| otError GetPropertyHandler_##name( \ |
| uint8_t aHeader, \ |
| spinel_prop_key_t aKey \ |
| ) |
| |
| #define NCP_SET_PROP_HANDLER(name) \ |
| otError SetPropertyHandler_##name( \ |
| uint8_t aHeader, \ |
| spinel_prop_key_t aKey, \ |
| const uint8_t *aValuePtr, \ |
| uint16_t aValueLen \ |
| ) |
| |
| #define NCP_INSERT_PROP_HANDLER(name) \ |
| otError InsertPropertyHandler_##name( \ |
| uint8_t aHeader, \ |
| spinel_prop_key_t aKey, \ |
| const uint8_t *aValuePtr, \ |
| uint16_t aValueLen \ |
| ) |
| |
| #define NCP_REMOVE_PROP_HANDLER(name) \ |
| otError RemovePropertyHandler_##name( \ |
| uint8_t aHeader, \ |
| spinel_prop_key_t aKey, \ |
| const uint8_t *aValuePtr, \ |
| uint16_t aValueLen \ |
| ) |
| |
| class NcpBase |
| { |
| public: |
| |
| /** |
| * This constructor creates and initializes an NcpBase instance. |
| * |
| * @param[in] aInstance The OpenThread instance structure. |
| * |
| */ |
| NcpBase(otInstance *aInstance); |
| |
| /** |
| * This static method returns the pointer to the single NCP instance. |
| * |
| @returns Pointer to the single NCP instance. |
| * |
| */ |
| static NcpBase *GetNcpInstance(void); |
| |
| protected: |
| |
| /** |
| * This method is called to start a new outbound frame. |
| * |
| * @retval OT_ERROR_NONE Successfully started a new frame. |
| * @retval OT_ERROR_NO_BUFS Insufficient buffer space available to start a new frame. |
| * |
| */ |
| otError OutboundFrameBegin(void); |
| |
| /** |
| * This method adds data to the current outbound frame being written. |
| * |
| * If no buffer space is available, this method should discard and clear the frame before returning an error status. |
| * |
| * @param[in] aDataBuffer A pointer to data buffer. |
| * @param[in] aDataBufferLength The length of the data buffer. |
| * |
| * @retval OT_ERROR_NONE Successfully added new data to the frame. |
| * @retval OT_ERROR_NO_BUFS Insufficient buffer space available to add data. |
| * |
| */ |
| otError OutboundFrameFeedData(const uint8_t *aDataBuffer, uint16_t aDataBufferLength); |
| |
| /** |
| * This method adds a message to the current outbound frame being written. |
| * |
| * If no buffer space is available, this method should discard and clear the frame before returning an error status. |
| * In case of success, the passed-in message @aMessage should be owned by outbound buffer and should be freed |
| * when either the the frame is successfully sent and removed or if the frame is discarded. |
| * |
| * @param[in] aMessage A reference to the message to be added to current frame. |
| * |
| * @retval OT_ERROR_NONE Successfully added the message to the frame. |
| * @retval OT_ERROR_NO_BUFS Insufficient buffer space available to add message. |
| * |
| */ |
| otError OutboundFrameFeedMessage(otMessage *aMessage); |
| |
| /** |
| * This method finalizes and sends the current outbound frame |
| * |
| * If no buffer space is available, this method should discard and clear the frame before returning an error status. |
| * |
| * @retval OT_ERROR_NONE Successfully added the message to the frame. |
| * @retval OT_ERROR_NO_BUFS Insufficient buffer space available to add message. |
| * |
| */ |
| otError OutboundFrameEnd(void); |
| |
| /** |
| * This method is called by the framer whenever a framing error |
| * is detected. |
| */ |
| void IncrementFrameErrorCounter(void); |
| |
| protected: |
| |
| /** |
| * Called by the subclass to indicate when a frame has been received. |
| */ |
| void HandleReceive(const uint8_t *aBuf, uint16_t aBufLength); |
| |
| /** |
| * Called by the subclass to learn when the host wake operation must be issued. |
| */ |
| bool ShouldWakeHost(void); |
| |
| /** |
| * Called by the subclass to learn when the transfer to the host should be deferred. |
| */ |
| bool ShouldDeferHostSend(void); |
| |
| private: |
| |
| otError OutboundFrameSend(void); |
| |
| NcpFrameBuffer::FrameTag GetLastOutboundFrameTag(void); |
| |
| #if OPENTHREAD_ENABLE_TMF_PROXY && OPENTHREAD_FTD |
| static void HandleTmfProxyStream(otMessage *aMessage, uint16_t aLocator, uint16_t aPort, void *aContext); |
| void HandleTmfProxyStream(otMessage *aMessage, uint16_t aLocator, uint16_t aPort); |
| #endif // OPENTHREAD_ENABLE_TMF_PROXY && OPENTHREAD_FTD |
| |
| static void HandleFrameRemovedFromNcpBuffer(void *aContext, NcpFrameBuffer::FrameTag aFrameTag, |
| NcpFrameBuffer *aNcpBuffer); |
| void HandleFrameRemovedFromNcpBuffer(NcpFrameBuffer::FrameTag aFrameTag); |
| |
| static void HandleDatagramFromStack(otMessage *aMessage, void *aContext); |
| void HandleDatagramFromStack(otMessage *aMessage); |
| |
| static void HandleRawFrame(const otRadioFrame *aFrame, void *aContext); |
| void HandleRawFrame(const otRadioFrame *aFrame); |
| |
| static void HandleActiveScanResult_Jump(otActiveScanResult *aResult, void *aContext); |
| void HandleActiveScanResult(otActiveScanResult *aResult); |
| |
| static void HandleEnergyScanResult_Jump(otEnergyScanResult *aResult, void *aContext); |
| void HandleEnergyScanResult(otEnergyScanResult *aResult); |
| |
| static void HandleJamStateChange_Jump(bool aJamState, void *aContext); |
| void HandleJamStateChange(bool aJamState); |
| |
| static void UpdateChangedProps(Tasklet &aTasklet); |
| void UpdateChangedProps(void); |
| |
| static void SendDoneTask(void *aContext); |
| void SendDoneTask(void); |
| |
| #if OPENTHREAD_ENABLE_RAW_LINK_API |
| |
| static void LinkRawReceiveDone(otInstance *aInstance, otRadioFrame *aFrame, otError aError); |
| void LinkRawReceiveDone(otRadioFrame *aFrame, otError aError); |
| |
| static void LinkRawTransmitDone(otInstance *aInstance, otRadioFrame *aFrame, bool aFramePending, otError aError); |
| void LinkRawTransmitDone(otRadioFrame *aFrame, bool aFramePending, otError aError); |
| |
| static void LinkRawEnergyScanDone(otInstance *aInstance, int8_t aEnergyScanMaxRssi); |
| void LinkRawEnergyScanDone(int8_t aEnergyScanMaxRssi); |
| |
| #endif // OPENTHREAD_ENABLE_RAW_LINK_API |
| |
| static void HandleNetifStateChanged(uint32_t aFlags, void *aContext); |
| |
| private: |
| |
| otError OutboundFrameFeedPacked(const char *aPackFormat, ...); |
| |
| otError OutboundFrameFeedVPacked(const char *aPackFormat, va_list aArgs); |
| |
| private: |
| |
| otError HandleCommand(uint8_t aHeader, unsigned int aCommand, const uint8_t *aArgPtr, uint16_t aArgLen); |
| |
| otError HandleCommandPropertyGet(uint8_t aHeader, spinel_prop_key_t aKey); |
| |
| otError HandleCommandPropertySet(uint8_t aHeader, spinel_prop_key_t aKey, const uint8_t *aValuePtr, |
| uint16_t aValueLen); |
| |
| otError HandleCommandPropertyInsert(uint8_t aHeader, spinel_prop_key_t aKey, const uint8_t *aValuePtr, |
| uint16_t aValueLen); |
| |
| otError HandleCommandPropertyRemove(uint8_t aHeader, spinel_prop_key_t aKey, const uint8_t *aValuePtr, |
| uint16_t aValueLen); |
| |
| otError SendLastStatus(uint8_t aHeader, spinel_status_t aLastStatus); |
| |
| otError GetPropertyHandler_ChannelMaskHelper(uint8_t aHeader, spinel_prop_key_t aKey, uint32_t channel_mask); |
| |
| private: |
| |
| otError SendPropertyUpdate(uint8_t aHeader, uint8_t aCommand, spinel_prop_key_t aKey, const uint8_t *aValuePtr, |
| uint16_t aValueLen); |
| |
| otError SendPropertyUpdate(uint8_t aHeader, uint8_t aCommand, spinel_prop_key_t aKey, otMessage *message); |
| |
| otError SendPropertyUpdate(uint8_t aHeader, uint8_t aCommand, spinel_prop_key_t aKey, const char *format, ...); |
| |
| otError SendSetPropertyResponse(uint8_t aHeader, spinel_prop_key_t aKey, otError aError); |
| |
| private: |
| |
| typedef otError(NcpBase::*CommandHandlerType)(uint8_t aHeader, unsigned int aCommand, const uint8_t *aArgPtr, |
| uint16_t aArgLen); |
| |
| typedef otError(NcpBase::*GetPropertyHandlerType)(uint8_t aHeader, spinel_prop_key_t aKey); |
| |
| typedef otError(NcpBase::*SetPropertyHandlerType)(uint8_t aHeader, spinel_prop_key_t aKey, |
| const uint8_t *aValuePtr, uint16_t aValueLen); |
| |
| struct CommandHandlerEntry |
| { |
| spinel_cid_t mCommand; |
| CommandHandlerType mHandler; |
| }; |
| |
| struct GetPropertyHandlerEntry |
| { |
| spinel_prop_key_t mPropKey; |
| GetPropertyHandlerType mHandler; |
| }; |
| |
| struct SetPropertyHandlerEntry |
| { |
| spinel_prop_key_t mPropKey; |
| SetPropertyHandlerType mHandler; |
| }; |
| |
| struct InsertPropertyHandlerEntry |
| { |
| spinel_prop_key_t mPropKey; |
| SetPropertyHandlerType mHandler; |
| }; |
| |
| struct RemovePropertyHandlerEntry |
| { |
| spinel_prop_key_t mPropKey; |
| SetPropertyHandlerType mHandler; |
| }; |
| |
| static const CommandHandlerEntry mCommandHandlerTable[]; |
| static const GetPropertyHandlerEntry mGetPropertyHandlerTable[]; |
| static const SetPropertyHandlerEntry mSetPropertyHandlerTable[]; |
| static const InsertPropertyHandlerEntry mInsertPropertyHandlerTable[]; |
| static const RemovePropertyHandlerEntry mRemovePropertyHandlerTable[]; |
| |
| // Command Handlers |
| |
| NCP_COMMAND_HANDLER(NOOP); |
| NCP_COMMAND_HANDLER(RESET); |
| NCP_COMMAND_HANDLER(PROP_VALUE_GET); |
| NCP_COMMAND_HANDLER(PROP_VALUE_SET); |
| NCP_COMMAND_HANDLER(PROP_VALUE_INSERT); |
| NCP_COMMAND_HANDLER(PROP_VALUE_REMOVE); |
| NCP_COMMAND_HANDLER(NET_SAVE); |
| NCP_COMMAND_HANDLER(NET_CLEAR); |
| NCP_COMMAND_HANDLER(NET_RECALL); |
| #if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE |
| NCP_COMMAND_HANDLER(PEEK); |
| NCP_COMMAND_HANDLER(POKE); |
| #endif |
| |
| // Property Get Handlers |
| |
| NCP_GET_PROP_HANDLER(LAST_STATUS); |
| NCP_GET_PROP_HANDLER(PROTOCOL_VERSION); |
| NCP_GET_PROP_HANDLER(INTERFACE_TYPE); |
| NCP_GET_PROP_HANDLER(VENDOR_ID); |
| NCP_GET_PROP_HANDLER(CAPS); |
| NCP_GET_PROP_HANDLER(NCP_VERSION); |
| NCP_GET_PROP_HANDLER(INTERFACE_COUNT); |
| NCP_GET_PROP_HANDLER(POWER_STATE); |
| NCP_GET_PROP_HANDLER(HWADDR); |
| NCP_GET_PROP_HANDLER(LOCK); |
| NCP_GET_PROP_HANDLER(HOST_POWER_STATE); |
| NCP_GET_PROP_HANDLER(PHY_ENABLED); |
| NCP_GET_PROP_HANDLER(PHY_FREQ); |
| NCP_GET_PROP_HANDLER(PHY_CHAN_SUPPORTED); |
| NCP_GET_PROP_HANDLER(PHY_CHAN); |
| NCP_GET_PROP_HANDLER(PHY_RSSI); |
| NCP_GET_PROP_HANDLER(PHY_TX_POWER); |
| NCP_GET_PROP_HANDLER(PHY_RX_SENSITIVITY); |
| NCP_GET_PROP_HANDLER(MAC_SCAN_STATE); |
| NCP_GET_PROP_HANDLER(MAC_15_4_PANID); |
| NCP_GET_PROP_HANDLER(MAC_15_4_LADDR); |
| NCP_GET_PROP_HANDLER(MAC_15_4_SADDR); |
| NCP_GET_PROP_HANDLER(MAC_RAW_STREAM_ENABLED); |
| NCP_GET_PROP_HANDLER(MAC_EXTENDED_ADDR); |
| NCP_GET_PROP_HANDLER(MAC_DATA_POLL_PERIOD); |
| NCP_GET_PROP_HANDLER(NET_SAVED); |
| NCP_GET_PROP_HANDLER(NET_IF_UP); |
| NCP_GET_PROP_HANDLER(NET_STACK_UP); |
| NCP_GET_PROP_HANDLER(NET_ROLE); |
| NCP_GET_PROP_HANDLER(NET_NETWORK_NAME); |
| NCP_GET_PROP_HANDLER(NET_XPANID); |
| NCP_GET_PROP_HANDLER(NET_MASTER_KEY); |
| NCP_GET_PROP_HANDLER(NET_KEY_SEQUENCE_COUNTER); |
| NCP_GET_PROP_HANDLER(NET_PARTITION_ID); |
| NCP_GET_PROP_HANDLER(NET_KEY_SWITCH_GUARDTIME); |
| NCP_GET_PROP_HANDLER(THREAD_LEADER); |
| NCP_GET_PROP_HANDLER(IPV6_ML_PREFIX); |
| NCP_GET_PROP_HANDLER(IPV6_ML_ADDR); |
| NCP_GET_PROP_HANDLER(IPV6_LL_ADDR); |
| NCP_GET_PROP_HANDLER(IPV6_ADDRESS_TABLE); |
| NCP_GET_PROP_HANDLER(IPV6_ROUTE_TABLE); |
| NCP_GET_PROP_HANDLER(IPV6_ICMP_PING_OFFLOAD); |
| NCP_GET_PROP_HANDLER(THREAD_RLOC16_DEBUG_PASSTHRU); |
| NCP_GET_PROP_HANDLER(THREAD_OFF_MESH_ROUTES); |
| NCP_GET_PROP_HANDLER(STREAM_NET); |
| NCP_GET_PROP_HANDLER(MAC_SCAN_MASK); |
| NCP_GET_PROP_HANDLER(MAC_SCAN_PERIOD); |
| NCP_GET_PROP_HANDLER(THREAD_LEADER_ADDR); |
| NCP_GET_PROP_HANDLER(THREAD_PARENT); |
| NCP_GET_PROP_HANDLER(THREAD_NEIGHBOR_TABLE); |
| NCP_GET_PROP_HANDLER(THREAD_LEADER_RID); |
| NCP_GET_PROP_HANDLER(THREAD_LEADER_WEIGHT); |
| #if OPENTHREAD_ENABLE_BORDER_ROUTER |
| NCP_GET_PROP_HANDLER(THREAD_NETWORK_DATA); |
| NCP_GET_PROP_HANDLER(THREAD_STABLE_NETWORK_DATA); |
| #endif |
| NCP_GET_PROP_HANDLER(THREAD_NETWORK_DATA_VERSION); |
| NCP_GET_PROP_HANDLER(THREAD_STABLE_NETWORK_DATA_VERSION); |
| NCP_GET_PROP_HANDLER(THREAD_LEADER_NETWORK_DATA); |
| NCP_GET_PROP_HANDLER(THREAD_STABLE_LEADER_NETWORK_DATA); |
| NCP_GET_PROP_HANDLER(MAC_PROMISCUOUS_MODE); |
| NCP_GET_PROP_HANDLER(THREAD_ASSISTING_PORTS); |
| NCP_GET_PROP_HANDLER(THREAD_ALLOW_LOCAL_NET_DATA_CHANGE); |
| NCP_GET_PROP_HANDLER(MAC_CNTR); |
| NCP_GET_PROP_HANDLER(NCP_CNTR); |
| NCP_GET_PROP_HANDLER(IP_CNTR); |
| NCP_GET_PROP_HANDLER(MSG_BUFFER_COUNTERS); |
| #if OPENTHREAD_ENABLE_MAC_WHITELIST |
| NCP_GET_PROP_HANDLER(MAC_WHITELIST); |
| NCP_GET_PROP_HANDLER(MAC_WHITELIST_ENABLED); |
| NCP_GET_PROP_HANDLER(MAC_BLACKLIST); |
| NCP_GET_PROP_HANDLER(MAC_BLACKLIST_ENABLED); |
| #endif |
| NCP_GET_PROP_HANDLER(THREAD_MODE); |
| NCP_GET_PROP_HANDLER(THREAD_CHILD_TIMEOUT); |
| NCP_GET_PROP_HANDLER(THREAD_RLOC16); |
| NCP_GET_PROP_HANDLER(THREAD_ON_MESH_NETS); |
| NCP_GET_PROP_HANDLER(NET_REQUIRE_JOIN_EXISTING); |
| NCP_GET_PROP_HANDLER(DEBUG_TEST_ASSERT); |
| NCP_GET_PROP_HANDLER(DEBUG_NCP_LOG_LEVEL); |
| NCP_GET_PROP_HANDLER(THREAD_DISCOVERY_SCAN_JOINER_FLAG); |
| NCP_GET_PROP_HANDLER(THREAD_DISCOVERY_SCAN_ENABLE_FILTERING); |
| NCP_GET_PROP_HANDLER(THREAD_DISCOVERY_SCAN_PANID); |
| #if OPENTHREAD_FTD |
| NCP_GET_PROP_HANDLER(THREAD_CHILD_TABLE); |
| NCP_GET_PROP_HANDLER(THREAD_LOCAL_LEADER_WEIGHT); |
| NCP_GET_PROP_HANDLER(THREAD_ROUTER_ROLE_ENABLED); |
| NCP_GET_PROP_HANDLER(NET_PSKC); |
| NCP_GET_PROP_HANDLER(THREAD_CHILD_COUNT_MAX); |
| NCP_GET_PROP_HANDLER(THREAD_ROUTER_UPGRADE_THRESHOLD); |
| NCP_GET_PROP_HANDLER(THREAD_ROUTER_DOWNGRADE_THRESHOLD); |
| NCP_GET_PROP_HANDLER(THREAD_ROUTER_SELECTION_JITTER); |
| NCP_GET_PROP_HANDLER(THREAD_CONTEXT_REUSE_DELAY); |
| NCP_GET_PROP_HANDLER(THREAD_NETWORK_ID_TIMEOUT); |
| #endif // #if OPENTHREAD_FTD |
| #if OPENTHREAD_ENABLE_COMMISSIONER |
| NCP_GET_PROP_HANDLER(THREAD_COMMISSIONER_ENABLED); |
| #endif |
| NCP_GET_PROP_HANDLER(THREAD_TMF_PROXY_ENABLED); |
| #if OPENTHREAD_ENABLE_JAM_DETECTION |
| NCP_GET_PROP_HANDLER(JAM_DETECT_ENABLE); |
| NCP_GET_PROP_HANDLER(JAM_DETECTED); |
| NCP_GET_PROP_HANDLER(JAM_DETECT_RSSI_THRESHOLD); |
| NCP_GET_PROP_HANDLER(JAM_DETECT_WINDOW); |
| NCP_GET_PROP_HANDLER(JAM_DETECT_BUSY); |
| NCP_GET_PROP_HANDLER(JAM_DETECT_HISTORY_BITMAP); |
| #endif |
| #if OPENTHREAD_ENABLE_LEGACY |
| NCP_GET_PROP_HANDLER(NEST_LEGACY_ULA_PREFIX); |
| #endif |
| |
| // Property Set Handlers |
| |
| NCP_SET_PROP_HANDLER(POWER_STATE); |
| NCP_SET_PROP_HANDLER(HOST_POWER_STATE); |
| NCP_SET_PROP_HANDLER(PHY_TX_POWER); |
| NCP_SET_PROP_HANDLER(PHY_CHAN); |
| NCP_SET_PROP_HANDLER(MAC_SCAN_MASK); |
| NCP_SET_PROP_HANDLER(MAC_SCAN_STATE); |
| NCP_SET_PROP_HANDLER(MAC_15_4_PANID); |
| NCP_SET_PROP_HANDLER(MAC_15_4_LADDR); |
| NCP_SET_PROP_HANDLER(MAC_DATA_POLL_PERIOD); |
| NCP_SET_PROP_HANDLER(MAC_RAW_STREAM_ENABLED); |
| #if OPENTHREAD_ENABLE_RAW_LINK_API |
| NCP_SET_PROP_HANDLER(MAC_15_4_SADDR); |
| NCP_SET_PROP_HANDLER(STREAM_RAW); |
| #endif |
| NCP_SET_PROP_HANDLER(NET_IF_UP); |
| NCP_SET_PROP_HANDLER(NET_STACK_UP); |
| NCP_SET_PROP_HANDLER(NET_ROLE); |
| NCP_SET_PROP_HANDLER(NET_NETWORK_NAME); |
| NCP_SET_PROP_HANDLER(NET_XPANID); |
| NCP_SET_PROP_HANDLER(NET_MASTER_KEY); |
| NCP_SET_PROP_HANDLER(NET_KEY_SEQUENCE_COUNTER); |
| NCP_SET_PROP_HANDLER(NET_KEY_SWITCH_GUARDTIME); |
| NCP_SET_PROP_HANDLER(STREAM_NET_INSECURE); |
| NCP_SET_PROP_HANDLER(STREAM_NET); |
| NCP_SET_PROP_HANDLER(IPV6_ML_PREFIX); |
| NCP_SET_PROP_HANDLER(IPV6_ICMP_PING_OFFLOAD); |
| NCP_SET_PROP_HANDLER(THREAD_RLOC16_DEBUG_PASSTHRU); |
| NCP_SET_PROP_HANDLER(THREAD_TMF_PROXY_STREAM); |
| #if OPENTHREAD_ENABLE_RAW_LINK_API |
| NCP_SET_PROP_HANDLER(PHY_ENABLED); |
| #endif |
| NCP_SET_PROP_HANDLER(MAC_PROMISCUOUS_MODE); |
| NCP_SET_PROP_HANDLER(MAC_SCAN_PERIOD); |
| #if OPENTHREAD_ENABLE_MAC_WHITELIST |
| NCP_SET_PROP_HANDLER(MAC_WHITELIST); |
| NCP_SET_PROP_HANDLER(MAC_WHITELIST_ENABLED); |
| NCP_SET_PROP_HANDLER(MAC_BLACKLIST); |
| NCP_SET_PROP_HANDLER(MAC_BLACKLIST_ENABLED); |
| #endif |
| #if OPENTHREAD_ENABLE_RAW_LINK_API |
| NCP_SET_PROP_HANDLER(MAC_SRC_MATCH_ENABLED); |
| NCP_SET_PROP_HANDLER(MAC_SRC_MATCH_SHORT_ADDRESSES); |
| NCP_SET_PROP_HANDLER(MAC_SRC_MATCH_EXTENDED_ADDRESSES); |
| #endif |
| NCP_SET_PROP_HANDLER(THREAD_MODE); |
| #if OPENTHREAD_ENABLE_BORDER_ROUTER |
| NCP_SET_PROP_HANDLER(THREAD_ALLOW_LOCAL_NET_DATA_CHANGE); |
| #endif |
| #if OPENTHREAD_FTD |
| NCP_SET_PROP_HANDLER(NET_PSKC); |
| NCP_SET_PROP_HANDLER(THREAD_LOCAL_LEADER_WEIGHT); |
| NCP_SET_PROP_HANDLER(THREAD_CHILD_COUNT_MAX); |
| NCP_SET_PROP_HANDLER(THREAD_CHILD_TIMEOUT); |
| NCP_SET_PROP_HANDLER(THREAD_ROUTER_UPGRADE_THRESHOLD); |
| NCP_SET_PROP_HANDLER(THREAD_ROUTER_DOWNGRADE_THRESHOLD); |
| NCP_SET_PROP_HANDLER(THREAD_ROUTER_SELECTION_JITTER); |
| NCP_SET_PROP_HANDLER(THREAD_CONTEXT_REUSE_DELAY); |
| NCP_SET_PROP_HANDLER(THREAD_NETWORK_ID_TIMEOUT); |
| NCP_SET_PROP_HANDLER(THREAD_PREFERRED_ROUTER_ID); |
| NCP_SET_PROP_HANDLER(THREAD_ROUTER_ROLE_ENABLED); |
| #if OPENTHREAD_CONFIG_ENABLE_STEERING_DATA_SET_OOB |
| NCP_SET_PROP_HANDLER(THREAD_STEERING_DATA); |
| #endif |
| #endif // #if OPENTHREAD_FTD |
| NCP_SET_PROP_HANDLER(THREAD_DISCOVERY_SCAN_JOINER_FLAG); |
| NCP_SET_PROP_HANDLER(THREAD_DISCOVERY_SCAN_ENABLE_FILTERING); |
| NCP_SET_PROP_HANDLER(THREAD_DISCOVERY_SCAN_PANID); |
| NCP_SET_PROP_HANDLER(THREAD_ASSISTING_PORTS); |
| NCP_SET_PROP_HANDLER(NET_REQUIRE_JOIN_EXISTING); |
| NCP_SET_PROP_HANDLER(CNTR_RESET); |
| NCP_SET_PROP_HANDLER(DEBUG_NCP_LOG_LEVEL); |
| #if OPENTHREAD_ENABLE_COMMISSIONER |
| NCP_SET_PROP_HANDLER(THREAD_COMMISSIONER_ENABLED); |
| #endif |
| NCP_SET_PROP_HANDLER(THREAD_TMF_PROXY_ENABLED); |
| #if OPENTHREAD_ENABLE_JAM_DETECTION |
| NCP_SET_PROP_HANDLER(JAM_DETECT_ENABLE); |
| NCP_SET_PROP_HANDLER(JAM_DETECT_RSSI_THRESHOLD); |
| NCP_SET_PROP_HANDLER(JAM_DETECT_WINDOW); |
| NCP_SET_PROP_HANDLER(JAM_DETECT_BUSY); |
| #endif |
| #if OPENTHREAD_ENABLE_DIAG |
| NCP_SET_PROP_HANDLER(NEST_STREAM_MFG); |
| #endif |
| #if OPENTHREAD_ENABLE_LEGACY |
| NCP_SET_PROP_HANDLER(NEST_LEGACY_ULA_PREFIX); |
| #endif |
| |
| // Property Insert Handlers |
| |
| #if OPENTHREAD_ENABLE_RAW_LINK_API |
| NCP_INSERT_PROP_HANDLER(MAC_SRC_MATCH_SHORT_ADDRESSES); |
| NCP_INSERT_PROP_HANDLER(MAC_SRC_MATCH_EXTENDED_ADDRESSES); |
| #endif |
| NCP_INSERT_PROP_HANDLER(IPV6_ADDRESS_TABLE); |
| #if OPENTHREAD_ENABLE_BORDER_ROUTER |
| NCP_INSERT_PROP_HANDLER(THREAD_OFF_MESH_ROUTES); |
| NCP_INSERT_PROP_HANDLER(THREAD_ON_MESH_NETS); |
| #endif |
| NCP_INSERT_PROP_HANDLER(THREAD_ASSISTING_PORTS); |
| #if OPENTHREAD_ENABLE_MAC_WHITELIST |
| NCP_INSERT_PROP_HANDLER(MAC_WHITELIST); |
| NCP_INSERT_PROP_HANDLER(MAC_BLACKLIST); |
| #endif |
| #if OPENTHREAD_ENABLE_COMMISSIONER |
| NCP_INSERT_PROP_HANDLER(THREAD_JOINERS); |
| #endif |
| |
| // Property Remove Handlers |
| |
| #if OPENTHREAD_ENABLE_RAW_LINK_API |
| NCP_REMOVE_PROP_HANDLER(MAC_SRC_MATCH_SHORT_ADDRESSES); |
| NCP_REMOVE_PROP_HANDLER(MAC_SRC_MATCH_EXTENDED_ADDRESSES); |
| #endif |
| NCP_REMOVE_PROP_HANDLER(IPV6_ADDRESS_TABLE); |
| #if OPENTHREAD_ENABLE_BORDER_ROUTER |
| NCP_REMOVE_PROP_HANDLER(THREAD_OFF_MESH_ROUTES); |
| NCP_REMOVE_PROP_HANDLER(THREAD_ON_MESH_NETS); |
| #endif |
| NCP_REMOVE_PROP_HANDLER(THREAD_ASSISTING_PORTS); |
| #if OPENTHREAD_ENABLE_MAC_WHITELIST |
| NCP_REMOVE_PROP_HANDLER(MAC_WHITELIST); |
| NCP_REMOVE_PROP_HANDLER(MAC_BLACKLIST); |
| #endif |
| #if OPENTHREAD_FTD |
| NCP_REMOVE_PROP_HANDLER(THREAD_ACTIVE_ROUTER_IDS); |
| #endif |
| |
| public: |
| otError StreamWrite(int aStreamId, const uint8_t *aDataPtr, int aDataLen); |
| |
| #if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE |
| void RegisterPeekPokeDelagates(otNcpDelegateAllowPeekPoke aAllowPeekDelegate, |
| otNcpDelegateAllowPeekPoke aAllowPokeDelegate); |
| #endif |
| |
| #if OPENTHREAD_ENABLE_LEGACY |
| public: |
| void HandleLegacyNodeDidJoin(const otExtAddress *aExtAddr); |
| void HandleDidReceiveNewLegacyUlaPrefix(const uint8_t *aUlaPrefix); |
| void RegisterLegacyHandlers(const otNcpLegacyHandlers *aHandlers); |
| #endif |
| |
| protected: |
| static NcpBase *sNcpInstance; |
| otInstance *mInstance; |
| NcpFrameBuffer mTxFrameBuffer; |
| |
| private: |
| enum |
| { |
| kTxBufferSize = OPENTHREAD_CONFIG_NCP_TX_BUFFER_SIZE, // Tx Buffer size (used by mTxFrameBuffer). |
| }; |
| |
| spinel_status_t mLastStatus; |
| uint32_t mSupportedChannelMask; |
| uint32_t mChannelMask; |
| uint16_t mScanPeriod; |
| bool mDiscoveryScanJoinerFlag; |
| bool mDiscoveryScanEnableFiltering; |
| uint16_t mDiscoveryScanPanId; |
| Tasklet mUpdateChangedPropsTask; |
| uint32_t mChangedFlags; |
| bool mShouldSignalEndOfScan; |
| spinel_host_power_state_t mHostPowerState; |
| bool mHostPowerStateInProgress; |
| NcpFrameBuffer::FrameTag mHostPowerReplyFrameTag; |
| uint8_t mHostPowerStateHeader; |
| |
| #if OPENTHREAD_ENABLE_JAM_DETECTION |
| bool mShouldSignalJamStateChange; |
| #endif |
| |
| #if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE |
| otNcpDelegateAllowPeekPoke mAllowPeekDelegate; |
| otNcpDelegateAllowPeekPoke mAllowPokeDelegate; |
| #endif |
| |
| spinel_tid_t mDroppedReplyTid; |
| uint16_t mDroppedReplyTidBitSet; |
| spinel_tid_t mNextExpectedTid; |
| uint8_t mTxBuffer[kTxBufferSize]; |
| |
| bool mAllowLocalNetworkDataChange; |
| bool mRequireJoinExistingNetwork; |
| bool mIsRawStreamEnabled; |
| bool mDisableStreamWrite; |
| |
| #if OPENTHREAD_ENABLE_RAW_LINK_API |
| uint8_t mCurTransmitTID; |
| uint8_t mCurReceiveChannel; |
| int8_t mCurScanChannel; |
| #endif // OPENTHREAD_ENABLE_RAW_LINK_API |
| |
| uint32_t mFramingErrorCounter; // Number of improperly formed received spinel frames. |
| uint32_t mRxSpinelFrameCounter; // Number of received (inbound) spinel frames. |
| uint32_t mRxSpinelOutOfOrderTidCounter; // Number of out of order received spinel frames (tid increase > 1). |
| uint32_t mTxSpinelFrameCounter; // Number of sent (outbound) spinel frames. |
| uint32_t mInboundSecureIpFrameCounter; // Number of secure inbound data/IP frames. |
| uint32_t mInboundInsecureIpFrameCounter; // Number of insecure inbound data/IP frames. |
| uint32_t mOutboundSecureIpFrameCounter; // Number of secure outbound data/IP frames. |
| uint32_t mOutboundInsecureIpFrameCounter; // Number of insecure outbound data/IP frames. |
| uint32_t mDroppedOutboundIpFrameCounter; // Number of dropped outbound data/IP frames. |
| uint32_t mDroppedInboundIpFrameCounter; // Number of dropped inbound data/IP frames. |
| |
| #if OPENTHREAD_ENABLE_LEGACY |
| const otNcpLegacyHandlers *mLegacyHandlers; |
| uint8_t mLegacyUlaPrefix[OT_NCP_LEGACY_ULA_PREFIX_LENGTH]; |
| bool mLegacyNodeDidJoin; |
| #endif |
| |
| }; |
| |
| } // namespace ot |
| |
| #endif // NCP_BASE_HPP_ |
