Botan::IPv6Subnet Class Reference

#include <ipv6_address.h>

Public Member Functions
const IPv6Address &	address () const
	The network address (host bits already zeroed).
bool	contains (const IPv6Address &ip) const
	True iff ip falls within this subnet.
	IPv6Subnet (IPv6Address address, size_t prefix_length)
bool	is_host () const
	True iff prefix_length() == 128.
size_t	prefix_length () const
	Prefix length in [0, 128].
std::vector< uint8_t >	serialize () const
std::string	to_string () const
	CIDR-style "2001:db8::/32".

Static Public Member Functions
static std::optional< IPv6Subnet >	from_address_and_mask (std::span< const uint8_t, 32 > addr_and_mask)
static std::optional< IPv6Subnet >	from_string (std::string_view str)
static IPv6Subnet	host (IPv6Address address)

Friends
bool	operator== (const IPv6Subnet &, const IPv6Subnet &)=default

Detailed Description

An IPv6 subnet in CIDR form: a network address paired with a prefix length

Definition at line 71 of file ipv6_address.h.

Constructor & Destructor Documentation

IPv6Subnet()

Botan::IPv6Subnet::IPv6Subnet	(	IPv6Address	address,
		size_t	prefix_length )

Construct from a network address and a prefix length in [0, 128]. Host bits of address are cleared.

Throws Invalid_Argument if prefix_length > 128.

Definition at line 94 of file ipv6_address.cpp.

                                                                :
      m_address(address & IPv6Address::netmask(prefix_length)), m_prefix_length(static_cast<uint8_t>(prefix_length)) {
   // IPv6Address::netmask validates prefix_length <= 128, so by this point
   // the static_cast is in range.
}

References address(), and prefix_length().

Referenced by from_address_and_mask(), from_string(), host(), and operator==.

Member Function Documentation

address()

const IPv6Address & Botan::IPv6Subnet::address ( ) const

inline

The network address (host bits already zeroed).

Definition at line 103 of file ipv6_address.h.

{ return m_address; }

Referenced by host(), and IPv6Subnet().

contains()

bool Botan::IPv6Subnet::contains

(

const IPv6Address &

ip

)

const

True iff ip falls within this subnet.

Definition at line 143 of file ipv6_address.cpp.

                                                     {
   return (ip & IPv6Address::netmask(m_prefix_length)) == m_address;
}

References Botan::IPv6Address::netmask().

from_address_and_mask()

std::optional< IPv6Subnet > Botan::IPv6Subnet::from_address_and_mask ( std::span< const uint8_t, 32 > addr_and_mask )

static

Construct from a network address and a 16-byte CIDR netmask. Returns nullopt if netmask is not a valid contiguous CIDR prefix.

Definition at line 101 of file ipv6_address.cpp.

                                                                                                  {
   const auto addr = IPv6Address(addr_and_mask.first<16>());
   const auto mask = IPv6Address(addr_and_mask.last<16>());
 
   if(const auto plen = mask.prefix_length()) {
      return IPv6Subnet(addr, *plen);
   } else {
      return {};
   }
}

References IPv6Subnet().

Referenced by Botan::GeneralName::decode_from().

from_string()

std::optional< IPv6Subnet > Botan::IPv6Subnet::from_string ( std::string_view str )

static

Parse the CIDR-style form "2001:db8::/32".

The "/N" suffix is required: bare addresses should be parsed via IPv6Address::from_string and wrapped with IPv6Subnet::host if needed.

Returns nullopt on parse failure or out-of-range prefix length.

Definition at line 113 of file ipv6_address.cpp.

                                                                  {
   const auto slash = str.find('/');
   if(slash == std::string_view::npos) {
      return std::nullopt;
   }
 
   auto addr = IPv6Address::from_string(str.substr(0, slash));
   if(!addr.has_value()) {
      return std::nullopt;
   }
 
   // Parse the prefix length as a decimal integer in [0, 128].
   const auto plen_str = str.substr(slash + 1);
   if(plen_str.empty() || plen_str.size() > 3) {
      return std::nullopt;
   }
   size_t plen = 0;
   for(const char c : plen_str) {
      if(c < '0' || c > '9') {
         return std::nullopt;
      }
      plen = plen * 10 + static_cast<size_t>(c - '0');
   }
   if(plen > 128) {
      return std::nullopt;
   }
 
   return IPv6Subnet(*addr, plen);
}

References Botan::IPv6Address::from_string(), and IPv6Subnet().

host()

IPv6Subnet Botan::IPv6Subnet::host ( IPv6Address address )

inlinestatic

A single-host subnet (prefix length 128) covering exactly address.

Definition at line 100 of file ipv6_address.h.

{ return IPv6Subnet(address, 128); }

References address(), and IPv6Subnet().

Referenced by Botan::GeneralName::ipv6_address().

is_host()

bool Botan::IPv6Subnet::is_host ( ) const

inline

True iff prefix_length() == 128.

Definition at line 109 of file ipv6_address.h.

{ return m_prefix_length == 128; }

Referenced by serialize().

prefix_length()

size_t Botan::IPv6Subnet::prefix_length ( ) const

inline

Prefix length in [0, 128].

Definition at line 106 of file ipv6_address.h.

{ return m_prefix_length; }

Referenced by IPv6Subnet().

serialize()

std::vector< uint8_t > Botan::IPv6Subnet::serialize

(

)

const

Bytes for use in a DER-encoded GeneralName iPAddress field:

• 16 bytes (the address) if is_host(); the SAN form per RFC 5280 4.2.1.6.
• 32 bytes (address || netmask) otherwise; the name constraint form per RFC 5280 4.2.1.10.

Definition at line 151 of file ipv6_address.cpp.

                                               {
   const auto addr = m_address.address();
   if(is_host()) {
      return std::vector<uint8_t>(addr.begin(), addr.end());
   }
   const auto mask = IPv6Address::netmask(m_prefix_length).address();
   std::vector<uint8_t> out;
   out.reserve(32);
   out.insert(out.end(), addr.begin(), addr.end());
   out.insert(out.end(), mask.begin(), mask.end());
   return out;
}

References Botan::IPv6Address::address(), is_host(), and Botan::IPv6Address::netmask().

to_string()

std::string Botan::IPv6Subnet::to_string

(

)

const

CIDR-style "2001:db8::/32".

Definition at line 147 of file ipv6_address.cpp.

                                      {
   return fmt("{}/{}", m_address.to_string(), static_cast<size_t>(m_prefix_length));
}

References Botan::fmt().

Friends And Related Symbol Documentation

operator==

bool operator== ( const IPv6Subnet & , const IPv6Subnet &  )

friend

References IPv6Subnet().

---

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

• src/lib/utils/ip_address/ipv6_address.h
• src/lib/utils/ip_address/ipv6_address.cpp