IpAddress.h

Go to the documentation of this file.

#ifndef PCAPPP_IP_ADDRESSES
#define PCAPPP_IP_ADDRESSES

#include <stdint.h>
#include <string.h>
#include <string>
#include <algorithm>
#include <ostream>

#ifndef PCPP_DEPRECATED
#if defined(__GNUC__) || defined(__clang__)
#define PCPP_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define PCPP_DEPRECATED __declspec(deprecated)
#else
#pragma message("WARNING: DEPRECATED feature is not implemented for this compiler")
#define PCPP_DEPRECATED
#endif
#endif



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() { memset(m_Bytes, 0, sizeof(m_Bytes)); }

        IPv4Address(uint32_t addrAsInt) { memcpy(m_Bytes, &addrAsInt, sizeof(m_Bytes)); }

        IPv4Address(const uint8_t bytes[4]) { memcpy(m_Bytes, bytes, sizeof(m_Bytes)); }

        IPv4Address(const std::string& addrAsString);

        inline uint32_t toInt() const;

        const uint8_t* toBytes() const { return m_Bytes; }

        std::string toString() const;

        bool isMulticast() const;

        bool isValid() const { return toInt() != 0; }

        bool operator==(const IPv4Address& rhs) const { return toInt() == rhs.toInt(); }

        bool operator<(const IPv4Address& rhs) const
        {
            uint32_t intVal = toInt();
            std::reverse((uint8_t*)(&intVal), (uint8_t*)(&intVal) + sizeof(intVal));

            uint32_t rhsIntVal = rhs.toInt();
            std::reverse((uint8_t*)(&rhsIntVal), (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;

        PCPP_DEPRECATED bool matchSubnet(const IPv4Address& subnet, const std::string& subnetMask) const;

        PCPP_DEPRECATED bool matchSubnet(const IPv4Address& subnet, const IPv4Address& subnetMask) const;

        static const IPv4Address Zero;

        static const IPv4Address MulticastRangeLowerBound;
        static const IPv4Address MulticastRangeUpperBound;

    private:
        uint8_t m_Bytes[4];
    }; // class IPv4Address


    // Implementation of inline methods

    uint32_t IPv4Address::toInt() const
    {
        uint32_t addr;
        memcpy(&addr, m_Bytes, sizeof(m_Bytes));
        return addr;
    }

    class IPv6Address
    {
    public:
        IPv6Address() { memset(m_Bytes, 0, sizeof(m_Bytes)); }

        IPv6Address(const uint8_t bytes[16]) { memcpy(m_Bytes, bytes, sizeof(m_Bytes)); }

        IPv6Address(const std::string& addrAsString);

        const uint8_t* toBytes() const { return m_Bytes; }

        std::string toString() const;

        bool isMulticast() const;

        bool isValid() const { return *this != Zero; }

        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, sizeof(m_Bytes)); }

        bool matchNetwork(const IPv6Network& network) const;

        bool matchNetwork(const std::string& network) const;

        PCPP_DEPRECATED bool matchSubnet(const IPv6Address& subnet, uint8_t prefixLength) const;

        static const IPv6Address Zero;

        static const IPv6Address MulticastRangeLowerBound;

    private:
        uint8_t m_Bytes[16];
    }; // class IPv6Address


    class IPAddress
    {
    public:
        enum AddressType
        {
            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 isValid() const { return (getType() == IPv4AddressType) ? m_IPv4.isValid() : m_IPv6.isValid(); }

        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; }

        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:
        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 IPv4Address(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;

        bool isValidNetmask(const std::string& netmask);
        void initFromAddressAndPrefixLength(const IPv4Address& address, uint8_t prefixLen);
        void initFromAddressAndNetmask(const IPv4Address& address, const std::string& netmask);
    };


    class IPv6Network
    {
    public:
        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 IPv6Address(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];

        bool isValidNetmask(const std::string& netmask);
        void initFromAddressAndPrefixLength(const IPv6Address& address, uint8_t prefixLen);
        void initFromAddressAndNetmask(const IPv6Address& address, const std::string& netmask);
    };


    class IPNetwork
    {
    public:
        IPNetwork(const IPAddress& address, uint8_t prefixLen)
        {
            if (address.isIPv4())
            {
                m_IPv4Network = new IPv4Network(address.getIPv4(), prefixLen);
                m_IPv6Network = nullptr;
            }
            else
            {
                m_IPv6Network = new IPv6Network(address.getIPv6(), prefixLen);
                m_IPv4Network = nullptr;
            }
        }

        IPNetwork(const IPAddress& address, const std::string& netmask)
        {
            if (address.isIPv4())
            {
                m_IPv4Network = new IPv4Network(address.getIPv4(), netmask);
                m_IPv6Network = nullptr;
            }
            else
            {
                m_IPv6Network = new IPv6Network(address.getIPv6(), netmask);
                m_IPv4Network = nullptr;
            }
        }

        IPNetwork(const std::string& addressAndNetmask)
        {
            try
            {
                m_IPv4Network = new IPv4Network(addressAndNetmask);
                m_IPv6Network = nullptr;
            }
            catch (const std::invalid_argument&)
            {
                m_IPv6Network = new IPv6Network(addressAndNetmask);
                m_IPv4Network = nullptr;
            }
        }

        IPNetwork(const IPNetwork& other)
        {
            m_IPv4Network = nullptr;
            m_IPv6Network = nullptr;

            if (other.m_IPv4Network)
            {
                m_IPv4Network = new IPv4Network(*other.m_IPv4Network);
            }

            if (other.m_IPv6Network)
            {
                m_IPv6Network = new IPv6Network(*other.m_IPv6Network);
            }
        }

        ~IPNetwork()
        {
            if (m_IPv4Network)
            {
                delete m_IPv4Network;
            }

            if (m_IPv6Network)
            {
                delete m_IPv6Network;
            }
        }

        IPNetwork& operator=(const IPNetwork& other)
        {
            if (other.isIPv4Network())
            {
                return this->operator=(*other.m_IPv4Network);
            }
            else
            {
                return this->operator=(*other.m_IPv6Network);
            }
        }

        IPNetwork& operator=(const IPv4Network& other)
        {
            if (m_IPv4Network)
            {
                delete m_IPv4Network;
                m_IPv4Network = nullptr;
            }

            if (m_IPv6Network)
            {
                delete m_IPv6Network;
                m_IPv6Network = nullptr;
            }

            m_IPv4Network = new IPv4Network(other);

            return *this;
        }

        IPNetwork& operator=(const IPv6Network& other)
        {
            if (m_IPv4Network)
            {
                delete m_IPv4Network;
                m_IPv4Network = nullptr;
            }

            if (m_IPv6Network)
            {
                delete m_IPv6Network;
                m_IPv6Network = nullptr;
            }

            m_IPv6Network = new IPv6Network(other);

            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());
            }
            else
            {
                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);
            }
            else
            {
                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:
        IPv4Network* m_IPv4Network;
        IPv6Network* m_IPv6Network;
    };
} // namespace pcpp

inline std::ostream& operator<<(std::ostream& os, const pcpp::IPv4Address& ipv4Address)
{
    os << ipv4Address.toString();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const pcpp::IPv6Address& ipv6Address)
{
    os << ipv6Address.toString();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const pcpp::IPAddress& ipAddress)
{
    os << ipAddress.toString();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const pcpp::IPv4Network& network)
{
    os << network.toString();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const pcpp::IPv6Network& network)
{
    os << network.toString();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const pcpp::IPNetwork& network)
{
    os << network.toString();
    return os;
}

#endif /* PCAPPP_IPADDRESS */