types.hpp

Go to the documentation of this file.

/*
 *    Copyright (c) 2017, 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_COMMON_TYPES_HPP_
#define OTBR_COMMON_TYPES_HPP_
 
#include "openthread-br/config.h"
 
#include <netinet/in.h>
#include <stdint.h>
#include <string.h>
#include <string>
#include <vector>
 
#include "common/byteswap.hpp"
 
#ifndef IN6ADDR_ANY
 
#define IN6ADDR_ANY "::"
#endif
 
#define OTBR_IP6_ADDRESS_SIZE 16
#define OTBR_IP6_PREFIX_SIZE 8
#define OTBR_IP4_ADDRESS_SIZE 4
#define OTBR_NETWORK_KEY_SIZE 16
#define OTBR_PSKC_SIZE 16
 
struct otIp6Prefix;
 
enum otbrError
{
    OTBR_ERROR_NONE = 0, 
 
    OTBR_ERROR_ERRNO              = -1,  
    OTBR_ERROR_DBUS               = -2,  
    OTBR_ERROR_MDNS               = -3,  
    OTBR_ERROR_OPENTHREAD         = -4,  
    OTBR_ERROR_REST               = -5,  
    OTBR_ERROR_SMCROUTE           = -6,  
    OTBR_ERROR_NOT_FOUND          = -7,  
    OTBR_ERROR_PARSE              = -8,  
    OTBR_ERROR_NOT_IMPLEMENTED    = -9,  
    OTBR_ERROR_INVALID_ARGS       = -10, 
    OTBR_ERROR_DUPLICATED         = -11, 
    OTBR_ERROR_ABORTED            = -12, 
    OTBR_ERROR_INVALID_STATE      = -13, 
    OTBR_ERROR_INFRA_LINK_CHANGED = -14, 
};
 
namespace otbr {
 
enum
{
    kSizePSKc        = 16,         
    kSizeNetworkName = 16,         
    kSizeExtPanId    = 8,          
    kSizeEui64       = 8,          
    kSizeExtAddr     = kSizeEui64, 
};
 
static constexpr char kSolicitedMulticastAddressPrefix[]   = "ff02::01:ff00:0";
static constexpr char kLinkLocalAllNodesMulticastAddress[] = "ff02::01";
 
class Ip6Address
{
public:
    Ip6Address(void)
    {
        m64[0] = 0;
        m64[1] = 0;
    }
 
    Ip6Address(uint16_t aLocator)
    {
        m64[0] = 0;
        m32[2] = 0;
        m16[6] = 0;
        m8[14] = aLocator >> 8;
        m8[15] = aLocator & 0xff;
    }
 
    Ip6Address(const uint8_t (&aAddress)[16]);
 
    bool operator<(const Ip6Address &aOther) const { return memcmp(this, &aOther, sizeof(Ip6Address)) < 0; }
 
    bool operator==(const Ip6Address &aOther) const { return m64[0] == aOther.m64[0] && m64[1] == aOther.m64[1]; }
 
    uint16_t ToLocator(void) const { return static_cast<uint16_t>(m8[14] << 8 | m8[15]); }
 
    Ip6Address ToSolicitedNodeMulticastAddress(void) const;
 
    std::string ToString(void) const;
 
    bool IsUnspecified(void) const { return m64[0] == 0 && m64[1] == 0; }
 
    bool IsMulticast(void) const { return m8[0] == 0xff; }
 
    bool IsLinkLocal(void) const { return (m16[0] & bswap_16(0xffc0)) == bswap_16(0xfe80); }
 
    bool IsLoopback(void) const { return (m32[0] == 0 && m32[1] == 0 && m32[2] == 0 && m32[3] == htobe32(1)); }
 
    static const Ip6Address &GetLinkLocalAllNodesMulticastAddress(void)
    {
        static Ip6Address sLinkLocalAllNodesMulticastAddress = FromString(kLinkLocalAllNodesMulticastAddress);
 
        return sLinkLocalAllNodesMulticastAddress;
    }
 
    static const Ip6Address &GetSolicitedMulticastAddressPrefix(void)
    {
        static Ip6Address sSolicitedMulticastAddressPrefix = FromString(kSolicitedMulticastAddressPrefix);
 
        return sSolicitedMulticastAddressPrefix;
    }
 
    static otbrError FromString(const char *aStr, Ip6Address &aAddr);
 
    void CopyTo(struct sockaddr_in6 &aSockAddr) const;
 
    void CopyFrom(const struct sockaddr_in6 &aSockAddr);
 
    void CopyTo(struct in6_addr &aIn6Addr) const;
 
    void CopyFrom(const struct in6_addr &aIn6Addr);
 
    union
    {
        uint8_t  m8[16];
        uint16_t m16[8];
        uint32_t m32[4];
        uint64_t m64[2];
    };
 
private:
    static Ip6Address FromString(const char *aStr);
};
 
class Ip6Prefix
{
public:
    Ip6Prefix(void) { Clear(); }
 
    void Set(const otIp6Prefix &aPrefix);
 
    std::string ToString(void) const;
 
    void Clear(void) { memset(reinterpret_cast<void *>(this), 0, sizeof(*this)); }
 
    bool IsValid(void) const { return mLength > 0 && mLength <= 128; }
 
    Ip6Address mPrefix; 
    uint8_t    mLength; 
};
 
class MacAddress
{
public:
    MacAddress(void)
    {
        m16[0] = 0;
        m16[1] = 0;
        m16[2] = 0;
    }
 
    std::string ToString(void) const;
 
    union
    {
        uint8_t  m8[6];
        uint16_t m16[3];
    };
};
 
struct MdnsResponseCounters
{
    uint32_t mSuccess;        
    uint32_t mNotFound;       
    uint32_t mInvalidArgs;    
    uint32_t mDuplicated;     
    uint32_t mNotImplemented; 
    uint32_t mUnknownError;   
    uint32_t mAborted;        
    uint32_t mInvalidState;   
};
 
struct MdnsTelemetryInfo
{
    static constexpr uint32_t kEmaFactorNumerator   = 1;
    static constexpr uint32_t kEmaFactorDenominator = 2;
 
    static_assert(kEmaFactorNumerator > 0, "kEmaFactorNumerator must be greater than 0");
    static_assert(kEmaFactorDenominator > kEmaFactorNumerator,
                  "kEmaFactorDenominator must be greater than kEmaFactorNumerator");
 
    MdnsResponseCounters mHostRegistrations;
    MdnsResponseCounters mServiceRegistrations;
    MdnsResponseCounters mHostResolutions;
    MdnsResponseCounters mServiceResolutions;
 
    uint32_t mHostRegistrationEmaLatency;    
    uint32_t mServiceRegistrationEmaLatency; 
    uint32_t mHostResolutionEmaLatency;      
    uint32_t mServiceResolutionEmaLatency;   
};
 
} // namespace otbr
 
#endif // OTBR_COMMON_TYPES_HPP_