Symbols ![]()
loading (2/5)...
Files ![]()
loading (4/5)...
ot::BorderRouter::RoutingManager class
Implements bi-directional routing between Thread and Infrastructure networks. The Border Routing manager works on both Thread interface and infrastructure interface. All ICMPv6 messages are sent/received on the infrastructure interface.
Syntax
class RoutingManager : public InstanceLocator
{
friend class ot::Notifier;
friend class ot::Instance;
#if OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE
friend void otPlatBorderRoutingProcessIcmp6Ra(otInstance *aInstance, const uint8_t *aMessage, uint16_t aLength);
friend void otPlatBorderRoutingProcessDhcp6PdPrefix(otInstance *aInstance,
const otBorderRoutingPrefixTableEntry *aPrefixInfo);
#endif
public:
typedef NetworkData::RoutePreference RoutePreference;
typedef otBorderRoutingPrefixTableIterator PrefixTableIterator;
typedef otBorderRoutingPrefixTableEntry PrefixTableEntry;
typedef otBorderRoutingRouterEntry RouterEntry;
typedef otBorderRoutingPeerBorderRouterEntry PeerBrEntry;
typedef otPdProcessedRaInfo PdProcessedRaInfo;
typedef otBorderRoutingRequestDhcp6PdCallback PdCallback;
static constexpr uint16_t kMaxPublishedPrefixes = 3;
enum State : uint8_t
{
kStateUninitialized = OT_BORDER_ROUTING_STATE_UNINITIALIZED,
kStateDisabled = OT_BORDER_ROUTING_STATE_DISABLED,
kStateStopped = OT_BORDER_ROUTING_STATE_STOPPED,
kStateRunning = OT_BORDER_ROUTING_STATE_RUNNING,
};
enum Dhcp6PdState : uint8_t
{
kDhcp6PdStateDisabled = OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED,
kDhcp6PdStateStopped = OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED,
kDhcp6PdStateRunning = OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING,
kDhcp6PdStateIdle = OT_BORDER_ROUTING_DHCP6_PD_STATE_IDLE,
};
explicit RoutingManager(Instance &aInstance);
Error Init(uint32_t aInfraIfIndex, bool aInfraIfIsRunning);
Error SetEnabled(bool aEnabled);
bool IsRunning(void) const { return mIsRunning; }
State GetState(void) const;
void RequestStop(void) { Stop(); }
RoutePreference GetRouteInfoOptionPreference(void) const { return mRioAdvertiser.GetPreference(); }
void SetRouteInfoOptionPreference(RoutePreference aPreference) { mRioAdvertiser.SetPreference(aPreference); }
void ClearRouteInfoOptionPreference(void) { mRioAdvertiser.ClearPreference(); }
Error SetExtraRouterAdvertOptions(const uint8_t *aOptions, uint16_t aLength);
RoutePreference GetRoutePreference(void) const { return mRoutePublisher.GetPreference(); }
void SetRoutePreference(RoutePreference aPreference) { mRoutePublisher.SetPreference(aPreference); }
void ClearRoutePreference(void) { mRoutePublisher.ClearPreference(); }
Error GetOmrPrefix(Ip6::Prefix &aPrefix) const;
Error GetFavoredOmrPrefix(Ip6::Prefix &aPrefix, RoutePreference &aPreference) const;
Error GetOnLinkPrefix(Ip6::Prefix &aPrefix) const;
Error GetFavoredOnLinkPrefix(Ip6::Prefix &aPrefix) const;
#if OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE
Nat64::State GetNat64PrefixManagerState(void) const { return mNat64PrefixManager.GetState(); }
void SetNat64PrefixManagerEnabled(bool aEnabled);
Error GetNat64Prefix(Ip6::Prefix &aPrefix);
Error GetFavoredNat64Prefix(Ip6::Prefix &aPrefix, RoutePreference &aRoutePreference);
void HandleDiscoverNat64PrefixDone(const Ip6::Prefix &aPrefix) { mNat64PrefixManager.HandleDiscoverDone(aPrefix); }
#endif
void HandleReceived(const InfraIf::Icmp6Packet &aPacket, const Ip6::Address &aSrcAddress);
void HandleInfraIfStateChanged(void) { EvaluateState(); }
static bool IsValidOmrPrefix(const NetworkData::OnMeshPrefixConfig &aOnMeshPrefixConfig);
static bool IsValidOmrPrefix(const Ip6::Prefix &aPrefix);
void InitPrefixTableIterator(PrefixTableIterator &aIterator) const { mRxRaTracker.InitIterator(aIterator); }
Error GetNextPrefixTableEntry(PrefixTableIterator &aIterator, PrefixTableEntry &aEntry) const
{
return mRxRaTracker.GetNextEntry(aIterator, aEntry);
}
Error GetNextRouterEntry(PrefixTableIterator &aIterator, RouterEntry &aEntry) const
{
return mRxRaTracker.GetNextRouter(aIterator, aEntry);
}
#if OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE
Error GetNextPeerBrEntry(PrefixTableIterator &aIterator, PeerBrEntry &aEntry) const
{
return mNetDataPeerBrTracker.GetNext(aIterator, aEntry);
}
uint16_t CountPeerBrs(uint32_t &aMinAge) const { return mNetDataPeerBrTracker.CountPeerBrs(aMinAge); }
#endif
#if OPENTHREAD_CONFIG_SRP_SERVER_ENABLE
void HandleSrpServerAutoEnableMode(void);
#endif
#if OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE
void SetDhcp6PdEnabled(bool aEnabled) { return mPdPrefixManager.SetEnabled(aEnabled); }
Dhcp6PdState GetDhcp6PdState(void) const { return mPdPrefixManager.GetState(); }
void SetRequestDhcp6PdCallback(PdCallback aCallback, void *aContext)
{
mPdPrefixManager.SetStateCallback(aCallback, aContext);
}
Error GetPdOmrPrefix(PrefixTableEntry &aPrefixInfo) const;
Error GetPdProcessedRaInfo(PdProcessedRaInfo &aPdProcessedRaInfo);
#endif
#if OPENTHREAD_CONFIG_BORDER_ROUTING_REACHABILITY_CHECK_ICMP6_ERROR_ENABLE
void CheckReachabilityToSendIcmpError(const Message &aMessage, const Ip6::Header &aIp6Header);
#endif
#if OPENTHREAD_CONFIG_BORDER_ROUTING_TESTING_API_ENABLE
void SetOnLinkPrefix(const Ip6::Prefix &aPrefix) { mOnLinkPrefixManager.SetLocalPrefix(aPrefix); }
#endif
private:
static constexpr uint8_t kMaxOnMeshPrefixes = OPENTHREAD_CONFIG_BORDER_ROUTING_MAX_ON_MESH_PREFIXES;
static constexpr uint8_t kOmrPrefixLength = 64;
static constexpr uint8_t kOnLinkPrefixLength = 64;
static constexpr uint8_t kBrUlaPrefixLength = 48;
static constexpr uint8_t kNat64PrefixLength = 96;
static constexpr uint16_t kOmrPrefixSubnetId = 1;
static constexpr uint16_t kNat64PrefixSubnetId = 2;
static constexpr uint32_t kDefaultOmrPrefixLifetime = 1800;
static constexpr uint32_t kDefaultOnLinkPrefixLifetime = 1800;
static constexpr uint32_t kDefaultNat64PrefixLifetime = 300;
static constexpr uint32_t kStaleTime = 600;
static constexpr uint32_t kInitalRaTxCount = 3;
static constexpr uint32_t kInitalRaInterval = Time::kOneSecondInMsec * 16;
static constexpr uint16_t kInitialRaJitter = Time::kOneSecondInMsec * 2;
static constexpr uint32_t kRaBeaconInterval = Time::kOneSecondInMsec * 180;
static constexpr uint16_t kRaBeaconJitter = Time::kOneSecondInMsec * 15;
static constexpr uint32_t kMinDelayBetweenRas = Time::kOneSecondInMsec * 3;
static constexpr uint32_t kRsReplyInterval = 250;
static constexpr uint16_t kRsReplyJitter = 250;
static constexpr uint32_t kEvaluationInterval = Time::kOneSecondInMsec * 3;
static constexpr uint16_t kEvaluationJitter = Time::kOneSecondInMsec * 1;
using Option = Ip6::Nd::Option;
using PrefixInfoOption = Ip6::Nd::PrefixInfoOption;
using RouteInfoOption = Ip6::Nd::RouteInfoOption;
using RaFlagsExtOption = Ip6::Nd::RaFlagsExtOption;
using RouterAdvert = Ip6::Nd::RouterAdvert;
using NeighborAdvertMessage = Ip6::Nd::NeighborAdvertMessage;
using TxMessage = Ip6::Nd::TxMessage;
using NeighborSolicitHeader = Ip6::Nd::NeighborSolicitHeader;
using RouterSolicitHeader = Ip6::Nd::RouterSolicitHeader;
using LinkLayerAddress = InfraIf::LinkLayerAddress;
enum RouterAdvTxMode : uint8_t
{
kInvalidateAllPrevPrefixes,
kAdvPrefixesFromNetData,
};
enum RouterAdvOrigin : uint8_t
{
kAnotherRouter,
kThisBrRoutingManager,
kThisBrOtherEntity,
};
enum ScheduleMode : uint8_t
{
kImmediately,
kForNextRa,
kAfterRandomDelay,
kToReplyToRs,
};
class LifetimedPrefix
{
public:
struct ExpirationChecker
{
explicit ExpirationChecker(TimeMilli aNow) { mNow = aNow; }
TimeMilli mNow;
};
const Ip6::Prefix &GetPrefix(void) const { return mPrefix; }
Ip6::Prefix &GetPrefix(void) { return mPrefix; }
const TimeMilli &GetLastUpdateTime(void) const { return mLastUpdateTime; }
uint32_t GetValidLifetime(void) const { return mValidLifetime; }
TimeMilli GetExpireTime(void) const { return CalculateExpirationTime(mValidLifetime); }
bool Matches(const Ip6::Prefix &aPrefix) const { return (mPrefix == aPrefix); }
bool Matches(const ExpirationChecker &aChecker) const { return (GetExpireTime() <= aChecker.mNow); }
void SetStaleTimeCalculated(bool aFlag) { mStaleTimeCalculated = aFlag; }
bool IsStaleTimeCalculated(void) const { return mStaleTimeCalculated; }
void SetDisregardFlag(bool aFlag) { mDisregard = aFlag; }
bool ShouldDisregard(void) const { return mDisregard; }
protected:
LifetimedPrefix(void) = default;
TimeMilli CalculateExpirationTime(uint32_t aLifetime) const;
Ip6::Prefix mPrefix;
bool mDisregard : 1;
bool mStaleTimeCalculated : 1;
uint32_t mValidLifetime;
TimeMilli mLastUpdateTime;
};
class OnLinkPrefix : public LifetimedPrefix, public Clearable<OnLinkPrefix>
{
public:
void SetFrom(const PrefixInfoOption &aPio);
void SetFrom(const PrefixTableEntry &aPrefixTableEntry);
uint32_t GetPreferredLifetime(void) const { return mPreferredLifetime; }
void ClearPreferredLifetime(void) { mPreferredLifetime = 0; }
bool IsDeprecated(void) const;
TimeMilli GetDeprecationTime(void) const;
TimeMilli GetStaleTime(void) const;
void AdoptValidAndPreferredLifetimesFrom(const OnLinkPrefix &aPrefix);
void CopyInfoTo(PrefixTableEntry &aEntry, TimeMilli aNow) const;
bool IsFavoredOver(const Ip6::Prefix &aPrefix) const;
private:
static constexpr uint32_t kFavoredMinPreferredLifetime = 1800;
uint32_t mPreferredLifetime;
};
class RoutePrefix : public LifetimedPrefix, public Clearable<RoutePrefix>
{
public:
void SetFrom(const RouteInfoOption &aRio);
void SetFrom(const RouterAdvert::Header &aRaHeader);
void ClearValidLifetime(void) { mValidLifetime = 0; }
TimeMilli GetStaleTime(void) const;
RoutePreference GetRoutePreference(void) const { return mRoutePreference; }
void CopyInfoTo(PrefixTableEntry &aEntry, TimeMilli aNow) const;
private:
RoutePreference mRoutePreference;
};
#if OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE
class RxRaTracker;
class NetDataPeerBrTracker : public InstanceLocator
{
friend class RxRaTracker;
public:
explicit NetDataPeerBrTracker(Instance &aInstance);
uint16_t CountPeerBrs(uint32_t &aMinAge) const;
Error GetNext(PrefixTableIterator &aIterator, PeerBrEntry &aEntry) const;
void HandleNotifierEvents(Events aEvents);
private:
struct PeerBr : LinkedListEntry<PeerBr>, Heap::Allocatable<PeerBr>
{
struct Filter
{
Filter(const NetworkData::Rlocs &aRlocs)
: mExcludeRlocs(aRlocs)
{
}
const NetworkData::Rlocs &mExcludeRlocs;
};
uint32_t GetAge(uint32_t aUptime) const { return aUptime - mDiscoverTime; }
bool Matches(uint16_t aRloc16) const { return mRloc16 == aRloc16; }
bool Matches(const Filter &aFilter) const { return !aFilter.mExcludeRlocs.Contains(mRloc16); }
PeerBr *mNext;
uint16_t mRloc16;
uint32_t mDiscoverTime;
};
OwningList<PeerBr> mPeerBrs;
};
#endif
void HandleRxRaTrackerSignalTask(void) { mRxRaTracker.HandleSignalTask(); }
void HandleRxRaTrackerExpirationTimer(void) { mRxRaTracker.HandleExpirationTimer(); }
void HandleRxRaTrackerStaleTimer(void) { mRxRaTracker.HandleStaleTimer(); }
void HandleRxRaTrackerRouterTimer(void) { mRxRaTracker.HandleRouterTimer(); }
class RxRaTracker : public InstanceLocator
{
friend class NetDataPeerBrTracker;
public:
explicit RxRaTracker(Instance &aInstance);
void Start(void);
void Stop(void);
void ProcessRouterAdvertMessage(const RouterAdvert::RxMessage &aRaMessage,
const Ip6::Address &aSrcAddress,
RouterAdvOrigin aRaOrigin);
void ProcessNeighborAdvertMessage(const NeighborAdvertMessage &aNaMessage);
bool ContainsDefaultOrNonUlaRoutePrefix(void) const { return mDecisionFactors.mHasNonUlaRoute; }
bool ContainsNonUlaOnLinkPrefix(void) const { return mDecisionFactors.mHasNonUlaOnLink; }
bool ContainsUlaOnLinkPrefix(void) const { return mDecisionFactors.mHasUlaOnLink; }
const Ip6::Prefix &GetFavoredOnLinkPrefix(void) const { return mDecisionFactors.mFavoredOnLinkPrefix; }
void SetHeaderFlagsOn(RouterAdvert::Header &aHeader) const;
const RouterAdvert::Header &GetLocalRaHeaderToMirror(void) const { return mLocalRaHeader; }
bool IsAddressOnLink(const Ip6::Address &aAddress) const;
bool IsAddressReachableThroughExplicitRoute(const Ip6::Address &aAddress) const;
void InitIterator(PrefixTableIterator &aIterator) const;
Error GetNextEntry(PrefixTableIterator &aIterator, PrefixTableEntry &aEntry) const;
Error GetNextRouter(PrefixTableIterator &aIterator, RouterEntry &aEntry) const;
void RemoveOrDeprecateOldEntries(TimeMilli aTimeThreshold);
void HandleLocalOnLinkPrefixChanged(void);
void HandleNetDataChange(void);
void HandleSignalTask(void);
void HandleExpirationTimer(void);
void HandleStaleTimer(void);
void HandleRouterTimer(void);
private:
template <class Type>
struct Entry : public Type,
public LinkedListEntry<Entry<Type>>,
#if OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
public Heap::Allocatable<Entry<Type>>
#else
public InstanceLocatorInit
#endif
{
#if !OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
void Init(Instance &aInstance) { InstanceLocatorInit::Init(aInstance); }
void Free(void);
#endif
Entry<Type> *mNext;
};
struct Router : public Clearable<Router>
{
static constexpr uint32_t kReachableInterval = OPENTHREAD_CONFIG_BORDER_ROUTING_ROUTER_ACTIVE_CHECK_TIMEOUT;
static constexpr uint32_t kPeerBrReachableInterval = Time::kOneSecondInMsec * 200;
static constexpr uint8_t kMaxNsProbes = 5;
static constexpr uint32_t kNsProbeRetryInterval = 1000;
static constexpr uint32_t kNsProbeTimeout = 2000;
static constexpr uint32_t kJitter = 2000;
static_assert(kMaxNsProbes < 255, "kMaxNsProbes MUST not be 255");
typedef LifetimedPrefix::ExpirationChecker EmptyChecker;
bool IsReachable(void) const { return mNsProbeCount <= kMaxNsProbes; }
bool ShouldCheckReachability(void) const;
void ResetReachabilityState(void);
void DetermineReachabilityTimeout(void);
bool Matches(const Ip6::Address &aAddress) const { return aAddress == mAddress; }
bool Matches(const EmptyChecker &aChecker);
bool IsPeerBr(void) const;
void CopyInfoTo(RouterEntry &aEntry, TimeMilli aNow, uint32_t aUptime) const;
using OnLinkPrefixList = OwningList<Entry<OnLinkPrefix>>;
using RoutePrefixList = OwningList<Entry<RoutePrefix>>;
Ip6::Address mAddress;
OnLinkPrefixList mOnLinkPrefixes;
RoutePrefixList mRoutePrefixes;
uint32_t mDiscoverTime;
TimeMilli mLastUpdateTime;
TimeMilli mTimeoutTime;
uint8_t mNsProbeCount;
bool mManagedAddressConfigFlag : 1;
bool mOtherConfigFlag : 1;
bool mSnacRouterFlag : 1;
bool mIsLocalDevice : 1;
bool mAllEntriesDisregarded : 1;
};
class Iterator : public PrefixTableIterator
{
public:
enum Type : uint8_t
{
kUnspecified,
kRouterIterator,
kPrefixIterator,
kPeerBrIterator,
};
enum EntryType : uint8_t
{
kOnLinkPrefix,
kRoutePrefix,
};
void Init(const Entry<Router> *aRoutersHead, uint32_t aUptime);
Error AdvanceToNextRouter(Type aType);
Error AdvanceToNextEntry(void);
uint32_t GetInitUptime(void) const { return mData0; }
TimeMilli GetInitTime(void) const { return TimeMilli(mData1); }
Type GetType(void) const { return static_cast<Type>(mData2); }
const Entry<Router> *GetRouter(void) const { return static_cast<const Entry<Router> *>(mPtr1); }
EntryType GetEntryType(void) const { return static_cast<EntryType>(mData3); }
template <class PrefixType> const Entry<PrefixType> *GetEntry(void) const
{
return static_cast<const Entry<PrefixType> *>(mPtr2);
}
#if OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE
using PeerBr = NetDataPeerBrTracker::PeerBr;
Error AdvanceToNextPeerBr(const PeerBr *aPeerBrsHead);
const PeerBr *GetPeerBrEntry(void) const { return static_cast<const PeerBr *>(mPtr2); }
#endif
private:
void SetRouter(const Entry<Router> *aRouter) { mPtr1 = aRouter; }
void SetInitUptime(uint32_t aUptime) { mData0 = aUptime; }
void SetInitTime(void) { mData1 = TimerMilli::GetNow().GetValue(); }
void SetEntry(const void *aEntry) { mPtr2 = aEntry; }
bool HasEntry(void) const { return mPtr2 != nullptr; }
void SetEntryType(EntryType aType) { mData3 = aType; }
void SetType(Type aType) { mData2 = aType; }
};
#if !OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
static constexpr uint16_t kMaxRouters = OPENTHREAD_CONFIG_BORDER_ROUTING_MAX_DISCOVERED_ROUTERS;
static constexpr uint16_t kMaxEntries = OPENTHREAD_CONFIG_BORDER_ROUTING_MAX_DISCOVERED_PREFIXES;
union SharedEntry
{
SharedEntry(void) { mNext = nullptr; }
void SetNext(SharedEntry *aNext) { mNext = aNext; }
SharedEntry *GetNext(void) { return mNext; }
const SharedEntry *GetNext(void) const { return mNext; }
template <class PrefixType> Entry<PrefixType> &GetEntry(void);
SharedEntry *mNext;
Entry<OnLinkPrefix> mOnLinkEntry;
Entry<RoutePrefix> mRouteEntry;
};
#endif
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 Evaluate(void);
void DetermineStaleTimeFor(const OnLinkPrefix &aPrefix, NextFireTime &aStaleTime);
void DetermineStaleTimeFor(const RoutePrefix &aPrefix, NextFireTime &aStaleTime);
void SendNeighborSolicitToRouter(const Router &aRouter);
#if OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
template <class Type> Entry<Type> *AllocateEntry(void) { return Entry<Type>::Allocate(); }
#else
template <class Type> Entry<Type> *AllocateEntry(void);
#endif
using SignalTask = TaskletIn<RoutingManager, &RoutingManager::HandleRxRaTrackerSignalTask>;
using ExpirationTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleRxRaTrackerExpirationTimer>;
using StaleTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleRxRaTrackerStaleTimer>;
using RouterTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleRxRaTrackerRouterTimer>;
using RouterList = OwningList<Entry<Router>>;
DecisionFactors mDecisionFactors;
RouterList mRouters;
ExpirationTimer mExpirationTimer;
StaleTimer mStaleTimer;
RouterTimer mRouterTimer;
SignalTask mSignalTask;
RouterAdvert::Header mLocalRaHeader;
TimeMilli mLocalRaHeaderUpdateTime;
#if !OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
Pool<SharedEntry, kMaxEntries> mEntryPool;
Pool<Entry<Router>, kMaxRouters> mRouterPool;
#endif
};
class OmrPrefixManager;
class OmrPrefix : public Clearable<OmrPrefix>
{
friend class OmrPrefixManager;
public:
OmrPrefix(void) { Clear(); }
bool IsEmpty(void) const { return (mPrefix.GetLength() == 0); }
const Ip6::Prefix &GetPrefix(void) const { return mPrefix; }
RoutePreference GetPreference(void) const { return mPreference; }
bool IsDomainPrefix(void) const { return mIsDomainPrefix; }
protected:
Ip6::Prefix mPrefix;
RoutePreference mPreference;
bool mIsDomainPrefix;
};
class FavoredOmrPrefix : public OmrPrefix
{
friend class OmrPrefixManager;
public:
bool IsInfrastructureDerived(void) const;
private:
void SetFrom(const NetworkData::OnMeshPrefixConfig &aOnMeshPrefixConfig);
void SetFrom(const OmrPrefix &aOmrPrefix);
bool IsFavoredOver(const NetworkData::OnMeshPrefixConfig &aOmrPrefixConfig) const;
};
class OmrPrefixManager : public InstanceLocator
{
public:
explicit OmrPrefixManager(Instance &aInstance);
void Init(const Ip6::Prefix &aBrUlaPrefix);
void Start(void);
void Stop(void);
void Evaluate(void);
void UpdateDefaultRouteFlag(bool aDefaultRoute);
bool ShouldAdvertiseLocalAsRio(void) const;
const Ip6::Prefix &GetGeneratedPrefix(void) const { return mGeneratedPrefix; }
const OmrPrefix &GetLocalPrefix(void) const { return mLocalPrefix; }
const FavoredOmrPrefix &GetFavoredPrefix(void) const { return mFavoredPrefix; }
private:
static constexpr uint16_t kInfoStringSize = 85;
typedef String<kInfoStringSize> InfoString;
void DetermineFavoredPrefix(void);
Error AddLocalToNetData(void);
Error AddOrUpdateLocalInNetData(void);
void RemoveLocalFromNetData(void);
InfoString LocalToString(void) const;
OmrPrefix mLocalPrefix;
Ip6::Prefix mGeneratedPrefix;
FavoredOmrPrefix mFavoredPrefix;
bool mIsLocalAddedInNetData;
bool mDefaultRoute;
};
void HandleOnLinkPrefixManagerTimer(void) { mOnLinkPrefixManager.HandleTimer(); }
class OnLinkPrefixManager : public InstanceLocator
{
public:
explicit OnLinkPrefixManager(Instance &aInstance);
static constexpr uint16_t kMaxOldPrefixes = OPENTHREAD_CONFIG_BORDER_ROUTING_MAX_OLD_ON_LINK_PREFIXES;
void Init(void);
void Start(void);
void Stop(void);
void Evaluate(void);
const Ip6::Prefix &GetLocalPrefix(void) const { return mLocalPrefix; }
const Ip6::Prefix &GetFavoredDiscoveredPrefix(void) const { return mFavoredDiscoveredPrefix; }
bool AddressMatchesLocalPrefix(const Ip6::Address &aAddress) const;
bool IsInitalEvaluationDone(void) const;
void HandleRaPrefixTableChanged(void);
bool ShouldPublishUlaRoute(void) const;
Error AppendAsPiosTo(RouterAdvert::TxMessage &aRaMessage);
void HandleNetDataChange(void);
void HandleExtPanIdChange(void);
void HandleTimer(void);
#if OPENTHREAD_CONFIG_BORDER_ROUTING_TESTING_API_ENABLE
void SetLocalPrefix(const Ip6::Prefix &aPrefix) { mLocalPrefix = aPrefix; }
#endif
private:
enum State : uint8_t
{
kIdle,
kPublishing,
kAdvertising,
kDeprecating,
};
struct OldPrefix
{
bool Matches(const Ip6::Prefix &aPrefix) const { return mPrefix == aPrefix; }
Ip6::Prefix mPrefix;
TimeMilli mExpireTime;
};
State GetState(void) const { return mState; }
void SetState(State aState);
bool IsPublishingOrAdvertising(void) const;
void GenerateLocalPrefix(void);
void PublishAndAdvertise(void);
void Deprecate(void);
void ResetExpireTime(TimeMilli aNow);
Error AppendCurPrefix(RouterAdvert::TxMessage &aRaMessage);
Error AppendOldPrefixes(RouterAdvert::TxMessage &aRaMessage);
void DeprecateOldPrefix(const Ip6::Prefix &aPrefix, TimeMilli aExpireTime);
void SavePrefix(const Ip6::Prefix &aPrefix, TimeMilli aExpireTime);
static const char *StateToString(State aState);
using ExpireTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleOnLinkPrefixManagerTimer>;
Ip6::Prefix mLocalPrefix;
State mState;
TimeMilli mExpireTime;
Ip6::Prefix mFavoredDiscoveredPrefix;
Array<OldPrefix, kMaxOldPrefixes> mOldLocalPrefixes;
ExpireTimer mTimer;
};
void HandleRioAdvertiserimer(void) { mRioAdvertiser.HandleTimer(); }
class RioAdvertiser : public InstanceLocator
{
public:
explicit RioAdvertiser(Instance &aInstance);
RoutePreference GetPreference(void) const { return mPreference; }
void SetPreference(RoutePreference aPreference);
void ClearPreference(void);
void HandleRoleChanged(void);
Error AppendRios(RouterAdvert::TxMessage &aRaMessage);
Error InvalidatPrevRios(RouterAdvert::TxMessage &aRaMessage);
bool HasAdvertised(const Ip6::Prefix &aPrefix) const { return mPrefixes.ContainsMatching(aPrefix); }
uint16_t GetAdvertisedRioCount(void) const { return mPrefixes.GetLength(); }
void HandleTimer(void);
private:
static constexpr uint32_t kDeprecationTime = TimeMilli::SecToMsec(300);
struct RioPrefix : public Clearable<RioPrefix>
{
bool Matches(const Ip6::Prefix &aPrefix) const { return (mPrefix == aPrefix); }
Ip6::Prefix mPrefix;
bool mIsDeprecating;
TimeMilli mExpirationTime;
};
struct RioPrefixArray :
#if OPENTHREAD_CONFIG_BORDER_ROUTING_USE_HEAP_ENABLE
public Heap::Array<RioPrefix>
#else
public Array<RioPrefix, 2 * kMaxOnMeshPrefixes>
#endif
{
void Add(const Ip6::Prefix &aPrefix);
};
void SetPreferenceBasedOnRole(void);
void UpdatePreference(RoutePreference aPreference);
Error AppendRio(const Ip6::Prefix &aPrefix,
uint32_t aRouteLifetime,
RoutePreference aPreference,
RouterAdvert::TxMessage &aRaMessage);
using RioTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleRioAdvertiserimer>;
RioPrefixArray mPrefixes;
RioTimer mTimer;
RoutePreference mPreference;
bool mUserSetPreference;
};
#if OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE
void HandleNat64PrefixManagerTimer(void) { mNat64PrefixManager.HandleTimer(); }
class Nat64PrefixManager : public InstanceLocator
{
public:
explicit Nat64PrefixManager(Instance &aInstance);
void SetEnabled(bool aEnabled);
Nat64::State GetState(void) const;
void Start(void);
void Stop(void);
void GenerateLocalPrefix(const Ip6::Prefix &aBrUlaPrefix);
const Ip6::Prefix &GetLocalPrefix(void) const { return mLocalPrefix; }
const Ip6::Prefix &GetFavoredPrefix(RoutePreference &aPreference) const;
void Evaluate(void);
void HandleDiscoverDone(const Ip6::Prefix &aPrefix);
void HandleTimer(void);
private:
void Discover(void);
void Publish(void);
using Nat64Timer = TimerMilliIn<RoutingManager, &RoutingManager::HandleNat64PrefixManagerTimer>;
bool mEnabled;
Ip6::Prefix mInfraIfPrefix;
Ip6::Prefix mLocalPrefix;
Ip6::Prefix mPublishedPrefix;
RoutePreference mPublishedPreference;
Nat64Timer mTimer;
};
#endif
void HandleRoutePublisherTimer(void) { mRoutePublisher.HandleTimer(); }
class RoutePublisher : public InstanceLocator
{
public:
explicit RoutePublisher(Instance &aInstance);
void Start(void) { Evaluate(); }
void Stop(void) { Unpublish(); }
void Evaluate(void);
void UpdateAdvPioFlags(bool aAdvPioFlag);
RoutePreference GetPreference(void) const { return mPreference; }
void SetPreference(RoutePreference aPreference);
void ClearPreference(void);
void HandleNotifierEvents(Events aEvents);
void HandleTimer(void);
static const Ip6::Prefix &GetUlaPrefix(void) { return AsCoreType(&kUlaPrefix); }
private:
static constexpr uint32_t kDelayBeforePrfUpdateOnLinkQuality3 = TimeMilli::SecToMsec(5 * 60);
static const otIp6Prefix kUlaPrefix;
enum State : uint8_t
{
kDoNotPublish,
kPublishDefault,
kPublishUla,
};
void DeterminePrefixFor(State aState, Ip6::Prefix &aPrefix) const;
void UpdatePublishedRoute(State aNewState);
void Unpublish(void);
void SetPreferenceBasedOnRole(void);
void UpdatePreference(RoutePreference aPreference);
static const char *StateToString(State aState);
using DelayTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleRoutePublisherTimer>;
State mState;
RoutePreference mPreference;
bool mUserSetPreference;
bool mAdvPioFlag;
DelayTimer mTimer;
};
struct TxRaInfo
{
typedef Crypto::Sha256::Hash Hash;
static constexpr uint16_t kNumHashEntries = 5;
TxRaInfo(void)
: mTxCount(0)
, mLastTxTime(TimerMilli::GetNow() - kMinDelayBetweenRas)
, mLastHashIndex(0)
{
}
void IncrementTxCountAndSaveHash(const InfraIf::Icmp6Packet &aRaMessage);
bool IsRaFromManager(const RouterAdvert::RxMessage &aRaMessage) const;
static void CalculateHash(const RouterAdvert::RxMessage &aRaMessage, Hash &aHash);
uint32_t mTxCount;
TimeMilli mLastTxTime;
Hash mHashes[kNumHashEntries];
uint16_t mLastHashIndex;
};
void HandleRsSenderTimer(void) { mRsSender.HandleTimer(); }
class RsSender : public InstanceLocator
{
public:
explicit RsSender(Instance &aInstance);
bool IsInProgress(void) const { return mTimer.IsRunning(); }
void Start(void);
void Stop(void);
void HandleTimer(void);
private:
static constexpr uint32_t kMaxStartDelay = 1000;
static constexpr uint32_t kTxInterval = 4000;
static constexpr uint32_t kRetryDelay = kTxInterval;
static constexpr uint32_t kWaitOnLastAttempt = 1000;
static constexpr uint8_t kMaxTxCount = 3;
Error SendRs(void);
using RsTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandleRsSenderTimer>;
uint8_t mTxCount;
RsTimer mTimer;
TimeMilli mStartTime;
};
#if OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE
void HandlePdPrefixManagerTimer(void) { mPdPrefixManager.HandleTimer(); }
class PdPrefixManager : public InstanceLocator
{
public:
typedef Dhcp6PdState State;
static constexpr RoutePreference kPdRoutePreference = RoutePreference::kRoutePreferenceMedium;
explicit PdPrefixManager(Instance &aInstance);
void SetEnabled(bool aEnabled);
void Start(void) { StartStop( true); }
void Stop(void) { StartStop( false); }
bool IsRunning(void) const { return GetState() == kDhcp6PdStateRunning; }
bool HasPrefix(void) const { return IsValidOmrPrefix(mPrefix.GetPrefix()); }
const Ip6::Prefix &GetPrefix(void) const { return mPrefix.GetPrefix(); }
State GetState(void) const;
void ProcessRa(const uint8_t *aRouterAdvert, uint16_t aLength);
void ProcessPrefix(const PrefixTableEntry &aPrefixTableEntry);
Error GetPrefixInfo(PrefixTableEntry &aInfo) const;
Error GetProcessedRaInfo(PdProcessedRaInfo &aPdProcessedRaInfo) const;
void HandleTimer(void) { WithdrawPrefix(); }
void SetStateCallback(PdCallback aCallback, void *aContext) { mStateCallback.Set(aCallback, aContext); }
void Evaluate(void);
private:
class PrefixEntry : public OnLinkPrefix
{
public:
PrefixEntry(void) { Clear(); }
bool IsEmpty(void) const { return (GetPrefix().GetLength() == 0); }
bool IsValidPdPrefix(void) const;
bool IsFavoredOver(const PrefixEntry &aOther) const;
};
void Process(const InfraIf::Icmp6Packet *aRaPacket, const PrefixTableEntry *aPrefixTableEntry);
bool ProcessPrefixEntry(PrefixEntry &aEntry, PrefixEntry &aFavoredEntry);
void EvaluateStateChange(State aOldState);
void WithdrawPrefix(void);
void StartStop(bool aStart);
void PauseResume(bool aPause);
static const char *StateToString(State aState);
using PrefixTimer = TimerMilliIn<RoutingManager, &RoutingManager::HandlePdPrefixManagerTimer>;
using StateCallback = Callback<PdCallback>;
bool mEnabled;
bool mIsStarted;
bool mIsPaused;
uint32_t mNumPlatformPioProcessed;
uint32_t mNumPlatformRaReceived;
TimeMilli mLastPlatformRaTime;
StateCallback mStateCallback;
PrefixTimer mTimer;
PrefixEntry mPrefix;
};
#endif
void EvaluateState(void);
void Start(void);
void Stop(void);
void HandleNotifierEvents(Events aEvents);
bool IsInitialized(void) const { return mInfraIf.IsInitialized(); }
bool IsEnabled(void) const { return mIsEnabled; }
Error LoadOrGenerateRandomBrUlaPrefix(void);
void EvaluateRoutingPolicy(void);
bool IsInitialPolicyEvaluationDone(void) const;
void ScheduleRoutingPolicyEvaluation(ScheduleMode aMode);
void HandleRsSenderFinished(TimeMilli aStartTime);
void SendRouterAdvertisement(RouterAdvTxMode aRaTxMode);
void HandleRouterAdvertisement(const InfraIf::Icmp6Packet &aPacket, const Ip6::Address &aSrcAddress);
void HandleRouterSolicit(const InfraIf::Icmp6Packet &aPacket, const Ip6::Address &aSrcAddress);
void HandleNeighborAdvertisement(const InfraIf::Icmp6Packet &aPacket);
bool NetworkDataContainsUlaRoute(void) const;
void HandleRaPrefixTableChanged(void);
void HandleLocalOnLinkPrefixChanged(void);
static TimeMilli CalculateExpirationTime(TimeMilli aUpdateTime, uint32_t aLifetime);
static bool IsValidBrUlaPrefix(const Ip6::Prefix &aBrUlaPrefix);
static bool IsValidOnLinkPrefix(const PrefixInfoOption &aPio);
static bool IsValidOnLinkPrefix(const Ip6::Prefix &aOnLinkPrefix);
static void LogRaHeader(const RouterAdvert::Header &aRaHeader);
static void LogPrefixInfoOption(const Ip6::Prefix &aPrefix, uint32_t aValidLifetime, uint32_t aPreferredLifetime);
static void LogRouteInfoOption(const Ip6::Prefix &aPrefix, uint32_t aLifetime, RoutePreference aPreference);
static const char *RouterAdvOriginToString(RouterAdvOrigin aRaOrigin);
using RoutingPolicyTimer = TimerMilliIn<RoutingManager, &RoutingManager::EvaluateRoutingPolicy>;
bool mIsRunning;
bool mIsEnabled;
InfraIf mInfraIf;
Ip6::Prefix mBrUlaPrefix;
OmrPrefixManager mOmrPrefixManager;
RioAdvertiser mRioAdvertiser;
RoutePreference mRioPreference;
bool mUserSetRioPreference;
OnLinkPrefixManager mOnLinkPrefixManager;
#if OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE
NetDataPeerBrTracker mNetDataPeerBrTracker;
#endif
RxRaTracker mRxRaTracker;
RoutePublisher mRoutePublisher;
#if OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE
Nat64PrefixManager mNat64PrefixManager;
#endif
#if OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE
PdPrefixManager mPdPrefixManager;
#endif
TxRaInfo mTxRaInfo;
RsSender mRsSender;
Heap::Data mExtraRaOptions;
RoutingPolicyTimer mRoutingPolicyTimer;
};
Fields
Field
Description
Declared as
This constant specifies the maximum number of route prefixes that may be published by `RoutingManager` in Thread Network Data. This is used by `NetworkData::Publisher` to reserve entries for use by `RoutingManager`. The number of published entries accounts for: - Route prefix `fc00::/7` or `::/0` - One entry for NAT64 published prefix. - One extra entry for transitions.
RoutingPolicyTimer
References
Code
Location
Scope
Referrer
Class Tree
ot::BorderRouter::RoutingManager is inherited by 1 classes:
Instances
Instance
Scope
Location
Project