inet.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2022 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************
 * This file is a part of EtcPal. For more information, go to:
 * https://github.com/ETCLabs/EtcPal
 ******************************************************************************/
 
 
#ifndef ETCPAL_CPP_INET_H_
#define ETCPAL_CPP_INET_H_
 
#include <algorithm>
#include <array>
#include <cstring>
#include <iterator>
#include <string>
#include "etcpal/inet.h"
#include "etcpal/cpp/common.h"
#include "etcpal/cpp/hash.h"
#include "etcpal/cpp/opaque_id.h"
 
namespace etcpal
{
 
enum class IpAddrType
{
  kInvalid = kEtcPalIpTypeInvalid,
  kV4      = kEtcPalIpTypeV4,
  kV6      = kEtcPalIpTypeV6
};
 
class IpAddr
{
public:
  ETCPAL_CONSTEXPR_14 IpAddr() noexcept;
  // Note: this constructor is not explicit by design, to allow implicit conversions e.g.
  //   etcpal::IpAddr ip = etcpal_c_function_that_returns_ip();
  constexpr IpAddr(const EtcPalIpAddr& c_ip) noexcept;
  IpAddr& operator=(const EtcPalIpAddr& c_ip) noexcept;
 
  ETCPAL_CONSTEXPR_14 IpAddr(uint32_t v4_data) noexcept;
  explicit IpAddr(const uint8_t* v6_data) noexcept;
  IpAddr(const uint8_t* v6_data, unsigned long scope_id) noexcept;
 
  constexpr const EtcPalIpAddr&          get() const noexcept;
  ETCPAL_CONSTEXPR_14 EtcPalIpAddr&      get() noexcept;
  std::string                            ToString() const;
  constexpr uint32_t                     v4_data() const noexcept;
  constexpr const uint8_t*               v6_data() const noexcept;
  std::array<uint8_t, ETCPAL_IPV6_BYTES> ToV6Array() const;
  constexpr unsigned long                scope_id() const noexcept;
 
  constexpr bool            IsValid() const noexcept;
  constexpr IpAddrType      type() const noexcept;
  constexpr etcpal_iptype_t raw_type() const noexcept;
  constexpr bool            IsV4() const noexcept;
  constexpr bool            IsV6() const noexcept;
  bool                      IsLinkLocal() const noexcept;
  bool                      IsLoopback() const noexcept;
  bool                      IsMulticast() const noexcept;
  bool                      IsWildcard() const noexcept;
  unsigned int              MaskLength() const noexcept;
 
  void SetAddress(uint32_t v4_data) noexcept;
  void SetAddress(const uint8_t* v6_data) noexcept;
  void SetAddress(const uint8_t* v6_data, unsigned long scope_id) noexcept;
 
  static IpAddr FromString(const char* ip_str) noexcept;
  static IpAddr FromString(const std::string& ip_str) noexcept;
  static IpAddr WildcardV4() noexcept;
  static IpAddr WildcardV6() noexcept;
  static IpAddr Wildcard(IpAddrType type) noexcept;
  static IpAddr NetmaskV4(unsigned int mask_length) noexcept;
  static IpAddr NetmaskV6(unsigned int mask_length) noexcept;
  static IpAddr Netmask(IpAddrType type, unsigned int mask_length) noexcept;
 
private:
  EtcPalIpAddr addr_{ETCPAL_IP_INVALID_INIT_VALUES};
};
 
ETCPAL_CONSTEXPR_14_OR_INLINE IpAddr::IpAddr() noexcept
{
  ETCPAL_IP_SET_INVALID(&addr_);
}
 
constexpr IpAddr::IpAddr(const EtcPalIpAddr& c_ip) noexcept : addr_(c_ip)
{
}
 
inline IpAddr& IpAddr::operator=(const EtcPalIpAddr& c_ip) noexcept
{
  addr_ = c_ip;
  return *this;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE IpAddr::IpAddr(uint32_t v4_data) noexcept
{
  ETCPAL_IP_SET_V4_ADDRESS(&addr_, v4_data);
}
 
inline IpAddr::IpAddr(const uint8_t* v6_data) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS(&addr_, v6_data);
}
 
inline IpAddr::IpAddr(const uint8_t* v6_data, unsigned long scope_id) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS_WITH_SCOPE_ID(&addr_, v6_data, scope_id);
}
 
