Symbols ![]()
loading...
Files ![]()
loading (1/5)...
ot::MeshForwarder class
Implements mesh forwarding within Thread.
Syntax
class MeshForwarder : public InstanceLocator,
private NonCopyable
{
friend class Mac::Mac;
friend class Instance;
friend class DataPollSender;
friend class IndirectSender;
friend class Ip6::Ip6;
friend class Mle::DiscoverScanner;
friend class TimeTicker;
public:
explicit MeshForwarder(Instance &aInstance);
void Start(void);
void Stop(void);
void SendMessage(OwnedPtr<Message> aMessagePtr);
#if OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE
Error SendEmptyMessage(void);
#endif
void HandleResolved(const Ip6::Address &aEid, Error aError);
bool GetRxOnWhenIdle(void) const;
void SetRxOnWhenIdle(bool aRxOnWhenIdle);
#if OPENTHREAD_FTD
typedef IndirectSender::MessageChecker MessageChecker;
void RemoveMessagesForChild(Child &aChild, MessageChecker aMessageChecker);
#endif
void RemoveDataResponseMessages(void);
Error EvictMessage(Message::Priority aPriority);
const PriorityQueue &GetSendQueue(void) const { return mSendQueue; }
const MessageQueue &GetReassemblyQueue(void) const { return mReassemblyList; }
const otIpCounters &GetCounters(void) const { return mIpCounters; }
void ResetCounters(void) { ClearAllBytes(mIpCounters); }
#if OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE
const uint32_t *GetTimeInQueueHistogram(uint16_t &aNumBins, uint32_t &aBinInterval) const
{
return mTxQueueStats.GetHistogram(aNumBins, aBinInterval);
}
uint32_t GetMaxTimeInQueue(void) const { return mTxQueueStats.GetMaxInterval(); }
void ResetTimeInQueueStat(void) { mTxQueueStats.Clear(); }
#endif
#if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
void HandleDeferredAck(Neighbor &aNeighbor, Error aError);
#endif
private:
static constexpr uint8_t kFailedRouterTransmissions = 4;
static constexpr uint8_t kFailedCslDataPollTransmissions = 15;
static constexpr uint8_t kReassemblyTimeout = OPENTHREAD_CONFIG_6LOWPAN_REASSEMBLY_TIMEOUT;
static constexpr uint8_t kMeshHeaderFrameMtu = OT_RADIO_FRAME_MAX_SIZE;
static constexpr uint8_t kMeshHeaderFrameFcsSize = sizeof(uint16_t);
static constexpr uint8_t kMeshHeaderHopsLeft = Mle::kMaxRouteCost + 3;
static constexpr uint32_t kTxDelayInterval = OPENTHREAD_CONFIG_MAC_COLLISION_AVOIDANCE_DELAY_INTERVAL;
#if OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_ENABLE
static constexpr uint32_t kTimeInQueueMarkEcn = OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_MARK_ECN_INTERVAL;
static constexpr uint32_t kTimeInQueueDropMsg = OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_DROP_MSG_INTERVAL;
#endif
enum MessageAction : uint8_t
{
kMessageReceive,
kMessageTransmit,
kMessagePrepareIndirect,
kMessageDrop,
kMessageReassemblyDrop,
kMessageEvict,
#if OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_ENABLE
kMessageMarkEcn,
kMessageQueueMgmtDrop,
#endif
#if (OPENTHREAD_CONFIG_MAX_FRAMES_IN_DIRECT_TX_QUEUE > 0)
kMessageFullQueueDrop,
#endif
};
struct RxInfo : public InstanceLocator
{
static constexpr uint16_t kInfoStringSize = 70;
typedef String<kInfoStringSize> InfoString;
explicit RxInfo(Instance &aInstance)
: InstanceLocator(aInstance)
, mParsedIp6Headers(false)
{
}
const Mac::Address &GetSrcAddr(void) const { return mMacAddrs.mSource; }
const Mac::Address &GetDstAddr(void) const { return mMacAddrs.mDestination; }
bool IsLinkSecurityEnabled(void) const { return mLinkInfo.IsLinkSecurityEnabled(); }
Error ParseIp6Headers(void);
InfoString ToString(void) const;
FrameData mFrameData;
ThreadLinkInfo mLinkInfo;
Mac::Addresses mMacAddrs;
Ip6::Headers mIp6Headers;
bool mParsedIp6Headers;
};
#if OPENTHREAD_FTD
#if OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_ENABLE
static constexpr uint16_t kQmFwdEntries = OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_FRAG_TAG_ENTRY_LIST_SIZE;
#else
static constexpr uint16_t kQmFwdEntries = 0;
#endif
static constexpr uint16_t kPrioFwdEntries = OPENTHREAD_CONFIG_NUM_FRAGMENT_PRIORITY_ENTRIES;
static constexpr uint16_t kFwdInfoEntries = OT_MAX(kPrioFwdEntries, kQmFwdEntries);
class FwdFrameInfo
{
public:
enum ExpireChecker : uint8_t
{
kIsExpired,
};
struct Info
{
uint16_t mSrcRloc16;
uint16_t mDatagramTag;
};
void Init(uint16_t aSrcRloc16, uint16_t aDatagramTag, Message::Priority aPriority);
bool Matches(const Info &aInfo) const;
bool Matches(const ExpireChecker) const { return IsExpired(); }
void ResetLifetime(void) { mLifetime = kLifetime; }
void DecrementLifetime(void) { mLifetime--; }
bool IsExpired(void) const { return (mLifetime == 0); }
#if OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_ENABLE
bool ShouldDrop(void) const { return mShouldDrop; }
void MarkToDrop(void) { mShouldDrop = true; }
#endif
Message::Priority GetPriority(void) const { return static_cast<Message::Priority>(mPriority); }
private:
#if OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_ENABLE
static constexpr uint8_t kRetainTime = OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_FRAG_TAG_RETAIN_TIME;
#else
static constexpr uint8_t kRetainTime = 0;
#endif
static constexpr uint8_t kLifetime = OT_MAX(kReassemblyTimeout, kRetainTime);
uint16_t mSrcRloc16;
uint16_t mDatagramTag;
uint8_t mLifetime;
uint8_t mPriority : 2;
#if OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_ENABLE
bool mShouldDrop : 1;
#endif
static_assert(Message::kNumPriorities <= 4, "mPriority as a 2-bit does not fit all `Priority` values");
};
using FwdFrameInfoArray = Array<FwdFrameInfo, kFwdInfoEntries>;
#endif
#if OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE
class TxQueueStats : public Clearable<TxQueueStats>
{
public:
const uint32_t *GetHistogram(uint16_t &aNumBins, uint32_t &aBinInterval) const;
uint32_t GetMaxInterval(void) const { return mMaxInterval; }
void UpdateFor(const Message &aMessage);
private:
static constexpr uint32_t kHistMaxInterval = OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_HISTOGRAM_MAX_INTERVAL;
static constexpr uint32_t kHistBinInterval = OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_HISTOGRAM_BIN_INTERVAL;
static constexpr uint16_t kNumHistBins = (kHistMaxInterval + kHistBinInterval - 1) / kHistBinInterval;
uint32_t mMaxInterval;
uint32_t mHistogram[kNumHistBins];
};
#endif
void SendIcmpErrorIfDstUnreach(const Message &aMessage, const Mac::Addresses &aMacAddrs);
Error CheckReachability(RxInfo &aRxInfo);
Error CheckReachability(uint16_t aMeshDest, const Ip6::Header &aIp6Header);
void UpdateRoutes(RxInfo &aRxInfo);
Error FrameToMessage(RxInfo &aRxInfo, uint16_t aDatagramSize, Message *&aMessage);
void GetMacDestinationAddress(const Ip6::Address &aIp6Addr, Mac::Address &aMacAddr);
void GetMacSourceAddress(const Ip6::Address &aIp6Addr, Mac::Address &aMacAddr);
Message *PrepareNextDirectTransmission(void);
void HandleMesh(RxInfo &aRxInfo);
void ResolveRoutingLoops(uint16_t aSourceRloc16, uint16_t aDestRloc16);
void HandleFragment(RxInfo &aRxInfo);
void HandleLowpanHc(RxInfo &aRxInfo);
void PrepareMacHeaders(Mac::TxFrame &aTxFrame, Mac::TxFrame::Info &aTxFrameInfo, const Message *aMessage);
uint16_t PrepareDataFrame(Mac::TxFrame &aFrame,
Message &aMessage,
const Mac::Addresses &aMacAddrs,
bool aAddMeshHeader,
uint16_t aMeshSource,
uint16_t aMeshDest,
bool aAddFragHeader);
uint16_t PrepareDataFrameWithNoMeshHeader(Mac::TxFrame &aFrame, Message &aMessage, const Mac::Addresses &aMacAddrs);
void PrepareEmptyFrame(Mac::TxFrame &aFrame, const Mac::Address &aMacDest, bool aAckRequest);
#if OPENTHREAD_CONFIG_DELAY_AWARE_QUEUE_MANAGEMENT_ENABLE
Error UpdateEcnOrDrop(Message &aMessage, bool aPreparingToSend);
Error RemoveAgedMessages(void);
#endif
#if (OPENTHREAD_CONFIG_MAX_FRAMES_IN_DIRECT_TX_QUEUE > 0)
bool IsDirectTxQueueOverMaxFrameThreshold(void) const;
void ApplyDirectTxQueueLimit(Message &aMessage);
#endif
void SendMesh(Message &aMessage, Mac::TxFrame &aFrame);
void SendDestinationUnreachable(uint16_t aMeshSource, const Ip6::Headers &aIp6Headers);
Error UpdateIp6Route(Message &aMessage);
Error UpdateIp6RouteFtd(const Ip6::Header &aIp6Header, Message &aMessage);
Error UpdateMeshRoute(Message &aMessage);
bool UpdateReassemblyList(void);
void UpdateFragmentPriority(Lowpan::FragmentHeader &aFragmentHeader,
uint16_t aFragmentLength,
uint16_t aSrcRloc16,
Message::Priority aPriority);
Error HandleDatagram(Message &aMessage, const Mac::Address &aMacSource);
void ClearReassemblyList(void);
void HandleDiscoverComplete(void);
void HandleReceivedFrame(Mac::RxFrame &aFrame);
Mac::TxFrame *HandleFrameRequest(Mac::TxFrames &aTxFrames);
Neighbor *UpdateNeighborOnSentFrame(Mac::TxFrame &aFrame,
Error aError,
const Mac::Address &aMacDest,
bool aIsDataPoll);
void UpdateNeighborLinkFailures(Neighbor &aNeighbor, Error aError, bool aAllowNeighborRemove, uint8_t aFailLimit);
void HandleSentFrame(Mac::TxFrame &aFrame, Error aError);
void UpdateSendMessage(Error aFrameTxError, Mac::Address &aMacDest, Neighbor *aNeighbor);
void FinalizeMessageDirectTx(Message &aMessage, Error aError);
void FinalizeAndRemoveMessage(Message &aMessage, Error aError, MessageAction aAction);
bool RemoveMessageIfNoPendingTx(Message &aMessage);
void HandleTimeTick(void);
void ScheduleTransmissionTask(void);
Error GetFramePriority(RxInfo &aRxInfo, Message::Priority &aPriority);
#if OPENTHREAD_FTD
void FinalizeMessageIndirectTxs(Message &aMessage);
FwdFrameInfo *FindFwdFrameInfoEntry(uint16_t aSrcRloc16, uint16_t aDatagramTag);
bool UpdateFwdFrameInfoArrayOnTimeTick(void);
Error GetFragmentPriority(Lowpan::FragmentHeader &aFragmentHeader,
uint16_t aSrcRloc16,
Message::Priority &aPriority);
void GetForwardFramePriority(RxInfo &aRxInfo, Message::Priority &aPriority);
#endif
void PauseMessageTransmissions(void) { mTxPaused = true; }
void ResumeMessageTransmissions(void);
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_COLLISION_AVOIDANCE_DELAY_ENABLE
void HandleTxDelayTimer(void);
#endif
void LogMessage(MessageAction aAction, const Message &aMessage);
void LogMessage(MessageAction aAction, const Message &aMessage, Error aError);
void LogMessage(MessageAction aAction, const Message &aMessage, Error aError, const Mac::Address *aAddress);
void LogFrame(const char *aActionText, const Mac::Frame &aFrame, Error aError);
void LogFragmentFrameDrop(Error aError, const RxInfo &aRxInfo, const Lowpan::FragmentHeader &aFragmentHeader);
void LogLowpanHcFrameDrop(Error aError, const RxInfo &aRxInfo);
#if OT_SHOULD_LOG_AT(OT_LOG_LEVEL_NOTE)
const char *MessageActionToString(MessageAction aAction, Error aError);
const char *MessagePriorityToString(const Message &aMessage);
#if OPENTHREAD_FTD
Error LogMeshFragmentHeader(MessageAction aAction,
const Message &aMessage,
const Mac::Address *aMacAddress,
Error aError,
uint16_t &aOffset,
Mac::Addresses &aMeshAddrs,
LogLevel aLogLevel);
void LogMeshIpHeader(const Message &aMessage,
uint16_t aOffset,
const Mac::Addresses &aMeshAddrs,
LogLevel aLogLevel);
void LogMeshMessage(MessageAction aAction,
const Message &aMessage,
const Mac::Address *aAddress,
Error aError,
LogLevel aLogLevel);
#endif
#if OPENTHREAD_CONFIG_LOG_SRC_DST_IP_ADDRESSES
void LogIp6AddressAndPort(const char *aLabel, const Ip6::Address &aAddress, uint16_t aPort, LogLevel aLogLevel);
#endif
void LogIp6SourceDestAddresses(const Ip6::Headers &aHeaders, LogLevel aLogLevel);
void LogIp6Message(MessageAction aAction,
const Message &aMessage,
const Mac::Address *aAddress,
Error aError,
LogLevel aLogLevel);
void AppendSecErrorPrioRssRadioLabelsToLogString(StringWriter &aString,
MessageAction aAction,
const Message &aMessage,
Error aError);
void AppendMacAddrToLogString(StringWriter &aString, MessageAction aAction, const Mac::Address *aMacAddress);
#endif
using TxTask = TaskletIn<MeshForwarder, &MeshForwarder::ScheduleTransmissionTask>;
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_COLLISION_AVOIDANCE_DELAY_ENABLE
using TxDelayTimer = TimerMilliIn<MeshForwarder, &MeshForwarder::HandleTxDelayTimer>;
#endif
PriorityQueue mSendQueue;
MessageQueue mReassemblyList;
uint16_t mFragTag;
uint16_t mMessageNextOffset;
Message *mSendMessage;
Mac::Addresses mMacAddrs;
uint16_t mMeshSource;
uint16_t mMeshDest;
bool mAddMeshHeader : 1;
bool mEnabled : 1;
bool mTxPaused : 1;
bool mSendBusy : 1;
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_COLLISION_AVOIDANCE_DELAY_ENABLE
bool mDelayNextTx : 1;
TxDelayTimer mTxDelayTimer;
#endif
TxTask mScheduleTransmissionTask;
otIpCounters mIpCounters;
#if OPENTHREAD_FTD
IndirectSender mIndirectSender;
FwdFrameInfoArray mFwdFrameInfoArray;
#endif
DataPollSender mDataPollSender;
#if OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE
TxQueueStats mTxQueueStats;
#endif
};
Fields
Field
Declared as
uint16_t
uint16_t
uint16_t
bool : 1
bool : 1
bool : 1
bool : 1
TxDelayTimer
FwdFrameInfoArray
References
Code
Location
Scope
Referrer
Class Tree
ot::MeshForwarder is inherited by 2 classess:
Instances
Instance
Scope
Location
Project