IPEndpoint.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Network Geographics 2014
 
#pragma once
 
#include <stdexcept>
 
#include "swoc/swoc_version.h"
#include "swoc/MemSpan.h"
#include "swoc/TextView.h"
#include "swoc/string_view_util.h"
#include "swoc/swoc_ip_util.h"
 
namespace swoc { inline namespace SWOC_VERSION_NS {
 
class IPAddr;
class IP4Addr;
class IP6Addr;
 
class IPSrv;
class IP4Srv;
class IP6Srv;

union IPEndpoint {
  using self_type   = IPEndpoint; 
  using string_view = std::string_view;
 
  struct sockaddr sa;      
  struct sockaddr_in sa4;  
  struct sockaddr_in6 sa6; 

  IPEndpoint();
  IPEndpoint(self_type const &that); 
  ~IPEndpoint() = default;

  explicit IPEndpoint(string_view const &text);

  explicit IPEndpoint(IPAddr const &addr);

  explicit IPEndpoint(IPSrv const &srv);

  IPEndpoint(sockaddr const *addr);

  IPEndpoint(sockaddr_in const *sin);

  IPEndpoint(sockaddr_in6 const *sin6);

  self_type &operator=(self_type const &that);

  static bool tokenize(string_view src, string_view *host = nullptr, string_view *port = nullptr, string_view *rest = nullptr);

  bool parse(string_view const &str);

  static void invalidate(sockaddr *addr);

  self_type &invalidate();

  static bool assign(sockaddr *dst, sockaddr const *src);

  self_type &assign(sockaddr const *addr);

  self_type &assign(sockaddr_in const *sin);

  self_type &assign(sockaddr_in6 const *sin6);

  self_type &assign(IPAddr const &addr);
 
  [[deprecated("Use IPSrv")]] self_type &assign(IPAddr const &addr, in_port_t port);

  self_type &assign(IP4Addr const &addr);

  self_type &assign(IP6Addr const &addr);

  self_type &assign(IP4Srv const &srv);

  self_type &assign(IP6Srv const &srv);

  self_type &assign(IPSrv const &srv);

  const self_type &copy_to(sockaddr *addr) const;

  bool is_valid() const;

  bool is_ip4() const;

  bool is_ip6() const;

  socklen_t size() const;

  sa_family_t family() const;

  sockaddr_in *ip4();

  sockaddr_in const *ip4() const;

  sockaddr_in6 *ip6();

  sockaddr_in6 const *ip6() const;

  self_type &set_to_any(int family);

  bool is_any() const;

  self_type &set_to_loopback(int family);

  bool is_loopback() const;

  bool is_link_local() const;

  static bool is_link_local(sockaddr const * sa);

  bool is_private() const;

  static bool is_private(sockaddr const * sa);

  bool is_multicast() const;

  static bool is_multicast(sockaddr const * sa);

  in_port_t network_order_port() const;

  in_port_t host_order_port() const;

  static bool is_valid(sockaddr const *sa);

  static in_port_t &port(sockaddr *sa);

  static in_port_t network_order_port(sockaddr const *sa);

  static in_port_t host_order_port(sockaddr const *sa);

  operator sockaddr *();

  operator sockaddr const *() const;

  size_t sa_size() const;

  static size_t sa_size(sockaddr const* sa);

  swoc::MemSpan<void const> raw_addr() const;