constexpr const EtcPalIpAddr& IpAddr::get() const noexcept
{
  return addr_;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE EtcPalIpAddr& IpAddr::get() noexcept
{
  return addr_;
}
 
inline std::string IpAddr::ToString() const
{
  std::array<char, ETCPAL_IP_STRING_BYTES> str_buf;  // NOLINT(cppcoreguidelines-pro-type-member-init)
 
  auto result = etcpal_ip_to_string(&addr_, str_buf.data());
  if (result == kEtcPalErrOk)
    return {str_buf.data()};
  return {};
}
 
constexpr uint32_t IpAddr::v4_data() const noexcept
{
  return ETCPAL_IP_V4_ADDRESS(&addr_);
}
 
constexpr const uint8_t* IpAddr::v6_data() const noexcept
{
  return ETCPAL_IP_V6_ADDRESS(&addr_);
}
 
inline std::array<uint8_t, ETCPAL_IPV6_BYTES> IpAddr::ToV6Array() const
{
  // RVO should hopefully make this only a single copy
  std::array<uint8_t, ETCPAL_IPV6_BYTES> arr;  // NOLINT(cppcoreguidelines-pro-type-member-init)
  std::memcpy(arr.data(), ETCPAL_IP_V6_ADDRESS(&addr_), ETCPAL_IPV6_BYTES);
  return arr;
}
 
constexpr unsigned long IpAddr::scope_id() const noexcept
{
  return ETCPAL_IP_V6_SCOPE_ID(&addr_);
}
 
constexpr bool IpAddr::IsValid() const noexcept
{
  return !ETCPAL_IP_IS_INVALID(&addr_);
}
 
constexpr IpAddrType IpAddr::type() const noexcept
{
  return static_cast<IpAddrType>(addr_.type);
}
 
constexpr etcpal_iptype_t IpAddr::raw_type() const noexcept
{
  return addr_.type;
}
 
constexpr bool IpAddr::IsV4() const noexcept
{
  return ETCPAL_IP_IS_V4(&addr_);
}
 
constexpr bool IpAddr::IsV6() const noexcept
{
  return ETCPAL_IP_IS_V6(&addr_);
}
 
inline bool IpAddr::IsLinkLocal() const noexcept
{
  return etcpal_ip_is_link_local(&addr_);
}
 
inline bool IpAddr::IsLoopback() const noexcept
{
  return etcpal_ip_is_loopback(&addr_);
}
 
inline bool IpAddr::IsMulticast() const noexcept
{
  return etcpal_ip_is_multicast(&addr_);
}
 
inline bool IpAddr::IsWildcard() const noexcept
{
  return etcpal_ip_is_wildcard(&addr_);
}
 
inline unsigned int IpAddr::MaskLength() const noexcept
{
  return etcpal_ip_mask_length(&addr_);
}
 
inline void IpAddr::SetAddress(uint32_t v4_data) noexcept
{
  ETCPAL_IP_SET_V4_ADDRESS(&addr_, v4_data);
}
 
inline void IpAddr::SetAddress(const uint8_t* v6_data) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS(&addr_, v6_data);
}
 
inline void IpAddr::SetAddress(const uint8_t* v6_data, unsigned long scope_id) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS_WITH_SCOPE_ID(&addr_, v6_data, scope_id);
}
 
inline IpAddr IpAddr::FromString(const char* ip_str) noexcept
{
  IpAddr result;
  if (etcpal_string_to_ip(kEtcPalIpTypeV4, ip_str, &result.addr_) != kEtcPalErrOk)
  {
    etcpal_string_to_ip(kEtcPalIpTypeV6, ip_str, &result.addr_);
  }
  return result;
}
 
inline IpAddr IpAddr::FromString(const std::string& ip_str) noexcept
{
  return FromString(ip_str.c_str());
}
 
inline IpAddr IpAddr::WildcardV4() noexcept
{
  return Wildcard(IpAddrType::kV4);
}
 
