public_suffix_list.h

Go to the documentation of this file.

// Copyright 2024-2026 Rimas Misevičius
// Distributed under the BSD-style license that can be
// found in the LICENSE file.
//
#ifndef UPA_PUBLIC_SUFFIX_LIST_H
#define UPA_PUBLIC_SUFFIX_LIST_H
 
#include "url.h"
 
#ifndef UPA_MODULE
# include <cstddef>
# include <cstdint>
# include <filesystem>
# include <fstream>
# include <ios>
# include <istream>
# include <memory>
# include <string>
# include <string_view>
# include <unordered_map>
# include <utility>
#endif // UPA_MODULE
 
namespace upa {
 
UPA_EXPORT_BEGIN

template <class StrT, enable_if_str_arg_t<StrT> = 0>
[[nodiscard]] constexpr std::size_t get_label_pos_by_index(const StrT& str_host, std::size_t index) {
    const auto inp = make_str_arg(str_host);
    const auto* first = inp.begin();
    const auto* last = inp.end();
    const auto* ptr = first;
    for (; index > 0; --index) {
        while (true) {
            if (ptr == last)
                return static_cast<std::size_t>(ptr - first);
            const auto c = util::to_unsigned(*ptr);
            if (c < 0x80) {
                ++ptr; // advance to next char
                if (c == '.')
                    break;
            } else {
                const auto cp = url_utf::read_utf_char(ptr, last).value;
                // These code points are mapped to '.' in the IDNA mapping table
                if (cp == 0x3002 || cp == 0xFF0E || cp == 0xFF61)
                    break;
            }
        }
    }
    return static_cast<std::size_t>(ptr - first);
}

class public_suffix_list {
    // label_item::code values
    static constexpr std::uint8_t DIFF_MASK  = 0x03;
    static constexpr std::uint8_t IS_RULE    = 0x04;
    static constexpr std::uint8_t IS_ICANN   = 0x08;
    static constexpr std::uint8_t IS_PRIVATE = 0x10;
public:
    enum class option {
        public_suffix = 0,      
        registrable_domain = 1, 
        allow_trailing_dot [[deprecated]] = 2 
    };

    struct result {
        [[nodiscard]] constexpr operator bool() const noexcept {
            return first_label_ind != static_cast<std::size_t>(-1);
        }

        [[nodiscard]] constexpr bool is_icann() const noexcept {
            return (code_ & IS_ICANN) != 0;
        }

        [[nodiscard]] constexpr bool is_private() const noexcept {
            return (code_ & IS_PRIVATE) != 0;
        }

        [[nodiscard]] constexpr bool wildcard_rule() const noexcept {
            return (code_ & DIFF_MASK) == 3;
        }

        [[nodiscard]] constexpr bool is_rules_match() const noexcept {
            return (code_ & IS_RULE) != 0;
        }

        std::size_t first_label_ind = static_cast<std::size_t>(-1);
        std::size_t first_label_pos = static_cast<std::size_t>(-1);
        std::uint8_t code_ = 0;
    };

    inline bool load(const std::filesystem::path& filename) {
        std::ifstream finp(filename, std::ios::in | std::ios::binary);
        return finp && load(finp);
    }

    UPA_API bool load(std::istream& input_stream);
 
    // Push interface to load Public Suffix List

    struct push_context {
        std::string remaining;
        std::uint8_t code_flags = 0;
        std::uint8_t error = 0;
    };

    UPA_API void push_line(push_context& ctx, std::string_view line);

    UPA_API void push(push_context& ctx, std::string_view buff);

    UPA_API bool finalize(push_context& ctx);
 
    // Get public suffix or registrable domain

    template <class StrT, enable_if_str_arg_t<StrT> = 0>
    [[nodiscard]] inline std::string get_suffix(const StrT& str_host,
        option opt = option::public_suffix) const {
        try {
            return std::string{ get_suffix_view(
                upa::url_host{ str_host },
                opt) };
        }
        catch (const upa::url_error&) {
            return {};
        }
    }

    [[nodiscard]] inline result get_suffix_info(const url& url,
        option opt = option::public_suffix) const {
        if (url.host_type() == HostType::Domain)
            return get_host_suffix_info(url.hostname(), opt);
        return {};
    }

