IpAddress.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <cstring>
#include <string>
#include <algorithm>
#include <ostream>
#include <array>
#include <memory>
 
#include "DeprecationUtils.h"
 
 
namespace pcpp
{
 
    // forward declarations
    class IPv4Network;
    class IPv6Network;
 
    // The implementation of the classes is based on document N4771 "Working Draft, C++ Extensions for Networking"
    // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4771.pdf
 
    class IPv4Address
    {
    public:
        IPv4Address() = default;
 
        IPv4Address(const uint32_t addrAsInt)
        {
            memcpy(m_Bytes.data(), &addrAsInt, sizeof(addrAsInt));
        }
 
        IPv4Address(const uint8_t bytes[4]) : IPv4Address(bytes, 4)
        {}
 
        IPv4Address(const uint8_t* bytes, size_t size);
 
        IPv4Address(const std::array<uint8_t, 4>& bytes) : m_Bytes(bytes)
        {}
 
        IPv4Address(const std::string& addrAsString);
 
        inline uint32_t toInt() const;
 
        const uint8_t* toBytes() const
        {
            return m_Bytes.data();
        }
 
        const std::array<uint8_t, 4>& toByteArray() const
        {
            return m_Bytes;
        }
 
        std::string toString() const;
 
        bool isMulticast() const;
 
        bool operator==(const IPv4Address& rhs) const
        {
            return toInt() == rhs.toInt();
        }
 
        bool operator<(const IPv4Address& rhs) const
        {
            uint32_t intVal = toInt();
            std::reverse(reinterpret_cast<uint8_t*>(&intVal), reinterpret_cast<uint8_t*>(&intVal) + sizeof(intVal));
 
            uint32_t rhsIntVal = rhs.toInt();
            std::reverse(reinterpret_cast<uint8_t*>(&rhsIntVal),
                         reinterpret_cast<uint8_t*>(&rhsIntVal) + sizeof(rhsIntVal));
 
            return intVal < rhsIntVal;
        }
 
        bool operator!=(const IPv4Address& rhs) const
        {
            return !(*this == rhs);
        }
 
        bool matchNetwork(const IPv4Network& network) const;
 
        bool matchNetwork(const std::string& network) const;
 
        static bool isValidIPv4Address(const std::string& addrAsString);
 
        static const IPv4Address Zero;
 
        static const IPv4Address MulticastRangeLowerBound;
        static const IPv4Address MulticastRangeUpperBound;
 
    private:
        std::array<uint8_t, 4> m_Bytes = { 0 };
    };  // class IPv4Address
 
    // Implementation of inline methods
 
    uint32_t IPv4Address::toInt() const
    {
        uint32_t addr = 0;
        memcpy(&addr, m_Bytes.data(), m_Bytes.size() * sizeof(uint8_t));
        return addr;
    }
 
    class IPv6Address
    {
    public:
        IPv6Address() = default;
 
        IPv6Address(const uint8_t bytes[16]) : IPv6Address(bytes, 16)
        {}
 
        IPv6Address(const uint8_t* bytes, size_t size);
 
        IPv6Address(const std::array<uint8_t, 16>& bytes) : m_Bytes(bytes)
        {}
 
        IPv6Address(const std::string& addrAsString);
 
        const uint8_t* toBytes() const
        {
            return m_Bytes.data();
        }
 
        const std::array<uint8_t, 16>& toByteArray() const
        {
            return m_Bytes;
        }
 
        std::string toString() const;
 
        bool isMulticast() const;
 
        bool operator==(const IPv6Address& rhs) const
        {
            return memcmp(toBytes(), rhs.toBytes(), sizeof(m_Bytes)) == 0;
        }
 
        bool operator<(const IPv6Address& rhs) const
        {
            return memcmp(toBytes(), rhs.toBytes(), sizeof(m_Bytes)) < 0;
        }
 
        bool operator!=(const IPv6Address& rhs) const
        {
            return !(*this == rhs);
        }
 
        PCPP_DEPRECATED("Use copyToNewBuffer instead.")
        void copyTo(uint8_t** arr, size_t& length) const;
 
        void copyTo(uint8_t* arr) const
        {
            copyTo(arr, 16);
        }
 
        size_t copyTo(uint8_t* buffer, size_t size) const;
 
        bool copyToNewBuffer(uint8_t** buffer, size_t& size) const;
 
        bool matchNetwork(const IPv6Network& network) const;
 
        bool matchNetwork(const std::string& network) const;
 
        static bool isValidIPv6Address(const std::string& addrAsString);
 
        static const IPv6Address Zero;
 
        static const IPv6Address MulticastRangeLowerBound;
 
    private:
        std::array<uint8_t, 16> m_Bytes = { 0 };
    };  // class IPv6Address
 
