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>
 
 
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])
        {
            memcpy(m_Bytes.data(), bytes, 4 * sizeof(uint8_t));
        }
 
        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])
        {
            memcpy(m_Bytes.data(), bytes, 16 * sizeof(uint8_t));
        }
 
        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);
        }
 
        void copyTo(uint8_t** arr, size_t& length) const;
 
        void copyTo(uint8_t* arr) const
        {
            memcpy(arr, m_Bytes.data(), m_Bytes.size() * sizeof(uint8_t));
        }
 
        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_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(address.getIPv4(), prefixLen));
            }
            else
            {
                m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(address.getIPv6(), prefixLen));
            }
        }
 
        IPNetwork(const IPAddress& address, const std::string& netmask)
        {
            if (address.isIPv4())
            {
                m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(address.getIPv4(), netmask));
            }
            else
            {
                m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(address.getIPv6(), netmask));
            }
        }
 
        IPNetwork(const std::string& addressAndNetmask)
        {
            try
            {
                m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(addressAndNetmask));
            }
            catch (const std::invalid_argument&)
            {
                m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(addressAndNetmask));
            }
        }
 
        IPNetwork(const IPNetwork& other)
        {
            if (other.m_IPv4Network)
            {
                m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(*other.m_IPv4Network));
            }
 
            if (other.m_IPv6Network)
            {
                m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(*other.m_IPv6Network));
            }
        }
 
        IPNetwork& operator=(const IPNetwork& other)
        {
            // NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature,misc-unconventional-assign-operator)
            if (other.isIPv4Network())
            {
                return this->operator=(*other.m_IPv4Network);
            }
 
            return this->operator=(*other.m_IPv6Network);
            // NOLINTEND(cppcoreguidelines-c-copy-assignment-signature,misc-unconventional-assign-operator)
        }
 
        IPNetwork& operator=(const IPv4Network& other)
        {
            // Create the new instance first to maintain strong exception guarantee.
            m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(other));
            m_IPv6Network = nullptr;
            return *this;
        }
 
        IPNetwork& operator=(const IPv6Network& other)
        {
            // Create the new instance first to maintain strong exception guarantee.
            m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(other));
            m_IPv4Network = nullptr;
            return *this;
        }
 
        uint8_t getPrefixLen() const
        {
            return (m_IPv4Network != nullptr ? m_IPv4Network->getPrefixLen() : m_IPv6Network->getPrefixLen());
        }
 
        std::string getNetmask() const
        {
            return (m_IPv4Network != nullptr ? m_IPv4Network->getNetmask() : m_IPv6Network->getNetmask());
        }
 
        IPAddress getNetworkPrefix() const
        {
            return (m_IPv4Network != nullptr ? IPAddress(m_IPv4Network->getNetworkPrefix())
                                             : IPAddress(m_IPv6Network->getNetworkPrefix()));
        }
 
        IPAddress getLowestAddress() const
        {
            return (m_IPv4Network != nullptr ? IPAddress(m_IPv4Network->getLowestAddress())
                                             : IPAddress(m_IPv6Network->getLowestAddress()));
        }
 
        IPAddress getHighestAddress() const
        {
            return (m_IPv4Network != nullptr ? IPAddress(m_IPv4Network->getHighestAddress())
                                             : IPAddress(m_IPv6Network->getHighestAddress()));
        }
 
        uint64_t getTotalAddressCount() const
        {
            return (m_IPv4Network != nullptr ? m_IPv4Network->getTotalAddressCount()
                                             : m_IPv6Network->getTotalAddressCount());
        }
 
        bool isIPv4Network() const
        {
            return m_IPv4Network != nullptr;
        }
 
        bool isIPv6Network() const
        {
            return m_IPv6Network != nullptr;
        }
 
        bool includes(const IPAddress& address) const
        {
            if (m_IPv4Network != nullptr)
            {
                if (address.isIPv6())
                {
                    return false;
                }
 
                return m_IPv4Network->includes(address.getIPv4());
            }
 
            if (address.isIPv4())
            {
                return false;
            }
 
            return m_IPv6Network->includes(address.getIPv6());
        }
 
        bool includes(const IPNetwork& network) const
        {
            if (m_IPv4Network != nullptr)
            {
                if (network.isIPv6Network())
                {
                    return false;
                }
 
                return m_IPv4Network->includes(*network.m_IPv4Network);
            }
 
            if (network.isIPv4Network())
            {
                return false;
            }
 
            return m_IPv6Network->includes(*network.m_IPv6Network);
        }
 
        std::string toString() const
        {
            return (m_IPv4Network != nullptr ? m_IPv4Network->toString() : m_IPv6Network->toString());
        }
 
    private:
        std::unique_ptr<IPv4Network> m_IPv4Network;
        std::unique_ptr<IPv6Network> m_IPv6Network;
    };
 
    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