Botan::URI::Authority Class Reference

#include <uri.h>

Public Types
using	Host = std::variant<DNSName, IPv4Address, IPv6Address>
enum class	HostKind : uint8_t { DNS = 0 , IPv4 = 1 , IPv6 = 2 }

Public Member Functions
const Host &	host () const
HostKind	host_kind () const
std::string	host_to_string () const
std::strong_ordering	operator<=> (const Authority &other) const
bool	operator== (const Authority &other) const
const std::string &	original_input () const
std::optional< uint16_t >	port () const
const std::optional< std::string > &	userinfo () const

Static Public Member Functions
static std::optional< Authority >	from_string (std::string_view raw)

Detailed Description

The optional authority component of a URI: a validated DNS name, IPv4 literal, or IPv6 literal, with an optional port.

Definition at line 31 of file uri.h.

Member Typedef Documentation

Host

using Botan::URI::Authority::Host = std::variant<DNSName, IPv4Address, IPv6Address>

A validated DNS name, or a literal IPv4 or IPv6 address.

Definition at line 36 of file uri.h.

Member Enumeration Documentation

HostKind

enum class Botan::URI::Authority::HostKind : uint8_t

strong

Tag for the alternative held by Host.

Enumerator
DNS
IPv4
IPv6

Definition at line 41 of file uri.h.

                                : uint8_t {
               DNS = 0,
               IPv4 = 1,
               IPv6 = 2,
            };

Member Function Documentation

from_string()

std::optional< URI::Authority > Botan::URI::Authority::from_string ( std::string_view raw )

static

Parse a bare authority "host[:port]" or "[ipv6][:port]". Returns nullopt for any parse failure.

Definition at line 248 of file uri.cpp.

                                                                      {
   if(raw.empty()) {
      return {};
   }
 
   // Capture the full input now; the userinfo prefix is stripped from
   // `raw` below, and m_raw must reflect the original
   const std::string original_input(raw);
 
   /*
   RFC 3986
     userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
 
   Thus a unencoded '@' is not allowed inside userinfo, and the single '@' splits the
   username from the authority. The @ being present at all is significant; an empty
   userinfo ("https://@example.com/") is distinct from no userinfo at all.
   */
   std::optional<std::string> userinfo;
   const auto first_at = raw.find('@');
   if(first_at != std::string_view::npos) {
      if(raw.find('@', first_at + 1) != std::string_view::npos) {
         return {};
      }
      const auto userinfo_view = raw.substr(0, first_at);
      if(!validate_userinfo(userinfo_view)) {
         return {};
      }
      userinfo = std::string(userinfo_view);
      raw.remove_prefix(first_at + 1);
   }
 
   std::string_view host_view;
   std::string_view port_str;
   std::optional<Host> host;
 
   if(!raw.empty() && raw.front() == '[') {
      // Bracketed IPv6 literal.
      const auto close = raw.find(']');
      if(close == std::string_view::npos) {
         return {};
      }
      host_view = raw.substr(1, close - 1);
      if(host_view.empty()) {
         return {};
      }
      const auto after = raw.substr(close + 1);
      if(!after.empty()) {
         if(after.front() != ':') {
            return {};
         }
         port_str = after.substr(1);
      }
      auto ipv6 = IPv6Address::from_string(host_view);
      if(!ipv6.has_value()) {
         return {};
      }
      host = *ipv6;
   } else {
      // host[:port] with no brackets. Only one ':' is allowed (port).
      const auto colon = raw.find(':');
      if(colon == std::string_view::npos) {
         host_view = raw;
      } else {
         host_view = raw.substr(0, colon);
         port_str = raw.substr(colon + 1);
 
         // Verify the `:` char is the only one that appears
         if(port_str.find(':') != std::string::npos) {
            return {};
         }
      }
 
      if(host_view.empty()) {
         return {};
      }
 
      // Technically valid per RFC 3986 but likely not something we want to support
      if(host_view.ends_with('.')) {
         return {};
      }
 
      if(auto ipv4 = IPv4Address::from_string(host_view)) {
         host = *ipv4;
      } else if(auto dns = DNSName::from_string(host_view)) {
         host = std::move(*dns);
      } else {
         return {};
      }
   }
 
   std::optional<uint16_t> port;
 
   if(!port_str.empty()) {
      port = parse_port(port_str);
      if(!port.has_value()) {
         return {};
      }
   }
 
   return Authority(original_input, std::move(userinfo), std::move(*host), port);
}

