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>
 
 
 
 
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 isValid() const { return toInt() != 0; }
 
        bool operator==(const IPv4Address& rhs) const { return toInt() == rhs.toInt(); }
 
        bool operator<(const IPv4Address& rhs) const { return toInt() < rhs.toInt(); }
 
        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;
 
    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 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;
 
    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; }
 
        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 */