    [[nodiscard]] inline result get_suffix_info(const url_host& host,
        option opt = option::public_suffix) const {
        if (host.type() == HostType::Domain)
            return get_host_suffix_info(host.name(), opt);
        return {};
    }

    template <class StrT, enable_if_str_arg_t<StrT> = 0>
    [[nodiscard]] inline result get_suffix_info(const StrT& str_host,
        option opt = option::public_suffix) const {
        try {
            auto res = get_suffix_info(upa::url_host{ str_host }, opt);
            res.first_label_pos = get_label_pos_by_index(str_host, res.first_label_ind);
            return res;
        }
        catch (const upa::url_error&) {
            return {};
        }
    }

    [[nodiscard]] inline std::string_view get_suffix_view(const url& url UPA_LIFETIMEBOUND,
        option opt = option::public_suffix) const {
        if (url.host_type() == HostType::Domain)
            return get_host_suffix_view(url.hostname(), opt);
        return {};
    }

    [[nodiscard]] inline std::string_view get_suffix_view(const url_host& host UPA_LIFETIMEBOUND,
        option opt = option::public_suffix) const {
        if (host.type() == HostType::Domain)
            return get_host_suffix_view(host.name(), opt);
        return {};
    }

    template <class StrT, enable_if_str_arg_t<StrT> = 0>
    [[nodiscard]] inline auto get_suffix_view(const StrT& str_host, option opt = option::public_suffix) const
        -> std::basic_string_view<typename str_arg<str_arg_char_t<StrT>>::value_type> {
        try {
            const auto arg = make_str_arg(str_host);
            const upa::url_host host{ arg };
            if (host.type() == HostType::Domain) {
                const auto res = get_host_suffix_info(host.name(), opt);
                if (res) {
                    const auto pos = get_label_pos_by_index(arg, res.first_label_ind);
                    return { arg.data() + pos, arg.size() - pos };
                }
            }
        }
        catch (const upa::url_error&) {}
        return {};
    }

    [[nodiscard]] UPA_API bool operator==(const public_suffix_list& other) const;
 
    // constructors, destructor, assignment operators
    UPA_API public_suffix_list();
    UPA_API ~public_suffix_list();
    UPA_API public_suffix_list(public_suffix_list&&) noexcept;
    public_suffix_list(const public_suffix_list&) = delete;
    UPA_API public_suffix_list& operator=(public_suffix_list&&) noexcept;
    public_suffix_list& operator=(const public_suffix_list&) = delete;
 
private:
    UPA_API result get_host_suffix_info(std::string_view hostname, option opt) const;
 
    inline std::string_view get_host_suffix_view(std::string_view hostname, option opt) const {
        const auto res = get_host_suffix_info(hostname, opt);
        if (res)
            return hostname.substr(res.first_label_pos);
        return {};
    }
 
private:
    struct label_item {
#ifdef __cpp_lib_generic_unordered_lookup
        // https://en.cppreference.com/w/cpp/container/unordered_map/find
        struct string_hash {
            using hash_type = std::hash<std::string_view>;
            using is_transparent = void;
 
            inline std::size_t operator()(const char* str) const { return hash_type{}(str); }
            inline std::size_t operator()(std::string_view str) const { return hash_type{}(str); }
            inline std::size_t operator()(std::string const& str) const { return hash_type{}(str); }
        };
        using map_type = std::unordered_map<std::string, label_item, string_hash, std::equal_to<>>;
#else
        using map_type = std::unordered_map<std::string, label_item>;
#endif
 
        std::uint8_t code = 0;
        std::unique_ptr<map_type> children;
 
        inline bool operator==(const label_item& b) const {
            return code == b.code && (
                (!children && !b.children) ||
                (children && b.children && *children == *b.children));
        }
    };
 
    label_item root_;
};
 
namespace idna {
 
template<>
struct enable_bitmask_operators<upa::public_suffix_list::option>
    : public std::true_type {};
 
} // namespace idna
 
UPA_EXPORT_END
 
} // namespace upa
 
#endif // UPA_PUBLIC_SUFFIX_LIST_H