| /* |
| * Copyright (c) 2016, The OpenThread Authors. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the |
| * names of its contributors may be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** |
| * @file |
| * This file includes definitions for maintaining Thread network topologies. |
| */ |
| |
| #ifndef TOPOLOGY_HPP_ |
| #define TOPOLOGY_HPP_ |
| |
| #include <openthread/platform/random.h> |
| |
| #include "openthread-core-config.h" |
| #include "common/message.hpp" |
| #include "mac/mac_frame.hpp" |
| #include "net/ip6.hpp" |
| #include "thread/link_quality.hpp" |
| #include "thread/mle_tlvs.hpp" |
| |
| namespace ot { |
| |
| /** |
| * This class represents a Thread neighbor. |
| * |
| */ |
| class Neighbor |
| { |
| public: |
| /** |
| * Neighbor link states. |
| * |
| */ |
| enum State |
| { |
| kStateInvalid, ///< Neighbor link is invalid |
| kStateRestored, ///< Neighbor is restored from non-volatile memory |
| kStateParentRequest, ///< Received an MLE Parent Request message |
| kStateChildIdRequest, ///< Received an MLE Child ID Request message |
| kStateLinkRequest, ///< Sent an MLE Link Request message |
| kStateChildUpdateRequest, ///< Sent an MLE Child Update Request message (trying to restore the child) |
| kStateValid, ///< Link is valid |
| }; |
| |
| /** |
| * This method returns the current state. |
| * |
| * @returns The current state. |
| * |
| */ |
| State GetState(void) const { return static_cast<State>(mState); } |
| |
| /** |
| * This method sets the current state. |
| * |
| * @param[in] aState The state value. |
| * |
| */ |
| void SetState(State aState) { mState = static_cast<uint8_t>(aState); } |
| |
| /** |
| * Check if the neighbor/child is being restored. |
| * |
| * @returns TRUE if the neighbor is being restored, FALSE otherwise. |
| * |
| */ |
| bool IsStateRestoring(void) const { return (mState == kStateRestored) || (mState == kStateChildUpdateRequest); } |
| |
| /** |
| * Check if the neighbor/child is in valid state or if it is being restored. |
| * When in these states messages can be sent to and/or received from the neighbor/child. |
| * |
| * @returns TRUE if the neighbor is in valid, restored, or being restored states, FALSE otherwise. |
| * |
| */ |
| bool IsStateValidOrRestoring(void) const { return (mState == kStateValid) || IsStateRestoring(); } |
| |
| /** |
| * This method gets the device mode flags. |
| * |
| * @returns The device mode flags. |
| * |
| */ |
| uint8_t GetDeviceMode(void) const { return mMode; } |
| |
| /** |
| * This method sets the device mode flags. |
| * |
| * @param[in] aMode The device mode flags. |
| * |
| */ |
| void SetDeviceMode(uint8_t aMode) { mMode = aMode; } |
| |
| /** |
| * This method indicates whether or not the device is rx-on-when-idle. |
| * |
| * @returns TRUE if rx-on-when-idle, FALSE otherwise. |
| * |
| */ |
| bool IsRxOnWhenIdle(void) const { return (mMode & Mle::ModeTlv::kModeRxOnWhenIdle) != 0; } |
| |
| /** |
| * This method indicates whether or not the device is a Full Thread Device. |
| * |
| * @returns TRUE if a Full Thread Device, FALSE otherwise. |
| * |
| */ |
| bool IsFullThreadDevice(void) const { return (mMode & Mle::ModeTlv::kModeFFD) != 0; } |
| |
| /** |
| * This method indicates whether or not the device uses secure IEEE 802.15.4 Data Request messages. |
| * |
| * @returns TRUE if using secure IEEE 802.15.4 Data Request messages, FALSE otherwise. |
| * |
| */ |
| bool IsSecureDataRequest(void) const { return (mMode & Mle::ModeTlv::kModeSecureDataRequest) != 0; } |
| |
| /** |
| * This method indicates whether or not the device requests Full Network Data. |
| * |
| * @returns TRUE if requests Full Network Data, FALSE otherwise. |
| * |
| */ |
| bool IsFullNetworkData(void) const { return (mMode & Mle::ModeTlv::kModeFullNetworkData) != 0; } |
| |
| /** |
| * This method sets all bytes of the Extended Address to zero. |
| * |
| */ |
| void ClearExtAddress(void) { memset(&mMacAddr, 0, sizeof(mMacAddr)); } |
| |
| /** |
| * This method returns the Extended Address. |
| * |
| * @returns A reference to the Extended Address. |
| * |
| */ |
| Mac::ExtAddress &GetExtAddress(void) { return mMacAddr; } |
| |
| /** |
| * This method returns the Extended Address. |
| * |
| * @returns A reference to the Extended Address. |
| * |
| */ |
| const Mac::ExtAddress &GetExtAddress(void) const { return mMacAddr; } |
| |
| /** |
| * This method sets the Extended Address. |
| * |
| * @param[in] aAddress The Extended Address value to set. |
| * |
| */ |
| void SetExtAddress(const Mac::ExtAddress &aAddress) { mMacAddr = aAddress; } |
| |
| /** |
| * This method gets the key sequence value. |
| * |
| * @returns The key sequence value. |
| * |
| */ |
| uint32_t GetKeySequence(void) const { return mKeySequence; } |
| |
| /** |
| * This method sets the key sequence value. |
| * |
| * @parma[in] aKeySequence The key sequence value. |
| * |
| */ |
| void SetKeySequence(uint32_t aKeySequence) { mKeySequence = aKeySequence; } |
| |
| /** |
| * This method returns the last heard time. |
| * |
| * @returns The last heard time. |
| * |
| */ |
| uint32_t GetLastHeard(void) const { return mLastHeard; } |
| |
| /** |
| * This method sets the last heard time. |
| * |
| * @param[in] aLastHeard The last heard time. |
| * |
| */ |
| void SetLastHeard(uint32_t aLastHeard) { mLastHeard = aLastHeard; } |
| |
| /** |
| * This method gets the link frame counter value. |
| * |
| * @returns The link frame counter value. |
| * |
| */ |
| uint32_t GetLinkFrameCounter(void) const { return mValidPending.mValid.mLinkFrameCounter; } |
| |
| /** |
| * This method sets the link frame counter value. |
| * |
| * @param[in] aFrameCounter The link frame counter value. |
| * |
| */ |
| void SetLinkFrameCounter(uint32_t aFrameCounter) { mValidPending.mValid.mLinkFrameCounter = aFrameCounter; } |
| |
| /** |
| * This method gets the MLE frame counter value. |
| * |
| * @returns The MLE frame counter value. |
| * |
| */ |
| uint32_t GetMleFrameCounter(void) const { return mValidPending.mValid.mMleFrameCounter; } |
| |
| /** |
| * This method sets the MLE frame counter value. |
| * |
| * @param[in] aFrameCounter The MLE frame counter value. |
| * |
| */ |
| void SetMleFrameCounter(uint32_t aFrameCounter) { mValidPending.mValid.mMleFrameCounter = aFrameCounter; } |
| |
| /** |
| * This method gets the RLOC16 value. |
| * |
| * @returns The RLOC16 value. |
| * |
| */ |
| uint16_t GetRloc16(void) const { return mValidPending.mValid.mRloc16; } |
| |
| /** |
| * This method sets the RLOC16 value. |
| * |
| * @param[in] aRloc16 The RLOC16 value. |
| * |
| */ |
| void SetRloc16(uint16_t aRloc16) { mValidPending.mValid.mRloc16 = aRloc16; } |
| |
| /** |
| * This method indicates whether an IEEE 802.15.4 Data Request message was received. |
| * |
| * @returns TRUE if an IEEE 802.15.4 Data Request message was received, FALSE otherwise. |
| * |
| */ |
| bool IsDataRequestPending(void) const { return mDataRequest; } |
| |
| /** |
| * This method sets the indicator for whether an IEEE 802.15.4 Data Request message was received. |
| * |
| * @param[in] aPending TRUE if an IEEE 802.15.4 Data Request message was received, FALSE otherwise. |
| * |
| */ |
| void SetDataRequestPending(bool aPending) { mDataRequest = aPending; } |
| |
| /** |
| * This method gets the number of consecutive link failures. |
| * |
| * @returns The number of consecutive link failures. |
| * |
| */ |
| uint8_t GetLinkFailures(void) const { return mLinkFailures; } |
| |
| /** |
| * This method increments the number of consecutive link failures. |
| * |
| */ |
| void IncrementLinkFailures(void) { mLinkFailures++; } |
| |
| /** |
| * This method resets the number of consecutive link failures to zero. |
| * |
| */ |
| void ResetLinkFailures(void) { mLinkFailures = 0; } |
| |
| /** |
| * This method returns the LinkQualityInfo object. |
| * |
| * @returns The LinkQualityInfo object. |
| * |
| */ |
| LinkQualityInfo &GetLinkInfo(void) { return mLinkInfo; } |
| |
| /** |
| * This method generates a new challenge value for MLE Link Request/Response exchanges. |
| * |
| */ |
| void GenerateChallenge(void); |
| |
| /** |
| * This method returns the current challenge value for MLE Link Request/Response exchanges. |
| * |
| * @returns The current challenge value. |
| * |
| */ |
| const uint8_t *GetChallenge(void) const { return mValidPending.mPending.mChallenge; } |
| |
| /** |
| * This method returns the size (byets) of the challenge value for MLE Link Request/Response exchanges. |
| * |
| * @returns The size (byets) of the challenge value for MLE Link Request/Response exchanges. |
| * |
| */ |
| uint8_t GetChallengeSize(void) const { return sizeof(mValidPending.mPending.mChallenge); } |
| |
| private: |
| Mac::ExtAddress mMacAddr; ///< The IEEE 802.15.4 Extended Address |
| uint32_t mLastHeard; ///< Time when last heard. |
| union |
| { |
| struct |
| { |
| uint32_t mLinkFrameCounter; ///< The Link Frame Counter |
| uint32_t mMleFrameCounter; ///< The MLE Frame Counter |
| uint16_t mRloc16; ///< The RLOC16 |
| } mValid; |
| struct |
| { |
| uint8_t mChallenge[Mle::ChallengeTlv::kMaxSize]; ///< The challenge value |
| uint8_t mChallengeLength; ///< The challenge length |
| } mPending; |
| } mValidPending; |
| |
| uint32_t mKeySequence; ///< Current key sequence |
| uint8_t mState : 3; ///< The link state |
| uint8_t mMode : 4; ///< The MLE device mode |
| bool mDataRequest : 1; ///< Indicates whether or not a Data Poll was received |
| uint8_t mLinkFailures; ///< Consecutive link failure count |
| LinkQualityInfo mLinkInfo; ///< Link quality info (contains average RSS, link margin and link quality) |
| }; |
| |
| /** |
| * This class represents a Thread Child. |
| * |
| */ |
| class Child : public Neighbor |
| { |
| public: |
| enum |
| { |
| kMaxIp6AddressPerChild = OPENTHREAD_CONFIG_IP_ADDRS_PER_CHILD, |
| kMaxRequestTlvs = 5, |
| }; |
| |
| /** |
| * This method clears the IPv6 addresses for the child. |
| * |
| */ |
| void ClearIp6Addresses(void) { memset(mIp6Address, 0, sizeof(mIp6Address)); } |
| |
| /** |
| * This method gets the IPv6 address at index @p aIndex. |
| * |
| * @param[in] aIndex The index into the IPv6 address list. |
| * |
| * @returns A reference to the IPv6 address entry at index @p aIndex. |
| * |
| */ |
| Ip6::Address &GetIp6Address(uint8_t aIndex) { return mIp6Address[aIndex]; } |
| |
| /** |
| * This method searches for a given IPv6 address in the child's IPv6 address list and provides the index of the |
| * address in the list if it is found. |
| * |
| * @param[in] aAddress The IPv6 address to search for in the IPv6 address list. |
| * @param[out] aIndex Pointer to variable where the index of address is provided if address is found in |
| * the list. @p aIndex can be set NULL if index is not required. |
| * |
| * @retval OT_ERROR_NONE Successfully found the address in IPv6 address list and updated @p aIndex. |
| * @retval OT_ERROR_NOT_FOUND Could not find the address in the list. |
| * |
| */ |
| otError FindIp6Address(const Ip6::Address &aAddress, uint8_t *aIndex) const; |
| |
| /** |
| * This method removes the address at index @p aIndex. |
| * |
| * @param[in] aIndex The index into the IPv6 address list. |
| * |
| */ |
| void RemoveIp6Address(uint8_t aIndex); |
| |
| /** |
| * This method gets the child timeout. |
| * |
| * @returns The child timeout. |
| * |
| */ |
| uint32_t GetTimeout(void) const { return mTimeout; } |
| |
| /** |
| * This method sets the child timeout. |
| * |
| * @param[in] aTimeout The child timeout. |
| * |
| */ |
| void SetTimeout(uint32_t aTimeout) { mTimeout = aTimeout; } |
| |
| /** |
| * This method gets the network data version. |
| * |
| * @returns The network data version. |
| * |
| */ |
| uint8_t GetNetworkDataVersion(void) const { return mNetworkDataVersion; } |
| |
| /** |
| * This method sets the network data version. |
| * |
| * @param[in] aVersion The network data version. |
| * |
| */ |
| void SetNetworkDataVersion(uint8_t aVersion) { mNetworkDataVersion = aVersion; } |
| |
| /** |
| * This method generates a new challenge value to use during a child attach. |
| * |
| */ |
| void GenerateChallenge(void); |
| |
| /** |
| * This method gets the current challenge value used during attach. |
| * |
| * @returns The current challenge value. |
| * |
| */ |
| const uint8_t *GetChallenge(void) const { return mAttachChallenge; } |
| |
| /** |
| * This method gets the challenge size (bytes) used during attach. |
| * |
| * @returns The challenge size (bytes). |
| * |
| */ |
| uint8_t GetChallengeSize(void) const { return sizeof(mAttachChallenge); } |
| |
| /** |
| * This method gets the IEEE 802.15.4 Frame Counter used during indirect retransmissions. |
| * |
| * @returns The IEEE 802.15.4 Frame Counter value. |
| * |
| */ |
| uint32_t GetIndirectFrameCounter(void) const { return mIndirectFrameCounter; } |
| |
| /** |
| * This method sets the IEEE 802.15.4 Frame Counter to use during indirect retransmissions. |
| * |
| * @param[in] aFrameCounter The IEEE 802.15.4 Frame Counter value. |
| * |
| */ |
| void SetIndirectFrameCounter(uint32_t aFrameCounter) { mIndirectFrameCounter = aFrameCounter; } |
| |
| /** |
| * This method gets the message buffer to use for indirect transmissions. |
| * |
| * @returns The message buffer. |
| * |
| */ |
| Message *GetIndirectMessage(void) { return mIndirectMessage; } |
| |
| /** |
| * This method sets the message buffer to use for indirect transmissions. |
| * |
| * @param[in] aMessage The message buffer. |
| * |
| */ |
| void SetIndirectMessage(Message *aMessage) { mIndirectMessage = aMessage; } |
| |
| /** |
| * This method gets the 6LoWPAN Fragment Offset to use for indirect transmissions. |
| * |
| * @returns The 6LoWPAN Fragment Offset value. |
| * |
| */ |
| uint16_t GetIndirectFragmentOffset(void) const { return mIndirectFragmentOffset; } |
| |
| /** |
| * This method sets the 6LoWPAN Fragment Offset to use for indirect transmissions. |
| * |
| * @param[in] aFragmentOffset The 6LoWPAN Fragment Offset value to use. |
| * |
| */ |
| void SetIndirectFragmentOffset(uint16_t aFragmentOffset) { mIndirectFragmentOffset = aFragmentOffset; } |
| |
| /** |
| * This method gets the IEEE 802.15.4 Key ID to use for indirect retransmissions. |
| * |
| * @returns The IEEE 802.15.4 Key ID value. |
| * |
| */ |
| uint8_t GetIndirectKeyId(void) const { return mIndirectKeyId; } |
| |
| /** |
| * This method sets the IEEE 802.15.4 Key ID value to use for indirect retransmissions. |
| * |
| * @param[in] aKeyId The IEEE 802.15.4 Key ID value. |
| * |
| */ |
| void SetIndirectKeyId(uint8_t aKeyId) { mIndirectKeyId = aKeyId; } |
| |
| /** |
| * This method gets the number of indirect transmission attempts for the current message. |
| * |
| * @returns The number of indirect transmission attempts. |
| * |
| */ |
| uint8_t GetIndirectTxAttempts(void) const { return mIndirectTxAttempts; } |
| |
| /** |
| * This method resets the number of indirect transmission attempts to zero. |
| * |
| */ |
| void ResetIndirectTxAttempts(void) { mIndirectTxAttempts = 0; } |
| |
| /** |
| * This method increments the number of indirect transmission attempts. |
| * |
| */ |
| void IncrementIndirectTxAttempts(void) { mIndirectTxAttempts++; } |
| |
| /** |
| * This method gets the IEEE 802.15.4 Data Sequence Number to use during indirect retransmissions. |
| * |
| * @returns The IEEE 802.15.4 Data Sequence Number value. |
| * |
| */ |
| uint8_t GetIndirectDataSequenceNumber(void) const { return mIndirectDsn; } |
| |
| /** |
| * This method sets the IEEE 802.15.4 Data Sequence Number to use during indirect retransmissions. |
| * |
| * @param[in] aDsn The IEEE 802.15.4 Data Sequence Number value. |
| * |
| */ |
| void SetIndirectDataSequenceNumber(uint8_t aDsn) { mIndirectDsn = aDsn; } |
| |
| /** |
| * This method indicates whether or not to source match on the short address. |
| * |
| * @returns TRUE if using the short address, FALSE if using the extended address. |
| * |
| */ |
| bool IsIndirectSourceMatchShort(void) const { return mUseShortAddress; } |
| |
| /** |
| * This method sets whether or not to source match on the short address. |
| * |
| * @param[in] aShort TRUE if using the short address, FALSE if using the extended address. |
| * |
| */ |
| void SetIndirectSourceMatchShort(bool aShort) { mUseShortAddress = aShort; } |
| |
| /** |
| * This method indicates whether or not the child needs to be added to the source match table. |
| * |
| * @returns TRUE if the child needs to be added to the source match table, FALSE otherwise. |
| * |
| */ |
| bool IsIndirectSourceMatchPending(void) const { return mSourceMatchPending; } |
| |
| /** |
| * This method sets whether or not the child needs to be added to the source match table. |
| * |
| * @param[in] aPending TRUE if the child needs to be added to the source match table, FALSE otherwise. |
| * |
| */ |
| void SetIndirectSourceMatchPending(bool aPending) { mSourceMatchPending = aPending; } |
| |
| /** |
| * This method returns the number of queued message(s) for the child |
| * |
| * @returns Number of queues message(s). |
| * |
| */ |
| uint16_t GetIndirectMessageCount(void) const { return mQueuedMessageCount; } |
| |
| /** |
| * This method increments the indirect message count. |
| * |
| */ |
| void IncrementIndirectMessageCount(void) { mQueuedMessageCount++; } |
| |
| /** |
| * This method decrements the indirect message count. |
| * |
| */ |
| void DecrementIndirectMessageCount(void) { mQueuedMessageCount--; } |
| |
| /** |
| * This method resets the indirect message count to zero. |
| * |
| */ |
| void ResetIndirectMessageCount(void) { mQueuedMessageCount = 0; } |
| |
| /** |
| * This method clears the requested TLV list. |
| * |
| */ |
| void ClearRequestTlvs(void) { memset(mRequestTlvs, Mle::Tlv::kInvalid, sizeof(mRequestTlvs)); } |
| |
| /** |
| * This method returns the requested TLV at index @p aIndex. |
| * |
| * @param[in] aIndex The index into the requested TLV list. |
| * |
| * @returns The requested TLV at index @p aIndex. |
| * |
| */ |
| uint8_t GetRequestTlv(uint8_t aIndex) const { return mRequestTlvs[aIndex]; } |
| |
| /** |
| * This method sets the requested TLV at index @p aIndex. |
| * |
| * @param[in] aIndex The index into the requested TLV list. |
| * @param[in] aType The TLV type. |
| * |
| */ |
| void SetRequestTlv(uint8_t aIndex, uint8_t aType) { mRequestTlvs[aIndex] = aType; } |
| |
| /** |
| * This method gets the mac address of child (either rloc16 or extended address depending on `UseShortAddress` flag). |
| * |
| * @param[out] aMacAddress A reference to a mac address object to which the child's address is copied. |
| * |
| * @returns A (const) reference to the mac address @a aMacAddress. |
| * |
| */ |
| const Mac::Address &GetMacAddress(Mac::Address &aMacAddress) const; |
| |
| #if OPENTHREAD_ENABLE_CHILD_SUPERVISION |
| |
| /** |
| * This method increments the number of seconds since last supervision of the child. |
| * |
| */ |
| void IncrementSecondsSinceLastSupervision(void) { mSecondsSinceSupervision++; } |
| |
| /** |
| * This method returns the number of seconds since last supervision of the child (last message to the child) |
| * |
| * @returns Number of seconds since last supervision of the child. |
| * |
| */ |
| uint16_t GetSecondsSinceLastSupervision(void) const { return mSecondsSinceSupervision; } |
| |
| /** |
| * This method resets the number of seconds since last supervision of the child to zero. |
| * |
| */ |
| void ResetSecondsSinceLastSupervision(void) { mSecondsSinceSupervision = 0; } |
| |
| #endif // #if OPENTHREAD_ENABLE_CHILD_SUPERVISION |
| |
| private: |
| Ip6::Address mIp6Address[kMaxIp6AddressPerChild]; ///< Registered IPv6 addresses |
| uint32_t mTimeout; ///< Child timeout |
| |
| union |
| { |
| uint8_t mRequestTlvs[kMaxRequestTlvs]; ///< Requested MLE TLVs |
| uint8_t mAttachChallenge[Mle::ChallengeTlv::kMaxSize]; ///< The challenge value |
| }; |
| |
| uint32_t mIndirectFrameCounter; ///< Frame counter for current indirect message (used fore retx). |
| Message *mIndirectMessage; ///< Current indirect message. |
| uint16_t mIndirectFragmentOffset; ///< 6LoWPAN fragment offset for the indirect message. |
| uint8_t mIndirectKeyId; ///< Key Id for current indirect message (used for retx). |
| uint8_t mIndirectTxAttempts; ///< Number of data poll triggered tx attempts. |
| uint8_t mIndirectDsn; ///< MAC level Data Sequence Number (DSN) for retx attempts. |
| uint8_t mNetworkDataVersion; ///< Current Network Data version |
| uint16_t mQueuedMessageCount : 13; ///< Number of queued indirect messages for the child. |
| bool mUseShortAddress : 1; ///< Indicates whether to use short or extended address. |
| bool mSourceMatchPending : 1; ///< Indicates whether or not pending to add to src match table. |
| |
| #if OPENTHREAD_ENABLE_CHILD_SUPERVISION |
| uint16_t mSecondsSinceSupervision; ///< Number of seconds since last supervision of the child. |
| #endif // OPENTHREAD_ENABLE_CHILD_SUPERVISION |
| |
| }; |
| |
| /** |
| * This class represents a Thread Router |
| * |
| */ |
| class Router : public Neighbor |
| { |
| public: |
| /** |
| * This method gets the router ID of the next hop to this router. |
| * |
| * @returns The router ID of the next hop to this router. |
| * |
| */ |
| uint8_t GetNextHop(void) const { return mNextHop; } |
| |
| /** |
| * This method sets the router ID of the next hop to this router. |
| * |
| * @param[in] aRouterId The router ID of the next hop to this router. |
| * |
| */ |
| void SetNextHop(uint8_t aRouterId) { mNextHop = aRouterId; } |
| |
| /** |
| * This method gets the link quality out value for this router. |
| * |
| * @returns The link quality out value for this router. |
| * |
| */ |
| uint8_t GetLinkQualityOut(void) const { return mLinkQualityOut; } |
| |
| /** |
| * This method sets the link quality out value for this router. |
| * |
| * @param[in] aLinkQuality The link quality out value for this router. |
| * |
| */ |
| void SetLinkQualityOut(uint8_t aLinkQuality) { mLinkQualityOut = aLinkQuality; } |
| |
| /** |
| * This method get the route cost to this router. |
| * |
| * @returns The route cost to this router. |
| * |
| */ |
| uint8_t GetCost(void) const { return mCost; } |
| |
| /** |
| * This method sets the router cost to this router. |
| * |
| * @param[in] aCost The router cost to this router. |
| * |
| */ |
| void SetCost(uint8_t aCost) { mCost = aCost; } |
| |
| /** |
| * This method indicates whether or not this router ID has been allocated. |
| * |
| * @returns TRUE if this router ID has been allocated, FALSE otherwise. |
| * |
| */ |
| bool IsAllocated(void) const { return mAllocated; } |
| |
| /** |
| * This method sets whether or not this router ID has been allocated. |
| * |
| * @param[in] aAllocated TRUE if this router ID has been allocated, FALSE otherwise. |
| * |
| */ |
| void SetAllocated(bool aAllocated) { mAllocated = aAllocated; } |
| |
| /** |
| * This method indicates whether the reclaim delay is in effect for this router ID. |
| * |
| * @returns TRUE if the reclaim delay is in effect, FALSE otherwise. |
| * |
| */ |
| bool IsReclaimDelay(void) const { return mReclaimDelay; } |
| |
| /** |
| * This method sets whether the reclaim delay is in effect for this router ID. |
| * |
| * @param[in] aReclaimDelay TRUE if the reclaim delay is in effect, FALSE otherwise. |
| * |
| */ |
| void SetReclaimDelay(bool aReclaimDelay) { mReclaimDelay = aReclaimDelay; } |
| |
| private: |
| uint8_t mNextHop; ///< The next hop towards this router |
| uint8_t mLinkQualityOut : 2; ///< The link quality out for this router |
| uint8_t mCost : 4; ///< The cost to this router via neighbor router |
| bool mAllocated : 1; ///< Indicates whether or not this entry is allocated |
| bool mReclaimDelay : 1; ///< Indicates whether or not this entry is waiting to be reclaimed |
| }; |
| |
| } // namespace ot |
| |
| #endif // TOPOLOGY_HPP_ |
