UT_IpAddress.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_IpAddress.h
 *
 * COMMENTS:
 *
 */

#ifndef __UT_IPADDRESS_H__
#define __UT_IPADDRESS_H__

#include "UT_API.h"

#include "UT_Assert.h"
#include "UT_FixedArray.h"
#include "UT_StringHolder.h"

#include <SYS/SYS_Compiler.h>

#include <cstdint>
#include <cstring>

enum class UT_IpAddressFamily
{
    ANY,
    IPv4,
    IPv6
};

/// This represents a Ipv4 address.
class UT_API UT_IpAddressV4
{
public:
    using bytes_t = UT_FixedArray<uint8, 4>;

    UT_IpAddressV4() : myAddress(0) {  }

    explicit UT_IpAddressV4(uint32_t addr) { convert_(addr); }
    explicit UT_IpAddressV4(const bytes_t& addr)
    {
        std::memcpy(&myAddress, addr.data(), 4);
    }
    UT_IpAddressV4(
            unsigned char i0,
            unsigned char i1,
            unsigned char i2,
            unsigned char i3)
    { 
        convert_(i0, i1, i2, i3);
    }
    UT_IpAddressV4(const UT_IpAddressV4& addr) :
        myAddress(addr.myAddress)
    {}
    UT_IpAddressV4& operator=(const UT_IpAddressV4& addr)
    {
        myAddress = addr.myAddress;
        return *this;
    }

    bool operator==(const UT_IpAddressV4& other) const
    {
        return myAddress == other.myAddress;
    }
    bool operator!=(const UT_IpAddressV4& other) const
    {
        return !(*this == other);
    }
    bool operator<(const UT_IpAddressV4& other) const
    {
        return toUInt() < other.toUInt();
    }
    bool operator>(const UT_IpAddressV4& other) const
    {
        return other.toUInt() < toUInt();
    }
    bool operator<=(const UT_IpAddressV4& other) const
    {
        return !(other < *this);
    }
    bool operator>=(const UT_IpAddressV4& other) const
    {
        return !(*this < other);
    }

    SYS_NO_DISCARD_RESULT bool isUnspecified() const
    {
        return toUInt() == 0;
    }
    SYS_NO_DISCARD_RESULT bool isLoopback() const
    {
        return (toUInt() & 0xFF000000) == 0x7F000000;
    }
    SYS_NO_DISCARD_RESULT bool isMulticast() const
    {
        return (toUInt() & 0xF0000000) == 0xE0000000;
    }
    SYS_NO_DISCARD_RESULT const bytes_t toBytes() const
    {
        bytes_t bytes;
        std::memcpy(bytes.data(), &myAddress, 4);
        return bytes;
    }

    // Returns value in host byte order
    SYS_NO_DISCARD_RESULT uint32_t toUInt() const;

    SYS_NO_DISCARD_RESULT static UT_IpAddressV4 fromString(
            const UT_StringRef& str);
    SYS_NO_DISCARD_RESULT UT_StringHolder toString() const;
    SYS_NO_DISCARD_RESULT static UT_IpAddressV4 any()
    {
        return UT_IpAddressV4();
    }
    SYS_NO_DISCARD_RESULT static UT_IpAddressV4 loopback()
    {
        return UT_IpAddressV4(0x7F000001);
    }
    SYS_NO_DISCARD_RESULT static UT_IpAddressV4 broadcast()
    {
        return UT_IpAddressV4(0xFFFFFFFF);
    }

    SYS_NO_DISCARD_RESULT static uint32_t networkToHost(uint32_t v);
    SYS_NO_DISCARD_RESULT static uint32_t hostToNetwork(uint32_t v);
private:
    void convert_(uint32_t addr);
    void convert_(uint8 i0, uint8 i1, uint8 i2, uint8 i3);

    // Stored in network byte order
    uint32_t myAddress;
};

/// This represents a Ipv6 address.
class UT_API UT_IpAddressV6
{
public:
    using bytes_t = UT_FixedArray<uint8, 16>;

    UT_IpAddressV6() : myAddress() {  }
    explicit UT_IpAddressV6(const bytes_t& addr) : myAddress(addr) {}

