uvco::AddressHandle Class Reference

AddressHandle is a light-weight wrapper around a struct / sockaddr_in(6), and is therefore cheap to copy. More...

#include <name_resolution.h>

Classes
struct	NtopHelper_
	A helper for calling inet_ntop(3). More...

Public Member Functions
	AddressHandle ()=default
	AddressHandle (const AddressHandle &)=default
	AddressHandle (AddressHandle &&)=default
AddressHandle &	operator= (const AddressHandle &)=default
AddressHandle &	operator= (AddressHandle &&)=default
	~AddressHandle ()=default
	AddressHandle (std::span< const uint8_t > ipv4_or_6, uint16_t port, uint32_t v6scope=0)
	AddressHandle (uint32_t ipv4, uint16_t port)
	AddressHandle (std::string_view ip, uint16_t port, uint32_t v6scope=0)
	AddressHandle (const struct addrinfo *ai)
	AddressHandle (const struct sockaddr *sa)
std::string	address () const
uint16_t	port () const
int	family () const
	Family is either AF_INET or AF_INET6.
const struct sockaddr *	sockaddr () const
std::string	toString () const

Static Public Attributes
static constexpr size_t	ipv4Length = 4
static constexpr size_t	ipv6Length = 16

Private Attributes
std::variant< struct sockaddr_in, struct sockaddr_in6 >	addr_

Detailed Description

AddressHandle is a light-weight wrapper around a struct / sockaddr_in(6), and is therefore cheap to copy.

It can be constructed from different forms of TCP/IP addresses, and also
supports formatting an address to a string.

In order to resolve a DNS hostname, use the `Resolver` class. 

Constructor & Destructor Documentation

AddressHandle() [1/8]

uvco::AddressHandle::AddressHandle ( )

default

AddressHandle() [2/8]

uvco::AddressHandle::AddressHandle ( const AddressHandle & )

default

AddressHandle() [3/8]

uvco::AddressHandle::AddressHandle ( AddressHandle && )

default

~AddressHandle()

uvco::AddressHandle::~AddressHandle ( )

default

AddressHandle() [4/8]

uvco::AddressHandle::AddressHandle	(	std::span< const uint8_t >	ipv4_or_6,
		uint16_t	port,
		uint32_t	v6scope = 0 )

                                               {
  if (ipv4_or_6.size() == ipv4Length) {
    struct sockaddr_in addr{};
    struct in_addr ipAddr{};
    ipAddr.s_addr = *(uint32_t *)ipv4_or_6.data();
 
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr = ipAddr;
    addr_ = addr;
  } else if (ipv4_or_6.size() == ipv6Length) {
    struct sockaddr_in6 addr{};
    struct in6_addr ipAddr{};
 
    std::ranges::copy(ipv4_or_6, static_cast<uint8_t *>(ipAddr.s6_addr));
 
    addr.sin6_family = AF_INET6;
    addr.sin6_port = htons(port);
    addr.sin6_addr = ipAddr;
    addr.sin6_scope_id = v6scope;
    addr_ = addr;
  } else {
    throw UvcoException("Invalid address size for IPv4/6 address!");
  }
}

AddressHandle() [5/8]

uvco::AddressHandle::AddressHandle	(	uint32_t	ipv4,
		uint16_t	port )

    : AddressHandle{std::span<const uint8_t>{(uint8_t *)(&ipv4), 4}, port} {}

AddressHandle() [6/8]

