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 112 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 296 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(), IPv6Subnet(), and prefix_length().

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

Member Function Documentation

address()

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

inline

The network address (host bits already zeroed).

Definition at line 150 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 347 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 303 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. The input must already be canonical, such that from_string and to_string are exact inverses: the address is RFC 5952 form with host bits clear ("2001:db8::/32") and the prefix length is canonical decimal ("/32", not "/032"). In particular the IPv4-mapped dotted form ("::ffff:1.2.3.4/120") is rejected even though IPv6Address::from_string would accept the address.

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

Definition at line 315 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 canonical decimal integer in [0, 128]
   const auto plen_str = str.substr(slash + 1);
 
   const auto plen = parse_sz(plen_str, /*require_canonical=*/true);
 
   if(!plen.has_value() || plen.value() > 128) {
      return std::nullopt;
   }
 
   const IPv6Subnet subnet(*addr, plen.value());
 
   // Require the input to already be canonical: from_string and to_string are
   // exact inverses, so a non-canonical address (including the IPv4-mapped
   // dotted form) or a set host bit is rejected rather than masked away
   if(subnet.to_string() != str) {
      return std::nullopt;
   }
 
   return subnet;
}

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

host()

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

inlinestatic

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

Definition at line 147 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 156 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 153 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 355 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 351 of file ipv6_address.cpp.

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

References Botan::fmt().

Referenced by from_string().

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