espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-07-31 08:07:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

[routing-manager] centralize RxRaTracker decision logic and signaling (#10389)

Browse Source 
This commit enhances `RoutingManager::RxRaTracker`:

- A new private `Evaluate()` method centralizes logic for handling
  changes in tracked routers and advertised prefixes. It removes
  expired entries, determines decision factors used by other
  `RoutingManager` components, and schedules timers.

- A new class `DecisionFactors` is added to track factors used by
  `RoutingManager`, including the favored on-link prefix, presence of
  ULA/non-ULA prefixes, and M/O flags for mirroring in emitted RA
  messages.

- `Evaluate()` determines these factors and signals changes using
  `HandleRaPrefixTableChanged()` only when necessary, simplifying
  signaling and avoiding redundant calculations.
This commit is contained in:
Abtin Keshavarzian
2024-06-26 11:03:23 -04:00
committed by GitHub
parent 588dfae6f4
commit c8681ff8e4
2 changed files with 185 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/border_router/routing_manager.cpp
+146 -209
View File
@@ -594,7 +594,7 @@ void RoutingManager::SendRouterAdvertisement(RouterAdvTxMode aRaTxMode)
header.SetToDefault();
}
mRxRaTracker.DetermineAndSetFlags(header);
mRxRaTracker.SetHeaderFlagsOn(header);
SuccessOrExit(error = raMsg.AppendHeader(header));
@@ -980,12 +980,11 @@ void RoutingManager::RxRaTracker::Stop(void)
{
mRouters.Free();
mLocalRaHeader.Clear();
mDecisionFactors.Clear();
mExpirationTimer.Stop();
mStaleTimer.Stop();
mRouterTimer.Stop();
SignalTableChanged();
}
void RoutingManager::RxRaTracker::ProcessRouterAdvertMessage(const RouterAdvert::RxMessage &aRaMessage,
@@ -1048,9 +1047,9 @@ void RoutingManager::RxRaTracker::ProcessRouterAdvertMessage(const RouterAdvert:
router->mIsLocalDevice = (aRaOrigin == kThisBrOtherEntity);
UpdateRouterOnRx(*router);
router->ResetReachabilityState();
RemoveRoutersWithNoEntriesOrFlags();
Evaluate();
exit:
return;
@@ -1070,13 +1069,11 @@ void RoutingManager::RxRaTracker::ProcessRaHeader(const RouterAdvert::Header &aR
if (aRouter.mManagedAddressConfigFlag != managedFlag)
{
aRouter.mManagedAddressConfigFlag = managedFlag;
SignalTableChanged();
}
if (aRouter.mOtherConfigFlag != otherFlag)
{
aRouter.mOtherConfigFlag = otherFlag;
SignalTableChanged();
}
if (aRaOrigin == kThisBrOtherEntity)
@@ -1104,7 +1101,6 @@ void RoutingManager::RxRaTracker::ProcessRaHeader(const RouterAdvert::Header &aR
if (mLocalRaHeader != oldHeader)
{
SignalTableChanged();
Get<RoutingManager>().ScheduleRoutingPolicyEvaluation(kAfterRandomDelay);
}
}
@@ -1134,10 +1130,6 @@ void RoutingManager::RxRaTracker::ProcessRaHeader(const RouterAdvert::Header &aR
entry->SetFrom(aRaHeader);
}
mExpirationTimer.FireAtIfEarlier(entry->GetExpireTime());
SignalTableChanged();
exit:
return;
}
@@ -1185,10 +1177,6 @@ void RoutingManager::RxRaTracker::ProcessPrefixInfoOption(const PrefixInfoOption
entry->AdoptValidAndPreferredLifetimesFrom(newPrefix);
}
mExpirationTimer.FireAtIfEarlier(entry->GetExpireTime());
SignalTableChanged();
exit:
return;
}
@@ -1241,10 +1229,6 @@ void RoutingManager::RxRaTracker::ProcessRouteInfoOption(const RouteInfoOption &
entry->SetFrom(aRio);
}
mExpirationTimer.FireAtIfEarlier(entry->GetExpireTime());
SignalTableChanged();
exit:
return;
}
@@ -1311,73 +1295,6 @@ template <class PrefixType> void RoutingManager::RxRaTracker::Entry<PrefixType>:
#endif // !OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
bool RoutingManager::RxRaTracker::ContainsDefaultOrNonUlaRoutePrefix(void) const
{
bool contains = false;
for (const Router &router : mRouters)
{
if (router.mRoutePrefixes.ContainsMatching(RoutePrefix::kIsNotUla))
{
contains = true;
break;
}
}
return contains;
}
bool RoutingManager::RxRaTracker::ContainsOnLinkPrefix(OnLinkPrefix::UlaChecker aUlaChecker) const
{
bool contains = false;
for (const Router &router : mRouters)
{
if (router.mOnLinkPrefixes.ContainsMatching(aUlaChecker))
{
contains = true;
break;
}
}
return contains;
}
bool RoutingManager::RxRaTracker::ContainsNonUlaOnLinkPrefix(void) const
{
return ContainsOnLinkPrefix(OnLinkPrefix::kIsNotUla);
}
bool RoutingManager::RxRaTracker::ContainsUlaOnLinkPrefix(void) const
{
return ContainsOnLinkPrefix(OnLinkPrefix::kIsUla);
}
void RoutingManager::RxRaTracker::FindFavoredOnLinkPrefix(Ip6::Prefix &aPrefix) const
{
// Find the smallest preferred on-link prefix entry in the table
// and return it in `aPrefix`. If there is none, `aPrefix` is
// cleared (prefix length is set to zero).
aPrefix.Clear();
for (const Router &router : mRouters)
{
for (const OnLinkPrefix &entry : router.mOnLinkPrefixes)
{
if (entry.IsDeprecated() || (entry.GetPreferredLifetime() < kFavoredOnLinkPrefixMinPreferredLifetime))
{
continue;
}
if ((aPrefix.GetLength() == 0) || (entry.GetPrefix() < aPrefix))
{
aPrefix = entry.GetPrefix();
}
}
}
}
void RoutingManager::RxRaTracker::HandleLocalOnLinkPrefixChanged(void)
{
const Ip6::Prefix &prefix = Get<RoutingManager>().mOnLinkPrefixManager.GetLocalPrefix();
@@ -1390,9 +1307,7 @@ void RoutingManager::RxRaTracker::HandleLocalOnLinkPrefixChanged(void)
VerifyOrExit(didRemove);
RemoveRoutersWithNoEntriesOrFlags();
SignalTableChanged();
Evaluate();
exit:
return;
@@ -1419,8 +1334,7 @@ void RoutingManager::RxRaTracker::HandleNetDataChange(void)
if (didRemove)
{
RemoveRoutersWithNoEntriesOrFlags();
SignalTableChanged();
Evaluate();
}
}
@@ -1436,7 +1350,6 @@ void RoutingManager::RxRaTracker::RemoveOrDeprecateOldEntries(TimeMilli aTimeThr
if (entry.GetLastUpdateTime() <= aTimeThreshold)
{
entry.ClearPreferredLifetime();
SignalTableChanged();
}
}
@@ -1445,7 +1358,6 @@ void RoutingManager::RxRaTracker::RemoveOrDeprecateOldEntries(TimeMilli aTimeThr
if (entry.GetLastUpdateTime() <= aTimeThreshold)
{
entry.ClearValidLifetime();
SignalTableChanged();
}
}
}
@@ -1453,18 +1365,55 @@ void RoutingManager::RxRaTracker::RemoveOrDeprecateOldEntries(TimeMilli aTimeThr
if (mLocalRaHeader.IsValid() && (mLocalRaHeaderUpdateTime <= aTimeThreshold))
{
mLocalRaHeader.Clear();
SignalTableChanged();
}
RemoveExpiredEntries();
Evaluate();
}
void RoutingManager::RxRaTracker::ScheduleAllTimers(void)
void RoutingManager::RxRaTracker::Evaluate(void)
{
TimeMilli now = TimerMilli::GetNow();
NextFireTime routerTimeout(now);
NextFireTime entryExpireTime(now);
NextFireTime staleTime(now);
DecisionFactors oldFactors = mDecisionFactors;
TimeMilli now = TimerMilli::GetNow();
NextFireTime routerTimeout(now);
NextFireTime entryExpireTime(now);
NextFireTime staleTime(now);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Remove expired prefix entries in routers and then remove any
// router that has with no prefix entries or flags.
mRouters.RemoveAndFreeAllMatching(Router::EmptyChecker(now));
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Determine decision factors (favored on-link prefix, has any
// ULA/non-ULA on-link/route prefix, M/O flags).
mDecisionFactors.Clear();
for (Router &router : mRouters)
{
mDecisionFactors.UpdateFlagsFrom(router);
for (OnLinkPrefix &entry : router.mOnLinkPrefixes)
{
mDecisionFactors.UpdateFrom(entry);
entry.SetStaleTimeCalculated(false);
}
for (RoutePrefix &entry : router.mRoutePrefixes)
{
mDecisionFactors.UpdateFrom(entry);
entry.SetStaleTimeCalculated(false);
}
}
if (oldFactors != mDecisionFactors)
{
mSignalTask.Post();
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Schedule timers
// If multiple routers advertise the same on-link or route prefix,
// the stale time for the prefix is determined by the latest stale
@@ -1476,19 +1425,6 @@ void RoutingManager::RxRaTracker::ScheduleAllTimers(void)
// their entries, `DetermineStaleTimeFor()` will consider all
// matching entries and mark "StaleTimeCalculated" flag on them.
for (Router &router : mRouters)
{
for (OnLinkPrefix &entry : router.mOnLinkPrefixes)
{
entry.SetStaleTimeCalculated(false);
}
for (RoutePrefix &entry : router.mRoutePrefixes)
{
entry.SetStaleTimeCalculated(false);
}
}
for (const Router &router : mRouters)
{
if (router.ShouldCheckReachability())
@@ -1604,43 +1540,9 @@ exit:
return;
}
void RoutingManager::RxRaTracker::RemoveRoutersWithNoEntriesOrFlags(void)
{
mRouters.RemoveAndFreeAllMatching(Router::kContainsNoEntriesOrFlags);
}
void RoutingManager::RxRaTracker::HandleExpirationTimer(void) { Evaluate(); }
void RoutingManager::RxRaTracker::HandleExpirationTimer(void) { RemoveExpiredEntries(); }
void RoutingManager::RxRaTracker::RemoveExpiredEntries(void)
{
TimeMilli now = TimerMilli::GetNow();
bool didRemove = false;
for (Router &router : mRouters)
{
LifetimedPrefix::ExpirationChecker expirationChecker(now);
didRemove |= router.mOnLinkPrefixes.RemoveAndFreeAllMatching(expirationChecker);
didRemove |= router.mRoutePrefixes.RemoveAndFreeAllMatching(expirationChecker);
}
RemoveRoutersWithNoEntriesOrFlags();
if (didRemove)
{
SignalTableChanged();
}
ScheduleAllTimers();
}
void RoutingManager::RxRaTracker::SignalTableChanged(void) { mSignalTask.Post(); }
void RoutingManager::RxRaTracker::HandleSignalTask(void)
{
ScheduleAllTimers();
Get<RoutingManager>().HandleRaPrefixTableChanged();
}
void RoutingManager::RxRaTracker::HandleSignalTask(void) { Get<RoutingManager>().HandleRaPrefixTableChanged(); }
void RoutingManager::RxRaTracker::ProcessNeighborAdvertMessage(const NeighborAdvertMessage &aNaMessage)
{
@@ -1653,22 +1555,14 @@ void RoutingManager::RxRaTracker::ProcessNeighborAdvertMessage(const NeighborAdv
LogInfo("Received NA from router %s", router->mAddress.ToString().AsCString());
UpdateRouterOnRx(*router);
router->ResetReachabilityState();
Evaluate();
exit:
return;
}
void RoutingManager::RxRaTracker::UpdateRouterOnRx(Router &aRouter)
{
aRouter.mNsProbeCount = 0;
aRouter.mLastUpdateTime = TimerMilli::GetNow();
aRouter.mTimeout =
aRouter.mLastUpdateTime + Random::NonCrypto::AddJitter(Router::kReachableTimeout, Router::kJitter);
mRouterTimer.FireAtIfEarlier(aRouter.mTimeout);
}
void RoutingManager::RxRaTracker::HandleRouterTimer(void)
{
TimeMilli now = TimerMilli::GetNow();
@@ -1701,21 +1595,17 @@ void RoutingManager::RxRaTracker::HandleRouterTimer(void)
if (!entry.IsDeprecated())
{
entry.ClearPreferredLifetime();
SignalTableChanged();
}
}
for (RoutePrefix &entry : router.mRoutePrefixes)
{
entry.ClearValidLifetime();
SignalTableChanged();
}
}
}
RemoveExpiredEntries();
ScheduleAllTimers();
Evaluate();
}
void RoutingManager::RxRaTracker::SendNeighborSolicitToRouter(const Router &aRouter)
@@ -1737,39 +1627,16 @@ exit:
return;
}
void RoutingManager::RxRaTracker::DetermineAndSetFlags(RouterAdvert::Header &aHeader) const
void RoutingManager::RxRaTracker::SetHeaderFlagsOn(RouterAdvert::Header &aHeader) const
{
// Determine the `M` and `O` flags to include in the RA message
// header to be emitted.
//
// If any discovered router on infrastructure which is not itself a
// stub router (e.g., another Thread BR) includes the `M` or `O`
// flag, we also include the same flag.
//
// If a router has failed to respond to max number of NS probe
// attempts, we consider it as offline and ignore its flags.
for (const Router &router : mRouters)
if (mDecisionFactors.mHeaderManagedAddressConfigFlag)
{
if (router.mStubRouterFlag)
{
continue;
}
aHeader.SetManagedAddressConfigFlag();
}
if (!router.IsReachable())
{
continue;
}
if (router.mManagedAddressConfigFlag)
{
aHeader.SetManagedAddressConfigFlag();
}
if (router.mOtherConfigFlag)
{
aHeader.SetOtherConfigFlag();
}
if (mDecisionFactors.mHeaderOtherConfigFlag)
{
aHeader.SetOtherConfigFlag();
}
}
@@ -1923,19 +1790,31 @@ bool RoutingManager::RxRaTracker::Router::ShouldCheckReachability(void) const
return IsReachable() && !mIsLocalDevice;
}
bool RoutingManager::RxRaTracker::Router::Matches(EmptyChecker aChecker) const
void RoutingManager::RxRaTracker::Router::ResetReachabilityState(void)
{
// Checks whether or not a `Router` instance has any useful info. An
// entry can be removed if it does not advertise M or O flags and
// Called when an RA or NA is received and processed.
mNsProbeCount = 0;
mLastUpdateTime = TimerMilli::GetNow();
mTimeout = mLastUpdateTime + Random::NonCrypto::AddJitter(kReachableTimeout, kJitter);
}
bool RoutingManager::RxRaTracker::Router::Matches(const EmptyChecker &aChecker)
{
// First removes all expired on-link or router prefixes. Then
// checks whether or not the router has any useful info.
bool hasFlags = false;
mOnLinkPrefixes.RemoveAndFreeAllMatching(aChecker);
mRoutePrefixes.RemoveAndFreeAllMatching(aChecker);
// Router can be removed if it does not advertise M or O flags and
// also does not have any advertised prefix entries (RIO/PIO). If
// the router already failed to respond to max NS probe attempts,
// we consider it as offline and therefore do not consider its
// flags anymore.
OT_UNUSED_VARIABLE(aChecker);
bool hasFlags = false;
if (IsReachable())
{
hasFlags = (mManagedAddressConfigFlag || mOtherConfigFlag);
@@ -1955,6 +1834,68 @@ void RoutingManager::RxRaTracker::Router::CopyInfoTo(RouterEntry &aEntry, TimeMi
aEntry.mIsReachable = IsReachable();
}
//---------------------------------------------------------------------------------------------------------------------
// RxRaTracker::DecisionFactors
void RoutingManager::RxRaTracker::DecisionFactors::UpdateFlagsFrom(const Router &aRouter)
{
// Determine the `M` and `O` flags to include in the RA message
// header to be emitted.
//
// If any discovered router on infrastructure which is not itself a
// stub router (e.g., another Thread BR) includes the `M` or `O`
// flag, we also include the same flag.
VerifyOrExit(!aRouter.mStubRouterFlag);
VerifyOrExit(aRouter.IsReachable());
if (aRouter.mManagedAddressConfigFlag)
{
mHeaderManagedAddressConfigFlag = true;
}
if (aRouter.mOtherConfigFlag)
{
mHeaderOtherConfigFlag = true;
}
exit:
return;
}
void RoutingManager::RxRaTracker::DecisionFactors::UpdateFrom(const OnLinkPrefix &aOnLinkPrefix)
{
if (aOnLinkPrefix.GetPrefix().IsUniqueLocal())
{
mHasUlaOnLink = true;
}
else
{
mHasNonUlaOnLink = true;
}
// Determine favored on-link prefix
VerifyOrExit(!aOnLinkPrefix.IsDeprecated());
VerifyOrExit(aOnLinkPrefix.GetPreferredLifetime() >= kFavoredOnLinkPrefixMinPreferredLifetime);
if ((mFavoredOnLinkPrefix.GetLength() == 0) || (aOnLinkPrefix.GetPrefix() < mFavoredOnLinkPrefix))
{
mFavoredOnLinkPrefix = aOnLinkPrefix.GetPrefix();
}
exit:
return;
}
void RoutingManager::RxRaTracker::DecisionFactors::UpdateFrom(const RoutePrefix &aRoutePrefix)
{
if (!mHasNonUlaRoute)
{
mHasNonUlaRoute = !aRoutePrefix.GetPrefix().IsUniqueLocal();
}
}
//---------------------------------------------------------------------------------------------------------------------
// FavoredOmrPrefix
@@ -2379,7 +2320,7 @@ void RoutingManager::OnLinkPrefixManager::Evaluate(void)
{
VerifyOrExit(!Get<RoutingManager>().mRsSender.IsInProgress());
Get<RoutingManager>().mRxRaTracker.FindFavoredOnLinkPrefix(mFavoredDiscoveredPrefix);
mFavoredDiscoveredPrefix = Get<RoutingManager>().mRxRaTracker.GetFavoredOnLinkPrefix();
if ((mFavoredDiscoveredPrefix.GetLength() == 0) || (mFavoredDiscoveredPrefix == mLocalPrefix))
{
@@ -2431,11 +2372,7 @@ void RoutingManager::OnLinkPrefixManager::HandleRaPrefixTableChanged(void)
// prefix has changed, we trigger a re-evaluation of the routing
// policy.
Ip6::Prefix newFavoredPrefix;
Get<RoutingManager>().mRxRaTracker.FindFavoredOnLinkPrefix(newFavoredPrefix);
if (newFavoredPrefix != mFavoredDiscoveredPrefix)
if (Get<RoutingManager>().mRxRaTracker.GetFavoredOnLinkPrefix() != mFavoredDiscoveredPrefix)
{
Get<RoutingManager>().ScheduleRoutingPolicyEvaluation(kAfterRandomDelay);
}
src/core/border_router/routing_manager.hpp
+39 -29
View File
@@ -54,6 +54,7 @@
#include "border_router/infra_if.hpp"
#include "common/array.hpp"
#include "common/callback.hpp"
#include "common/equatable.hpp"
#include "common/error.hpp"
#include "common/heap_allocatable.hpp"
#include "common/heap_array.hpp"
@@ -658,12 +659,6 @@ private:
// base class for `OnLinkPrefix` or `RoutePrefix`.
public:
enum UlaChecker : bool
{
kIsNotUla = false,
kIsUla = true,
};
struct ExpirationChecker
{
explicit ExpirationChecker(TimeMilli aNow) { mNow = aNow; }
@@ -677,7 +672,6 @@ private:
TimeMilli GetExpireTime(void) const { return CalculateExpirationTime(mValidLifetime); }
bool Matches(const Ip6::Prefix &aPrefix) const { return (mPrefix == aPrefix); }
bool Matches(const UlaChecker &aIsUla) const { return (mPrefix.IsUniqueLocal() == aIsUla); }
bool Matches(const ExpirationChecker &aChecker) const { return (GetExpireTime() <= aChecker.mNow); }
void SetStaleTimeCalculated(bool aFlag) { mStaleTimeCalculated = aFlag; }
@@ -761,25 +755,27 @@ private:
RouterAdvOrigin aRaOrigin);
void ProcessNeighborAdvertMessage(const NeighborAdvertMessage &aNaMessage);
bool ContainsDefaultOrNonUlaRoutePrefix(void) const;
bool ContainsNonUlaOnLinkPrefix(void) const;
bool ContainsUlaOnLinkPrefix(void) const;
// Decision factors
bool ContainsDefaultOrNonUlaRoutePrefix(void) const { return mDecisionFactors.mHasNonUlaRoute; }
bool ContainsNonUlaOnLinkPrefix(void) const { return mDecisionFactors.mHasNonUlaOnLink; }
bool ContainsUlaOnLinkPrefix(void) const { return mDecisionFactors.mHasUlaOnLink; }
void FindFavoredOnLinkPrefix(Ip6::Prefix &aPrefix) const;
void HandleLocalOnLinkPrefixChanged(void);
void HandleNetDataChange(void);
void RemoveOrDeprecateOldEntries(TimeMilli aTimeThreshold);
const Ip6::Prefix &GetFavoredOnLinkPrefix(void) const { return mDecisionFactors.mFavoredOnLinkPrefix; }
void SetHeaderFlagsOn(RouterAdvert::Header &aHeader) const;
const RouterAdvert::Header &GetLocalRaHeaderToMirror(void) const { return mLocalRaHeader; }
void DetermineAndSetFlags(RouterAdvert::Header &aHeader) const;
// Iterating over discovered items
void InitIterator(PrefixTableIterator &aIterator) const;
Error GetNextEntry(PrefixTableIterator &aIterator, PrefixTableEntry &aEntry) const;
Error GetNextRouter(PrefixTableIterator &aIterator, RouterEntry &aEntry) const;
// Callbacks notifying of changes
void RemoveOrDeprecateOldEntries(TimeMilli aTimeThreshold);
void HandleLocalOnLinkPrefixChanged(void);
void HandleNetDataChange(void);
// Tasklet or timer callbacks
void HandleSignalTask(void);
void HandleExpirationTimer(void);
void HandleStaleTimer(void);
@@ -822,15 +818,13 @@ private:
static_assert(kMaxNsProbes < 255, "kMaxNsProbes MUST not be 255");
enum EmptyChecker : uint8_t
{
kContainsNoEntriesOrFlags
};
typedef LifetimedPrefix::ExpirationChecker EmptyChecker;
bool IsReachable(void) const { return mNsProbeCount <= kMaxNsProbes; }
bool ShouldCheckReachability(void) const;
void ResetReachabilityState(void);
bool Matches(const Ip6::Address &aAddress) const { return aAddress == mAddress; }
bool Matches(EmptyChecker aChecker) const;
bool Matches(const EmptyChecker &aChecker);
void CopyInfoTo(RouterEntry &aEntry, TimeMilli aNow) const;
using OnLinkPrefixList = OwningList<Entry<OnLinkPrefix>>;
@@ -911,18 +905,32 @@ private:
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
struct DecisionFactors : public Clearable<DecisionFactors>, public Equatable<DecisionFactors>
{
DecisionFactors(void) { Clear(); }
bool HasFavoredOnLink(void) const { return (mFavoredOnLinkPrefix.GetLength() != 0); }
void UpdateFlagsFrom(const Router &aRouter);
void UpdateFrom(const OnLinkPrefix &aOnLinkPrefix);
void UpdateFrom(const RoutePrefix &aRoutePrefix);
Ip6::Prefix mFavoredOnLinkPrefix;
bool mHasNonUlaRoute : 1;
bool mHasNonUlaOnLink : 1;
bool mHasUlaOnLink : 1;
bool mHeaderManagedAddressConfigFlag : 1;
bool mHeaderOtherConfigFlag : 1;
};
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProcessRaHeader(const RouterAdvert::Header &aRaHeader, Router &aRouter, RouterAdvOrigin aRaOrigin);
void ProcessPrefixInfoOption(const PrefixInfoOption &aPio, Router &aRouter);
void ProcessRouteInfoOption(const RouteInfoOption &aRio, Router &aRouter);
void ProcessRaFlagsExtOption(const RaFlagsExtOption &aFlagsOption, Router &aRouter);
bool ContainsOnLinkPrefix(OnLinkPrefix::UlaChecker aUlaChecker) const;
void RemoveRoutersWithNoEntriesOrFlags(void);
void RemoveExpiredEntries(void);
void SignalTableChanged(void);
void ScheduleAllTimers(void);
void Evaluate(void);
void DetermineStaleTimeFor(const OnLinkPrefix &aPrefix, NextFireTime &aStaleTime);
void DetermineStaleTimeFor(const RoutePrefix &aPrefix, NextFireTime &aStaleTime);
void UpdateRouterOnRx(Router &aRouter);
void SendNeighborSolicitToRouter(const Router &aRouter);
#if OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
template <class Type> Entry<Type> *AllocateEntry(void) { return Entry<Type>::Allocate(); }
@@ -936,6 +944,7 @@ private:
using RouterTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleRxRaTrackerRouterTimer>;
using RouterList = OwningList<Entry<Router>>;
DecisionFactors mDecisionFactors;
RouterList mRouters;
ExpirationTimer mExpirationTimer;
StaleTimer mStaleTimer;
@@ -943,6 +952,7 @@ private:
SignalTask mSignalTask;
RouterAdvert::Header mLocalRaHeader;
TimeMilli mLocalRaHeaderUpdateTime;
#if !OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
Pool<SharedEntry, kMaxEntries> mEntryPool;
Pool<Entry<Router>, kMaxRouters> mRouterPool;