  static string_view family_name(sa_family_t family);
};
 
inline IPEndpoint::IPEndpoint() {
  sa.sa_family = AF_UNSPEC;
}
 
inline IPEndpoint::IPEndpoint(IPAddr const &addr) {
  this->assign(addr);
}
 
inline IPEndpoint::IPEndpoint(IPSrv const &srv) {
  this->assign(srv);
}
 
inline IPEndpoint::IPEndpoint(sockaddr const *addr) {
  this->assign(addr);
}
 
inline IPEndpoint::IPEndpoint(IPEndpoint::self_type const &that) : self_type(&that.sa) {}
 
inline IPEndpoint &
IPEndpoint::invalidate() {
  sa.sa_family = AF_UNSPEC;
  return *this;
}
 
inline void
IPEndpoint::invalidate(sockaddr *addr) {
  addr->sa_family = AF_UNSPEC;
}
 
inline bool
IPEndpoint::is_valid() const {
  return sa.sa_family == AF_INET || sa.sa_family == AF_INET6;
}
 
inline IPEndpoint &
IPEndpoint::operator=(self_type const &that) {
  self_type::assign(&sa, &that.sa);
  return *this;
}
 
inline IPEndpoint &
IPEndpoint::assign(sockaddr_in const *sin) {
  std::memcpy(&sa4, sin, sizeof(sockaddr_in));
  return *this;
}
 
inline IPEndpoint &
IPEndpoint::assign(sockaddr_in6 const *sin6) {
  std::memcpy(&sa6, sin6, sizeof(sockaddr_in6));
  return *this;
}
 
inline IPEndpoint &
IPEndpoint::assign(sockaddr const *src) {
  self_type::assign(&sa, src);
  return *this;
}
 
inline IPEndpoint const &
IPEndpoint::copy_to(sockaddr *addr) const {
  self_type::assign(addr, &sa);
  return *this;
}
 
inline bool
IPEndpoint::is_ip4() const {
  return AF_INET == sa.sa_family;
}
 
inline bool
IPEndpoint::is_ip6() const {
  return AF_INET6 == sa.sa_family;
}
 
inline sa_family_t
IPEndpoint::family() const {
  return sa.sa_family;
}
 
inline sockaddr_in *
IPEndpoint::ip4() {
  return this->is_ip4() ? &sa4 : nullptr;
}
 
inline sockaddr_in const *
IPEndpoint::ip4() const {
  return this->is_ip4() ? &sa4 : nullptr;
}
 
inline sockaddr_in6 *
IPEndpoint::ip6() {
  return this->is_ip6() ? &sa6 : nullptr;
}
 
inline sockaddr_in6 const *
IPEndpoint::ip6() const {
  return this->is_ip6() ? &sa6 : nullptr;
}
 
inline in_port_t
IPEndpoint::network_order_port() const {
  return this->is_valid() ? this->port(const_cast<sockaddr *>(&sa)) : 0;
}
 
inline in_port_t
IPEndpoint::host_order_port() const {
  return ntohs(this->network_order_port());
}
 
inline bool
IPEndpoint::is_valid(sockaddr const *sa) {
  return sa && (sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
}
 
inline in_port_t &
IPEndpoint::port(sockaddr *sa) {
  switch (sa->sa_family) {
  case AF_INET:
    return reinterpret_cast<sockaddr_in *>(sa)->sin_port;
  case AF_INET6:
    return reinterpret_cast<sockaddr_in6 *>(sa)->sin6_port;
  }
  // Force a failure upstream by returning a null reference.
  throw std::domain_error("sockaddr does not contain a valid IP address");
}
 
inline in_port_t
IPEndpoint::network_order_port(sockaddr const *sa) {
  return self_type::is_valid(sa) ? self_type::port(const_cast<sockaddr *>(sa)) : 0;
}
 
inline in_port_t
IPEndpoint::host_order_port(sockaddr const *sa) {
  return self_type::is_valid(sa) ? ntohs(self_type::port(const_cast<sockaddr *>(sa))) : 0;
}
 
inline swoc::MemSpan<void const>
IPEndpoint::raw_addr() const {
  switch (sa.sa_family) {
  case AF_INET:
    return {&sa4.sin_addr, sizeof(sa4.sin_addr)};
  case AF_INET6:
    return {&sa6.sin6_addr, sizeof(sa6.sin6_addr)};
  }
  return {};
}
 
inline bool IPEndpoint::is_link_local() const {
  return swoc::ip::is_link_local(&sa);
}
 
inline bool IPEndpoint::is_link_local(sockaddr const * sa) {
  return swoc::ip::is_link_local(sa);
}
 
inline bool IPEndpoint::is_private() const {
  return swoc::ip::is_private(&sa);
}
 
inline bool IPEndpoint::is_private(sockaddr const * sa) {
  return swoc::ip::is_private(sa);
}
 
inline bool IPEndpoint::is_multicast() const {
  return swoc::ip::is_multicast(&sa);
}
 
inline bool IPEndpoint::is_multicast(sockaddr const * sa) {
  return swoc::ip::is_multicast(sa);
}
 
inline IPEndpoint::operator sockaddr *() { return &sa; }
 
inline IPEndpoint::operator sockaddr const *() const { return &sa; }
 
inline size_t IPEndpoint::sa_size() const {
  return sa_size(&sa);
}
 
inline size_t IPEndpoint::sa_size(sockaddr const* sa) {
  return AF_INET == sa->sa_family ? sizeof(sockaddr_in) : AF_INET6 == sa->sa_family ? sizeof(sockaddr_in6) : sizeof(sockaddr);
}
 
}} // namespace swoc::SWOC_VERSION_NS