IPAddr.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Network Geographics 2014
 
#pragma once
 
#include <cstddef>
 
#include "swoc/swoc_version.h"
#include "swoc/swoc_meta.h"
#include "swoc/MemSpan.h"
#include "swoc/swoc_ip_util.h"
 
namespace swoc { inline namespace SWOC_VERSION_NS {
 
using std::string_view;
 
union IPEndpoint;
class IPAddr;
class IPMask;

class IP4Addr {
  using self_type = IP4Addr; 
  friend class IP4Range;
 
public:
  static constexpr size_t SIZE  = sizeof(in_addr_t);                                 
  static constexpr size_t WIDTH = std::numeric_limits<unsigned char>::digits * SIZE; 
 
  static const self_type MIN;                      
  static const self_type MAX;                      
  static constexpr sa_family_t AF_value = AF_INET; 
 
  constexpr IP4Addr() = default; 

  IP4Addr(self_type const &that) = default;

  explicit constexpr IP4Addr(in_addr_t addr);

  explicit IP4Addr(sockaddr_in const *s);

  IP4Addr(string_view const &text);

  self_type &operator=(self_type const &that) = default;

  self_type &operator=(in_addr_t ip);

  self_type &operator=(sockaddr_in const *sa);

  self_type &operator++();

  self_type &operator--();

  uint8_t operator[](unsigned idx) const;

  self_type &operator&=(IPMask const &mask);

  self_type &operator|=(IPMask const &mask);

  sockaddr *copy_to(sockaddr *sa) const;

  sockaddr_in *copy_to(sockaddr_in *sin) const;

  in_addr_t network_order() const;

  in_addr_t host_order() const;

  bool load(string_view const &text);

  int cmp(self_type const &that) const;

  constexpr sa_family_t family() const;

  bool is_any() const;

  bool is_multicast() const;

  bool is_loopback() const;

  bool is_link_local() const;

  bool is_private() const;

  self_type &operator<<=(unsigned n);

  self_type &operator>>=(unsigned n);

  self_type &operator&=(self_type const &that);

  self_type &operator|=(self_type const &that);

  constexpr static in_addr_t reorder(in_addr_t src);
 
protected:
  using bytes = std::array<uint8_t, 4>;
 
  friend bool operator==(self_type const &, self_type const &);
  friend bool operator!=(self_type const &, self_type const &);
  friend bool operator<(self_type const &, self_type const &);
  friend bool operator<=(self_type const &, self_type const &);
 
  in_addr_t _addr = INADDR_ANY; 
};

class IP6Addr {
  using self_type = IP6Addr; 
 
  friend class IP6Range;
  friend class IPMask;
 
public:
  static constexpr size_t WIDTH         = 128;                                          
  static constexpr size_t SIZE          = WIDTH / std::numeric_limits<uint8_t>::digits; 
  static constexpr sa_family_t AF_value = AF_INET6;                                     
 
  using quad_type                 = uint16_t;                 
  static constexpr size_t N_QUADS = SIZE / sizeof(quad_type); 
  static constexpr size_t QUAD_WIDTH = std::numeric_limits<uint8_t>::digits * sizeof(quad_type);

  using raw_type = std::array<uint8_t, SIZE>;

  static const self_type MIN;
  static const self_type MAX;
 
  IP6Addr()                      = default; 
  IP6Addr(self_type const &that) = default;

  explicit IP6Addr(in6_addr const &addr);

  explicit IP6Addr(sockaddr_in6 const *addr) { *this = addr; }

  IP6Addr(string_view const &text);

  explicit IP6Addr(IP4Addr addr);

  self_type &operator=(self_type const &that) = default;

  self_type &operator<<=(unsigned n);

  self_type &operator>>=(unsigned n);

  self_type &operator&=(self_type const &that);

  self_type &operator|=(self_type const &that);

  self_type &operator++();

  self_type &operator--();

  self_type &operator=(in6_addr const &addr);

