Symbols ![]()
loading...
Files ![]()
loading...
ot::Ncp::NcpBase class
Syntax
class NcpBase
{
public:
enum
{
kSpinelCmdHeaderSize = 2,
kSpinelPropIdSize = 3,
#if OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE && OPENTHREAD_RADIO
kSpinelInterfaceCount = SPINEL_HEADER_IID_MAX + 1,
#else
kSpinelInterfaceCount = 1,
#endif
};
explicit NcpBase(Instance *aInstance);
#if OPENTHREAD_CONFIG_MULTIPAN_RCP_ENABLE && OPENTHREAD_RADIO
explicit NcpBase(Instance **aInstances, uint8_t aCount);
#endif
static NcpBase *GetNcpInstance(void);
uint8_t InstanceToIid(Instance *aInstance);
Instance *IidToInstance(uint8_t aIid);
#if OPENTHREAD_CONFIG_MULTIPAN_RCP_ENABLE
void NotifySwitchoverDone(otInstance *aInstance, bool aSuccess);
#endif
spinel_iid_t GetCurCommandIid(void) const;
otError StreamWrite(int aStreamId, const uint8_t *aDataPtr, int aDataLen);
void Log(otLogLevel aLogLevel, otLogRegion aLogRegion, const char *aLogString);
#if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE
void RegisterPeekPokeDelegates(otNcpDelegateAllowPeekPoke aAllowPeekDelegate,
otNcpDelegateAllowPeekPoke aAllowPokeDelegate);
#endif
void IncrementFrameErrorCounter(void);
void HandleReceive(const uint8_t *aBuf, uint16_t aBufLength);
bool ShouldWakeHost(void);
bool ShouldDeferHostSend(void);
bool InfraIfHasAddress(uint32_t aInfraIfIndex, const otIp6Address *aAddress);
otError InfraIfSendIcmp6Nd(uint32_t aInfraIfIndex,
const otIp6Address *aDestAddress,
const uint8_t *aBuffer,
uint16_t aBufferLength);
protected:
static constexpr uint8_t kBitsPerByte = 8;
typedef otError (NcpBase::*PropertyHandler)(void);
enum ResponseType
{
kResponseTypeGet = 0,
kResponseTypeSet,
kResponseTypeLastStatus,
};
struct ResponseEntry
{
uint8_t mIid : 2;
uint8_t mTid : 4;
bool mIsInUse : 1;
ResponseType mType : 2;
uint32_t mPropKeyOrStatus : 24;
};
struct HandlerEntry
{
spinel_prop_key_t mKey;
NcpBase::PropertyHandler mHandler;
};
Spinel::Buffer::FrameTag GetLastOutboundFrameTag(void);
otError HandleCommand(uint8_t aHeader);
#if __cplusplus >= 201103L
static constexpr bool AreHandlerEntriesSorted(const HandlerEntry *aHandlerEntries, size_t aSize);
#endif
static PropertyHandler FindPropertyHandler(const HandlerEntry *aHandlerEntries,
size_t aSize,
spinel_prop_key_t aKey);
static PropertyHandler FindGetPropertyHandler(spinel_prop_key_t aKey);
static PropertyHandler FindSetPropertyHandler(spinel_prop_key_t aKey);
static PropertyHandler FindInsertPropertyHandler(spinel_prop_key_t aKey);
static PropertyHandler FindRemovePropertyHandler(spinel_prop_key_t aKey);
bool HandlePropertySetForSpecialProperties(uint8_t aHeader, spinel_prop_key_t aKey, otError &aError);
otError HandleCommandPropertySet(uint8_t aHeader, spinel_prop_key_t aKey);
otError HandleCommandPropertyInsertRemove(uint8_t aHeader, spinel_prop_key_t aKey, unsigned int aCommand);
otError WriteLastStatusFrame(uint8_t aHeader, spinel_status_t aLastStatus);
otError WritePropertyValueIsFrame(uint8_t aHeader, spinel_prop_key_t aPropKey, bool aIsGetResponse = true);
otError WritePropertyValueInsertedRemovedFrame(uint8_t aHeader,
unsigned int aResponseCommand,
spinel_prop_key_t aPropKey,
const uint8_t *aValuePtr,
uint16_t aValueLen);
otError SendQueuedResponses(void);
bool IsResponseQueueEmpty(void) const { return (mResponseQueueHead == mResponseQueueTail); }
otError EnqueueResponse(uint8_t aHeader, ResponseType aType, unsigned int aPropKeyOrStatus);
otError PrepareGetResponse(uint8_t aHeader, spinel_prop_key_t aPropKey)
{
return EnqueueResponse(aHeader, kResponseTypeGet, aPropKey);
}
otError PrepareSetResponse(uint8_t aHeader, spinel_prop_key_t aPropKey)
{
return EnqueueResponse(aHeader, kResponseTypeSet, aPropKey);
}
otError PrepareLastStatusResponse(uint8_t aHeader, spinel_status_t aStatus)
{
return EnqueueResponse(aHeader, kResponseTypeLastStatus, aStatus);
}
static uint8_t GetWrappedResponseQueueIndex(uint8_t aPosition);
static void UpdateChangedProps(Tasklet &aTasklet);
void UpdateChangedProps(void);
static void HandleFrameRemovedFromNcpBuffer(void *aContext,
Spinel::Buffer::FrameTag aFrameTag,
Spinel::Buffer::Priority aPriority,
Spinel::Buffer *aNcpBuffer);
void HandleFrameRemovedFromNcpBuffer(Spinel::Buffer::FrameTag aFrameTag);
otError EncodeChannelMask(uint32_t aChannelMask);
otError DecodeChannelMask(uint32_t &aChannelMask);
#if OPENTHREAD_RADIO || OPENTHREAD_CONFIG_LINK_RAW_ENABLE
otError PackRadioFrame(otRadioFrame *aFrame, otError aError);
#if OPENTHREAD_CONFIG_MULTIPAN_RCP_ENABLE
void NotifySwitchoverDone(bool aSuccess);
#endif
static void LinkRawReceiveDone(otInstance *aInstance, otRadioFrame *aFrame, otError aError);
void LinkRawReceiveDone(uint8_t aIid, otRadioFrame *aFrame, otError aError);
static void LinkRawTransmitDone(otInstance *aInstance,
otRadioFrame *aFrame,
otRadioFrame *aAckFrame,
otError aError);
void LinkRawTransmitDone(uint8_t aIid, otRadioFrame *aFrame, otRadioFrame *aAckFrame, otError aError);
static void LinkRawEnergyScanDone(otInstance *aInstance, int8_t aEnergyScanMaxRssi);
void LinkRawEnergyScanDone(uint8_t aIid, int8_t aEnergyScanMaxRssi);
static inline uint8_t GetNcpBaseIid(otInstance *aInstance)
{
return sNcpInstance->InstanceToIid(static_cast<Instance *>(aInstance));
}
#endif
#if OPENTHREAD_MTD || OPENTHREAD_FTD
static void HandleStateChanged(otChangedFlags aFlags, void *aContext);
void ProcessThreadChangedFlags(void);
static void HandlePcapFrame(const otRadioFrame *aFrame, bool aIsTx, void *aContext);
void HandlePcapFrame(const otRadioFrame *aFrame, bool aIsTx);
static void HandleTimeSyncUpdate(void *aContext);
void HandleTimeSyncUpdate(void);
#if OPENTHREAD_FTD
static void HandleNeighborTableChanged(otNeighborTableEvent aEvent, const otNeighborTableEntryInfo *aEntry);
void HandleNeighborTableChanged(otNeighborTableEvent aEvent, const otNeighborTableEntryInfo &aEntry);
#if OPENTHREAD_CONFIG_MLE_PARENT_RESPONSE_CALLBACK_API_ENABLE
static void HandleParentResponseInfo(otThreadParentResponseInfo *aInfo, void *aContext);
void HandleParentResponseInfo(const otThreadParentResponseInfo &aInfo);
#endif
#endif
static void HandleDatagramFromStack(otMessage *aMessage, void *aContext);
void HandleDatagramFromStack(otMessage *aMessage);
otError SendQueuedDatagramMessages(void);
otError SendDatagramMessage(otMessage *aMessage);
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);
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
static void HandleCommissionerEnergyReport_Jump(uint32_t aChannelMask,
const uint8_t *aEnergyData,
uint8_t aLength,
void *aContext);
void HandleCommissionerEnergyReport(uint32_t aChannelMask, const uint8_t *aEnergyData, uint8_t aLength);
static void HandleCommissionerPanIdConflict_Jump(uint16_t aPanId, uint32_t aChannelMask, void *aContext);
void HandleCommissionerPanIdConflict(uint16_t aPanId, uint32_t aChannelMask);
#endif
#if OPENTHREAD_CONFIG_JOINER_ENABLE
static void HandleJoinerCallback_Jump(otError aError, void *aContext);
void HandleJoinerCallback(otError aError);
#endif
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_INITIATOR_ENABLE
static void HandleLinkMetricsReport_Jump(const otIp6Address *aSource,
const otLinkMetricsValues *aMetricsValues,
otLinkMetricsStatus aStatus,
void *aContext);
void HandleLinkMetricsReport(const otIp6Address *aSource,
const otLinkMetricsValues *aMetricsValues,
otLinkMetricsStatus aStatus);
static void HandleLinkMetricsMgmtResponse_Jump(const otIp6Address *aSource,
otLinkMetricsStatus aStatus,
void *aContext);
void HandleLinkMetricsMgmtResponse(const otIp6Address *aSource, otLinkMetricsStatus aStatus);
static void HandleLinkMetricsEnhAckProbingIeReport_Jump(otShortAddress aShortAddress,
const otExtAddress *aExtAddress,
const otLinkMetricsValues *aMetricsValues,
void *aContext);
void HandleLinkMetricsEnhAckProbingIeReport(otShortAddress aShortAddress,
const otExtAddress *aExtAddress,
const otLinkMetricsValues *aMetricsValues);
#endif
static void HandleMlrRegResult_Jump(void *aContext,
otError aError,
uint8_t aMlrStatus,
const otIp6Address *aFailedAddresses,
uint8_t aFailedAddressNum);
void HandleMlrRegResult(otError aError,
uint8_t aMlrStatus,
const otIp6Address *aFailedAddresses,
uint8_t aFailedAddressNum);
otError EncodeOperationalDataset(const otOperationalDataset &aDataset);
otError DecodeOperationalDataset(otOperationalDataset &aDataset,
const uint8_t **aTlvs = nullptr,
uint8_t *aTlvsLength = nullptr,
const otIp6Address **aDestIpAddress = nullptr,
bool aAllowEmptyValues = false);
otError EncodeNeighborInfo(const otNeighborInfo &aNeighborInfo);
#if OPENTHREAD_CONFIG_MULTI_RADIO
otError EncodeNeighborMultiRadioInfo(uint32_t aSpinelRadioLink, const otRadioLinkInfo &aInfo);
#endif
#if OPENTHREAD_FTD
otError EncodeChildInfo(const otChildInfo &aChildInfo);
#endif
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_INITIATOR_ENABLE
otError EncodeLinkMetricsValues(const otLinkMetricsValues *aMetricsValues);
#endif
#if OPENTHREAD_CONFIG_UDP_FORWARD_ENABLE
static void HandleUdpForwardStream(otMessage *aMessage,
uint16_t aPeerPort,
otIp6Address *aPeerAddr,
uint16_t aSockPort,
void *aContext);
void HandleUdpForwardStream(otMessage *aMessage, uint16_t aPeerPort, otIp6Address &aPeerAddr, uint16_t aPort);
#endif
#endif
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_INITIATOR_ENABLE || OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
otError DecodeLinkMetrics(otLinkMetrics *aMetrics, bool aAllowPduCount);
#endif
otError CommandHandler_NOOP(uint8_t aHeader);
otError CommandHandler_RESET(uint8_t aHeader);
otError CommandHandler_PROP_VALUE_update(uint8_t aHeader, unsigned int aCommand);
#if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE
otError CommandHandler_PEEK(uint8_t aHeader);
otError CommandHandler_POKE(uint8_t aHeader);
#endif
#if OPENTHREAD_MTD || OPENTHREAD_FTD
otError CommandHandler_NET_CLEAR(uint8_t aHeader);
#endif
template <spinel_prop_key_t aKey> otError HandlePropertyGet(void);
template <spinel_prop_key_t aKey> otError HandlePropertySet(void);
template <spinel_prop_key_t aKey> otError HandlePropertyInsert(void);
template <spinel_prop_key_t aKey> otError HandlePropertyRemove(void);
otError HandlePropertySet_SPINEL_PROP_HOST_POWER_STATE(uint8_t aHeader);
#if OPENTHREAD_CONFIG_DIAG_ENABLE
static_assert(OPENTHREAD_CONFIG_DIAG_OUTPUT_BUFFER_SIZE <=
OPENTHREAD_CONFIG_NCP_TX_BUFFER_SIZE - kSpinelCmdHeaderSize - kSpinelPropIdSize,
"diag output buffer should be smaller than NCP HDLC tx buffer");
otError HandlePropertySet_SPINEL_PROP_NEST_STREAM_MFG(uint8_t aHeader);
#endif
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
otError HandlePropertySet_SPINEL_PROP_MESHCOP_COMMISSIONER_GENERATE_PSKC(uint8_t aHeader);
otError HandlePropertySet_SPINEL_PROP_THREAD_COMMISSIONER_ENABLED(uint8_t aHeader);
#endif
#if OPENTHREAD_RADIO || OPENTHREAD_CONFIG_LINK_RAW_ENABLE
otError DecodeStreamRawTxRequest(otRadioFrame &aFrame);
otError HandlePropertySet_SPINEL_PROP_STREAM_RAW(uint8_t aHeader);
#endif
void ResetCounters(void);
static uint8_t ConvertLogLevel(otLogLevel aLogLevel);
static unsigned int ConvertLogRegion(otLogRegion aLogRegion);
#if OPENTHREAD_CONFIG_DIAG_ENABLE
static void HandleDiagOutput_Jump(const char *aFormat, va_list aArguments, void *aContext);
void HandleDiagOutput(const char *aFormat, va_list aArguments);
#endif
#if OPENTHREAD_ENABLE_NCP_VENDOR_HOOK
otError VendorCommandHandler(uint8_t aHeader, unsigned int aCommand);
void VendorHandleFrameRemovedFromNcpBuffer(Spinel::Buffer::FrameTag aFrameTag);
otError VendorGetPropertyHandler(spinel_prop_key_t aPropKey);
otError VendorSetPropertyHandler(spinel_prop_key_t aPropKey);
#endif
static void ThreadDetachGracefullyHandler(void *aContext);
void ThreadDetachGracefullyHandler(void);
static void DatasetSendMgmtPendingSetHandler(otError aResult, void *aContext);
void DatasetSendMgmtPendingSetHandler(otError aResult);
protected:
static NcpBase *sNcpInstance;
static spinel_status_t ThreadErrorToSpinelStatus(otError aError);
static uint8_t LinkFlagsToFlagByte(bool aRxOnWhenIdle, bool aDeviceType, bool aNetworkData);
enum
{
kTxBufferSize = OPENTHREAD_CONFIG_NCP_TX_BUFFER_SIZE,
kResponseQueueSize = OPENTHREAD_CONFIG_NCP_SPINEL_RESPONSE_QUEUE_SIZE,
kInvalidScanChannel = -1,
};
Instance *mInstance;
#if OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE && OPENTHREAD_RADIO
Instance *mInstances[kSpinelInterfaceCount];
#endif
Spinel::Buffer mTxFrameBuffer;
Spinel::Encoder mEncoder;
Spinel::Decoder mDecoder;
bool mHostPowerStateInProgress;
spinel_status_t mLastStatus;
uint32_t mScanChannelMask;
uint16_t mScanPeriod;
bool mDiscoveryScanJoinerFlag;
bool mDiscoveryScanEnableFiltering;
uint16_t mDiscoveryScanPanId;
Tasklet mUpdateChangedPropsTask;
uint32_t mThreadChangedFlags;
ChangedPropsSet mChangedPropsSet;
spinel_host_power_state_t mHostPowerState;
Spinel::Buffer::FrameTag mHostPowerReplyFrameTag;
uint8_t mHostPowerStateHeader;
#if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE
otNcpDelegateAllowPeekPoke mAllowPeekDelegate;
otNcpDelegateAllowPeekPoke mAllowPokeDelegate;
#endif
uint8_t mTxBuffer[kTxBufferSize];
spinel_tid_t mNextExpectedTid[kSpinelInterfaceCount];
uint8_t mResponseQueueHead;
uint8_t mResponseQueueTail;
ResponseEntry mResponseQueue[kResponseQueueSize];
bool mAllowLocalNetworkDataChange;
bool mRequireJoinExistingNetwork;
bool mIsRawStreamEnabled[kSpinelInterfaceCount];
bool mPcapEnabled;
bool mDisableStreamWrite;
bool mShouldEmitChildTableUpdate;
#if OPENTHREAD_CONFIG_TMF_NETDATA_SERVICE_ENABLE
bool mAllowLocalServerDataChange;
#endif
#if OPENTHREAD_FTD
#if OPENTHREAD_CONFIG_MLE_STEERING_DATA_SET_OOB_ENABLE
otExtAddress mSteeringDataAddress;
#endif
uint8_t mPreferredRouteId;
#endif
uint8_t mCurCommandIid;
#if OPENTHREAD_RADIO || OPENTHREAD_CONFIG_LINK_RAW_ENABLE
uint8_t mCurTransmitTID[kSpinelInterfaceCount];
int8_t mCurScanChannel[kSpinelInterfaceCount];
bool mSrcMatchEnabled[kSpinelInterfaceCount];
#endif
#if OPENTHREAD_MTD || OPENTHREAD_FTD
otMessageQueue mMessageQueue;
uint32_t mInboundSecureIpFrameCounter;
uint32_t mInboundInsecureIpFrameCounter;
uint32_t mOutboundSecureIpFrameCounter;
uint32_t mOutboundInsecureIpFrameCounter;
uint32_t mDroppedOutboundIpFrameCounter;
uint32_t mDroppedInboundIpFrameCounter;
#if OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE
enum : uint8_t
{
kSrpClientMaxHostAddresses = OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_HOST_ADDRESSES,
};
otError EncodeSrpClientHostInfo(const otSrpClientHostInfo &aHostInfo);
otError EncodeSrpClientServices(const otSrpClientService *aServices);
static void HandleSrpClientCallback(otError aError,
const otSrpClientHostInfo *aHostInfo,
const otSrpClientService *aServices,
const otSrpClientService *aRemovedServices,
void *aContext);
void HandleSrpClientCallback(otError aError,
const otSrpClientHostInfo *aHostInfo,
const otSrpClientService *aServices,
const otSrpClientService *aRemovedServices);
bool mSrpClientCallbackEnabled;
#endif
#endif
uint32_t mFramingErrorCounter;
uint32_t mRxSpinelFrameCounter;
uint32_t mRxSpinelOutOfOrderTidCounter;
uint32_t mTxSpinelFrameCounter;
bool mDidInitialUpdates;
spinel_status_t mDatasetSendMgmtPendingSetResult;
uint64_t mLogTimestampBase;
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_NCP_INFRA_IF_ENABLE && OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE
otError InfraIfAddAddress(const otIp6Address &aAddress);
bool InfraIfContainsAddress(const otIp6Address &aAddress);
static constexpr uint8_t kMaxInfraIfAddrs = 10;
otIp6Address mInfraIfAddrs[kMaxInfraIfAddrs];
uint8_t mInfraIfAddrCount;
uint32_t mInfraIfIndex;
#endif
#if OPENTHREAD_CONFIG_DIAG_ENABLE
char *mDiagOutput;
uint16_t mDiagOutputLen;
#endif
};
Fields
Field
Declared as
uint16_t