ipv6_addr.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef IPV6_ADDR_H
#define IPV6_ADDR_H
 
struct IPADDR6;   // Forward
 
#include <basictypes.h>
#include <nbprintfinternal.h>
#include <nettypes.h>
 
class IPADDR6
{
   protected:
    void Compactformat(char *cp) const;
    beuint32_t val[4];
 
   public:
    // IPv6 operator = overload
    IPADDR6 &operator=(const IPADDR6 &v)
    {
        val[0] = v.val[0];
        val[1] = v.val[1];
        val[2] = v.val[2];
        val[3] = v.val[3];
        return *this;
    }
 
    bool IsEmbeddedIPV4() const { return ((val[2] == 0xFFFF) && (val[0] == 0) && (val[1] == 0)); }
 
    IPADDR4 Extract4() const
    {
        IPADDR4 i4;
        if(IsEmbeddedIPV4())
            i4 = val[3];
        else
            i4=0;
        return i4;
    };
 
    uint32_t GetEmbededIP4Uint()const 
    {                       
        if(!IsEmbeddedIPV4()) return 0;
        return (uint32_t) val[3];
 
    }
 
 
    // Operator = overload
    IPADDR6 &operator=(const IPADDR4 v4)
    {
        val[0] = 0;
        val[1] = 0;
        val[2] = 0xFFFF;
        val[3] = v4;
        return *this;
    }
 
    //---------------------------------------------------------------------------------------
    // Member functions to query IP address status
    //---------------------------------------------------------------------------------------
 
    bool IsNull() const { return ((val[0] | val[1] | val[3] | ((val[2] != 0xFFFF) && (val[2] != 0))) == 0); }
 
    bool NotNull() const { return !IsNull(); }
 
    inline bool IsLoopBack() const { if(IsEmbeddedIPV4()) 
                                        { return Extract4().IsLoopBack(); }
                                     else
                                        { return ((val[3] == 1) && (val[2] == 0) && (val[1] == 0) && (val[0] == 0)); }
                                   };
 
    inline bool IsMultiCast() const { return ((val[0] & 0xff000000) == 0xff000000); };
 
    inline bool IsLinkLocal() const { return ((val[0] & 0xffc00000) == 0xfe800000); };
 
    MACADR McastMac() const;
 
    //---------------------------------------------------------------------------------------
    // Member functions to display/print an IP address
    //---------------------------------------------------------------------------------------
 
    void print(bool bCompact = true, bool bShowV4Raw = false) const;
 
    void fdprint(int fd, bool bCompact = true, bool bShowV4Raw = false) const;
 
    int sprintf(char *cp, int maxl, bool bCompact = true, bool bShowV4Raw = false) const;
 
    //---------------------------------------------------------------------------------------
    // Static functions that return an IPADDR6 object
    //---------------------------------------------------------------------------------------
 
    static IPADDR6 AsciiToIp6(const char *cp, bool bembed_v4addresses = true);   // false only parses a v6
 
    // Used internally to generate auto-configuration addresses, such as a prefix received from a router.
    static IPADDR6 FromIPMask(MACADR &ma, const IPADDR6 &g_root, int mask_len);
 
    // Internal use only
    static IPADDR6 SolicitedNodeIP6(const IPADDR6 &ip6);
 
    static IPADDR6 NullIP();
 
    //---------------------------------------------------------------------------------------
    // Member functions that correspond to the static functions
    //---------------------------------------------------------------------------------------
 
    void SetFromAscii(const char *cp, bool bembed_v4addresses = true);
 
    void SetGlobal(MACADR &ma, const IPADDR6 &g_root);   // Internal use only
    void SetSolicitedNodeIP6(const IPADDR6 &ip6);        // Internal use only
 
    // Used internally to generate auto-configuration addresses, such as a prefix received from a router.
    void SetFromIPMask(MACADR &ma, const IPADDR6 &g_root, int mask_len);
 
    void SetFromIP4(IPADDR4 ip);
 
    void SetFromUint32Shortcut(uint32_t w0, uint32_t w1, uint32_t w2, uint32_t w3)
    {
        val[0] = w0;
        val[1] = w1;
        val[2] = w2;
        val[3] = w3;
    }
 
    void SetNull()
    {
        val[0] = 0;
        val[1] = 0;
        val[2] = 0;
        val[3] = 0;
    }
 
    uint32_t csum();   // Calculate the inet pre csum for this
 
    //---------------------------------------------------------------------------------------
    // Constructors
    //---------------------------------------------------------------------------------------
 
    IPADDR6() { SetNull(); };
    IPADDR6(IPADDR4 ip4) { SetFromIP4(ip4); };
    IPADDR6(uint32_t w0, uint32_t w1, uint32_t w2, uint32_t w3) { SetFromUint32Shortcut(w0, w1, w2, w3); };
 
    //---------------------------------------------------------------------------------------
    // Internal use only, used by system printf functions
    //---------------------------------------------------------------------------------------
 
    int GetPrintLen(bool compact);
    int PrintHelper(PutCharsFunction *pf, void *data, bool compact);
 
    // Access the uint32_t values
    beuint32_t inline GetInternalValue(int i) const { return val[i]; };
 
    //---------------------------------------------------------------------------------------
    // Friend functions for operator overloading
    //---------------------------------------------------------------------------------------
 
    friend bool operator==(const IPADDR6 i, const IPADDR6 j);
    friend bool operator!=(const IPADDR6 i, const IPADDR6 j);
    friend bool operator>(const IPADDR6 i, const IPADDR6 j);
    friend bool operator<(const IPADDR6 i, const IPADDR6 j);
 
} __attribute__((packed));
 
//---------------------------------------------------------------------------------------
// friend function implementations for operator overload
//---------------------------------------------------------------------------------------
 
inline bool operator==(const IPADDR6 i, const IPADDR6 j)
{
    return ((i.val[3] == j.val[3]) && (i.val[2] == j.val[2]) && (i.val[1] == j.val[1]) && (i.val[0] == j.val[0]));
}
 
inline bool operator!=(const IPADDR6 i, const IPADDR6 j)
{
    return !((i.val[3] == j.val[3]) && (i.val[2] == j.val[2]) && (i.val[1] == j.val[1]) && (i.val[0] == j.val[0]));
}
 
inline bool operator>(const IPADDR6 i, const IPADDR6 j)
{
    if (i.val[0] > j.val[0]) return true;
 
    if (i.val[0] == j.val[0])
    {
        if (i.val[1] > j.val[1]) return true;
 
        if (i.val[1] == j.val[1])
        {
            if (i.val[2] > j.val[2]) return true;
 
            if (i.val[2] == j.val[2])
            {
                if (i.val[3] > j.val[3]) return true;
            }
        }
    }
    return false;
};
 
inline bool operator<(const IPADDR6 i, const IPADDR6 j)
{
    if (i.val[0] < j.val[0]) return true;
 
    if (i.val[0] == j.val[0])
    {
        if (i.val[1] < j.val[1]) return true;
        if (i.val[1] == j.val[1])
        {
            if (i.val[2] < j.val[2]) return true;
            if (i.val[2] == j.val[2])
            {
                if (i.val[3] < j.val[3]) return true;
            }
        }
    }
    return false;
};
 
#endif