  self_type &operator=(sockaddr_in6 const *addr);

  constexpr uint8_t operator[](int idx) const;

  sockaddr_in6 *copy_to(sockaddr_in6 *sin6) const;

  sockaddr *copy_to(sockaddr *sa) const;

  in6_addr host_order() const;

  in6_addr &host_order(in6_addr &dst) const;

  in6_addr network_order() const;

  in6_addr &network_order(in6_addr &dst) const;

  bool load(string_view const &str);

  int cmp(self_type const &that) const;

  constexpr sa_family_t family() const;

  bool is_any() const;

  bool is_loopback() const;

  bool is_multicast() const;

  bool is_link_local() const;

  bool is_private() const;

  bool is_mapped_ip4() const;

  self_type &clear();

  self_type &operator&=(IPMask const &that);

  self_type &operator|=(IPMask const &that);

  static void reorder(in6_addr &dst, raw_type const &src);

  static void reorder(raw_type &dst, in6_addr const &src);
 
  template <typename T>
  auto
  as_span() -> std::enable_if_t<swoc::meta::is_any_of_v<T, std::byte, uint8_t, uint16_t, uint32_t, uint64_t>, swoc::MemSpan<T>> {
    return swoc::MemSpan(_addr._store).template rebind<T>();
  }
 
  template <typename T>
  auto
  as_span() const
    -> std::enable_if_t<swoc::meta::is_any_of_v<typename std::remove_const_t<T>, std::byte, uint8_t, uint16_t, uint32_t, uint64_t>,
                        swoc::MemSpan<T const>> {
    return swoc::MemSpan<uint64_t const>(_addr._store).template rebind<T const>();
  }
 
protected:
  friend bool operator==(self_type const &, self_type const &);
 
  friend bool operator!=(self_type const &, self_type const &);
 
  friend bool operator<(self_type const &, self_type const &);
 
  friend bool operator<=(self_type const &, self_type const &);

  using quad_store_type = std::array<quad_type, N_QUADS>;

  static constexpr quad_type QUAD_MASK = ~quad_type{0};

  using word_type = uint64_t;
 
  static constexpr size_t WORD_SIZE = sizeof(word_type);

  static constexpr size_t WORD_WIDTH = std::numeric_limits<uint8_t>::digits * WORD_SIZE;

  static constexpr word_type WORD_MASK = ~word_type(0);

  static constexpr size_t N_STORE = SIZE / WORD_SIZE;

  using word_store_type = std::array<word_type, N_STORE>;

  union Addr {
    word_store_type _store = {0}; 
    quad_store_type _quad;        
    raw_type _raw;                
    in6_addr _in6;                
  } _addr;
  static_assert(sizeof(in6_addr) == sizeof(raw_type));
 
  static constexpr unsigned LSW = 1; 
  static constexpr unsigned MSW = 0; 

  static constexpr std::array<unsigned, N_QUADS> QUAD_IDX = {3, 2, 1, 0, 7, 6, 5, 4};

  static constexpr std::array<unsigned, SIZE> RAW_IDX = {7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8};

  static void reorder(unsigned char dst[WORD_SIZE], unsigned char const src[WORD_SIZE]);

  IP6Addr(word_store_type::value_type msw, word_store_type::value_type lsw)
    : _addr{
        {msw, lsw}
  } {}
 
  friend IP6Addr operator&(IP6Addr const &addr, IPMask const &mask);
 
  friend IP6Addr operator|(IP6Addr const &addr, IPMask const &mask);
};

class IPAddr {
  friend class IPRange;
 
  using self_type = IPAddr; 
public:
  IPAddr()                                    = default; 
  IPAddr(self_type const &that)               = default; 
  self_type &operator=(self_type const &that) = default; 

  explicit IPAddr(in_addr_t addr);

  IPAddr(IP4Addr const &addr) : _addr{addr}, _family(IP4Addr::AF_value) {}

  explicit IPAddr(in6_addr const &addr);