inline IpAddr IpAddr::WildcardV6() noexcept
{
  return Wildcard(IpAddrType::kV6);
}
 
inline IpAddr IpAddr::Wildcard(IpAddrType type) noexcept
{
  IpAddr result;
  etcpal_ip_set_wildcard(static_cast<etcpal_iptype_t>(type), &result.addr_);
  return result;
}
 
inline IpAddr IpAddr::NetmaskV4(unsigned int mask_length) noexcept
{
  return Netmask(IpAddrType::kV4, mask_length);
}
 
inline IpAddr IpAddr::NetmaskV6(unsigned int mask_length) noexcept
{
  return Netmask(IpAddrType::kV6, mask_length);
}
 
inline IpAddr IpAddr::Netmask(IpAddrType type, unsigned int mask_length) noexcept
{
  return etcpal_ip_mask_from_length(static_cast<etcpal_iptype_t>(type), mask_length);
}
 
class SockAddr
{
public:
  ETCPAL_CONSTEXPR_14 SockAddr() noexcept;
  // Note: this constructor is not explicit by design, to allow implicit conversions e.g.
  //   etcpal::SockAddr sa = etcpal_c_function_that_returns_sockaddr();
  constexpr SockAddr(const EtcPalSockAddr& c_sa) noexcept;
  SockAddr& operator=(const EtcPalSockAddr& c_sa) noexcept;
 
  ETCPAL_CONSTEXPR_14 SockAddr(uint32_t v4_data, uint16_t port) noexcept;
  SockAddr(const uint8_t* v6_data, uint16_t port) noexcept;
  SockAddr(const uint8_t* v6_data, unsigned long scope_id, uint16_t port) noexcept;
  ETCPAL_CONSTEXPR_14 SockAddr(IpAddr ip, uint16_t port) noexcept;
 
  constexpr const EtcPalSockAddr&        get() const noexcept;
  ETCPAL_CONSTEXPR_14 EtcPalSockAddr&    get() noexcept;
  std::string                            ToString() const;
  constexpr IpAddr                       ip() const noexcept;
  constexpr uint16_t                     port() const noexcept;
  constexpr uint32_t                     v4_data() const noexcept;
  constexpr const uint8_t*               v6_data() const noexcept;
  std::array<uint8_t, ETCPAL_IPV6_BYTES> ToV6Array() const;
  constexpr unsigned long                scope_id() const noexcept;
 
  constexpr bool            IsValid() const noexcept;
  constexpr IpAddrType      type() const noexcept;
  constexpr etcpal_iptype_t raw_type() const noexcept;
  constexpr bool            IsV4() const noexcept;
  constexpr bool            IsV6() const noexcept;
  bool                      IsLinkLocal() const noexcept;
  bool                      IsLoopback() const noexcept;
  bool                      IsMulticast() const noexcept;
  bool                      IsWildcard() const noexcept;
 
  void SetAddress(uint32_t v4_data) noexcept;
  void SetAddress(const uint8_t* v6_data) noexcept;
  void SetAddress(const uint8_t* v6_data, unsigned long scope_id) noexcept;
  void SetAddress(const IpAddr& ip) noexcept;
  void SetPort(uint16_t port) noexcept;
 
private:
  EtcPalSockAddr addr_{0, ETCPAL_IP_INVALID_INIT};
};
 
ETCPAL_CONSTEXPR_14_OR_INLINE SockAddr::SockAddr() noexcept
{
  ETCPAL_IP_SET_INVALID(&addr_.ip);
}
 
constexpr SockAddr::SockAddr(const EtcPalSockAddr& c_sa) noexcept : addr_(c_sa)
{
}
 
inline SockAddr& SockAddr::operator=(const EtcPalSockAddr& c_sa) noexcept
{
  addr_ = c_sa;
  return *this;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE SockAddr::SockAddr(uint32_t v4_data, uint16_t port) noexcept
{
  ETCPAL_IP_SET_V4_ADDRESS(&addr_.ip, v4_data);
  addr_.port = port;
}
 
inline SockAddr::SockAddr(const uint8_t* v6_data, uint16_t port) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS(&addr_.ip, v6_data);
  addr_.port = port;
}
 
