host.hpp

#pragma once
 
// ------------------------------------------------------------------------------------------------
// 3. Hosts (domains and IP addresses)
//
// https://url.spec.whatwg.org/#hosts-(domains-and-ip-addresses)
// https://triple-underscore.github.io/URL-ja.html#hosts-(domains-and-ip-addresses)
// ------------------------------------------------------------------------------------------------
 
#include <wordring/whatwg/url/infra.hpp>
#include <wordring/whatwg/url/url_defs.hpp>
 
#include <wordring/whatwg/encoding/encoding.hpp>
#include <wordring/whatwg/infra/infra.hpp>
#include <wordring/whatwg/infra/unicode.hpp>
 
#include <array>
#include <cassert>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <variant>
 
namespace wordring::whatwg
{
    
    // --------------------------------------------------------------------------------------------
    // 3.1. Host representation
    //
    // https://url.spec.whatwg.org/#host-representation
    // --------------------------------------------------------------------------------------------
 
    enum class host_type_name : std::uint32_t
    {
        Domain = 1,
        Ipv4Address,
        Ipv6Address,
        OpaqueHost,
        EmptyHost
    };
 
    struct domain_base
    {
        domain_base(std::u32string const& val) : m_value(val) {}
 
        std::u32string m_value;
    };
 
    struct ipv4_address_base { std::uint32_t m_value; };
 
    struct ipv6_address_base { std::array<std::uint16_t, 8> m_value; };
 
    struct opaque_host_base
    {
        std::u32string m_value;
    };
 
    struct empty_host_base { std::nullptr_t m_value = nullptr; };
 
    class host_base
    {
    public:
        using value_type = std::variant<
            domain_base,
            ipv4_address_base,
            ipv6_address_base,
            opaque_host_base,
            empty_host_base>;
 
    public:
        template <typename Value>
        host_base(Value const& val) : m_value(val) {}
 
        template <typename Value>
        host_base(Value&& val) : m_value(std::move(val)) {}
 
        host_type_name type()
        {
            switch (m_value.index())
            {
            case 0: return host_type_name::Domain;
            case 1: return host_type_name::Ipv4Address;
            case 2: return host_type_name::Ipv6Address;
            case 3: return host_type_name::OpaqueHost;
            case 4: return host_type_name::EmptyHost;
            default:
                break;
            }
            return static_cast<host_type_name>(0);
        }
 
    protected:
        value_type m_value;
    };
 
    // --------------------------------------------------------------------------------------------
    // 3.2. Host miscellaneous
    //
    // https://url.spec.whatwg.org/#host-miscellaneous
    // --------------------------------------------------------------------------------------------
 
    inline bool is_forbidden_host_code_point(std::uint32_t cp)
    {
        switch (cp)
        {
        case U'\x00':
        case U'\x09':
        case U'\x0A':
        case U'\x0D':
        case U'\x20':
        case U'\x23':
        case U'\x25':
        case U'\x2F':
        case U'\x3A':
        case U'\x3F':
        case U'\x40':
        case U'\x5B':
        case U'\x5C':
        case U'\x5D':
            return true;
        }
        return false;
    }
 
    // --------------------------------------------------------------------------------------------
    // 3.3. IDNA
    //
    // https://url.spec.whatwg.org/#idna
    // --------------------------------------------------------------------------------------------
 
    std::u32string domain_to_ascii(std::u32string const& s, bool beStrict, std::error_code& ec);
 
    inline std::u32string domain_to_ascii(std::u32string const& s, std::error_code& ec)
    {
        return domain_to_ascii(s, false, ec);
    }
 
    std::u32string domain_to_unicode(std::u32string const& s, std::error_code& ec);
 
    
    // --------------------------------------------------------------------------------------------
    // 3.4. Host writing
    //
    // https://url.spec.whatwg.org/#host-writing
    // --------------------------------------------------------------------------------------------
 
    bool is_valid_domain_string(std::u32string const& s);
    bool is_valid_ipv4_address_string(std::u32string const& s);
    bool is_valid_ipv6_address_string(std::u32string const& s);
 
    inline bool is_valid_host_string(std::u32string const& s)
    {
        if (is_valid_domain_string(s) || is_valid_ipv4_address_string(s)) return true;
        if (s.size() < 3 || s.front() != U'[' || s.back() != U']') return false;
        return is_valid_ipv6_address_string(std::u32string(++s.begin(), --s.end()));
    }
 
    bool is_valid_domain_string(std::u32string const& s);
 
    bool is_valid_ipv4_address_string(std::u32string const& s);
 
    inline bool is_valid_ipv6_address_string(std::u32string const& s)
    {
        return true;
    }
 