  IPAddr(IP6Addr const &addr) : _addr{addr}, _family(IP6Addr::AF_value) {}

  explicit IPAddr(sockaddr const *addr);

  explicit IPAddr(IPEndpoint const &addr);

  explicit IPAddr(string_view const &text);

  self_type &assign(sockaddr const *addr);

  self_type &assign(sockaddr_in const *addr);

  self_type &assign(sockaddr_in6 const *addr);

  self_type &assign(in_addr_t addr);

  self_type &assign(in6_addr const &addr);

  self_type &operator=(IPEndpoint const &ip);

  self_type &operator=(in_addr_t ip);

  self_type &operator=(in6_addr const &addr);
 
  bool operator==(self_type const &that) const;
 
  bool operator!=(self_type const &that) const;
 
  bool operator<(self_type const &that) const;
 
  bool operator>(self_type const &that) const;
 
  bool operator<=(self_type const &that) const;
 
  bool operator>=(self_type const &that) const;

  self_type &operator=(sockaddr const *addr);
 
  self_type &operator&=(IPMask const &mask);
 
  self_type &operator|=(IPMask const &mask);

  sockaddr *copy_to(sockaddr *sa) const;

  bool load(string_view const &text);

  int cmp(self_type const &that) const;

  bool is_same_family(self_type const &that);

  sa_family_t family() const;

  bool is_ip4() const;

  bool is_ip6() const;

  IP4Addr const &ip4() const;

  explicit operator IP4Addr() const;

  IP6Addr const &ip6() const;

  explicit operator IP6Addr() const;

  bool is_valid() const;

  self_type &invalidate();

  bool is_loopback() const;

  bool is_multicast() const;

  bool is_link_local() const;

  bool is_private() const;

  static self_type const INVALID;
 
protected:
  friend IP4Addr;
  friend IP6Addr;

  union raw_addr_type {
    IP4Addr _ip4; 
    IP6Addr _ip6; 
 
    constexpr raw_addr_type();
 
    raw_addr_type(in_addr_t addr) : _ip4(addr) {}
 
    raw_addr_type(in6_addr const &addr) : _ip6(addr) {}
 
    raw_addr_type(IP4Addr const &addr) : _ip4(addr) {}
 
    raw_addr_type(IP6Addr const &addr) : _ip6(addr) {}
  } _addr;
 
  sa_family_t _family{AF_UNSPEC}; 
};

class IPMask {
  using self_type = IPMask; 
 
  friend class IP4Addr;
  friend class IP6Addr;
 
public:
  using raw_type = uint8_t; 
 
  IPMask() = default; 

  explicit IPMask(raw_type width);

  bool is_valid() const;

  bool load(string_view const &text);

  static self_type mask_for(IPAddr const &addr);

  static self_type mask_for(IP4Addr const &addr);

  static self_type mask_for(IP6Addr const &addr);

  self_type &clear();

  raw_type width() const;

  self_type &operator<<=(raw_type n);

  self_type &operator>>=(raw_type n);

  IP4Addr as_ip4() const;

  IP6Addr as_ip6() const;
 
protected:
  static constexpr auto INVALID = std::numeric_limits<raw_type>::max();
 
  raw_type _cidr = INVALID; 