    bool operator==(const UT_IpAddressV6& other) const
    {
        return std::memcmp(myAddress.data(), other.myAddress.data(), 16) == 0;
    }
    bool operator!=(const UT_IpAddressV6& other) const
    {
        return !(*this == other);
    }
    bool operator<(const UT_IpAddressV6& other) const
    {
        return myAddress < other.myAddress;
    }
    bool operator>(const UT_IpAddressV6& other) const
    {
        return other < *this;
    }
    bool operator<=(const UT_IpAddressV6& other) const
    {
        return !(other < *this);
    }
    bool operator>=(const UT_IpAddressV6& other) const
    {
        return !(*this < other);
    }

    SYS_NO_DISCARD_RESULT bool isLoopback() const
    {
        // Pure IPv6 loopback ::1.
        const bool pure_v6_loopback
                = myAddress[0] == 0 && myAddress[1] == 0 && myAddress[2] == 0
                  && myAddress[3] == 0 && myAddress[4] == 0
                  && myAddress[5] == 0 && myAddress[6] == 0
                  && myAddress[7] == 0 && myAddress[8] == 0
                  && myAddress[9] == 0 && myAddress[10] == 0
                  && myAddress[11] == 0 && myAddress[12] == 0
                  && myAddress[13] == 0 && myAddress[14] == 0
                  && myAddress[15] == 1;
        if (pure_v6_loopback)
            return true;
        // IPv4-mapped loopback ::ffff:127.x.x.x. A dual-stack v6 listener
        // receives v4 clients as v4-mapped v6 at the socket layer, and
        // downstream IP checks (license IP mask, isLocalConnection) rely on
        // this method recognizing the v4 loopback form.
        return isV4Mapped() && toV4().isLoopback();
    }
    SYS_NO_DISCARD_RESULT bool isUnspecified() const
    {
        return myAddress[0] == 0 && myAddress[1] == 0 && myAddress[2] == 0
               && myAddress[3] == 0 && myAddress[4] == 0 && myAddress[5] == 0
               && myAddress[6] == 0 && myAddress[7] == 0 && myAddress[8] == 0
               && myAddress[9] == 0 && myAddress[10] == 0 && myAddress[11] == 0
               && myAddress[12] == 0 && myAddress[13] == 0 && myAddress[14] == 0
               && myAddress[15] == 0;
    }
    SYS_NO_DISCARD_RESULT bool isV4Mapped() const
    {
        return myAddress[0] == 0 && myAddress[1] == 0 && myAddress[2] == 0
               && myAddress[3] == 0 && myAddress[4] == 0 && myAddress[5] == 0
               && myAddress[6] == 0 && myAddress[7] == 0 && myAddress[8] == 0
               && myAddress[9] == 0 && myAddress[10] == 0xff
               && myAddress[11] == 0xff;
    }
    SYS_NO_DISCARD_RESULT bool isLinkLocal() const
    {
        return myAddress[0] == 0xfe && ((myAddress[1] & 0xc0) == 0x80);
    }
    SYS_NO_DISCARD_RESULT bool isSiteLocal() const
    {
        return myAddress[0] == 0xfe && ((myAddress[1] & 0xc0) == 0xc0);
    }
    SYS_NO_DISCARD_RESULT bool isMulticast() const
    {
        return myAddress[0] == 0xff;
    }
    SYS_NO_DISCARD_RESULT static UT_IpAddressV6 loopback()
    {
        return UT_IpAddressV6({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1});
    }

    SYS_NO_DISCARD_RESULT const bytes_t& toBytes() const { return myAddress; }

    SYS_NO_DISCARD_RESULT static UT_IpAddressV6 fromString(
            const UT_StringRef& str);
    SYS_NO_DISCARD_RESULT UT_StringHolder toString() const;
    SYS_NO_DISCARD_RESULT UT_IpAddressV4 toV4() const
    {
        UT_ASSERT(isV4Mapped());
        return UT_IpAddressV4(
                myAddress[12], myAddress[13], myAddress[14], myAddress[15]);
    }

private:
    bytes_t myAddress;
};