uvco::AddressHandle::AddressHandle	(	std::string_view	ip,
		uint16_t	port,
		uint32_t	v6scope = 0 )

                                               {
  if (ip.contains(':')) {
    struct in6_addr ipAddr{};
    uv_status status = inet_pton(AF_INET6, ip.data(), &ipAddr);
    if (status != 1) {
      throw UvcoException(fmt::format("invalid IPv6 address: {}", ip));
    }
 
    struct sockaddr_in6 addr{};
    addr.sin6_family = AF_INET6;
    addr.sin6_addr = ipAddr;
    addr.sin6_port = htons(port);
    addr.sin6_scope_id = v6scope;
    addr_ = addr;
  } else {
    struct in_addr ipAddr;
    uv_status status = inet_pton(AF_INET, ip.data(), &ipAddr);
    if (status != 1) {
      throw UvcoException(fmt::format("invalid IPv4 address: {}", ip));
    }
 
    struct sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr = ipAddr;
    addr.sin_port = htons(port);
    addr_ = addr;
  }
}

AddressHandle() [7/8]

uvco::AddressHandle::AddressHandle ( const struct addrinfo * ai )

explicit

                                                      {
  if (ai->ai_family == AF_INET) {
    BOOST_ASSERT(ai->ai_addrlen >= sizeof(struct sockaddr_in));
    addr_ = *(struct sockaddr_in *)ai->ai_addr;
  } else if (ai->ai_family == AF_INET6) {
    BOOST_ASSERT(ai->ai_addrlen >= sizeof(struct sockaddr_in6));
    addr_ = *(struct sockaddr_in6 *)ai->ai_addr;
  }
}

AddressHandle() [8/8]

uvco::AddressHandle::AddressHandle ( const struct sockaddr * sa )

explicit

                                                      {
  int af = sa->sa_family;
  if (af == AF_INET) {
    const auto *addr = (struct sockaddr_in *)sa;
    addr_ = *addr;
  } else if (af == AF_INET6) {
    const auto *addr = (struct sockaddr_in6 *)sa;
    addr_ = *addr;
  } else {
    throw UvcoException(fmt::format("unknown address family {}", af));
  }
}

Member Function Documentation

address()

std::string uvco::AddressHandle::address ( ) const

inlinenodiscard

                                          {
    return std::visit(NtopHelper_{}, addr_);
  }

family()

int uvco::AddressHandle::family

(

)

const

Family is either AF_INET or AF_INET6.

                                {
  if (addr_.index() == 0)
    return AF_INET;
  if (addr_.index() == 1)
    return AF_INET6;
  throw UvcoException("family(): unknown address variant!");
}

operator=() [1/2]

AddressHandle & uvco::AddressHandle::operator= ( AddressHandle && )

default

operator=() [2/2]

AddressHandle & uvco::AddressHandle::operator= ( const AddressHandle & )

default

port()

uint16_t uvco::AddressHandle::port ( ) const

nodiscard

                                   {
  if (addr_.index() == 0) {
    const auto &addr = std::get<0>(addr_);
    return ntohs(addr.sin_port);
  } else {
    const auto &addr = std::get<1>(addr_);
    return ntohs(addr.sin6_port);
  }
}

sockaddr()

const struct sockaddr * uvco::AddressHandle::sockaddr

(

)

const

The inner sockaddr struct. May refer to either a sockaddr_in or a sockaddr_in6, depending on family().

                                                     {
  return std::visit(
      [](const auto &sockaddr) -> const struct sockaddr * {
        return (const struct sockaddr *)&sockaddr;
      },
      addr_);
}

toString()

std::string uvco::AddressHandle::toString ( ) const

nodiscard

                                        {
  if (family() == AF_INET) {
    return fmt::format("{}:{}", address(), port());
  }
  if (family() == AF_INET6) {
    return fmt::format("[{}]:{}", address(), port());
  }
  return {};
}

Member Data Documentation

addr_

std::variant<struct sockaddr_in, struct sockaddr_in6> uvco::AddressHandle::addr_

private

ipv4Length

size_t uvco::AddressHandle::ipv4Length = 4

staticconstexpr

ipv6Length

size_t uvco::AddressHandle::ipv6Length = 16

staticconstexpr

---

The documentation for this class was generated from the following files:

• uvco/name_resolution.h
• uvco/name_resolution.cc