    inline bool is_valid_opaque_host_string(std::u32string const& s)
    {
        return true;
    }
    
    // --------------------------------------------------------------------------------------------
    // 3.5. Host parsing
    //
    // https://url.spec.whatwg.org/#host-parsing
    // --------------------------------------------------------------------------------------------
 
    std::optional<host_base> parse_ipv4(std::u32string const& in, std::error_code& ec);
    std::optional<host_base> parse_ipv6(std::u32string const& in, std::error_code& ec);
    std::optional<host_base> parse_opaque_host(std::u32string const& in, std::error_code& ec);
 
    std::pair<std::optional<std::uint32_t>, bool> parse_ipv4_number(std::u32string s);
 
    inline std::optional<host_base> parse_host(
        std::u32string const& in, bool isNotSpecial, std::error_code& ec)
    {
        // 1.
        if (!in.empty() && in.front() == U'[')
        {
            if (in.back() != U']')
            {
                ec = url_error_name::ParseFailed;
                return std::optional<host_base>();
            }
            return parse_ipv6(std::u32string(++in.begin(), --in.end()), ec);
        }
        // 2.
        if (isNotSpecial) return parse_opaque_host(in, ec);
        // 3.
        assert(!in.empty());
        // 4.
        std::string tmp;
        string_percent_decode(in.begin(), in.end(), std::back_inserter(tmp));
        encoding::io_queue<char> in_q = encoding::to_io_queue_convert(tmp.begin(), tmp.end());
        encoding::io_queue<char32_t> out_q;
        encoding::utf8_decode_without_bom(in_q, out_q);
        std::u32string domain;
        encoding::from_io_queue_convert(out_q, std::back_inserter(domain));
        // 5.
        std::u32string asciiDomain = domain_to_ascii(domain, ec);
        // 6.
        if (ec) return std::optional<host_base>();
        // 7.
        if (std::find_if(asciiDomain.begin(), asciiDomain.end(), is_forbidden_host_code_point) != asciiDomain.end())
        {
            ec = url_error_name::ParseFailed;
            return std::optional<host_base>();
        }
        // 8.
        std::optional<host_base> ipv4 = parse_ipv4(asciiDomain, ec);
        // 9.
        if(ec) return std::optional<host_base>();
        // 10.
        return std::optional<host_base>();
    }
 
    inline std::optional<host_base> parse_host(std::u32string const& in, std::error_code& ec)
    {
        return parse_host(in, false, ec);
    }
 
    inline std::optional<host_base> parse_ipv4(std::u32string const& in, std::error_code& ec)
    {
        // 1.
        bool validationError = false;
        // 2.
        std::vector<std::u32string> parts;
        strictly_split_on_particular_delimiter(in.begin(), in.end(), std::back_inserter(parts), U'.');
        // 3.
        if (!parts.empty() && parts.back().empty())
        {
            validationError = true;
            if (1 < parts.size()) parts.erase(--parts.end());
        }
        // 4.
        if (4 < parts.size()) return opaque_host_base{ in };
 
        return std::optional<host_base>();
    }
 
    inline std::pair<std::optional<std::uint32_t>, bool> parse_ipv4_number(std::u32string s)
    {
        // 1.
        bool validationError = false;
        // 2.
        std::uint32_t R = 10;
        // 3.
        if (2 <= s.size() && s.front() == U'0' && (s.at(1) == U'x' || s.at(1) == U'X'))
        {
            validationError = true;
            s.erase(0, 2);
            R = 16;
        }
        // 4.
        else if (2 <= s.size() && s.front() == U'0')
        {
            validationError = true;
            s.erase(0, 1);
            R = 8;
        }
        // 5.
        if (s.empty()) return std::make_pair(std::optional<std::uint32_t>(), validationError);
        // 6.
        std::u32string_view sv = R == 8 ? U"012345678" : (R == 10 ? U"0123456789" : U"0123456789abcdefABCDEF");
        for (char32_t cp : s) if (std::find(sv.begin(), sv.end(), cp) == sv.end())
        {
            return std::make_pair(std::optional<std::uint32_t>(), validationError);
        }
        // 7.
        std::string tmp;
        std::copy(s.begin(), s.end(), std::back_inserter(tmp));
        std::uint32_t i;
        std::from_chars(tmp.data(), tmp.data() + tmp.length(), i, R);
        // 8.
        return std::make_pair(std::optional<std::uint32_t>(i), validationError);
    }
 
    inline std::optional<host_base> parse_ipv6(std::u32string const& in, std::error_code& ec)
    {
        return std::optional<host_base>();
    }
 
    inline std::optional<host_base> parse_opaque_host(std::u32string const& in, std::error_code& ec)
    {
        return std::optional<host_base>();
    }
 
}