inline SockAddr::SockAddr(const uint8_t* v6_data, unsigned long scope_id, uint16_t port) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS_WITH_SCOPE_ID(&addr_.ip, v6_data, scope_id);
  addr_.port = port;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE SockAddr::SockAddr(IpAddr ip, uint16_t port) noexcept
{
  addr_.ip   = ip.get();
  addr_.port = port;
}
 
constexpr const EtcPalSockAddr& SockAddr::get() const noexcept
{
  return addr_;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE EtcPalSockAddr& SockAddr::get() noexcept
{
  return addr_;
}
 
inline std::string SockAddr::ToString() const
{
  if (ETCPAL_IP_IS_V4(&addr_.ip))
    return ip().ToString() + ':' + std::to_string(addr_.port);
  if (ETCPAL_IP_IS_V6(&addr_.ip))
    return '[' + ip().ToString() + "]:" + std::to_string(addr_.port);
  return {};
}
 
constexpr IpAddr SockAddr::ip() const noexcept
{
  return addr_.ip;
}
 
constexpr uint16_t SockAddr::port() const noexcept
{
  return addr_.port;
}
 
constexpr uint32_t SockAddr::v4_data() const noexcept
{
  return ETCPAL_IP_V4_ADDRESS(&addr_.ip);
}
 
constexpr const uint8_t* SockAddr::v6_data() const noexcept
{
  return ETCPAL_IP_V6_ADDRESS(&addr_.ip);
}
 
inline std::array<uint8_t, ETCPAL_IPV6_BYTES> SockAddr::ToV6Array() const
{
  // RVO should hopefully make this only a single copy
  std::array<uint8_t, ETCPAL_IPV6_BYTES> arr;  // NOLINT(cppcoreguidelines-pro-type-member-init)
  std::memcpy(arr.data(), ETCPAL_IP_V6_ADDRESS(&addr_.ip), ETCPAL_IPV6_BYTES);
  return arr;
}
 
constexpr unsigned long SockAddr::scope_id() const noexcept
{
  return ETCPAL_IP_V6_SCOPE_ID(&addr_.ip);
}
 
constexpr bool SockAddr::IsValid() const noexcept
{
  return !ETCPAL_IP_IS_INVALID(&addr_.ip);
}
 
constexpr IpAddrType SockAddr::type() const noexcept
{
  return static_cast<IpAddrType>(addr_.ip.type);
}
 
constexpr etcpal_iptype_t SockAddr::raw_type() const noexcept
{
  return addr_.ip.type;
}
 
constexpr bool SockAddr::IsV4() const noexcept
{
  return ETCPAL_IP_IS_V4(&addr_.ip);
}
 
constexpr bool SockAddr::IsV6() const noexcept
{
  return ETCPAL_IP_IS_V6(&addr_.ip);
}
 
inline bool SockAddr::IsLinkLocal() const noexcept
{
  return etcpal_ip_is_link_local(&addr_.ip);
}
 
inline bool SockAddr::IsLoopback() const noexcept
{
  return etcpal_ip_is_loopback(&addr_.ip);
}
 
inline bool SockAddr::IsMulticast() const noexcept
{
  return etcpal_ip_is_multicast(&addr_.ip);
}
 
inline bool SockAddr::IsWildcard() const noexcept
{
  return etcpal_ip_is_wildcard(&addr_.ip);
}
 
inline void SockAddr::SetAddress(uint32_t v4_data) noexcept
{
  ETCPAL_IP_SET_V4_ADDRESS(&addr_.ip, v4_data);
}
 
inline void SockAddr::SetAddress(const uint8_t* v6_data) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS(&addr_.ip, v6_data);
}
 
inline void SockAddr::SetAddress(const uint8_t* v6_data, unsigned long scope_id) noexcept
{
  ETCPAL_IP_SET_V6_ADDRESS_WITH_SCOPE_ID(&addr_.ip, v6_data, scope_id);
}
 
inline void SockAddr::SetAddress(const IpAddr& ip) noexcept
{
  addr_.ip = ip.get();
}
 
inline void SockAddr::SetPort(uint16_t port) noexcept
{
  addr_.port = port;
}
 