/// This represents either an Ipv4 address or an Ipv6 address.
class UT_API UT_IpAddress
{
public:
    UT_IpAddress() :
        myType(Type::ipv4)
    {
        myIP.myIPv4 = UT_IpAddressV4();
    }
    UT_IpAddress(const UT_IpAddressV4::bytes_t& addr)
        : myType(Type::ipv4)
    {
        myIP.myIPv4 = UT_IpAddressV4(addr);
    }
    UT_IpAddress(const UT_IpAddressV6::bytes_t& addr)
        : myType(Type::ipv6)
    {
        myIP.myIPv6 = UT_IpAddressV6(addr);
    }
    UT_IpAddress(
            unsigned char i0,
            unsigned char i1,
            unsigned char i2,
            unsigned char i3)
        : myType(Type::ipv4)
    {
        myIP.myIPv4 = UT_IpAddressV4(i0, i1, i2, i3);
    }
    UT_IpAddress(const UT_IpAddress& ip) : myType(ip.myType)
    {
        if (myType == Type::ipv4)
        {
            myIP.myIPv4 = ip.myIP.myIPv4;
        }
        else
        {
            myIP.myIPv6 = ip.myIP.myIPv6;
        }
    }
    UT_IpAddress(const UT_IpAddressV4& ip) : myType(Type::ipv4)
    {
        myIP.myIPv4 = ip;
    }
    UT_IpAddress(const UT_IpAddressV6& ip) : myType(Type::ipv6)
    {
        myIP.myIPv6 = ip;
    }

    bool operator==(const UT_IpAddress& other) const
    {
        if (isV4())
        {
            if (!other.isV4())
                return false;
            return myIP.myIPv4 == other.myIP.myIPv4;
        }
        return other.isV6() && myIP.myIPv6 == other.myIP.myIPv6;
    }
    bool operator!=(const UT_IpAddress& other) const
    {
        return !(*this == other);
    }

    UT_IpAddress& operator=(const UT_IpAddress& ip)
    {
        myType = ip.myType;
        if (myType == Type::ipv4)
        {
            myIP.myIPv4 = ip.myIP.myIPv4;
        }
        else
        {
            myIP.myIPv6 = ip.myIP.myIPv6;
        }
        return *this;
    }
    UT_IpAddress& operator=(const UT_IpAddressV4& ip)
    {
        myIP.myIPv4 = ip;
        myType = Type::ipv4;
        return *this;
    }
    UT_IpAddress& operator=(const UT_IpAddressV6& ip)
    {
        myIP.myIPv6 = ip;
        myType = Type::ipv6;
        return *this;
    }

    SYS_NO_DISCARD_RESULT bool isV4() const { return myType == Type::ipv4; }
    SYS_NO_DISCARD_RESULT bool isV6() const { return myType == Type::ipv6; }
    SYS_NO_DISCARD_RESULT bool isUnspecified() const
    {
        if (isV4())
            return myIP.myIPv4.isUnspecified();
        return myIP.myIPv6.isUnspecified();
    }
    SYS_NO_DISCARD_RESULT bool isLoopback() const
    {
        if (isV4())
            return myIP.myIPv4.isLoopback();
        return myIP.myIPv6.isLoopback();
    }

    SYS_NO_DISCARD_RESULT static UT_IpAddress fromString(
            const UT_StringRef& str)
    {
        // Check what type this address is in.
        exint idx = str.findCharIndex(':');
        if (idx >= 0)
        {
            return UT_IpAddress(UT_IpAddressV6::fromString(str));
        }
        return UT_IpAddress(UT_IpAddressV4::fromString(str));
    }

    SYS_NO_DISCARD_RESULT UT_StringHolder toString() const
    {
        if (isV4())
            return myIP.myIPv4.toString();
        return myIP.myIPv6.toString();
    }

    SYS_NO_DISCARD_RESULT UT_IpAddressV4 toV4() const
    {
        if (!isV4())
            return UT_IpAddressV4();
        return myIP.myIPv4;
    }
    SYS_NO_DISCARD_RESULT UT_IpAddressV6 toV6() const
    {
        if (!isV6())
            return UT_IpAddressV6();
        return myIP.myIPv6;
    }

private:
    enum class Type
    {
        ipv4,
        ipv6
    };

    Type myType;
    union IP
    {
        IP()
        {
            new(&myIPv6) UT_IpAddressV6;
        }

        UT_IpAddressV4 myIPv4;
        UT_IpAddressV6 myIPv6;
    } myIP;
};

class UT_API UT_IpNetworkV4
{
public:
    using address_t = UT_IpAddressV4; 
    static constexpr uint32_t host_address_len = 32;