References Botan::DNSName::from_string(), Botan::IPv4Address::from_string(), Botan::IPv6Address::from_string(), host(), original_input(), Botan::URI::original_input(), port(), and userinfo().

Referenced by Botan::URI::from_string(), and Botan::OS::open_socket_udp().

host()

const Host & Botan::URI::Authority::host ( ) const

inline

Parsed host: a DNS name, an IPv4 literal, or an IPv6 literal.

Definition at line 56 of file uri.h.

{ return m_host; }

Referenced by from_string().

host_kind()

URI::Authority::HostKind Botan::URI::Authority::host_kind

(

)

const

Which alternative of host() is held.

Definition at line 354 of file uri.cpp.

                                                   {
   if(std::holds_alternative<DNSName>(m_host)) {
      return HostKind::DNS;
   } else if(std::holds_alternative<IPv4Address>(m_host)) {
      return HostKind::IPv4;
   } else if(std::holds_alternative<IPv6Address>(m_host)) {
      return HostKind::IPv6;
   } else {
      BOTAN_ASSERT_UNREACHABLE();
   }
}

References BOTAN_ASSERT_UNREACHABLE.

host_to_string()

std::string Botan::URI::Authority::host_to_string

(

)

const

The host as a string: DNS names and dotted-IPv4 literals are returned verbatim; IPv6 literals are returned without surrounding brackets. Lowercased for DNS / IPv4; the IPv6 form is whatever IPv6Address::to_string produces.

Definition at line 350 of file uri.cpp.

                                             {
   return std::visit([](const auto& h) -> std::string { return h.to_string(); }, m_host);
}

operator<=>()

std::strong_ordering Botan::URI::Authority::operator<=>

(

const Authority &

other

)

const

Order two authorities

Parameters

other

the authority to compare against

Returns

the ordering of this authority relative to other

Definition at line 146 of file uri.cpp.

                                        =>(const URI::Authority& other) const {
   /*
   Userinfo is compared without normalization; RFC 3986 6.2.2.1:
      When a URI uses components of the generic syntax, the component
      syntax equivalence rules always apply; namely, that the scheme
      and host are case-insensitive and therefore should be normalized
      to lowercase. ... The other generic syntax components are assumed
      to be case-sensitive unless specifically defined otherwise by the
      scheme.
   */
   return std::tie(m_userinfo, m_host, m_port) <=> std::tie(other.m_userinfo, other.m_host, other.m_port);
}

operator==()

bool Botan::URI::Authority::operator==

(

const Authority &

other

)

const

Compare two authorities

Parameters

other

the authority to compare against

Returns

true if the two authorities are equal

Definition at line 159 of file uri.cpp.

                                                           {
   return m_userinfo == other.m_userinfo && m_host == other.m_host && m_port == other.m_port;
}

original_input()

const std::string & Botan::URI::Authority::original_input ( ) const

inline

The original input that was parsed

Definition at line 79 of file uri.h.

{ return m_raw; }

Referenced by from_string().

port()

std::optional< uint16_t > Botan::URI::Authority::port ( ) const

inline

Port if present; nullopt otherwise.

Definition at line 74 of file uri.h.

{ return m_port; }

Referenced by from_string().

userinfo()

const std::optional< std::string > & Botan::URI::Authority::userinfo ( ) const

inline

The userinfo component, preserved verbatim (no case normalization or pct-decoding) and compared verbatim for identity. nullopt if no "@" was present; present-but-empty (e.g. "https://@example.com/") is distinguished from absent.

Definition at line 87 of file uri.h.

{ return m_userinfo; }

Referenced by from_string().

---

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

• src/lib/utils/uri/uri.h
• src/lib/utils/uri/uri.cpp