    class IPAddress
    {
    public:
        enum AddressType : uint8_t
        {
            IPv4AddressType,
            IPv6AddressType
        };
 
        IPAddress() : m_Type(IPv4AddressType)
        {}
 
        IPAddress(const IPv4Address& addr) : m_Type(IPv4AddressType), m_IPv4(addr)
        {}
 
        IPAddress(const IPv6Address& addr) : m_Type(IPv6AddressType), m_IPv6(addr)
        {}
 
        IPAddress(const std::string& addrAsString);
 
        inline IPAddress& operator=(const IPv4Address& addr);
 
        inline IPAddress& operator=(const IPv6Address& addr);
 
        AddressType getType() const
        {
            return static_cast<AddressType>(m_Type);
        }
 
        std::string toString() const
        {
            return (getType() == IPv4AddressType) ? m_IPv4.toString() : m_IPv6.toString();
        }
 
        bool isIPv4() const
        {
            return getType() == IPv4AddressType;
        }
 
        bool isIPv6() const
        {
            return getType() == IPv6AddressType;
        }
 
        bool isMulticast() const
        {
            return (getType() == IPv4AddressType) ? m_IPv4.isMulticast() : m_IPv6.isMulticast();
        }
 
        const IPv4Address& getIPv4() const
        {
            return m_IPv4;
        }
 
        const IPv6Address& getIPv6() const
        {
            return m_IPv6;
        }
 
        bool isZero() const
        {
            return (getType() == IPv4AddressType) ? m_IPv4 == IPv4Address::Zero : m_IPv6 == IPv6Address::Zero;
        }
 
        inline bool operator==(const IPAddress& rhs) const;
 
        inline bool operator<(const IPAddress& rhs) const;
 
        bool operator!=(const IPAddress& rhs) const
        {
            return !(*this == rhs);
        }
 
    private:
        uint8_t m_Type;
        IPv4Address m_IPv4;
        IPv6Address m_IPv6;
    };
 
    // implementation of inline methods
 
    bool IPAddress::operator==(const IPAddress& rhs) const
    {
        if (isIPv4())
        {
            return rhs.isIPv4() ? (m_IPv4 == rhs.m_IPv4) : false;
        }
 
        return rhs.isIPv6() ? m_IPv6 == rhs.m_IPv6 : false;
    }
 
    bool IPAddress::operator<(const IPAddress& rhs) const
    {
        if (isIPv4())
        {
            // treat IPv4 as less than IPv6
            // If current obj is IPv4 and other is IPv6 return true
            return rhs.isIPv4() ? (m_IPv4 < rhs.m_IPv4) : true;
        }
        return rhs.isIPv6() ? m_IPv6 < rhs.m_IPv6 : false;
    }
 
    IPAddress& IPAddress::operator=(const IPv4Address& addr)
    {
        m_Type = IPv4AddressType;
        m_IPv4 = addr;
        return *this;
    }
 
    IPAddress& IPAddress::operator=(const IPv6Address& addr)
    {
        m_Type = IPv6AddressType;
        m_IPv6 = addr;
        return *this;
    }
 
    class IPv4Network
    {
    public:
        explicit IPv4Network(const IPv4Address& address) : IPv4Network(address, 32U)
        {}
 
        IPv4Network(const IPv4Address& address, uint8_t prefixLen);
 
        IPv4Network(const IPv4Address& address, const std::string& netmask);
 
        IPv4Network(const std::string& addressAndNetmask);
 
        uint8_t getPrefixLen() const;
 
        std::string getNetmask() const
        {
            return IPv4Address(m_Mask).toString();
        }
 
        IPv4Address getNetworkPrefix() const
        {
            return m_NetworkPrefix;
        }
 
        IPv4Address getLowestAddress() const;
 
        IPv4Address getHighestAddress() const;
 
        uint64_t getTotalAddressCount() const;
 
        bool includes(const IPv4Address& address) const;
 
        bool includes(const IPv4Network& network) const;
 
        std::string toString() const;
 
    private:
        uint32_t m_NetworkPrefix{};
        uint32_t m_Mask{};
 
        static bool isValidNetmask(const IPv4Address& netmaskAddress);
        void initFromAddressAndPrefixLength(const IPv4Address& address, uint8_t prefixLen);
        void initFromAddressAndNetmask(const IPv4Address& address, const IPv4Address& netmaskAddress);
    };
 
    class IPv6Network
    {
    public:
        explicit IPv6Network(const IPv6Address& address) : IPv6Network(address, 128U)
        {}
 
        IPv6Network(const IPv6Address& address, uint8_t prefixLen);
 
        IPv6Network(const IPv6Address& address, const std::string& netmask);
 
        IPv6Network(const std::string& addressAndNetmask);
 