class MacAddr
{
public:
  MacAddr() = default;
  // Note: this constructor is not explicit by design, to allow implicit conversions e.g.
  //   etcpal::MacAddr sa = etcpal_c_function_that_returns_macaddr();
  constexpr MacAddr(const EtcPalMacAddr& c_mac) noexcept;
  MacAddr& operator=(const EtcPalMacAddr& c_mac) noexcept;
  explicit MacAddr(const uint8_t* mac_data) noexcept;
 
  constexpr const EtcPalMacAddr&        get() const noexcept;
  ETCPAL_CONSTEXPR_14 EtcPalMacAddr&    get() noexcept;
  std::string                           ToString() const;
  constexpr const uint8_t*              data() const noexcept;
  std::array<uint8_t, ETCPAL_MAC_BYTES> ToArray() const noexcept;
 
  bool IsNull() const noexcept;
 
  static MacAddr FromString(const char* mac_str) noexcept;
  static MacAddr FromString(const std::string& mac_str) noexcept;
 
private:
  EtcPalMacAddr addr_{};
};
 
constexpr MacAddr::MacAddr(const EtcPalMacAddr& c_mac) noexcept : addr_(c_mac)
{
}
 
inline MacAddr& MacAddr::operator=(const EtcPalMacAddr& c_mac) noexcept
{
  addr_ = c_mac;
  return *this;
}
 
inline MacAddr::MacAddr(const uint8_t* mac_data) noexcept
{
  std::memcpy(addr_.data, mac_data, ETCPAL_MAC_BYTES);
}
 
