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>



namespace pcpp
{

    // 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 matchSubnet(const IPv4Address& subnet, const std::string& subnetMask) const;

        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 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
    // * The class is a version-independent representation for an IP address
    // */
    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;
    }

} // namespace pcpp

#endif /* PCAPPP_IPADDRESS */