inet.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 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"
 
namespace etcpal
{
 
enum class IpAddrType
{
  Invalid = kEtcPalIpTypeInvalid,
  V4 = kEtcPalIpTypeV4,
  V6 = 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 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
{
  char str_buf[ETCPAL_IP_STRING_BYTES];
  auto result = etcpal_ip_to_string(&addr_, str_buf);
  if (result == kEtcPalErrOk)
    return str_buf;
  else
    return std::string();
}
 
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;
  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 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::V4);
}
 
inline IpAddr IpAddr::WildcardV6() noexcept
{
  return Wildcard(IpAddrType::V6);
}
 
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::V4, mask_length);
}
 
inline IpAddr IpAddr::NetmaskV6(unsigned int mask_length) noexcept
{
  return Netmask(IpAddrType::V6, 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 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);
  else if (ETCPAL_IP_IS_V6(&addr_.ip))
    return '[' + ip().ToString() + "]:" + std::to_string(addr_.port);
  else
    return std::string();
}
 
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;
  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 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
{
  char str_buf[ETCPAL_MAC_STRING_BYTES];
  etcpal_mac_to_string(&addr_, str_buf);
  return str_buf;
}
 
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;
  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());
}
 
// 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);
}
 
// 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);
}
 
 
};  // namespace etcpal
 
#endif  // ETCPAL_CPP_LOCK_H_