  static raw_type mask_for_quad(IP6Addr::quad_type q);
};
 
// --- Implementation
 
inline constexpr IP4Addr::IP4Addr(in_addr_t addr) : _addr(addr) {}
 
inline IP4Addr::IP4Addr(string_view const &text) {
  if (!this->load(text)) {
    _addr = INADDR_ANY;
  }
}
 
inline constexpr sa_family_t
IP4Addr::family() const {
  return AF_value;
}
 
inline auto
IP4Addr::operator<<=(unsigned n) -> self_type & {
  _addr <<= n;
  return *this;
}
 
inline auto
IP4Addr::operator>>=(unsigned n) -> self_type & {
  _addr >>= n;
  return *this;
}
 
inline auto
IP4Addr::operator&=(self_type const &that) -> self_type & {
  _addr &= that._addr;
  return *this;
}
 
inline auto
IP4Addr::operator|=(self_type const &that) -> self_type & {
  _addr |= that._addr;
  return *this;
}
 
inline auto
IP4Addr::operator++() -> self_type & {
  ++_addr;
  return *this;
}
 
inline auto
IP4Addr::operator--() -> self_type & {
  --_addr;
  return *this;
}
 
inline in_addr_t
IP4Addr::network_order() const {
  return htonl(_addr);
}
 
inline in_addr_t
IP4Addr::host_order() const {
  return _addr;
}
 
inline auto
IP4Addr::operator=(in_addr_t ip) -> self_type & {
  _addr = ntohl(ip);
  return *this;
}
 
inline sockaddr *
IP4Addr::copy_to(sockaddr *sa) const {
  this->copy_to(reinterpret_cast<sockaddr_in *>(sa));
  return sa;
}

 
inline bool
operator==(IP4Addr const &lhs, IP4Addr const &rhs) {
  return lhs._addr == rhs._addr;
}

inline bool
operator!=(IP4Addr const &lhs, IP4Addr const &rhs) {
  return lhs._addr != rhs._addr;
}

inline bool
operator<(IP4Addr const &lhs, IP4Addr const &rhs) {
  return lhs._addr < rhs._addr;
}

inline bool
operator<=(IP4Addr const &lhs, IP4Addr const &rhs) {
  return lhs._addr <= rhs._addr;
}

inline bool
operator>(IP4Addr const &lhs, IP4Addr const &rhs) {
  return rhs < lhs;
}

inline bool
operator>=(IP4Addr const &lhs, IP4Addr const &rhs) {
  return rhs <= lhs;
}
 
inline IP4Addr &
IP4Addr::operator&=(IPMask const &mask) {
  _addr &= mask.as_ip4()._addr;
  return *this;
}
 
inline IP4Addr &
IP4Addr::operator|=(IPMask const &mask) {
  _addr |= ~(mask.as_ip4()._addr);
  return *this;
}
 
inline bool
IP4Addr::is_any() const {
  return _addr == INADDR_ANY;
}
 
inline bool
IP4Addr::is_loopback() const {
  return (*this)[0] == IN_LOOPBACKNET;
}
 
inline bool
IP4Addr::is_multicast() const {
  return IN_MULTICAST(_addr);
}
 
inline bool
IP4Addr::is_link_local() const {
  return ip::is_link_local_host_order(_addr);
}
 
inline bool
IP4Addr::is_private() const {
  return ip::is_private_host_order(_addr);
}
 
inline uint8_t
IP4Addr::operator[](unsigned int idx) const {
  return reinterpret_cast<bytes const &>(_addr)[3 - idx];
}
 
inline int
IP4Addr::cmp(IP4Addr::self_type const &that) const {
  return _addr < that._addr ? -1 : _addr > that._addr ? 1 : 0;
}
 
constexpr in_addr_t
IP4Addr::reorder(in_addr_t src) {
  return ((src & 0xFF) << 24) | (((src >> 8) & 0xFF) << 16) | (((src >> 16) & 0xFF) << 8) | ((src >> 24) & 0xFF);
}
 
// +++ IP6Addr +++
 
inline constexpr sa_family_t
IP6Addr::family() const {
  return AF_value;
}
 
inline IP6Addr::IP6Addr(in6_addr const &addr) {
  *this = addr;
}
 
inline IP6Addr::IP6Addr(string_view const &text) {
  if (!this->load(text)) {
    this->clear();
  }
}
 
inline IP6Addr::IP6Addr(IP4Addr addr) {
  _addr._store[MSW]        = 0;
  _addr._quad[QUAD_IDX[4]] = 0;
  _addr._quad[QUAD_IDX[5]] = 0xffff;
  _addr._quad[QUAD_IDX[6]] = addr.host_order() >> QUAD_WIDTH;
  _addr._quad[QUAD_IDX[7]] = addr.host_order();
}
 
inline bool
IP6Addr::is_loopback() const {
  return _addr._store[MSW] == 0 && _addr._store[LSW] == 1;
}
 
inline bool
IP6Addr::is_multicast() const {
  return _addr._raw[RAW_IDX[0]] == 0xFF;
}
 
inline bool
IP6Addr::is_any() const {
  return _addr._store[MSW] == 0 && _addr._store[LSW] == 0;
}
 
inline bool
IP6Addr::is_mapped_ip4() const {
  return 0 == _addr._store[MSW] && (_addr._quad[QUAD_IDX[4]] == 0 && _addr._quad[QUAD_IDX[5]] == 0xFFFF);
}
 
inline bool
IP6Addr::is_link_local() const {
  return _addr._raw[RAW_IDX[0]] == 0xFE && (_addr._raw[RAW_IDX[1]] & 0xC0) == 0x80; // fe80::/10
}
 
inline bool
IP6Addr::is_private() const {
  return (_addr._raw[RAW_IDX[0]] & 0xFE) == 0xFC; // fc00::/7
}
 
inline in6_addr
IP6Addr::host_order() const {
  Addr zret{
    {_addr._store[LSW], _addr._store[MSW]}
  };
  return zret._in6;
}
 
inline in6_addr &
IP6Addr::host_order(in6_addr &dst) const {
  Addr *addr      = reinterpret_cast<Addr *>(&dst);
  addr->_store[0] = _addr._store[LSW];
  addr->_store[1] = _addr._store[MSW];
  return dst;
}
 
inline in6_addr
IP6Addr::network_order() const {
  in6_addr zret;
  return this->network_order(zret);
}
 
inline in6_addr &
IP6Addr::network_order(in6_addr &dst) const {
  self_type::reorder(dst, _addr._raw);
  return dst;
}
 
inline auto
IP6Addr::clear() -> self_type & {
  _addr._store[MSW] = _addr._store[LSW] = 0;
  return *this;
}
 
inline auto
IP6Addr::operator=(in6_addr const &addr) -> self_type & {
  self_type::reorder(_addr._raw, addr);
  return *this;
}
 
inline auto
IP6Addr::operator=(sockaddr_in6 const *addr) -> self_type & {
  if (addr) {
    *this = addr->sin6_addr;
  } else {
    this->clear();
  }
  return *this;
}
 
inline auto
IP6Addr::operator++() -> self_type & {
  if (++(_addr._store[LSW]) == 0) {
    ++(_addr._store[MSW]);
  }
  return *this;
}
 
inline auto
IP6Addr::operator--() -> self_type & {
  if (--(_addr._store[LSW]) == ~static_cast<uint64_t>(0)) {
    --(_addr._store[MSW]);
  }
  return *this;
}
 
inline void
IP6Addr::reorder(unsigned char dst[WORD_SIZE], unsigned char const src[WORD_SIZE]) {
  for (size_t idx = 0; idx < WORD_SIZE; ++idx) {
    dst[idx] = src[WORD_SIZE - (idx + 1)];
  }
}

inline bool
operator==(IP6Addr const &lhs, IP6Addr const &rhs) {
  return lhs._addr._store[IP6Addr::MSW] == rhs._addr._store[IP6Addr::MSW] &&
         lhs._addr._store[IP6Addr::LSW] == rhs._addr._store[IP6Addr::LSW];
}

inline bool
operator!=(IP6Addr const &lhs, IP6Addr const &rhs) {
  return lhs._addr._store[IP6Addr::MSW] != rhs._addr._store[IP6Addr::MSW] ||
         lhs._addr._store[IP6Addr::LSW] != rhs._addr._store[IP6Addr::LSW];
}

inline bool
operator<(IP6Addr const &lhs, IP6Addr const &rhs) {
  return lhs._addr._store[IP6Addr::MSW] < rhs._addr._store[IP6Addr::MSW] ||
         (lhs._addr._store[IP6Addr::MSW] == rhs._addr._store[IP6Addr::MSW] &&
          lhs._addr._store[IP6Addr::LSW] < rhs._addr._store[IP6Addr::LSW]);
}

inline bool
operator>(IP6Addr const &lhs, IP6Addr const &rhs) {
  return rhs < lhs;
}

inline bool
operator<=(IP6Addr const &lhs, IP6Addr const &rhs) {
  return lhs._addr._store[IP6Addr::MSW] < rhs._addr._store[IP6Addr::MSW] ||
         (lhs._addr._store[IP6Addr::MSW] == rhs._addr._store[IP6Addr::MSW] &&
          lhs._addr._store[IP6Addr::LSW] <= rhs._addr._store[IP6Addr::LSW]);
}

inline bool
operator>=(IP6Addr const &lhs, IP6Addr const &rhs) {
  return rhs <= lhs;
}
 
inline sockaddr *
IP6Addr::copy_to(sockaddr *sa) const {
  this->copy_to(reinterpret_cast<sockaddr_in6 *>(sa));
  return sa;
}
 
inline auto
IP6Addr::operator&=(IPMask const &mask) -> self_type & {
  if (mask._cidr <= WORD_WIDTH) {
    _addr._store[LSW] = 0;
    if (0 == mask._cidr) {
      _addr._store[MSW] = 0;
    } else if (mask._cidr < WORD_WIDTH) {
      _addr._store[MSW] &= (WORD_MASK << (WORD_WIDTH - mask._cidr));
    }
  } else if (mask._cidr < WIDTH) {
    _addr._store[LSW] &= (WORD_MASK << (2 * WORD_WIDTH - mask._cidr));
  }
  return *this;
}
 
inline auto
IP6Addr::operator|=(IPMask const &mask) -> self_type & {
  if (mask._cidr > WORD_WIDTH) {
    if (mask._cidr < WIDTH) {
      _addr._store[LSW] |= (WORD_MASK >> (mask._cidr - WORD_WIDTH));
    }
  } else {
    _addr._store[LSW] = WORD_MASK;
    if (0 == mask._cidr) {
      _addr._store[MSW] = WORD_MASK;
    } else if (mask._cidr < WORD_WIDTH) {
      _addr._store[MSW] |= (WORD_MASK >> mask._cidr);
    }
  }
  return *this;
}
 
// +++ IPMask +++
 
inline IPMask::IPMask(raw_type width) : _cidr(width) {}
 
inline bool
IPMask::is_valid() const {
  return _cidr < INVALID;
}
 
inline auto
IPMask::width() const -> raw_type {
  return _cidr;
}
 
inline bool
operator==(IPMask const &lhs, IPMask const &rhs) {
  return lhs.width() == rhs.width();
}
 
inline bool
operator!=(IPMask const &lhs, IPMask const &rhs) {
  return lhs.width() != rhs.width();
}
 
inline bool
operator<(IPMask const &lhs, IPMask const &rhs) {
  return lhs.width() < rhs.width();
}
 
inline IP4Addr
IPMask::as_ip4() const {
  static constexpr auto MASK = ~in_addr_t{0};
  in_addr_t addr             = MASK;
  if (0 == _cidr) {
    addr = in_addr_t(0);
  } else if (_cidr < IP4Addr::WIDTH) {
    addr <<= IP4Addr::WIDTH - _cidr;
  }
  return IP4Addr{addr};
}
 
inline auto
IPMask::clear() -> self_type & {
  _cidr = INVALID;
  return *this;
}
 
inline auto
IPMask::operator<<=(raw_type n) -> self_type & {
  _cidr -= n;
  return *this;
}
 
inline auto
IPMask::operator>>=(IPMask::raw_type n) -> self_type & {
  _cidr += n;
  return *this;
}
 
// +++ mixed mask operators +++
 
inline IP4Addr
operator&(IP4Addr const &addr, IPMask const &mask) {
  return IP4Addr{addr} &= mask;
}
 
inline IP4Addr
operator|(IP4Addr const &addr, IPMask const &mask) {
  return IP4Addr{addr} |= mask;
}
 
inline IP6Addr
operator&(IP6Addr const &addr, IPMask const &mask) {
  return IP6Addr{addr} &= mask;
}
 
inline IP6Addr
operator|(IP6Addr const &addr, IPMask const &mask) {
  return IP6Addr{addr} |= mask;
}
 
constexpr uint8_t
IP6Addr::operator[](int idx) const {
  return _addr._raw[RAW_IDX[idx]];
}
 
inline IPAddr
operator&(IPAddr const &addr, IPMask const &mask) {
  return IPAddr{addr} &= mask;
}
 
inline IPAddr
operator|(IPAddr const &addr, IPMask const &mask) {
  return IPAddr{addr} |= mask;
}
 
// @c constexpr constructor is required to initialize _something_, it can't be completely uninitializing.
inline constexpr IPAddr::raw_addr_type::raw_addr_type() : _ip4(INADDR_ANY) {}
 
inline IPAddr::IPAddr(in_addr_t addr) : _addr(addr), _family(IP4Addr::AF_value) {}
 
inline IPAddr::IPAddr(in6_addr const &addr) : _addr(addr), _family(IP6Addr::AF_value) {}
 
inline IPAddr::IPAddr(sockaddr const *addr) {
  this->assign(addr);
}
 
inline IPAddr::IPAddr(string_view const &text) {
  this->load(text);
}
 
inline IPAddr &
IPAddr::operator=(in_addr_t addr) {
  _family    = AF_INET;
  _addr._ip4 = addr;
  return *this;
}
 
inline IPAddr &
IPAddr::operator=(in6_addr const &addr) {
  _family    = AF_INET6;
  _addr._ip6 = addr;
  return *this;
}
 
inline IPAddr &
IPAddr::operator=(sockaddr const *addr) {
  return this->assign(addr);
}
 
inline sa_family_t
IPAddr::family() const {
  return _family;
}
 
inline bool
IPAddr::is_ip4() const {
  return AF_INET == _family;
}
 
inline bool
IPAddr::is_ip6() const {
  return AF_INET6 == _family;
}
 
inline bool
IPAddr::is_same_family(self_type const &that) {
  return this->is_valid() && _family == that._family;
}
 
inline bool
IPAddr::is_loopback() const {
  return (AF_INET == _family && _addr._ip4.is_loopback()) || (AF_INET6 == _family && _addr._ip6.is_loopback());
}
 
inline bool
IPAddr::is_link_local() const {
  return this->is_ip4() ? this->ip4().is_link_local() : this->is_ip6() ? this->ip6().is_link_local() : false;
}
 
inline bool
IPAddr::is_private() const {
  return this->is_ip4() ? this->ip4().is_private() : this->is_ip6() ? this->ip6().is_private() : false;
}
 
inline IPAddr &
IPAddr::assign(in_addr_t addr) {
  _family    = AF_INET;
  _addr._ip4 = addr;
  return *this;
}
 
inline IPAddr &
IPAddr::assign(in6_addr const &addr) {
  _family    = AF_INET6;
  _addr._ip6 = addr;
  return *this;
}
 
inline IPAddr &
IPAddr::assign(sockaddr_in const *addr) {
  if (addr) {
    _family    = AF_INET;
    _addr._ip4 = addr;
  } else {
    _family = AF_UNSPEC;
  }
  return *this;
}
 
inline IPAddr &
IPAddr::assign(sockaddr_in6 const *addr) {
  if (addr) {
    _family    = AF_INET6;
    _addr._ip6 = addr->sin6_addr;
  } else {
    _family = AF_UNSPEC;
  }
  return *this;
}
 
inline bool
IPAddr::is_valid() const {
  return _family == AF_INET || _family == AF_INET6;
}
 
inline IPAddr &
IPAddr::invalidate() {
  _family = AF_UNSPEC;
  return *this;
}
 
// Associated operators.

bool operator==(IPAddr const &lhs, sockaddr const *rhs);

inline bool
operator==(sockaddr const *lhs, IPAddr const &rhs) {
  return rhs == lhs;
}

inline bool
operator!=(IPAddr const &lhs, sockaddr const *rhs) {
  return !(lhs == rhs);
}

inline bool
operator!=(sockaddr const *lhs, IPAddr const &rhs) {
  return !(rhs == lhs);
}
 
inline IP4Addr const &
IPAddr::ip4() const {
  return _addr._ip4;
}
inline IPAddr::operator IP4Addr() const {
  return _addr._ip4;
}
 
inline IP6Addr const &
IPAddr::ip6() const {
  return _addr._ip6;
}
inline IPAddr::operator IP6Addr() const {
  return _addr._ip6;
}
 
inline bool
IPAddr::operator==(self_type const &that) const {
  return _family == that.family() &&
         (
           ( this->is_ip4() && _addr._ip4 == that._addr._ip4 ) ||
           ( this->is_ip6() && _addr._ip6 == that._addr._ip6 ) ||
           _family == AF_UNSPEC
         );
}
 
inline bool
IPAddr::operator!=(self_type const &that) const {
  return !(*this == that);
}
 
inline bool
IPAddr::operator>(self_type const &that) const {
  return that < *this;
}
 
inline bool
IPAddr::operator<=(self_type const &that) const {
  return !(that < *this);
}
 
inline bool
IPAddr::operator>=(self_type const &that) const {
  return !(*this < that);
}
 
// Disambiguating between comparisons and implicit conversions.
 
inline bool
operator==(IPAddr const &lhs, IP4Addr const &rhs) {
  return lhs.is_ip4() && lhs.ip4() == rhs;
}
 
inline bool
operator!=(IPAddr const &lhs, IP4Addr const &rhs) {
  return !lhs.is_ip4() || lhs.ip4() != rhs;
}
 
inline bool
operator==(IP4Addr const &lhs, IPAddr const &rhs) {
  return rhs.is_ip4() && lhs == rhs.ip4();
}
 
inline bool
operator!=(IP4Addr const &lhs, IPAddr const &rhs) {
  return !rhs.is_ip4() || lhs != rhs.ip4();
}
 
inline bool
operator==(IPAddr const &lhs, IP6Addr const &rhs) {
  return lhs.is_ip6() && lhs.ip6() == rhs;
}
 
inline bool
operator!=(IPAddr const &lhs, IP6Addr const &rhs) {
  return !lhs.is_ip6() || lhs.ip6() != rhs;
}
 
inline bool
operator==(IP6Addr const &lhs, IPAddr const &rhs) {
  return rhs.is_ip6() && lhs == rhs.ip6();
}
 
inline bool
operator!=(IP6Addr const &lhs, IPAddr const &rhs) {
  return !rhs.is_ip6() || lhs != rhs.ip6();
}
}} // namespace swoc::SWOC_VERSION_NS
 
namespace std {

template <> struct hash<swoc::IP4Addr> {
  size_t
  operator()(swoc::IP4Addr const &addr) const {
    return addr.network_order();
  }
};

template <> struct hash<swoc::IP6Addr> {
  size_t
  operator()(swoc::IP6Addr const &addr) const {
    // XOR the 64 chunks
    auto words = addr.as_span<uint64_t>();
    return words[0] ^ words[1];
  }
};

template <> struct hash<swoc::IPAddr> {
  size_t
  operator()(swoc::IPAddr const &addr) const {
    return addr.is_ip4() ? hash<swoc::IP4Addr>()(addr.ip4()) : addr.is_ip6() ? hash<swoc::IP6Addr>()(addr.ip6()) : 0;
  }
};
 
} // namespace std