types.hpp

Go to the documentation of this file.

/*
 *    Copyright (c) 2020, 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 OTBR_DBUS_COMMON_TYPES_HPP_
#define OTBR_DBUS_COMMON_TYPES_HPP_
 
#include "dbus/common/error.hpp"
 
#include <stdint.h>
 
#include <array>
#include <string>
#include <vector>
 
namespace otbr {
namespace DBus {
 
enum DeviceRole
{
    OTBR_DEVICE_ROLE_DISABLED = 0,
    OTBR_DEVICE_ROLE_DETACHED = 1,
    OTBR_DEVICE_ROLE_CHILD    = 2,
    OTBR_DEVICE_ROLE_ROUTER   = 3,
    OTBR_DEVICE_ROLE_LEADER   = 4,
};
 
struct ActiveScanResult
{
    uint64_t             mExtAddress;    
    std::string          mNetworkName;   
    uint64_t             mExtendedPanId; 
    std::vector<uint8_t> mSteeringData;  
    uint16_t             mPanId;         
    uint16_t             mJoinerUdpPort; 
    uint8_t              mChannel;       
    int8_t               mRssi;          
    uint8_t              mLqi;           
    uint8_t              mVersion;       
    bool                 mIsNative;      
    bool                 mDiscover;      
};
 
struct EnergyScanResult
{
    uint8_t mChannel; 
    int8_t  mMaxRssi; 
};
 
struct LinkModeConfig
{
    bool mRxOnWhenIdle; 
    bool mDeviceType;   
    bool mNetworkData;  
};
 
struct Ip6Prefix
{
    std::vector<uint8_t> mPrefix; 
 
    uint8_t mLength; 
};
 
using Ip4Address = std::array<uint8_t, 4>;
using Ip6Address = std::array<uint8_t, 16>;
 
struct OnMeshPrefix
{
    Ip6Prefix mPrefix;
 
    uint16_t mRloc16;
 
    int8_t mPreference;
 
    bool mPreferred;
 
    bool mSlaac;
 
    bool mDhcp;
 
    bool mConfigure;
 
    bool mDefaultRoute;
 
    bool mOnMesh;
 
    bool mStable;
 
    bool mNdDns;
 
    bool mDp;
};
 
struct ExternalRoute
{
    Ip6Prefix mPrefix;
 
    uint16_t mRloc16;
 
    int8_t mPreference;
 
    bool mStable;
 
    bool mNextHopIsThisDevice;
};
 
struct MacCounters
{
    uint32_t mTxTotal;
 
    uint32_t mTxUnicast;
 
    uint32_t mTxBroadcast;
 
    uint32_t mTxAckRequested;
 
    uint32_t mTxAcked;
 
    uint32_t mTxNoAckRequested;
 
    uint32_t mTxData;
 
    uint32_t mTxDataPoll;
 
    uint32_t mTxBeacon;
 
    uint32_t mTxBeaconRequest;
 
    uint32_t mTxOther;
 
    uint32_t mTxRetry;
 
    uint32_t mTxDirectMaxRetryExpiry;
 
    uint32_t mTxIndirectMaxRetryExpiry;
 
    uint32_t mTxErrCca;
 
    uint32_t mTxErrAbort;
 
    uint32_t mTxErrBusyChannel;
 
    uint32_t mRxTotal;
 
    uint32_t mRxUnicast;
 
    uint32_t mRxBroadcast;
 
    uint32_t mRxData;
 
    uint32_t mRxDataPoll;
 
    uint32_t mRxBeacon;
 
    uint32_t mRxBeaconRequest;
 
    uint32_t mRxOther;
 
    uint32_t mRxAddressFiltered;
 
    uint32_t mRxDestAddrFiltered;
 
    uint32_t mRxDuplicated;
 
    uint32_t mRxErrNoFrame;
 
    uint32_t mRxErrUnknownNeighbor;
 
    uint32_t mRxErrInvalidSrcAddr;
 
    uint32_t mRxErrSec;
 
    uint32_t mRxErrFcs;
 
    uint32_t mRxErrOther;
};
 
struct IpCounters
{
    uint32_t mTxSuccess; 
    uint32_t mRxSuccess; 
    uint32_t mTxFailure; 
    uint32_t mRxFailure; 
};
 
struct ChannelQuality
{
    uint8_t  mChannel;
    uint16_t mOccupancy;
};
 
struct ChildInfo
{
    uint64_t mExtAddress;         
    uint32_t mTimeout;            
    uint32_t mAge;                
    uint16_t mRloc16;             
    uint16_t mChildId;            
    uint8_t  mNetworkDataVersion; 
    uint8_t  mLinkQualityIn;      
    int8_t   mAverageRssi;        
    int8_t   mLastRssi;           
    uint16_t mFrameErrorRate;     
    uint16_t mMessageErrorRate;   
    bool     mRxOnWhenIdle;       
    bool     mFullThreadDevice;   
    bool     mFullNetworkData;    
    bool     mIsStateRestoring;   
};
 
struct NeighborInfo
{
    uint64_t mExtAddress;       
    uint32_t mAge;              
    uint16_t mRloc16;           
    uint32_t mLinkFrameCounter; 
    uint32_t mMleFrameCounter;  
    uint8_t  mLinkQualityIn;    
    int8_t   mAverageRssi;      
    int8_t   mLastRssi;         
    uint16_t mFrameErrorRate;   
    uint16_t mMessageErrorRate; 
    bool     mRxOnWhenIdle;     
    bool     mFullThreadDevice; 
    bool     mFullNetworkData;  
    bool     mIsChild;          
};
 
struct LeaderData
{
    uint32_t mPartitionId;       
    uint8_t  mWeighting;         
    uint8_t  mDataVersion;       
    uint8_t  mStableDataVersion; 
    uint8_t  mLeaderRouterId;    
};
 
struct TxtEntry
{
    std::string          mKey;
    std::vector<uint8_t> mValue;
};
 
enum SrpServerState : uint8_t
{
    OTBR_SRP_SERVER_STATE_DISABLED = 0, 
    OTBR_SRP_SERVER_STATE_RUNNING  = 1, 
    OTBR_SRP_SERVER_STATE_STOPPED  = 2, 
};
 
enum SrpServerAddressMode : uint8_t
{
    OTBR_SRP_SERVER_ADDRESS_MODE_UNICAST = 0, 
    OTBR_SRP_SERVER_ADDRESS_MODE_ANYCAST = 1, 
};
 
struct SrpServerInfo
{
    struct Registration
    {
        uint32_t mFreshCount;        
        uint32_t mDeletedCount;      
        uint64_t mLeaseTimeTotal;    
        uint64_t mKeyLeaseTimeTotal; 
        uint64_t mRemainingLeaseTimeTotal;    
        uint64_t mRemainingKeyLeaseTimeTotal; 
    };
 
    struct ResponseCounters
    {
        uint32_t mSuccess;       
        uint32_t mServerFailure; 
        uint32_t mFormatError;   
        uint32_t mNameExists;    
        uint32_t mRefused;       
        uint32_t mOther;         
    };
 
    SrpServerState       mState;            
    uint16_t             mPort;             
    SrpServerAddressMode mAddressMode;      
    Registration         mHosts;            
    Registration         mServices;         
    ResponseCounters     mResponseCounters; 
};
 
struct DnssdCounters
{
    uint32_t mSuccessResponse;        
    uint32_t mServerFailureResponse;  
    uint32_t mFormatErrorResponse;    
    uint32_t mNameErrorResponse;      
    uint32_t mNotImplementedResponse; 
    uint32_t mOtherResponse;          
 
    uint32_t mResolvedBySrp; 
};
 
struct RadioSpinelMetrics
{
    uint32_t mRcpTimeoutCount;         
    uint32_t mRcpUnexpectedResetCount; 
    uint32_t mRcpRestorationCount;     
    uint32_t mSpinelParseErrorCount;   
};
 
struct RcpInterfaceMetrics
{
    uint8_t  mRcpInterfaceType;             
    uint64_t mTransferredFrameCount;        
    uint64_t mTransferredValidFrameCount;   
    uint64_t mTransferredGarbageFrameCount; 
    uint64_t mRxFrameCount;                 
    uint64_t mRxFrameByteCount;             
    uint64_t mTxFrameCount;                 
    uint64_t mTxFrameByteCount;             
};
 
struct RadioCoexMetrics
{
    uint32_t mNumGrantGlitch;          
    uint32_t mNumTxRequest;            
    uint32_t mNumTxGrantImmediate;     
    uint32_t mNumTxGrantWait;          
    uint32_t mNumTxGrantWaitActivated; 
    uint32_t mNumTxGrantWaitTimeout;   
    uint32_t mNumTxGrantDeactivatedDuringRequest; 
    uint32_t mNumTxDelayedGrant;                  
    uint32_t mAvgTxRequestToGrantTime;            
    uint32_t mNumRxRequest;                       
    uint32_t mNumRxGrantImmediate;                
    uint32_t mNumRxGrantWait;                     
    uint32_t mNumRxGrantWaitActivated; 
    uint32_t mNumRxGrantWaitTimeout;   
    uint32_t mNumRxGrantDeactivatedDuringRequest; 
    uint32_t mNumRxDelayedGrant;                  
    uint32_t mAvgRxRequestToGrantTime;            
    uint32_t mNumRxGrantNone;                     
    bool     mStopped;                            
};
 
struct BorderRoutingCounters
{
    struct PacketsAndBytes
    {
        uint64_t mPackets; 
        uint64_t mBytes;   
    };
 
    PacketsAndBytes mInboundUnicast;    
    PacketsAndBytes mInboundMulticast;  
    PacketsAndBytes mOutboundUnicast;   
    PacketsAndBytes mOutboundMulticast; 
};
 
struct Nat64ComponentState
{
    std::string mPrefixManagerState;
    std::string mTranslatorState;
};
 
struct Nat64TrafficCounters
{
    uint64_t m4To6Packets; 
    uint64_t m4To6Bytes;   
    uint64_t m6To4Packets; 
    uint64_t m6To4Bytes;   
};
 
struct Nat64PacketCounters
{
    uint64_t m4To6Packets; 
    uint64_t m6To4Packets; 
};
 
struct Nat64ProtocolCounters
{
    Nat64TrafficCounters mTotal; 
    Nat64TrafficCounters mIcmp;  
    Nat64TrafficCounters mUdp;   
    Nat64TrafficCounters mTcp;   
};
 
struct Nat64AddressMapping
{
    uint64_t   mId;              
    Ip4Address mIp4;             
    Ip6Address mIp6;             
    uint32_t   mRemainingTimeMs; 
 
    Nat64ProtocolCounters mCounters;
};
 
struct Nat64ErrorCounters
{
    Nat64PacketCounters mUnknown;          
    Nat64PacketCounters mIllegalPacket;    
    Nat64PacketCounters mUnsupportedProto; 
    Nat64PacketCounters mNoMapping;        
};
 
} // namespace DBus
} // namespace otbr
 
#endif // OTBR_DBUS_COMMON_TYPES_HPP_