/src/PcapPlusPlus/Common++/header/IpAddress.h

Source
#pragma once

#include <cstdint>
#include <cstring>
#include <string>
#include <algorithm>
#include <ostream>
#include <array>
#include <memory>

#include "DeprecationUtils.h"

/// @file

/// @namespace pcpp
/// @brief The main namespace for the PcapPlusPlus lib
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
  /// Represents an IPv4 address (of type XXX.XXX.XXX.XXX)
  class IPv4Address
  {
  public:
    /// A default constructor that creates an instance of the class with the zero-initialized address
    IPv4Address() = default;

    /// A constructor that creates an instance of the class out of 4-byte integer value.
    /// @param[in] addrAsInt The address as 4-byte integer in network byte order
    IPv4Address(const uint32_t addrAsInt)
    {
      memcpy(m_Bytes.data(), &addrAsInt, sizeof(addrAsInt));
    }

    /// A constructor that creates an instance of the class out of 4-byte array.
    /// @param[in] bytes The address as 4-byte array in network byte order
    /// @remarks This constructor assumes that the provided array is exactly 4 bytes long.
    /// Prefer using the constructor with size parameter if the array length is not guaranteed to be 4 bytes.
    IPv4Address(const uint8_t bytes[4]) : IPv4Address(bytes, 4)
    {}

    /// A constructor that creates an instance of the class out of a 4-byte array.
    /// @param[in] bytes The address as 4-byte array in network byte order
    /// @param[in] size The size of the array in bytes
    /// @throws std::invalid_argument If the provided bytes pointer is null.
    /// @throws std::out_of_range If the provided size is smaller than 4 bytes.
    IPv4Address(const uint8_t* bytes, size_t size);

    /// A constructor that creates an instance of the class out of a 4-byte standard array.
    /// @param[in] bytes The address as 4-byte standard array in network byte order
    IPv4Address(const std::array<uint8_t, 4>& bytes) : m_Bytes(bytes)
    {}

    /// A constructor that creates an instance of the class out of std::string value.
    /// @param[in] addrAsString The std::string representation of the address
    /// @throws std::invalid_argument The provided string does not represent a valid IPv4 address.
    IPv4Address(const std::string& addrAsString);

    /// @return A 4-byte integer in network byte order representing the IPv4 address
    inline uint32_t toInt() const;

    /// @return A non-owning pointer to 4-byte C-style array representing the IPv4 address
    const uint8_t* toBytes() const
    {
      return m_Bytes.data();
    }

    /// @return A reference to a 4-byte standard array representing the IPv4 address
    const std::array<uint8_t, 4>& toByteArray() const
    {
      return m_Bytes;
    }

    /// @return A string representation of the address
    std::string toString() const;

    /// @return True if an address is multicast, false otherwise.
    bool isMulticast() const;

    /// Overload of the equal-to operator
    /// @param[in] rhs The object to compare with
    /// @return True if the addresses are equal, false otherwise
    bool operator==(const IPv4Address& rhs) const
    {
      return toInt() == rhs.toInt();
    }

    /// Overload of the less-than operator
    /// @param[in] rhs The object to compare with
    /// @return True if the address value is lower than the other address value, false otherwise
    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;
    }

    /// Overload of the not-equal-to operator
    /// @param[in] rhs The object to compare with
    /// @return True if the addresses are not equal, false otherwise
    bool operator!=(const IPv4Address& rhs) const
    {
      return !(*this == rhs);
    }

    /// Checks whether the address matches a network.
    /// @param network An IPv4Network network
    /// @return True if the address matches the network or false otherwise
    bool matchNetwork(const IPv4Network& network) const;

    /// Checks whether the address matches a network.
    /// For example: this method will return true for address 10.1.1.9 and network which is one of:
    /// 10.1.1.1/24, 10.1.1.1/255.255.255.0
    /// Another example: this method will return false for address 11.1.1.9 and network which is one of:
    /// 10.1.1.1/16, 10.1.1.1/255.255.0.0
    /// @param[in] network A string in one of these formats:
    ///  - X.X.X.X/Y where X.X.X.X is a valid IP address and Y is a number between 0 and 32
    ///  - X.X.X.X/Y.Y.Y.Y where X.X.X.X is a valid IP address and Y.Y.Y.Y is a valid netmask
    /// @return True if the address matches the network or false if it doesn't or if the network is invalid
    bool matchNetwork(const std::string& network) const;

    /// A static method that checks whether a string represents a valid IPv4 address
    /// @param[in] addrAsString The std::string representation of the address
    /// @return True if the address is valid, false otherwise
    static bool isValidIPv4Address(const std::string& addrAsString);

    /// A static value representing a zero value of IPv4 address, meaning address of value "0.0.0.0".
    static const IPv4Address Zero;

    /// A static values representing the lower and upper bound of IPv4 multicast ranges. The bounds are inclusive.
    /// MulticastRangeLowerBound is initialized to "224.0.0.0".
    /// MulticastRangeUpperBound is initialized to "239.255.255.255".
    /// In order to check whether the address is a multicast address the isMulticast method can be used.
    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
  /// Represents an IPv6 address (of type xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx).
  class IPv6Address
  {
  public:
    /// A default constructor that creates an instance of the class with the zero-initialized address.
    IPv6Address() = default;

    /// A constructor that creates an instance of the class out of 16-byte array.
    /// @param[in] bytes The address as 16-byte array in network byte order
    /// @remarks This constructor assumes that the provided array is exactly 16 bytes long.
    /// Prefer using the constructor with size parameter if the array length is not guaranteed to be 16 bytes.
    IPv6Address(const uint8_t bytes[16]) : IPv6Address(bytes, 16)
    {}

    /// @brief A constructor that creates an instance of the class out of a 16-byte array.
    /// @param bytes The address as 16-byte array in network byte order
    /// @param size The size of the array in bytes
    /// @throws std::invalid_argument If the provided buffer is null.
    /// @throws std::out_of_range If the provided size is smaller than 16 bytes.
    IPv6Address(const uint8_t* bytes, size_t size);

    /// A constructor that creates an instance of the class out of a 16-byte standard array.
    /// @param[in] bytes The address as 16-byte standard array in network byte order
    IPv6Address(const std::array<uint8_t, 16>& bytes) : m_Bytes(bytes)
    {}

    /// A constructor that creates an instance of the class out of std::string value.
    /// @param[in] addrAsString The std::string representation of the address
    /// @throws std::invalid_argument The provided string does not represent a valid IPv6 address.
    IPv6Address(const std::string& addrAsString);

    /// Returns a view of the IPv6 address as a 16-byte raw C-style array
    /// @return A non-owning pointer to 16-byte array representing the IPv6 address
    const uint8_t* toBytes() const
    {
      return m_Bytes.data();
    }

    /// Returns a view of the IPv6 address as a std::array of bytes
    /// @return A reference to a 16-byte standard array representing the IPv6 address
    const std::array<uint8_t, 16>& toByteArray() const
    {
      return m_Bytes;
    }

    /// Returns a std::string representation of the address
    /// @return A string representation of the address
    std::string toString() const;

    /// Determine whether the address is a multicast address
    /// @return True if an address is multicast
    bool isMulticast() const;

    /// Overload of the equal-to operator
    /// @param[in] rhs The object to compare with
    /// @return True if the addresses are equal, false otherwise
    bool operator==(const IPv6Address& rhs) const
    {
      return memcmp(toBytes(), rhs.toBytes(), sizeof(m_Bytes)) == 0;
    }

    /// Overload of the less-than operator
    /// @param[in] rhs The object to compare with
    /// @return True if the address value is lower than the other address value, false otherwise
    bool operator<(const IPv6Address& rhs) const
    {
      return memcmp(toBytes(), rhs.toBytes(), sizeof(m_Bytes)) < 0;
    }

    /// Overload of the not-equal-to operator
    /// @param[in] rhs The object to compare with
    /// @return True if the addresses are not equal, false otherwise
    bool operator!=(const IPv6Address& rhs) const
    {
      return !(*this == rhs);
    }

    /// Allocates a byte array and copies address value into it. Array deallocation is user responsibility
    /// @param[in] arr A pointer to where array will be allocated
    /// @param[out] length Returns the length in bytes of the array that was allocated
    /// @throws std::invalid_argument If the provided pointer is null.
    /// @deprecated Use copyToNewBuffer instead.
    PCPP_DEPRECATED("Use copyToNewBuffer instead.")
    void copyTo(uint8_t** arr, size_t& length) const;

    /// Gets a pointer to an already allocated byte array and copies the address value to it.
    /// This method assumes array allocated size is at least 16 (the size of an IPv6 address)
    /// @param[in] arr A pointer to the array which address will be copied to
    /// @remarks This method assumes that the provided array is at least 16 bytes long.
    /// Prefer using the copyTo(uint8_t* buffer, size_t size) method if the array length is not guaranteed to be 16
    /// bytes.
    void copyTo(uint8_t* arr) const
    {
      copyTo(arr, 16);
    }

    /// @brief Copies the address value to a user-provided buffer.
    ///
    /// This function supports querying. If the buffer is null and size is zero, it returns the required size.
    ///
    /// @param[in] buffer A pointer to the buffer where the address will be copied
    /// @param[in] size The size of the buffer in bytes
    /// @return The number of bytes copied to the buffer or the number of required bytes, which is always 16 for
    /// IPv6 addresses.
    /// @throws std::invalid_argument If the provided buffer is null and size is not zero.
    size_t copyTo(uint8_t* buffer, size_t size) const;

    /// @brief Allocates a new buffer and copies the address value to it.
    /// The user is responsible for deallocating the buffer.
    ///
    /// @param buffer A pointer to a pointer where the new buffer will be allocated
    /// @param size A reference to a size_t variable that will be updated with the size of the allocated buffer
    /// @return True if the buffer was successfully allocated and the address was copied, false otherwise.
    /// @throws std::invalid_argument If the buffer pointer is null.
    bool copyToNewBuffer(uint8_t** buffer, size_t& size) const;

    /// Checks whether the address matches a network.
    /// @param network An IPv6Network network
    /// @return True if the address matches the network or false otherwise
    bool matchNetwork(const IPv6Network& network) const;

    /// Checks whether the address matches a network.
    /// For example: this method will return true for address d6e5:83dc:0c58:bc5d:1449:5898:: and network
    /// which is one of:
    /// d6e5:83dc:0c58:bc5d::/64, d6e5:83dc:0c58:bc5d::/ffff:ffff:ffff:ffff::
    /// Another example: this method will return false for address d6e5:83dc:: and network which is one of:
    /// d6e5:83dc:0c58:bc5d::/64, d6e5:83dc:0c58:bc5d::/ffff:ffff:ffff:ffff::
    /// @param[in] network A string in one of these formats:
    ///  - IPV6_ADDRESS/Y where IPV6_ADDRESS is a valid IPv6 address and Y is a number between 0 and 128
    ///  - IPV6_ADDRESS/IPV6_NETMASK where IPV6_ADDRESS is a valid IPv6 address and IPV6_NETMASK is a valid
    ///    IPv6 netmask
    /// @return True if the address matches the network or false if it doesn't or if the network is invalid
    bool matchNetwork(const std::string& network) const;

    /// A static method that checks whether a string represents a valid IPv6 address
    /// @param[in] addrAsString The std::string representation of the address
    /// @return True if the address is valid, false otherwise
    static bool isValidIPv6Address(const std::string& addrAsString);

    /// A static value representing a zero value of IPv6 address, meaning address of value
    /// "0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0".
    static const IPv6Address Zero;

    /// A static value representing the lower bound of IPv6 multicast ranges. The bound is inclusive.
    /// MulticastRangeLowerBound is initialized to "ff00:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0".
    /// In order to check whether the address is a multicast address the isMulticast method can be used.
    static const IPv6Address MulticastRangeLowerBound;

  private:
    std::array<uint8_t, 16> m_Bytes = { 0 };
  };  // class IPv6Address

  /// @class IPAddress
  /// The class is a version-independent representation for an IP address
  class IPAddress
  {
  public:
    /// An enum representing the address type: IPv4 or IPv6
    enum AddressType : uint8_t
    {
      /// IPv4 address type
      IPv4AddressType,
      /// IPv6 address type
      IPv6AddressType
    };

    /// A default constructor that creates an instance of the class with unspecified IPv4 address
    IPAddress() : m_Type(IPv4AddressType)
    {}

    /// A constructor that creates an instance of the class out of IPv4Address.
    /// @param[in] addr A const reference to instance of IPv4Address
    IPAddress(const IPv4Address& addr) : m_Type(IPv4AddressType), m_IPv4(addr)
    {}

    /// A constructor that creates an instance of the class out of IPv6Address.
    /// @param[in] addr A const reference to instance of IPv6Address
    IPAddress(const IPv6Address& addr) : m_Type(IPv6AddressType), m_IPv6(addr)
    {}

    /// A constructor that creates an instance of the class out of std::string value
    /// @param[in] addrAsString The std::string representation of the address
    /// @throws std::invalid_argument The provided string does not represent a valid IPv4 or IPv6 address.
    IPAddress(const std::string& addrAsString);

    /// Overload of an assignment operator.
    /// @param[in] addr A const reference to instance of IPv4Address
    /// @return A reference to the assignee
    inline IPAddress& operator=(const IPv4Address& addr);

    /// Overload of an assignment operator.
    /// @param[in] addr A const reference to instance of IPv6Address
    /// @return A reference to the assignee
    inline IPAddress& operator=(const IPv6Address& addr);

    /// Gets the address type: IPv4 or IPv6
    /// @return The address type
    AddressType getType() const
    {
      return static_cast<AddressType>(m_Type);
    }

    /// Returns a std::string representation of the address
    /// @return A string representation of the address
    std::string toString() const
    {
      return (getType() == IPv4AddressType) ? m_IPv4.toString() : m_IPv6.toString();
    }

    /// @return Determine whether the object contains an IP version 4 address
    bool isIPv4() const
    {
      return getType() == IPv4AddressType;
    }

    /// @return Determine whether the object contains an IP version 6 address
    bool isIPv6() const
    {
      return getType() == IPv6AddressType;
    }

    /// Determine whether the address is a multicast address
    /// @return True if an address is multicast
    bool isMulticast() const
    {
      return (getType() == IPv4AddressType) ? m_IPv4.isMulticast() : m_IPv6.isMulticast();
    }

    /// Get a reference to IPv4 address instance
    /// @return The const reference to IPv4Address instance
    const IPv4Address& getIPv4() const
    {
      return m_IPv4;
    }

    /// Get a reference to IPv6 address instance
    /// @return The const reference to IPv6Address instance
    const IPv6Address& getIPv6() const
    {
      return m_IPv6;
    }

    /// @return True if the address is zero, false otherwise
    bool isZero() const
    {
      return (getType() == IPv4AddressType) ? m_IPv4 == IPv4Address::Zero : m_IPv6 == IPv6Address::Zero;
    }

    /// Overload of the equal-to operator
    /// @param[in] rhs The object to compare with
    /// @return True if the addresses are equal, false otherwise
    inline bool operator==(const IPAddress& rhs) const;

    /// Overload of the less-than operator
    /// @param[in] rhs The object to compare with
    /// @return True if the address value is lower than the other address value, false otherwise
    inline bool operator<(const IPAddress& rhs) const;

    /// Overload of the not-equal-to operator
    /// @param[in] rhs The object to compare with
    /// @return True if the addresses are not equal, false otherwise
    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
  /// A class representing IPv4 network definition
  class IPv4Network
  {
  public:
    /// A constructor that creates an instance of the class out of an address and a full prefix length,
    /// essentially making a network of consisting of only 1 address.
    /// @param address An address representing the network prefix.
    explicit IPv4Network(const IPv4Address& address) : IPv4Network(address, 32U)
    {}

    /// A constructor that creates an instance of the class out of an address representing the network prefix
    /// and a prefix length
    /// @param address An address representing the network prefix. If the address is invalid std::invalid_argument
    /// exception is thrown
    /// @param prefixLen A number between 0 and 32 representing the prefix length.
    /// @throws std::invalid_argument Prefix length is out of acceptable range.
    IPv4Network(const IPv4Address& address, uint8_t prefixLen);

    /// A constructor that creates an instance of the class out of an address representing the network prefix
    /// and a netmask
    /// @param address An address representing the network prefix. If the address is invalid std::invalid_argument
    /// exception is thrown
    /// @param netmask A string representing a netmask in the format of X.X.X.X, for example: 255.255.0.0.
    /// Please notice that netmasks that start with zeros are invalid, for example: 0.0.255.255. The only netmask
    /// starting with zeros that is valid is 0.0.0.0.
    /// @throws std::invalid_argument The provided netmask is invalid.
    IPv4Network(const IPv4Address& address, const std::string& netmask);

    /// A constructor that creates an instance of the class out of a string representing the network prefix and
    /// a prefix length or a netmask
    /// @param addressAndNetmask A string in one of these formats:
    ///  - X.X.X.X/Y where X.X.X.X is a valid IPv4 address representing the network prefix and Y is a number between
    ///    0 and 32 representing the network prefix
    ///  - X.X.X.X/Y.Y.Y.Y where X.X.X.X is a valid IPv4 address representing the network prefix and Y.Y.Y.Y is
    ///    a valid netmask
    /// @throws std::invalid_argument The provided string does not represent a valid address and netmask format.
    IPv4Network(const std::string& addressAndNetmask);

    /// @return The prefix length, for example: the prefix length of 10.10.10.10/255.0.0.0 is 8
    uint8_t getPrefixLen() const;

    /// @return The netmask, for example: the netmask of 10.10.10.10/8 is 255.0.0.0
    std::string getNetmask() const
    {
      return IPv4Address(m_Mask).toString();
    }

    /// @return The network prefix, for example: the network prefix of 10.10.10.10/16 is 10.10.0.0
    IPv4Address getNetworkPrefix() const
    {
      return m_NetworkPrefix;
    }

    /// @return The lowest non-reserved IPv4 address in this network, for example: the lowest address
    /// in 10.10.10.10/16 is 10.10.0.1
    IPv4Address getLowestAddress() const;

    /// @return The highest non-reserved IPv4 address in this network, for example: the highest address
    /// in 10.10.10.10/16 is 10.10.255.254
    IPv4Address getHighestAddress() const;

    /// @return The number of addresses in this network including reserved addresses, for example:
    /// the number of addresses in 10.10.0.0/24 is 256
    uint64_t getTotalAddressCount() const;

    /// @param address An IPv4 address
    /// @return True is the address belongs to the network, false otherwise or if the address isn't valid
    bool includes(const IPv4Address& address) const;

    /// @param network An IPv4 network
    /// @return True is the input network is completely included within this network, false otherwise, for example:
    /// 10.10.10.10/16 includes 10.10.10.10/24 but doesn't include 10.10.10.10/8
    bool includes(const IPv4Network& network) const;

    /// @return A string representation of the network in a format of NETWORK_PREFIX/PREFIX_LEN, for example:
    /// 192.168.0.0/16
    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
  /// A class representing IPv6 network definition
  class IPv6Network
  {
  public:
    /// A constructor that creates an instance of the class out of an address and a full prefix length,
    /// essentially making a network of consisting of only 1 address.
    /// @param address An address representing the network prefix.
    explicit IPv6Network(const IPv6Address& address) : IPv6Network(address, 128U)
    {}

    /// A constructor that creates an instance of the class out of an address representing the network prefix
    /// and a prefix length
    /// @param address An address representing the network prefix. If the address is invalid std::invalid_argument
    /// exception is thrown
    /// @param prefixLen A number between 0 and 128 representing the prefix length.
    /// @throws std::invalid_argument Prefix length is out of acceptable range.
    IPv6Network(const IPv6Address& address, uint8_t prefixLen);

    /// A constructor that creates an instance of the class out of an address representing the network prefix
    /// and a netmask
    /// @param address An address representing the network prefix. If the address is invalid std::invalid_argument
    /// exception is thrown
    /// @param netmask A string representing a netmask in valid IPv6 format, for example: ffff:ffff::.
    /// Please notice that netmasks that start with zeros are invalid, for example: 0:ffff::. The only netmask
    /// starting with zeros that is valid is all zeros (::).
    /// @throws std::invalid_argument The provided netmask is invalid.
    IPv6Network(const IPv6Address& address, const std::string& netmask);

    /// A constructor that creates an instance of the class out of a string representing the network prefix and
    /// a prefix length or a netmask
    /// @param addressAndNetmask A string in one of these formats:
    ///  - IPV6_ADDRESS/Y where IPV6_ADDRESS is a valid IPv6 address representing the network prefix and Y is
    ///    a number between 0 and 128 representing the network prefix
    ///  - IPV6_ADDRESS/IPV6_NETMASK where IPV6_ADDRESS is a valid IPv6 address representing the network prefix
    ///    and IPV6_NETMASK is a valid IPv6 netmask
    /// @throws std::invalid_argument The provided string does not represent a valid address and netmask format.
    IPv6Network(const std::string& addressAndNetmask);

    /// @return The prefix length, for example: the prefix length of 3546::/ffff:: is 16
    uint8_t getPrefixLen() const;

    /// @return The netmask, for example: the netmask of 3546::/16 is ffff::
    std::string getNetmask() const
    {
      return IPv6Address(m_Mask).toString();
    }

    /// @return The network prefix, for example: the network prefix of 3546:f321::/16 is 3546::
    IPv6Address getNetworkPrefix() const
    {
      return { m_NetworkPrefix };
    }

    /// @return The lowest non-reserved IPv6 address in this network, for example: the lowest address in 3546::/16
    /// is 3546::1
    IPv6Address getLowestAddress() const;

    /// @return The highest IPv6 address in this network, for example: the highest address in 3546::/16 is
    /// 3546:ffff:ffff:ffff:ffff:ffff:ffff:ffff
    IPv6Address getHighestAddress() const;

    /// @return The number of addresses in this network, for example: the number of addresses in 16ff::/120 is 256.
    /// If the number of addresses exceeds the size of uint64_t a std::out_of_range exception is thrown
    uint64_t getTotalAddressCount() const;

    /// @param address An IPv6 address
    /// @return True is the address belongs to the network, false otherwise or if the address isn't valid
    bool includes(const IPv6Address& address) const;

    /// @param network An IPv6 network
    /// @return True is the input network is completely included within this network, false otherwise, for example:
    /// 3546::/64 includes 3546::/120 but doesn't include 3546::/16
    bool includes(const IPv6Network& network) const;

    /// @return A string representation of the network in a format of NETWORK_PREFIX/PREFIX_LEN, for example:
    /// fda7:9f81:6c23:275::/64
    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
  /// A class representing version independent IP network definition, both IPv4 and IPv6 are included
  class IPNetwork
  {
  public:
    /// A constructor that creates an instance of the class out of an IP address and a full prefix length,
    /// essentially making a network of consisting of only 1 address.
    /// @param address An address representing the network prefix.
    explicit IPNetwork(const IPAddress& address) : IPNetwork(address, address.isIPv4() ? 32U : 128U)
    {}

    /// A constructor that creates an instance of the class out of an address representing the network prefix
    /// and a prefix length
    /// @param address An address representing the network prefix. If the address is invalid std::invalid_argument
    /// exception is thrown
    /// @param prefixLen A number representing the prefix length. Allowed ranges are 0 - 32 for IPv4 networks and 0
    /// - 128 for IPv6 networks.
    /// @throws std::invalid_argument Prefix length is out of acceptable range.
    IPNetwork(const IPAddress& address, uint8_t prefixLen)
    {
      if (address.isIPv4())
      {
        m_NetworkVariant = IPv4Network(address.getIPv4(), prefixLen);
      }
      else
      {
        m_NetworkVariant = IPv6Network(address.getIPv6(), prefixLen);
      }
    }

    /// A constructor that creates an instance of the class out of an address representing the network prefix
    /// and a netmask
    /// @param address An address representing the network prefix. If the address is invalid std::invalid_argument
    /// exception is thrown
    /// @param netmask A string representing a netmask in valid format, for example: ffff:ffff:: for IPv6 networks
    /// or 255.255.0.0 for IPv4 networks.
    /// Please notice that netmasks that start with zeros are invalid, for example: 0:ffff:: or 0.255.255.255.
    /// The only netmask starting with zeros that is valid is all zeros (:: or 0.0.0.0).
    /// @throws std::invalid_argument The provided netmask is invalid.
    IPNetwork(const IPAddress& address, const std::string& netmask)
    {
      if (address.isIPv4())
      {
        m_NetworkVariant = IPv4Network(address.getIPv4(), netmask);
      }
      else
      {
        m_NetworkVariant = IPv6Network(address.getIPv6(), netmask);
      }
    }

    /// A constructor that creates an instance of the class out of a string representing the network prefix and
    /// a prefix length or a netmask
    /// @param addressAndNetmask A string in one of these formats:
    ///  - IP_ADDRESS/Y where IP_ADDRESS is a valid IP address representing the network prefix and Y is
    ///    a number representing the network prefix
    ///  - IP_ADDRESS/NETMASK where IP_ADDRESS is a valid IP address representing the network prefix and NETMASK
    ///    is a valid netmask for this type of network (IPv4 or IPv6 network)
    /// @throws std::invalid_argument The provided string does not represent a valid address and netmask format.
    IPNetwork(const std::string& addressAndNetmask)
    {
      try
      {
        m_NetworkVariant = IPv4Network(addressAndNetmask);
      }
      catch (const std::invalid_argument&)
      {
        m_NetworkVariant = IPv6Network(addressAndNetmask);
      }
    }

    /// A copy c'tor for this class
    /// @param other The instance to copy from
    IPNetwork(const IPNetwork& other) : m_NetworkVariant(other.m_NetworkVariant)
    {}

    /// Overload of an assignment operator.
    /// @param[in] other An instance of IPNetwork to assign
    /// @return A reference to the assignee
    IPNetwork& operator=(const IPNetwork& other)
    {
      m_NetworkVariant = other.m_NetworkVariant;
      return *this;
    }

    /// Overload of an assignment operator.
    /// @param[in] other An instance of IPv4Network to assign
    /// @return A reference to the assignee
    IPNetwork& operator=(const IPv4Network& other)
    {
      m_NetworkVariant = other;
      return *this;
    }

    /// Overload of an assignment operator.
    /// @param[in] other An instance of IPv6Network to assign
    /// @return A reference to the assignee
    IPNetwork& operator=(const IPv6Network& other)
    {
      m_NetworkVariant = other;
      return *this;
    }

    /// @return The prefix length, for example: the prefix length of 3546::/ffff:: is 16, the prefix length of
    /// 10.10.10.10/255.0.0.0 is 8
    uint8_t getPrefixLen() const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        return ip4->getPrefixLen();
      }

      return m_NetworkVariant.getIPv6().getPrefixLen();
    }

    /// @return The netmask, for example: the netmask of 3546::/16 is ffff::, the netmask of 10.10.10.10/8 is
    /// 255.0.0.0
    std::string getNetmask() const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        return ip4->getNetmask();
      }

      return m_NetworkVariant.getIPv6().getNetmask();
    }

    /// @return The network prefix, for example: the network prefix of 3546:f321::/16 is 3546::, the network prefix
    /// of 10.10.10.10/16 is 10.10.0.0
    IPAddress getNetworkPrefix() const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        return IPAddress(ip4->getNetworkPrefix());
      }

      return IPAddress(m_NetworkVariant.getIPv6().getNetworkPrefix());
    }

    /// @return The lowest non-reserved IP address in this network, for example: the lowest address in 3546::/16 is
    /// 3546::1, the lowest address in 10.10.10.10/16 is 10.10.0.1
    IPAddress getLowestAddress() const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        return IPAddress(ip4->getLowestAddress());
      }
      return IPAddress(m_NetworkVariant.getIPv6().getLowestAddress());
    }

    /// @return The highest non-reserved IP address in this network, for example: the highest address in 3546::/16
    /// is 3546:ffff:ffff:ffff:ffff:ffff:ffff:ffff, the highest address in 10.10.10.10/16 is 10.10.255.254
    IPAddress getHighestAddress() const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        return IPAddress(ip4->getHighestAddress());
      }

      return IPAddress(m_NetworkVariant.getIPv6().getHighestAddress());
    }

    /// @return The number of addresses in this network, for example: the number of addresses in 16ff::/120 is 256,
    /// the number of addresses in 10.10.0.0/24 is 256. If the number of addresses exceeds the size of uint64_t
    /// a std::out_of_range exception is thrown
    uint64_t getTotalAddressCount() const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        return ip4->getTotalAddressCount();
      }
      return m_NetworkVariant.getIPv6().getTotalAddressCount();
    }

    /// @return True if this is an IPv4 network, false otherwise
    bool isIPv4Network() const
    {
      return m_NetworkVariant.getType() == NetworkVariant::Type::IPv4;
    }

    /// @return True if this is an IPv6 network, false otherwise
    bool isIPv6Network() const
    {
      return m_NetworkVariant.getType() == NetworkVariant::Type::IPv6;
    }

    /// @param address An IP address
    /// @return True is the address belongs to the network, false otherwise or if the address isn't valid
    bool includes(const IPAddress& address) const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        if (address.isIPv6())
        {
          return false;
        }
        return ip4->includes(address.getIPv4());
      }

      if (address.isIPv4())
      {
        return false;
      }

      return m_NetworkVariant.getIPv6().includes(address.getIPv6());
    }

    /// @param network An IP network
    /// @return True is the input network is completely included within this network, false otherwise
    bool includes(const IPNetwork& network) const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4 != nullptr)
      {
        auto otherIp4 = network.m_NetworkVariant.tryGetIPv4();
        if (otherIp4 == nullptr)
        {
          return false;
        }
        return ip4->includes(*otherIp4);
      }

      auto& ip6 = m_NetworkVariant.getIPv6();
      auto otherIp6 = network.m_NetworkVariant.tryGetIPv6();
      if (otherIp6 == nullptr)
      {
        return false;
      }
      return ip6.includes(*otherIp6);
    }

    /// @return A string representation of the network in a format of NETWORK_PREFIX/PREFIX_LEN, for example:
    /// fda7:9f81:6c23:275::/64 or 192.168.0.0/16
    std::string toString() const
    {
      auto ip4 = m_NetworkVariant.tryGetIPv4();
      if (ip4)
      {
        return ip4->toString();
      }

      return m_NetworkVariant.getIPv6().toString();
    }

  private:
    // TODO: C++17 Replace with std::variant.
    class NetworkVariant
    {
    public:
      enum class Type
      {
        IPv4,
        IPv6
      };

      NetworkVariant() : m_Type(Type::IPv4), m_IPv4Net(IPv4Address::Zero)
      {}
      NetworkVariant(IPv4Network const& net) : m_Type(Type::IPv4), m_IPv4Net(net)
      {}
      NetworkVariant(IPv6Network const& net) : m_Type(Type::IPv6), m_IPv6Net(net)
      {}
      ~NetworkVariant()
      {
        destroyActiveMem();
      }

      NetworkVariant& operator=(IPv4Network const& other)
      {
        swapTo(Type::IPv4);
        m_IPv4Net = other;
        return *this;
      }
      NetworkVariant& operator=(IPv6Network const& other)
      {
        swapTo(Type::IPv6);
        m_IPv6Net = other;
        return *this;
      }
      NetworkVariant& operator=(NetworkVariant const& other)
      {
        swapTo(other.m_Type);
        switch (other.m_Type)
        {
        case Type::IPv4:
          m_IPv4Net = other.m_IPv4Net;
          break;
        case Type::IPv6:
          m_IPv6Net = other.m_IPv6Net;
          break;
        }
        return *this;
      }

      Type getType() const noexcept
      {
        return m_Type;
      }

      IPv4Network& getIPv4()
      {
        throwIfNot(Type::IPv4);
        return m_IPv4Net;
      }

      IPv4Network const& getIPv4() const
      {
        throwIfNot(Type::IPv4);
        return m_IPv4Net;
      }

      IPv4Network* tryGetIPv4() noexcept
      {
        return (m_Type == Type::IPv4) ? &m_IPv4Net : nullptr;
      }
      IPv4Network const* tryGetIPv4() const noexcept
      {
        return (m_Type == Type::IPv4) ? &m_IPv4Net : nullptr;
      }

      IPv6Network& getIPv6()
      {
        throwIfNot(Type::IPv6);
        return m_IPv6Net;
      }

      IPv6Network const& getIPv6() const
      {
        throwIfNot(Type::IPv6);
        return m_IPv6Net;
      }

      IPv6Network* tryGetIPv6() noexcept
      {
        return (m_Type == Type::IPv6) ? &m_IPv6Net : nullptr;
      }
      IPv6Network const* tryGetIPv6() const noexcept
      {
        return (m_Type == Type::IPv6) ? &m_IPv6Net : nullptr;
      }

    private:
      void throwIfNot(Type type) const
      {
        if (type != m_Type)
        {
          throw std::runtime_error("Bad variant access");
        }
      }

      void swapTo(Type newType) noexcept;
      void destroyActiveMem() noexcept;

      Type m_Type;
      union {
        IPv4Network m_IPv4Net;
        IPv6Network m_IPv6Net;
      };
    };

    NetworkVariant m_NetworkVariant;
  };

  namespace literals
  {
    inline IPv4Address operator""_ipv4(const char* addrString, std::size_t size)
    {
      return IPv4Address(std::string(addrString, size));
    }

    inline IPv6Address operator""_ipv6(const char* addrString, std::size_t size)
    {
      return IPv6Address(std::string(addrString, size));
    }
  }  // namespace literals

  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

Coverage Report

Created: 2026-05-16 06:37