IpAddress.h

Go to the documentation of this file.

#ifndef PCAPPP_IPADDRESS
#define PCAPPP_IPADDRESS

#include <memory>
#include <stdint.h>
#include <string>

#define MAX_ADDR_STRING_LEN 40 //xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx


struct in_addr;
struct in6_addr;

namespace pcpp
{

    class IPAddress
    {
    protected:
        bool m_IsValid;
        char m_AddressAsString[MAX_ADDR_STRING_LEN];

        // protected c'tor
        IPAddress() : m_IsValid(false) {}
    public:
#if __cplusplus > 199711L
        typedef std::unique_ptr<IPAddress> Ptr_t; 
#else
        typedef std::auto_ptr<IPAddress> Ptr_t; 
#endif

        enum AddressType {
            IPv4AddressType,
            IPv6AddressType
        };

        virtual ~IPAddress();

        virtual AddressType getType() const = 0;

        std::string toString() const { return std::string(m_AddressAsString); }

        bool isValid() { return m_IsValid; }

        virtual IPAddress* clone() const = 0;

        bool equals(const IPAddress* other);

        static Ptr_t fromString(char* addressAsString);

        static Ptr_t fromString(std::string addressAsString);
    };

    class IPv4Address : public IPAddress
    {
    private:
        in_addr* m_pInAddr;
        void init(char* addressAsString);
    public:
        IPv4Address(uint32_t addressAsInt);

        IPv4Address(char* addressAsString);

        IPv4Address(std::string addressAsString);

        IPv4Address(in_addr* inAddr);

        ~IPv4Address();

        IPv4Address(const IPv4Address& other);

        AddressType getType() const { return IPv4AddressType; }

        IPAddress* clone() const;

        uint32_t toInt() const;

        in_addr* toInAddr() { return m_pInAddr; }

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

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

        IPv4Address& operator=(const IPv4Address& other);

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

        static IPv4Address Zero;
    };


    class IPv6Address : public IPAddress
    {
    private:
        in6_addr* m_pInAddr;
        void init(char* addressAsString);
    public:
        ~IPv6Address();

        IPv6Address(uint8_t* addressAsUintArr);

        IPv6Address(char* addressAsString);

        IPv6Address(std::string addressAsString);

        IPv6Address(const IPv6Address& other);

        AddressType getType() const { return IPv6AddressType; }

        IPAddress* clone() const;

        in6_addr* toIn6Addr() { return m_pInAddr; }

        void copyTo(uint8_t** arr, size_t& length);

        void copyTo(uint8_t* arr) const;

        bool operator==(const IPv6Address& other);

        bool operator!=(const IPv6Address& other);

        IPv6Address& operator=(const IPv6Address& other);

        static IPv6Address Zero;
    };

} // namespace pcpp

#endif /* PCAPPP_IPADDRESS */