        uint8_t getPrefixLen() const;
 
        std::string getNetmask() const
        {
            return IPv6Address(m_Mask).toString();
        }
 
        IPv6Address getNetworkPrefix() const
        {
            return { m_NetworkPrefix };
        }
 
        IPv6Address getLowestAddress() const;
 
        IPv6Address getHighestAddress() const;
 
        uint64_t getTotalAddressCount() const;
 
        bool includes(const IPv6Address& address) const;
 
        bool includes(const IPv6Network& network) const;
 
        std::string toString() const;
 
    private:
        uint8_t m_NetworkPrefix[16]{};
        uint8_t m_Mask[16]{};
 
        static bool isValidNetmask(const IPv6Address& netmaskAddress);
        void initFromAddressAndPrefixLength(const IPv6Address& address, uint8_t prefixLen);
        void initFromAddressAndNetmask(const IPv6Address& address, const IPv6Address& netmaskAddress);
    };
 
    class IPNetwork
    {
    public:
        explicit IPNetwork(const IPAddress& address) : IPNetwork(address, address.isIPv4() ? 32U : 128U)
        {}
 
        IPNetwork(const IPAddress& address, uint8_t prefixLen)
        {
            if (address.isIPv4())
            {
                m_NetworkVariant = IPv4Network(address.getIPv4(), prefixLen);
            }
            else
            {
                m_NetworkVariant = IPv6Network(address.getIPv6(), prefixLen);
            }
        }
 
        IPNetwork(const IPAddress& address, const std::string& netmask)
        {
            if (address.isIPv4())
            {
                m_NetworkVariant = IPv4Network(address.getIPv4(), netmask);
            }
            else
            {
                m_NetworkVariant = IPv6Network(address.getIPv6(), netmask);
            }
        }
 
        IPNetwork(const std::string& addressAndNetmask)
        {
            try
            {
                m_NetworkVariant = IPv4Network(addressAndNetmask);
            }
            catch (const std::invalid_argument&)
            {
                m_NetworkVariant = IPv6Network(addressAndNetmask);
            }
        }
 
        IPNetwork(const IPNetwork& other) : m_NetworkVariant(other.m_NetworkVariant)
        {}
 
        IPNetwork& operator=(const IPNetwork& other)
        {
            m_NetworkVariant = other.m_NetworkVariant;
            return *this;
        }
 
        IPNetwork& operator=(const IPv4Network& other)
        {
            m_NetworkVariant = other;
            return *this;
        }
 
        IPNetwork& operator=(const IPv6Network& other)
        {
            m_NetworkVariant = other;
            return *this;
        }
 
        uint8_t getPrefixLen() const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                return ip4->getPrefixLen();
            }
 
