ot::AddressResolver class

Implements the EID-to-RLOC mapping and caching.

Syntax

Show:

Summary

Declaration

from address_resolver.hpp:66

class AddressResolver : public InstanceLocator, private NonCopyable { friend class TimeTicker; friend class Tmf::Agent; class CacheEntry; class CacheEntryList; public: class Iterator : public otCacheEntryIterator, public Clearable<Iterator> { friend class AddressResolver; static constexpr uint8_t kListIndex = 0; static constexpr uint8_t kEntryIndex = 1; const CacheEntry *GetEntry(void) const { return static_cast<const CacheEntry *>(mData[kEntryIndex]); } void SetEntry(const CacheEntry *aEntry) { mData[kEntryIndex] = aEntry; } const CacheEntryList *GetList(void) const { return static_cast<const CacheEntryList *>(mData[kListIndex]); } void SetList(const CacheEntryList *aList) { mData[kListIndex] = aList; } }; class EntryInfo : public otCacheEntryInfo, public Clearable<EntryInfo> { public: enum State : uint8_t { kStateCached = OT_CACHE_ENTRY_STATE_CACHED, kStateSnooped = OT_CACHE_ENTRY_STATE_SNOOPED, kStateQuery = OT_CACHE_ENTRY_STATE_QUERY, kStateRetryQuery = OT_CACHE_ENTRY_STATE_RETRY_QUERY, }; }; explicit AddressResolver(Instance &aInstance); #if OPENTHREAD_FTD void Clear(void); Error GetNextCacheEntry(EntryInfo &aInfo, Iterator &aIterator) const; void RemoveEntriesForRloc16(uint16_t aRloc16); void RemoveEntriesForRouterId(uint8_t aRouterId); void RemoveEntryForAddress(const Ip6::Address &aEid); void ReplaceEntriesForRloc16(uint16_t aOldRloc16, uint16_t aNewRloc16); void UpdateSnoopedCacheEntry(const Ip6::Address &aEid, uint16_t aRloc16, uint16_t aDest); Error Resolve(const Ip6::Address &aEid, uint16_t &aRloc16) { return Resolve(aEid, aRloc16, true); } uint16_t LookUp(const Ip6::Address &aEid); void RestartAddressQueries(void); void SendAddressQueryResponse(const Ip6::Address &aTarget, const Ip6::InterfaceIdentifier &aMeshLocalIid, const uint32_t *aLastTransactionTimeTlv, const Ip6::Address &aDestination); void SendAddressError(const Ip6::Address &aTarget, const Ip6::InterfaceIdentifier &aMeshLocalIid, const Ip6::Address *aDestination); private: static constexpr uint16_t kCacheEntries = OPENTHREAD_CONFIG_TMF_ADDRESS_CACHE_ENTRIES; static constexpr uint16_t kMaxNonEvictableSnoopedEntries = OT_MAX(1, OPENTHREAD_CONFIG_TMF_ADDRESS_CACHE_MAX_SNOOP_ENTRIES); static constexpr uint16_t kAddressQueryTimeout = OPENTHREAD_CONFIG_TMF_ADDRESS_QUERY_TIMEOUT; static constexpr uint16_t kAddressQueryInitialRetryDelay = OPENTHREAD_CONFIG_TMF_ADDRESS_QUERY_INITIAL_RETRY_DELAY; static constexpr uint16_t kAddressQueryMaxRetryDelay = OPENTHREAD_CONFIG_TMF_ADDRESS_QUERY_MAX_RETRY_DELAY; static constexpr uint16_t kSnoopBlockEvictionTimeout = OPENTHREAD_CONFIG_TMF_SNOOP_CACHE_ENTRY_TIMEOUT; class CacheEntry : public InstanceLocatorInit { public: void Init(Instance &aInstance); CacheEntry *GetNext(void); const CacheEntry *GetNext(void) const; void SetNext(CacheEntry *aEntry); const Ip6::Address &GetTarget(void) const { return mTarget; } void SetTarget(const Ip6::Address &aTarget) { mTarget = aTarget; } uint16_t GetRloc16(void) const { return mRloc16; } void SetRloc16(uint16_t aRloc16) { mRloc16 = aRloc16; } const Ip6::InterfaceIdentifier &GetMeshLocalIid(void) const { return mInfo.mCached.mMeshLocalIid; } void SetMeshLocalIid(const Ip6::InterfaceIdentifier &aIid) { mInfo.mCached.mMeshLocalIid = aIid; } uint32_t GetLastTransactionTime(void) const { return mInfo.mCached.mLastTransactionTime; } void SetLastTransactionTime(uint32_t aTime) { mInfo.mCached.mLastTransactionTime = aTime; } bool IsLastTransactionTimeValid(void) const { return GetLastTransactionTime() != kInvalidLastTransTime; } void MarkLastTransactionTimeAsInvalid(void) { SetLastTransactionTime(kInvalidLastTransTime); } void DecrementTimeout(void) { mInfo.mOther.mTimeout--; } bool IsTimeoutZero(void) const { return mInfo.mOther.mTimeout == 0; } uint16_t GetTimeout(void) const { return mInfo.mOther.mTimeout; } void SetTimeout(uint16_t aTimeout) { mInfo.mOther.mTimeout = aTimeout; } void DecrementFreshnessTimeout(void) { mFreshnessTimeout--; } bool IsFreshnessTimeoutZero(void) const { return mFreshnessTimeout == 0; } void ResetFreshnessTimeout(void) { mFreshnessTimeout = kFreshnessTimeout; } uint16_t GetRetryDelay(void) const { return mInfo.mOther.mRetryDelay; } void SetRetryDelay(uint16_t aDelay) { mInfo.mOther.mRetryDelay = aDelay; } bool CanEvict(void) const { return mInfo.mOther.mCanEvict; } void SetCanEvict(bool aCanEvict) { mInfo.mOther.mCanEvict = aCanEvict; } bool IsInRampDown(void) const { return mInfo.mOther.mRampDown; } void SetRampDown(bool aRampDown) { mInfo.mOther.mRampDown = aRampDown; } bool Matches(const Ip6::Address &aEid) const { return GetTarget() == aEid; } private: static constexpr uint16_t kNoNextIndex = 0x3fff; static constexpr uint32_t kInvalidLastTransTime = 0xffffffff; static constexpr uint8_t kFreshnessTimeout = 3; static_assert(kCacheEntries < kNoNextIndex, "kCacheEntries is too large and does not fit in 14 bit index"); Ip6::Address mTarget; uint16_t mRloc16; uint16_t mNextIndex : 14; uint8_t mFreshnessTimeout : 2; union { struct { uint32_t mLastTransactionTime; Ip6::InterfaceIdentifier mMeshLocalIid; } mCached; struct { uint16_t mTimeout; uint16_t mRetryDelay; bool mCanEvict; bool mRampDown; } mOther; } mInfo; }; typedef Pool<CacheEntry, kCacheEntries> CacheEntryPool; class CacheEntryList : public LinkedList<CacheEntry> { }; enum EntryChange : uint8_t { kEntryAdded, kEntryUpdated, kEntryRemoved, }; enum Reason : uint8_t { kReasonQueryRequest, kReasonSnoop, kReasonReceivedNotification, kReasonRemovingRouterId, kReasonRemovingRloc16, kReasonReceivedIcmpDstUnreachNoRoute, kReasonEvictingForNewEntry, kReasonRemovingEid, }; CacheEntryPool &GetCacheEntryPool(void) { return mCacheEntryPool; } Error Resolve(const Ip6::Address &aEid, uint16_t &aRloc16, bool aAllowAddressQuery); void Remove(uint16_t aRloc16, bool aMatchRouterId); void Remove(const Ip6::Address &aEid, Reason aReason); CacheEntry *FindCacheEntry(const Ip6::Address &aEid, CacheEntryList *&aList, CacheEntry *&aPrevEntry); CacheEntry *NewCacheEntry(bool aSnoopedEntry); void RemoveCacheEntry(CacheEntry &aEntry, CacheEntryList &aList, CacheEntry *aPrevEntry, Reason aReason); Error UpdateCacheEntry(const Ip6::Address &aEid, uint16_t aRloc16); Error SendAddressQuery(const Ip6::Address &aEid); #if OPENTHREAD_CONFIG_TMF_ALLOW_ADDRESS_RESOLUTION_USING_NET_DATA_SERVICES Error ResolveUsingNetDataServices(const Ip6::Address &aEid, uint16_t &aRloc16); #endif static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); #endif template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); #if OPENTHREAD_FTD static void HandleIcmpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo, const otIcmp6Header *aIcmpHeader); void HandleIcmpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo, const Ip6::Icmp::Header &aIcmpHeader); void HandleTimeTick(void); void LogCacheEntryChange(EntryChange aChange, Reason aReason, const CacheEntry &aEntry, CacheEntryList *aList = nullptr); const char *ListToString(const CacheEntryList *aList) const; static AddressResolver::CacheEntry *GetEntryAfter(CacheEntry *aPrev, CacheEntryList &aList); CacheEntryPool mCacheEntryPool; CacheEntryList mCachedList; CacheEntryList mSnoopedList; CacheEntryList mQueryList; CacheEntryList mQueryRetryList; Ip6::Icmp::Handler mIcmpHandler; #endif };

Fields

Field

Declared as

ot::AddressResolver::kCacheEntries

ot::AddressResolver::kMaxNonEvictableSnoopedEntries

ot::AddressResolver::kAddressQueryTimeout

ot::AddressResolver::kAddressQueryInitialRetryDelay

ot::AddressResolver::kAddressQueryMaxRetryDelay

ot::AddressResolver::kSnoopBlockEvictionTimeout

ot::AddressResolver::mCacheEntryPool

CacheEntryPool

ot::AddressResolver::mCachedList

CacheEntryList

ot::AddressResolver::mSnoopedList

CacheEntryList

ot::AddressResolver::mQueryList

CacheEntryList

ot::AddressResolver::mQueryRetryList

CacheEntryList

ot::AddressResolver::mIcmpHandler

Ip6::Icmp::Handler

Methods

Clear()

Clears the EID-to-RLOC cache.

GetNextCacheEntry() const

Gets the information about the next EID cache entry (using an iterator).

RemoveEntriesForRloc16()

Removes the EID-to-RLOC cache entries corresponding to an RLOC16.

RemoveEntriesForRouterId()

Removes all EID-to-RLOC cache entries associated with a Router ID.

RemoveEntryForAddress()

Removes the cache entry for the EID.

ReplaceEntriesForRloc16()

Replaces all EID-to-RLOC cache entries corresponding to an old RLOC16 with a new RLOC16.

UpdateSnoopedCacheEntry()

Updates an existing entry or adds a snooped cache entry for a given EID. The method is intended to add an entry for snoop optimization (inspection of a received message to create a cache entry mapping an EID to a RLOC).

Resolve()

LookUp()

Looks up the RLOC16 for a given EID in the address cache. When a cache entry is successfully looked up using this method, it will be marked as "cached and in-use". Specifically, a snooped entry (`kStateSnooped`) will be marked as cached (`kStateCached`).