Refactored domain name processing (#141)

* Moved domain functions to header file

* Refactored domain functions

* Refactored domain functions some more

* Updated host processing

* Reworked domain processing to later allow parameterizing allocators

* Reworked domain to u8 processing

* Made more extensive use of range-v3 in domain name processing

* Made more extensive use of range v3

Author: glynos

include/skyr/v1/containers/static_vector.hpp

@@ -111,7 +111,13 @@ class static_vector {
 
   ///
   /// \return
-  [[nodiscard]] constexpr auto data() const noexcept -> const value_type * {
+  [[nodiscard]] constexpr auto data() noexcept -> pointer {
+    return impl_.data();
+  }
+
+  ///
+  /// \return
+  [[nodiscard]] constexpr auto data() const noexcept -> const_pointer {
     return impl_.data();
   }
 
@@ -133,6 +139,11 @@ class static_vector {
     return size_ == 0;
   }
 
+  ///
+  constexpr void clear() noexcept {
+    size_ = 0;
+  }
+
   ///
   /// \return
   [[nodiscard]] constexpr auto begin() noexcept -> iterator {

include/skyr/v1/core/check_input.hpp

@@ -8,6 +8,11 @@
 
 #include <locale>
 #include <string>
+#include <range/v3/distance.hpp>
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/algorithm/remove_if.hpp>
+#include <range/v3/view/reverse.hpp>
+#include <range/v3/action/erase.hpp>
 
 namespace skyr {
 inline namespace v1 {
@@ -16,18 +21,17 @@ constexpr static auto is_c0_control_or_space = [] (auto byte) {
 };
 
 inline auto remove_leading_c0_control_or_space(std::string_view input, bool *validation_error) {
-  auto first = begin(input), last = end(input);
-  auto it = std::find_if_not(first, last, is_c0_control_or_space);
-  *validation_error |= (it != first);
-  input.remove_prefix(std::distance(first, it));
+  auto it = ranges::find_if_not(input, is_c0_control_or_space);
+  *validation_error |= (it != ranges::cbegin(input));
+  input.remove_prefix(std::distance(ranges::cbegin(input), it));
   return input;
 }
 
 inline auto remove_trailing_c0_control_or_space(std::string_view input, bool *validation_error) {
-  auto first = rbegin(input), last = rend(input);
-  auto it = std::find_if_not(first, last, is_c0_control_or_space);
-  *validation_error |= (it != first);
-  input.remove_suffix(std::distance(first, it));
+  auto reversed = ranges::reverse_view(input);
+  auto it = ranges::find_if_not(reversed, is_c0_control_or_space);
+  *validation_error |= (it != ranges::cbegin(reversed));
+  input.remove_suffix(std::distance(ranges::cbegin(reversed), it));
   return input;
 }
 
@@ -36,10 +40,9 @@ inline auto remove_tabs_and_newlines(std::string &input, bool *validation_error)
     return (byte == '\t') || (byte == '\r') || (byte == '\n');
   };
 
-  auto first = begin(input), last = end(input);
-  auto it = std::remove_if(first, last, is_tab_or_newline);
-  *validation_error |= (it != last);
-  input.erase(it, last);
+  auto it = ranges::remove_if(input, is_tab_or_newline);
+  *validation_error |= (it != std::cend(input));
+  ranges::erase(input, it, std::cend(input));
 }
 }  // namespace v1
 }  // namespace skyr

include/skyr/v1/core/host.hpp

@@ -9,15 +9,22 @@
 #include <variant>
 #include <string>
 #include <cassert>
+#include <algorithm>
 #include <tl/expected.hpp>
+#include <range/v3/algorithm/find_if.hpp>
+#include <range/v3/range/access.hpp>
 #include <skyr/v1/core/errors.hpp>
 #include <skyr/v1/network/ipv4_address.hpp>
 #include <skyr/v1/network/ipv6_address.hpp>
+#include <skyr/v1/percent_encoding/percent_encoded_char.hpp>
+#include <skyr/v1/percent_encoding/percent_decode.hpp>
+#include <skyr/v1/domain/domain.hpp>
+
 
 namespace skyr {
 inline namespace v1 {
-/// Represents a domain in a [URL host](https://url.spec.whatwg.org/#host-representation)
-struct domain {
+/// Represents a domain name in a [URL host](https://url.spec.whatwg.org/#host-representation)
+struct domain_name {
   std::string name;
 };
 
@@ -35,7 +42,7 @@ class host {
   using host_types = std::variant<
       skyr::v1::ipv4_address,
       skyr::v1::ipv6_address,
-      skyr::v1::domain,
+      skyr::v1::domain_name,
       skyr::v1::opaque_host,
       skyr::v1::empty_host
       >;
@@ -54,13 +61,13 @@ class host {
 
   /// Constructor
   /// \param host A domain name
-  explicit host(skyr::v1::domain host)
-      : host_(host) {}
+  explicit host(skyr::v1::domain_name host)
+      : host_(std::move(host)) {}
 
   /// Constructor
   /// \param host An opaque host string
   explicit host(skyr::v1::opaque_host host)
-      : host_(host) {}
+      : host_(std::move(host)) {}
 
   /// Constructor
   /// \param hsost An empty host
@@ -79,7 +86,7 @@ class host {
       else if constexpr (std::is_same_v<T, skyr::v1::ipv6_address>) {
         return "[" + host.serialize() + "]";
       }
-      else if constexpr (std::is_same_v<T, skyr::v1::domain> ||
+      else if constexpr (std::is_same_v<T, skyr::v1::domain_name> ||
                          std::is_same_v<T, skyr::v1::opaque_host>) {
         return host.name;
       }
@@ -93,14 +100,14 @@ class host {
 
   ///
   /// \return \c true if the host is a domain, \c false otherwise
-  [[nodiscard]] auto is_domain() const noexcept {
-    return std::holds_alternative<skyr::v1::domain>(host_);
+  [[nodiscard]] auto is_domain_name() const noexcept {
+    return std::holds_alternative<skyr::v1::domain_name>(host_);
   }
 
   ///
   /// \return
-  [[nodiscard]] auto domain() const noexcept -> std::optional<std::string> {
-    return is_domain() ? std::make_optional(std::get<skyr::v1::domain>(host_).name) : std::nullopt;
+  [[nodiscard]] auto domain_name() const noexcept -> std::optional<std::string> {
+    return is_domain_name() ? std::make_optional(std::get<skyr::v1::domain_name>(host_).name) : std::nullopt;
   }
 
   ///
@@ -150,16 +157,105 @@ class host {
   host_types host_;
 };
 
+namespace details {
+constexpr static auto is_forbidden_host_point = [](auto byte) {
+  return
+      (byte == '\0') || (byte == '\t') || (byte == '\n') || (byte == '\r') || (byte == ' ') || (byte == '#') ||
+          (byte == '%') || (byte == '/') || (byte == ':') || (byte == '<') || (byte == '>') || (byte == '?') ||
+          (byte == '@') || (byte == '[') || (byte == '\\') || (byte == ']') || (byte == '^');
+};
+
+inline auto parse_opaque_host(std::string_view input,
+                              bool *validation_error) -> tl::expected<skyr::v1::opaque_host, url_parse_errc> {
+  constexpr static auto is_forbidden = [] (auto byte) -> bool {
+    return (byte != '%') && is_forbidden_host_point(byte);
+  };
+
+  if (std::cend(input) != ranges::find_if(input, is_forbidden)) {
+    *validation_error |= true;
+    return tl::make_unexpected(url_parse_errc::forbidden_host_point);
+  }
+
+  auto output = std::string();
+  for (auto c : input) {
+    auto pct_encoded = percent_encode_byte(std::byte(c), percent_encoding::encode_set::c0_control);
+    output += pct_encoded.to_string();
+  }
+  return skyr::v1::opaque_host{std::move(output)};
+}
+}  // namespace details
+
 /// Parses a string to either a domain, IPv4 address or IPv6 address according to
 /// https://url.spec.whatwg.org/#host-parsing
 /// \param input An input string
 /// \param is_not_special \c true to process only non-special hosts, \c false otherwise
 /// \param validation_error Set to \c true if there was a validation error
 /// \return A host as a domain (std::string), ipv4_address or ipv6_address, or an error code
-auto parse_host(
+inline auto parse_host(
     std::string_view input,
     bool is_not_special,
-    bool *validation_error) -> tl::expected<host, url_parse_errc>;
+    bool *validation_error) -> tl::expected<host, url_parse_errc> {
+  if (input.empty()) {
+    return host{empty_host{}};
+  }
+
+  if (input.front() == '[') {
+    if (input.back() != ']') {
+      *validation_error |= true;
+      return tl::make_unexpected(url_parse_errc::invalid_ipv6_address);
+    }
+
+    auto view = std::string_view(input);
+    view.remove_prefix(1);
+    view.remove_suffix(1);
+    bool ipv6_validation_error = false;
+    auto ipv6_address = parse_ipv6_address(view, &ipv6_validation_error);
+    if (ipv6_address) {
+      *validation_error = ipv6_validation_error;
+      return skyr::v1::host{ipv6_address.value()};
+    }
+    else {
+      return tl::make_unexpected(url_parse_errc::invalid_ipv6_address);
+    }
+  }
+
+  if (is_not_special) {
+    return details::parse_opaque_host(input, validation_error).and_then(
+        [] (auto &&h) -> tl::expected<host, url_parse_errc> { return host{h}; });
+  }
+
+  auto domain_name = std::string{};
+  auto range = percent_encoding::percent_decode_range{input};
+  for (auto it = std::cbegin(range); it != std::cend(range); ++it) {
+    if (!*it) {
+      return tl::make_unexpected(url_parse_errc::cannot_decode_host_point);
+    }
+    domain_name.push_back((*it).value());
+  }
+
+  auto ascii_domain = std::string{};
+  if (!domain_to_ascii(domain_name, &ascii_domain)) {
+    return tl::make_unexpected(url_parse_errc::domain_error);
+  }
+
+  if (ranges::cend(ascii_domain) != ranges::find_if(ascii_domain, details::is_forbidden_host_point)) {
+    *validation_error |= true;
+    return tl::make_unexpected(url_parse_errc::domain_error);
+  }
+
+  bool ipv4_validation_error = false;
+  auto host = parse_ipv4_address(ascii_domain, &ipv4_validation_error);
+  if (!host) {
+    if (host.error() == ipv4_address_errc::overflow) {
+      return tl::make_unexpected(url_parse_errc::invalid_ipv4_address);
+    }
+    else {
+      return skyr::v1::host{skyr::v1::domain_name{std::move(ascii_domain)}};
+    }
+  }
+  *validation_error = ipv4_validation_error;
+  return skyr::v1::host{host.value()};
+}
 
 /// Parses a string to either a domain, IPv4 address or IPv6 address according to
 /// https://url.spec.whatwg.org/#host-parsing