    UT_IpNetworkV4() :
        myAddress(),
        myPrefixLength(host_address_len)
    {}
    UT_IpNetworkV4(const address_t& address, uint16 prefix_length)
        : myAddress(address), myPrefixLength(prefix_length)
    {
        UT_ASSERT(myPrefixLength <= host_address_len);
    }
    UT_IpNetworkV4(const UT_IpNetworkV4& net)
        : myAddress(net.myAddress), myPrefixLength(net.myPrefixLength)
    {
    }
    UT_IpNetworkV4& operator=(const UT_IpNetworkV4& other)
    {
        myAddress = other.myAddress;
        myPrefixLength = other.myPrefixLength;
        return *this;
    }
    bool operator==(const UT_IpNetworkV4& other) const
    {
        return myAddress == other.myAddress
               && myPrefixLength == other.myPrefixLength;
    }
    bool operator!=(const UT_IpNetworkV4& other) const
    {
        return !(*this == other);
    }
    SYS_NO_DISCARD_RESULT static UT_IpNetworkV4 fromString(
            const UT_StringRef& str);
    SYS_NO_DISCARD_RESULT const address_t& address() const
    {
        return myAddress;
    }
    SYS_NO_DISCARD_RESULT address_t netmask() const;
    SYS_NO_DISCARD_RESULT address_t network() const
    {
        return UT_IpAddressV4(myAddress.toUInt() & netmask().toUInt());
    }
    SYS_NO_DISCARD_RESULT UT_IpNetworkV4 canonical() const
    {
        return UT_IpNetworkV4(network(), myPrefixLength);
    }
    SYS_NO_DISCARD_RESULT uint16_t prefixLength() const { return myPrefixLength; }
    SYS_NO_DISCARD_RESULT bool isHost() const { return myPrefixLength == host_address_len; }
    SYS_NO_DISCARD_RESULT bool isSubnetOf(const UT_IpNetworkV4& other) const;
    SYS_NO_DISCARD_RESULT UT_StringHolder toString() const
    {
        UT_StringHolder str;
        str.format("{}/{}", myAddress.toString(), myPrefixLength);
        return str;
    }
    SYS_NO_DISCARD_RESULT static UT_IpNetworkV4 loopback()
    {
        return UT_IpNetworkV4(UT_IpAddressV4::loopback(), host_address_len);
    }

private:
    address_t myAddress;
    uint16_t myPrefixLength;
};

class UT_API UT_IpNetworkV6
{
public:
    using address_t = UT_IpAddressV6;
    static constexpr uint32_t host_address_len = 128;

    UT_IpNetworkV6() :
        myAddress(),
        myPrefixLength(host_address_len)
    {}
    UT_IpNetworkV6(const address_t& address, uint32_t prefix_length)
        : myAddress(address), myPrefixLength(prefix_length)
    {
        UT_ASSERT(myPrefixLength <= host_address_len);
    }
    UT_IpNetworkV6(const UT_IpNetworkV6& other)
        : myAddress(other.myAddress), myPrefixLength(other.myPrefixLength)
    {
    }

    UT_IpNetworkV6& operator=(const UT_IpNetworkV6& other)
    {
        myAddress = other.myAddress;
        myPrefixLength = other.myPrefixLength;
        return *this;
    }
    bool operator==(const UT_IpNetworkV6& net) const
    {
        return myAddress == net.myAddress
               && myPrefixLength == net.myPrefixLength;
    }
    bool operator!=(const UT_IpNetworkV6& net) const { return !(*this == net); }

    SYS_NO_DISCARD_RESULT static UT_IpNetworkV6 fromString(
            const UT_StringRef& str);
    SYS_NO_DISCARD_RESULT address_t network() const;
    SYS_NO_DISCARD_RESULT const address_t& address() const
    {
        return myAddress;
    }
    SYS_NO_DISCARD_RESULT UT_IpNetworkV6 canonical() const
    {
        return UT_IpNetworkV6(network(), myPrefixLength);
    }
    SYS_NO_DISCARD_RESULT uint32_t prefixLength() const { return myPrefixLength; }
    SYS_NO_DISCARD_RESULT bool isHost() const { return myPrefixLength == host_address_len; }
    SYS_NO_DISCARD_RESULT bool isSubnetOf(const UT_IpNetworkV6& net) const;
    SYS_NO_DISCARD_RESULT UT_StringHolder toString() const
    {
        UT_StringHolder str;
        str.format("{}/{}", myAddress.toString(), myPrefixLength);
        return str;
    }
    SYS_NO_DISCARD_RESULT static UT_IpNetworkV6 loopback()
    {
        return UT_IpNetworkV6(UT_IpAddressV6::loopback(), host_address_len);
    }
private:
    address_t myAddress;
    uint32_t myPrefixLength;
};

#endif // __UT_IPADDRESS_H__