constexpr const EtcPalMacAddr& MacAddr::get() const noexcept
{
  return addr_;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE EtcPalMacAddr& MacAddr::get() noexcept
{
  return addr_;
}
 
inline std::string MacAddr::ToString() const
{
  std::array<char, ETCPAL_MAC_STRING_BYTES> str_buf;  // NOLINT(cppcoreguidelines-pro-type-member-init)
  etcpal_mac_to_string(&addr_, str_buf.data());
  return {str_buf.data()};
}
 
constexpr const uint8_t* MacAddr::data() const noexcept
{
  return addr_.data;
}
 
inline std::array<uint8_t, ETCPAL_MAC_BYTES> MacAddr::ToArray() const noexcept
{
  // RVO should hopefully make this only a single copy
  std::array<uint8_t, ETCPAL_MAC_BYTES> arr;  // NOLINT(cppcoreguidelines-pro-type-member-init)
  std::memcpy(arr.data(), addr_.data, ETCPAL_MAC_BYTES);
  return arr;
}
 
inline bool MacAddr::IsNull() const noexcept
{
  return ETCPAL_MAC_IS_NULL(&addr_);
}
 
inline MacAddr MacAddr::FromString(const char* mac_str) noexcept
{
  MacAddr result;
  etcpal_string_to_mac(mac_str, &result.addr_);
  return result;
}
 
inline MacAddr MacAddr::FromString(const std::string& mac_str) noexcept
{
  return FromString(mac_str.c_str());
}
 
 
namespace detail
{
class NetintIndexType
{
};
}  // namespace detail
 
 
using NetintIndex = etcpal::OpaqueId<detail::NetintIndexType, unsigned int, 0>;
 
class NetintInfo
{
public:
  NetintInfo() = default;
  constexpr NetintInfo(const EtcPalNetintInfo& c_info) noexcept;
  NetintInfo& operator=(const EtcPalNetintInfo& c_info) noexcept;
 
  constexpr const EtcPalNetintInfo& get() const noexcept;
 
  constexpr NetintIndex index() const noexcept;
  constexpr IpAddr      addr() const noexcept;
  constexpr IpAddr      mask() const noexcept;
  constexpr MacAddr     mac() const noexcept;
  std::string           id() const noexcept;
  std::string           friendly_name() const noexcept;
  constexpr bool        is_default() const noexcept;
 
  constexpr bool IsValid() const noexcept;
  constexpr      operator NetintIndex() const noexcept;
 
private:
  EtcPalNetintInfo info_{};
};
 
constexpr NetintInfo::NetintInfo(const EtcPalNetintInfo& c_info) noexcept : info_(c_info)
{
}
 
inline NetintInfo& NetintInfo::operator=(const EtcPalNetintInfo& c_info) noexcept
{
  info_ = c_info;
  return *this;
}
 
constexpr const EtcPalNetintInfo& NetintInfo::get() const noexcept
{
  return info_;
}
 
constexpr NetintIndex NetintInfo::index() const noexcept
{
  return NetintIndex(info_.index);
}
 
constexpr IpAddr NetintInfo::addr() const noexcept
{
  return info_.addr;
}
 
constexpr IpAddr NetintInfo::mask() const noexcept
{
  return info_.mask;
}
 
constexpr MacAddr NetintInfo::mac() const noexcept
{
  return info_.mac;
}
 
inline std::string NetintInfo::id() const noexcept
{
  return info_.id;
}
 
inline std::string NetintInfo::friendly_name() const noexcept
{
  return info_.friendly_name;
}
 
constexpr bool NetintInfo::is_default() const noexcept
{
  return info_.is_default;
}
 
constexpr bool NetintInfo::IsValid() const noexcept
{
  return index().IsValid();
}
 
constexpr NetintInfo::operator NetintIndex() const noexcept
{
  return index();
}
 
// Operators
 
 
 
// Special operators for comparing with the underlying types
 
inline bool operator==(const EtcPalIpAddr& c_ip, const IpAddr& ip) noexcept
{
  return c_ip == ip.get();
}
 
inline bool operator!=(const EtcPalIpAddr& c_ip, const IpAddr& ip) noexcept
{
  return !(c_ip == ip);
}
 
inline bool operator==(const IpAddr& ip, const EtcPalIpAddr& c_ip) noexcept
{
  return ip.get() == c_ip;
}
 
inline bool operator!=(const IpAddr& ip, const EtcPalIpAddr& c_ip) noexcept
{
  return !(ip == c_ip);
}
 
inline bool operator==(const EtcPalSockAddr& c_ip, const SockAddr& ip) noexcept
{
  return c_ip == ip.get();
}
 
inline bool operator!=(const EtcPalSockAddr& c_ip, const SockAddr& ip) noexcept
{
  return !(c_ip == ip);
}
 
inline bool operator==(const SockAddr& ip, const EtcPalSockAddr& c_ip) noexcept
{
  return ip.get() == c_ip;
}
 
inline bool operator!=(const SockAddr& ip, const EtcPalSockAddr& c_ip) noexcept
{
  return !(ip == c_ip);
}
 
inline bool operator==(const EtcPalMacAddr& c_mac, const MacAddr& mac) noexcept
{
  return c_mac == mac.get();
}
 
inline bool operator!=(const EtcPalMacAddr& c_mac, const MacAddr& mac) noexcept
{
  return !(c_mac == mac);
}
 
inline bool operator==(const MacAddr& mac, const EtcPalMacAddr& c_mac) noexcept
{
  return mac.get() == c_mac;
}
 
inline bool operator!=(const MacAddr& mac, const EtcPalMacAddr& c_mac) noexcept
{
  return !(mac == c_mac);
}
 
inline bool operator==(const EtcPalNetintInfo& c_info, const NetintInfo& info) noexcept
{
  return c_info == info.get();
}
 
inline bool operator!=(const EtcPalNetintInfo& c_info, const NetintInfo& info) noexcept
{
  return !(c_info == info);
}
 
inline bool operator==(const NetintInfo& info, const EtcPalNetintInfo& c_info) noexcept
{
  return info.get() == c_info;
}
 
inline bool operator!=(const NetintInfo& info, const EtcPalNetintInfo& c_info) noexcept
{
  return !(info == c_info);
}
 
// Standard operators
 
inline bool operator==(const IpAddr& a, const IpAddr& b) noexcept
{
  return a.get() == b.get();
}
 
inline bool operator!=(const IpAddr& a, const IpAddr& b) noexcept
{
  return !(a == b);
}
 
inline bool operator<(const IpAddr& a, const IpAddr& b) noexcept
{
  return a.get() < b.get();
}
 
inline bool operator>(const IpAddr& a, const IpAddr& b) noexcept
{
  return b < a;
}
 
inline bool operator<=(const IpAddr& a, const IpAddr& b) noexcept
{
  return !(b < a);
}
 
inline bool operator>=(const IpAddr& a, const IpAddr& b) noexcept
{
  return !(a < b);
}
 
inline bool operator==(const SockAddr& a, const SockAddr& b) noexcept
{
  return a.get() == b.get();
}
 
inline bool operator!=(const SockAddr& a, const SockAddr& b) noexcept
{
  return !(a == b);
}
 
inline bool operator<(const SockAddr& a, const SockAddr& b) noexcept
{
  return a.get() < b.get();
}
 
inline bool operator>(const SockAddr& a, const SockAddr& b) noexcept
{
  return b < a;
}
 
inline bool operator<=(const SockAddr& a, const SockAddr& b) noexcept
{
  return !(b < a);
}
 
inline bool operator>=(const SockAddr& a, const SockAddr& b) noexcept
{
  return !(a < b);
}
 
inline bool operator==(const MacAddr& a, const MacAddr& b) noexcept
{
  return a.get() == b.get();
}
 
inline bool operator!=(const MacAddr& a, const MacAddr& b) noexcept
{
  return !(a == b);
}
 
inline bool operator<(const MacAddr& a, const MacAddr& b) noexcept
{
  return a.get() < b.get();
}
 
inline bool operator>(const MacAddr& a, const MacAddr& b) noexcept
{
  return b < a;
}
 
inline bool operator<=(const MacAddr& a, const MacAddr& b) noexcept
{
  return !(b < a);
}
 
inline bool operator>=(const MacAddr& a, const MacAddr& b) noexcept
{
  return !(a < b);
}
 
inline bool operator==(const NetintInfo& a, const NetintInfo& b) noexcept
{
  return a.get() == b.get();
}
 
inline bool operator!=(const NetintInfo& a, const NetintInfo& b) noexcept
{
  return !(a == b);
}
 
inline bool operator<(const NetintInfo& a, const NetintInfo& b) noexcept
{
  return a.get() < b.get();
}
 
inline bool operator>(const NetintInfo& a, const NetintInfo& b) noexcept
{
  return b < a;
}
 
inline bool operator<=(const NetintInfo& a, const NetintInfo& b) noexcept
{
  return !(b < a);
}
 
inline bool operator>=(const NetintInfo& a, const NetintInfo& b) noexcept
{
  return !(a < b);
}
 
 
};  // namespace etcpal
 
 
// Inject new std::hash specializations for etcpal::IpAddr, SockAddr, and MacAddr, so that they can be used in
// hash-based containers (e.g. unordered_map and unordered_set) without a user needing to create a hash specialization.
//
// The std::hash specializations use an efficient combination of hashes of the underlying data.
namespace std
{
template <>
struct hash<::etcpal::IpAddr>
{
  std::size_t operator()(const ::etcpal::IpAddr& addr) const noexcept
  {
    size_t seed = 0u;
 
    if (addr.IsV6())
    {
      for (int i = 0; i < ETCPAL_IPV6_BYTES; ++i)
        ::etcpal::HashCombine(seed, addr.v6_data()[i]);
 
      ::etcpal::HashCombine(seed, addr.scope_id());
    }
    else if (addr.IsV4())
    {
      ::etcpal::HashCombine(seed, addr.v4_data());
    }
 
    ::etcpal::HashCombine(seed, static_cast<int>(addr.type()));
 
    return seed;
  }
};
 
template <>
struct hash<::etcpal::SockAddr>
{
  std::size_t operator()(const ::etcpal::SockAddr& addr) const noexcept
  {
    size_t seed = 0u;
    ::etcpal::HashCombine(seed, addr.ip());
    ::etcpal::HashCombine(seed, addr.port());
 
    return seed;
  }
};
 
template <>
struct hash<::etcpal::MacAddr>
{
  std::size_t operator()(const ::etcpal::MacAddr& addr) const noexcept
  {
    size_t seed = 0u;
    for (int i = 0; i < ETCPAL_MAC_BYTES; ++i)
      ::etcpal::HashCombine(seed, addr.data()[i]);
 
    return seed;
  }
};
};  // namespace std
 
#endif  // ETCPAL_CPP_LOCK_H_