            return m_NetworkVariant.getIPv6().getPrefixLen();
        }
 
        std::string getNetmask() const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                return ip4->getNetmask();
            }
 
            return m_NetworkVariant.getIPv6().getNetmask();
        }
 
        IPAddress getNetworkPrefix() const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                return IPAddress(ip4->getNetworkPrefix());
            }
 
            return IPAddress(m_NetworkVariant.getIPv6().getNetworkPrefix());
        }
 
        IPAddress getLowestAddress() const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                return IPAddress(ip4->getLowestAddress());
            }
            return IPAddress(m_NetworkVariant.getIPv6().getLowestAddress());
        }
 
        IPAddress getHighestAddress() const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                return IPAddress(ip4->getHighestAddress());
            }
 
            return IPAddress(m_NetworkVariant.getIPv6().getHighestAddress());
        }
 
        uint64_t getTotalAddressCount() const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                return ip4->getTotalAddressCount();
            }
            return m_NetworkVariant.getIPv6().getTotalAddressCount();
        }
 
        bool isIPv4Network() const
        {
            return m_NetworkVariant.getType() == NetworkVariant::Type::IPv4;
        }
 
        bool isIPv6Network() const
        {
            return m_NetworkVariant.getType() == NetworkVariant::Type::IPv6;
        }
 
        bool includes(const IPAddress& address) const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                if (address.isIPv6())
                {
                    return false;
                }
                return ip4->includes(address.getIPv4());
            }
 
            if (address.isIPv4())
            {
                return false;
            }
 
            return m_NetworkVariant.getIPv6().includes(address.getIPv6());
        }
 
        bool includes(const IPNetwork& network) const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4 != nullptr)
            {
                auto otherIp4 = network.m_NetworkVariant.tryGetIPv4();
                if (otherIp4 == nullptr)
                {
                    return false;
                }
                return ip4->includes(*otherIp4);
            }
 
            auto& ip6 = m_NetworkVariant.getIPv6();
            auto otherIp6 = network.m_NetworkVariant.tryGetIPv6();
            if (otherIp6 == nullptr)
            {
                return false;
            }
            return ip6.includes(*otherIp6);
        }
 
        std::string toString() const
        {
            auto ip4 = m_NetworkVariant.tryGetIPv4();
            if (ip4)
            {
                return ip4->toString();
            }
 
            return m_NetworkVariant.getIPv6().toString();
        }
 
    private:
        // TODO: C++17 Replace with std::variant.
        class NetworkVariant
        {
        public:
            enum class Type
            {
                IPv4,
                IPv6
            };
 
            NetworkVariant() : m_Type(Type::IPv4), m_IPv4Net(IPv4Address::Zero)
            {}
            NetworkVariant(IPv4Network const& net) : m_Type(Type::IPv4), m_IPv4Net(net)
            {}
            NetworkVariant(IPv6Network const& net) : m_Type(Type::IPv6), m_IPv6Net(net)
            {}
            ~NetworkVariant()
            {
                destroyActiveMem();
            }
 
            NetworkVariant& operator=(IPv4Network const& other)
            {
                swapTo(Type::IPv4);
                m_IPv4Net = other;
                return *this;
            }
            NetworkVariant& operator=(IPv6Network const& other)
            {
                swapTo(Type::IPv6);
                m_IPv6Net = other;
                return *this;
            }
            NetworkVariant& operator=(NetworkVariant const& other)
            {
                swapTo(other.m_Type);
                switch (other.m_Type)
                {
                case Type::IPv4:
                    m_IPv4Net = other.m_IPv4Net;
                    break;
                case Type::IPv6:
                    m_IPv6Net = other.m_IPv6Net;
                    break;
                }
                return *this;
            }
 
            Type getType() const noexcept
            {
                return m_Type;
            }
 
            IPv4Network& getIPv4()
            {
                throwIfNot(Type::IPv4);
                return m_IPv4Net;
            }
 
            IPv4Network const& getIPv4() const
            {
                throwIfNot(Type::IPv4);
                return m_IPv4Net;
            }
 
            IPv4Network* tryGetIPv4() noexcept
            {
                return (m_Type == Type::IPv4) ? &m_IPv4Net : nullptr;
            }
            IPv4Network const* tryGetIPv4() const noexcept
            {
                return (m_Type == Type::IPv4) ? &m_IPv4Net : nullptr;
            }
 
            IPv6Network& getIPv6()
            {
                throwIfNot(Type::IPv6);
                return m_IPv6Net;
            }
 
            IPv6Network const& getIPv6() const
            {
                throwIfNot(Type::IPv6);
                return m_IPv6Net;
            }
 
            IPv6Network* tryGetIPv6() noexcept
            {
                return (m_Type == Type::IPv6) ? &m_IPv6Net : nullptr;
            }
            IPv6Network const* tryGetIPv6() const noexcept
            {
                return (m_Type == Type::IPv6) ? &m_IPv6Net : nullptr;
            }
 
        private:
            void throwIfNot(Type type) const
            {
                if (type != m_Type)
                {
                    throw std::runtime_error("Bad variant access");
                }
            }
 
            void swapTo(Type newType) noexcept;
            void destroyActiveMem() noexcept;
 
            Type m_Type;
            union {
                IPv4Network m_IPv4Net;
                IPv6Network m_IPv6Net;
            };
        };
 
        NetworkVariant m_NetworkVariant;
    };
 
    namespace literals
    {
        inline IPv4Address operator""_ipv4(const char* addrString, std::size_t size)
        {
            return IPv4Address(std::string(addrString, size));
        }
 
        inline IPv6Address operator""_ipv6(const char* addrString, std::size_t size)
        {
            return IPv6Address(std::string(addrString, size));
        }
    }  // namespace literals
 
    inline std::ostream& operator<<(std::ostream& oss, const pcpp::IPv4Address& ipv4Address)
    {
        oss << ipv4Address.toString();
        return oss;
    }
 
    inline std::ostream& operator<<(std::ostream& oss, const pcpp::IPv6Address& ipv6Address)
    {
        oss << ipv6Address.toString();
        return oss;
    }
 
    inline std::ostream& operator<<(std::ostream& oss, const pcpp::IPAddress& ipAddress)
    {
        oss << ipAddress.toString();
        return oss;
    }
 
    inline std::ostream& operator<<(std::ostream& oss, const pcpp::IPv4Network& network)
    {
        oss << network.toString();
        return oss;
    }
 
    inline std::ostream& operator<<(std::ostream& oss, const pcpp::IPv6Network& network)
    {
        oss << network.toString();
        return oss;
    }
 
    inline std::ostream& operator<<(std::ostream& oss, const pcpp::IPNetwork& network)
    {
        oss << network.toString();
        return oss;
    }
}  // namespace pcpp