topology.hpp

Go to the documentation of this file.

/*
 *  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.
 */

#ifndef TOPOLOGY_HPP_
#define TOPOLOGY_HPP_

#include "openthread-core-config.h"

#include <openthread/platform/random.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 {

class Neighbor
{
public:
    enum State
    {
        kStateInvalid,                   
        kStateRestored,                  
        kStateParentRequest,             
        kStateChildIdRequest,            
        kStateLinkRequest,               
        kStateChildUpdateRequest,        
        kStateValid,                     
    };

    State GetState(void) const { return static_cast<State>(mState); }

    void SetState(State aState) { mState = static_cast<uint8_t>(aState); }

    bool IsStateRestoring(void) const { return (mState == kStateRestored) || (mState == kStateChildUpdateRequest); }

    bool IsStateValidOrRestoring(void) const { return (mState == kStateValid) || IsStateRestoring(); }

    uint8_t GetDeviceMode(void) const { return mMode; }

    void SetDeviceMode(uint8_t aMode) { mMode = aMode; }

    bool IsRxOnWhenIdle(void) const { return (mMode & Mle::ModeTlv::kModeRxOnWhenIdle) != 0; }

    bool IsFullThreadDevice(void) const { return (mMode & Mle::ModeTlv::kModeFFD) != 0; }

    bool IsSecureDataRequest(void) const { return (mMode & Mle::ModeTlv::kModeSecureDataRequest) != 0; }

    bool IsFullNetworkData(void) const { return (mMode & Mle::ModeTlv::kModeFullNetworkData) != 0; }

    void ClearExtAddress(void) { memset(&mMacAddr, 0, sizeof(mMacAddr)); }

    Mac::ExtAddress &GetExtAddress(void) { return mMacAddr; }

    const Mac::ExtAddress &GetExtAddress(void) const { return mMacAddr; }

    void SetExtAddress(const Mac::ExtAddress &aAddress) { mMacAddr = aAddress; }

    uint32_t GetKeySequence(void) const { return mKeySequence; }

    void SetKeySequence(uint32_t aKeySequence) { mKeySequence = aKeySequence; }

    uint32_t GetLastHeard(void) const { return mLastHeard; }

    void SetLastHeard(uint32_t aLastHeard) { mLastHeard = aLastHeard; }

    uint32_t GetLinkFrameCounter(void) const { return mValidPending.mValid.mLinkFrameCounter; }

    void SetLinkFrameCounter(uint32_t aFrameCounter) { mValidPending.mValid.mLinkFrameCounter = aFrameCounter; }

    uint32_t GetMleFrameCounter(void) const { return mValidPending.mValid.mMleFrameCounter; }

    void SetMleFrameCounter(uint32_t aFrameCounter) { mValidPending.mValid.mMleFrameCounter = aFrameCounter; }

    uint16_t GetRloc16(void) const { return mValidPending.mValid.mRloc16; }

    void SetRloc16(uint16_t aRloc16) { mValidPending.mValid.mRloc16 = aRloc16; }

    bool IsDataRequestPending(void) const { return mDataRequest; }

    void SetDataRequestPending(bool aPending) { mDataRequest = aPending; }

    uint8_t GetLinkFailures(void) const { return mLinkFailures; }

    void IncrementLinkFailures(void) { mLinkFailures++; }

    void ResetLinkFailures(void) { mLinkFailures = 0; }

    LinkQualityInfo &GetLinkInfo(void) { return mLinkInfo; }

    void GenerateChallenge(void);

    const uint8_t *GetChallenge(void) const { return mValidPending.mPending.mChallenge; }

    uint8_t GetChallengeSize(void) const { return sizeof(mValidPending.mPending.mChallenge); }

private:
    Mac::ExtAddress mMacAddr;            
    uint32_t        mLastHeard;          
    union
    {
        struct
        {
            uint32_t mLinkFrameCounter;  
            uint32_t mMleFrameCounter;   
            uint16_t mRloc16;            
        } mValid;
        struct
        {
            uint8_t mChallenge[Mle::ChallengeTlv::kMaxSize];  
            uint8_t mChallengeLength;    
        } mPending;
    } mValidPending;

    uint32_t        mKeySequence;        
    uint8_t         mState : 3;          
    uint8_t         mMode : 4;           
    bool            mDataRequest : 1;    
    uint8_t         mLinkFailures;       
    LinkQualityInfo mLinkInfo;           
};

class Child : public Neighbor
{
public:
    enum
    {
        kMaxIp6AddressPerChild = OPENTHREAD_CONFIG_IP_ADDRS_PER_CHILD,
        kMaxRequestTlvs        = 5,
    };

    void ClearIp6Addresses(void) { memset(mIp6Address, 0, sizeof(mIp6Address)); }

    Ip6::Address &GetIp6Address(uint8_t aIndex) { return mIp6Address[aIndex]; }

    otError FindIp6Address(const Ip6::Address &aAddress, uint8_t *aIndex) const;

    void RemoveIp6Address(uint8_t aIndex);

    uint32_t GetTimeout(void) const { return mTimeout; }

    void SetTimeout(uint32_t aTimeout) { mTimeout = aTimeout; }

    uint8_t GetNetworkDataVersion(void) const { return mNetworkDataVersion; }

    void SetNetworkDataVersion(uint8_t aVersion) { mNetworkDataVersion = aVersion; }

    void GenerateChallenge(void);

    const uint8_t *GetChallenge(void) const { return mAttachChallenge; }

    uint8_t GetChallengeSize(void) const { return sizeof(mAttachChallenge); }

    uint32_t GetIndirectFrameCounter(void) const { return mIndirectFrameCounter; }

    void SetIndirectFrameCounter(uint32_t aFrameCounter) { mIndirectFrameCounter = aFrameCounter; }

    Message *GetIndirectMessage(void) { return mIndirectMessage; }

    void SetIndirectMessage(Message *aMessage) { mIndirectMessage = aMessage; }

    uint16_t GetIndirectFragmentOffset(void) const { return mIndirectFragmentOffset; }

    void SetIndirectFragmentOffset(uint16_t aFragmentOffset) { mIndirectFragmentOffset = aFragmentOffset; }

    uint8_t GetIndirectKeyId(void) const { return mIndirectKeyId; }

    void SetIndirectKeyId(uint8_t aKeyId) { mIndirectKeyId = aKeyId; }

    uint8_t GetIndirectTxAttempts(void) const { return mIndirectTxAttempts; }

    void ResetIndirectTxAttempts(void) { mIndirectTxAttempts = 0; }

    void IncrementIndirectTxAttempts(void) { mIndirectTxAttempts++; }

    uint8_t GetIndirectDataSequenceNumber(void) const { return mIndirectDsn; }

    void SetIndirectDataSequenceNumber(uint8_t aDsn) { mIndirectDsn = aDsn; }

    bool IsIndirectSourceMatchShort(void) const { return mUseShortAddress; }

    void SetIndirectSourceMatchShort(bool aShort) { mUseShortAddress = aShort; }

    bool IsIndirectSourceMatchPending(void) const { return mSourceMatchPending; }

    void SetIndirectSourceMatchPending(bool aPending) { mSourceMatchPending = aPending; }

    uint16_t GetIndirectMessageCount(void) const { return mQueuedMessageCount; }

    void IncrementIndirectMessageCount(void) { mQueuedMessageCount++; }

    void DecrementIndirectMessageCount(void) { mQueuedMessageCount--; }

    void ResetIndirectMessageCount(void) { mQueuedMessageCount = 0; }

    void ClearRequestTlvs(void) { memset(mRequestTlvs, Mle::Tlv::kInvalid, sizeof(mRequestTlvs)); }

    uint8_t GetRequestTlv(uint8_t aIndex) const { return mRequestTlvs[aIndex]; }

    void SetRequestTlv(uint8_t aIndex, uint8_t aType) { mRequestTlvs[aIndex] = aType; }

    const Mac::Address &GetMacAddress(Mac::Address &aMacAddress) const;

#if OPENTHREAD_ENABLE_CHILD_SUPERVISION

    void IncrementSecondsSinceLastSupervision(void) { mSecondsSinceSupervision++; }

    uint16_t GetSecondsSinceLastSupervision(void) const { return mSecondsSinceSupervision; }

    void ResetSecondsSinceLastSupervision(void) { mSecondsSinceSupervision = 0; }

#endif // #if OPENTHREAD_ENABLE_CHILD_SUPERVISION

private:
    Ip6::Address mIp6Address[kMaxIp6AddressPerChild];  
    uint32_t     mTimeout;                             

    union
    {
        uint8_t mRequestTlvs[kMaxRequestTlvs];                 
        uint8_t mAttachChallenge[Mle::ChallengeTlv::kMaxSize]; 
    };

    uint32_t     mIndirectFrameCounter;                
    Message     *mIndirectMessage;                     
    uint16_t     mIndirectFragmentOffset;              
    uint8_t      mIndirectKeyId;                       
    uint8_t      mIndirectTxAttempts;                  
    uint8_t      mIndirectDsn;                         
    uint8_t      mNetworkDataVersion;                  
    uint16_t     mQueuedMessageCount : 13;             
    bool         mUseShortAddress : 1;                 
    bool         mSourceMatchPending : 1;              

#if OPENTHREAD_ENABLE_CHILD_SUPERVISION
    uint16_t     mSecondsSinceSupervision;             
#endif // OPENTHREAD_ENABLE_CHILD_SUPERVISION

};

class Router : public Neighbor
{
public:
    uint8_t GetNextHop(void) const { return mNextHop; }

    void SetNextHop(uint8_t aRouterId) { mNextHop = aRouterId; }

    uint8_t GetLinkQualityOut(void) const { return mLinkQualityOut; }

    void SetLinkQualityOut(uint8_t aLinkQuality) { mLinkQualityOut = aLinkQuality; }

    uint8_t GetCost(void) const { return mCost; }

    void SetCost(uint8_t aCost) { mCost = aCost; }

    bool IsAllocated(void) const { return mAllocated; }

    void SetAllocated(bool aAllocated) { mAllocated = aAllocated; }

    bool IsReclaimDelay(void) const { return mReclaimDelay; }

    void SetReclaimDelay(bool aReclaimDelay) { mReclaimDelay = aReclaimDelay; }

private:
    uint8_t mNextHop;             
    uint8_t mLinkQualityOut : 2;  
    uint8_t mCost : 4;            
    bool    mAllocated : 1;       
    bool    mReclaimDelay : 1;    
};

}  // namespace ot

#endif  // TOPOLOGY_HPP_