tld.cpp

Go to the documentation of this file.

/* TLD library -- TLD, domain name, and sub-domain extraction
 * Copyright (c) 2011-2025  Made to Order Software Corp.  All Rights Reserved
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
// self
//
#include    "libtld/tld.h"
#include    "libtld/tld_data.h"
#include    "libtld/tld_file.h"
 
 
// C++
//
#include    <sstream>
 
 
// C
//
#if defined(MO_DARWIN)
#include    <malloc/malloc.h>
#endif
#if !defined(MO_DARWIN) && !defined(MO_FREEBSD)
#include    <malloc.h>
#endif
#include    <stdlib.h>
#include    <limits.h>
#include    <string.h>
#include    <ctype.h>
 
#ifdef WIN32
#define strncasecmp _strnicmp
#endif
 
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
static struct tld_file * g_tld_file = nullptr;
 
 
 
 
namespace
{
 
 
 
void tags_to_info(const struct tld_description *tld, struct tld_info *info)
{
    tld_tag const * tag;
    uint32_t l;
    char const * str;
    for(uint32_t idx(0); idx < tld->f_tags_count; ++idx)
    {
        tag = tld_file_tag(g_tld_file, tld->f_tags + idx * 2);
        if(tag == nullptr)
        {
            continue;
        }
 
        str = tld_file_string(g_tld_file, tag->f_tag_name, &l);
        if(str == nullptr)
        {
            continue;
        }
        if(l == 8
        && memcmp(str, "category", l) == 0)
        {
            str = tld_file_string(g_tld_file, tag->f_tag_value, &l);
            if(str != nullptr)
            {
                info->f_category = tld_word_to_category(str, l);
            }
        }
        else if(l == 7
             && memcmp(str, "country", l) == 0)
        {
            str = tld_file_string(g_tld_file, tag->f_tag_value, &l);
            if(str != nullptr
            && l < sizeof(info->f_country))
            {
                memcpy(info->f_country, str, l);
                info->f_country[l] = '\0'; // the tld_clear_info() already does that -- double safe
            }
        }
    }
}
 
 
bool is_hex(int c)
{
    return (c >= '0' && c <= '9')
        || (c >= 'A' && c <= 'F')
        || (c >= 'a' && c <= 'f');
}
 
 
int h2d(int c)
{
    if(c >= 'a')
    {
        return c - 'a' + 10;
    }
    if(c >= 'A')
    {
        return c - 'A' + 10;
    }
    return c - '0';
}
 
 
 
} // no name namespace
 
 
 
static enum tld_result tld_load_tlds_if_not_loaded()
{
    if(g_tld_file == nullptr)
    {
        return tld_load_tlds(nullptr, 1);
    }
 
    return TLD_RESULT_SUCCESS;
}
 
 
static int cmp(const char *a, int l, const char *b, int n)
{
    /* if `a == "*"` then we have a bug in our algorithm
    if(a[0] == '*'
    && a[1] == '\0')
    {
        return 0;
    }
    */
 
    /* n represents the maximum number of characters to check in b */
    while(l > 0 && n > 0)
    {
        if(*a < *b)
        {
            return -1;
        }
        if(*a > *b)
        {
            return 1;
        }
        ++a;
        ++b;
        --l;
        --n;
    }
    if(l == 0)
    {
        if(n > 0)
        {
            /* in this case n > 0 so b is larger */
            return -1;
        }
        return 0;
    }
    /* in this case l > 0 so a is larger */
    return 1;
}
 
 
static int search(int i, int j, char const * domain, int n)
{
    int auto_match = -1, p, r;
    uint32_t l;
    struct tld_description const * tld;
    char const * name;
    enum tld_result result;
 
    result = tld_load_tlds_if_not_loaded();
    if(result != TLD_RESULT_SUCCESS)
    {
        return -1;
    }
 
#ifdef _DEBUG
    if(static_cast<uint32_t>(i) > static_cast<uint32_t>(j))
    {
        // LCOV_EXCL_START
        std::cerr
            << "error: i ("
            << i
            << ") is larger than j ("
            << j
            << ") which is not expected in search()."
            << std::endl;
        std::terminate();
        // LCOV_EXCL_STOP
    }
#endif
 
    if(i < j)
    {
#ifdef _DEBUG
        if(static_cast<uint32_t>(i) >= g_tld_file->f_descriptions_count
        || static_cast<uint32_t>(j) > g_tld_file->f_descriptions_count) // can be equal to max. (actually it should always be on first call)
        {
            // LCOV_EXCL_START
            std::cerr
                << "error: i ("
                << i
                << ") or j ("
                << j
                << ") is too large, max is "
                << g_tld_file->f_descriptions_count
                << '.'
                << std::endl;
            std::terminate();
            // LCOV_EXCL_STOP
        }
#endif
 
        /* the "*" breaks the binary search, we have to handle it specially */
        tld = tld_file_description(g_tld_file, i);
        if(tld == nullptr)
        {
            return -1;      // LCOV_EXCL_LINE -- see above (already checked)
        }
        name = tld_file_string(g_tld_file, tld->f_tld, &l);
        if(name == nullptr)
        {
            return -1;      // LCOV_EXCL_LINE -- see above (already checked)
        }
        if(l == 1 && name[0] == '*')
        {
            auto_match = i;
            ++i;
        }
 
        while(i < j)
        {
            p = (j - i) / 2 + i;
            tld = tld_file_description(g_tld_file, p);
            if(tld == nullptr)
            {
                return -1;
            }
            name = tld_file_string(g_tld_file, tld->f_tld, &l);
            if(name == nullptr)
            {
                return -1;
            }
#if 0
std::cerr << "--- name offset: " << tld->f_tld << " --- ptr: " << reinterpret_cast<void const *>(name) << ", cmp(\"" << std::string(name, l) << "\", \"" << std::string(domain, n) << "\") == " << r << "\n";
#endif
#ifdef _DEBUG
            if(l == 1 && name[0] == '*')
            {
                // LCOV_EXCL_START
                std::cerr
                    << "fatal error: found an asterisk within an array of sub-domains at "
                    << p
                    << std::endl;
                std::terminate();
                // LCOV_EXCL_STOP
            }
#endif
            r = cmp(name, l, domain, n);
#if 0
std::cerr << "--- name offset: " << tld->f_tld << " --- cmp(\"" << std::string(name, l) << "\", \"" << std::string(domain, n) << "\") == " << r << "\n";
#endif
            if(r < 0)
            {
                /* eliminate the first half */
                i = p + 1;
            }
            else if(r > 0)
            {
                /* eliminate the second half */
                j = p;
            }
            else
            {
                /* match */
                return p;
            }
        }
    }
 
    return auto_match;
}
 
 
void tld_clear_info(struct tld_info *info)
{
    info->f_category = TLD_CATEGORY_UNDEFINED;
    info->f_status = TLD_STATUS_UNDEFINED;
    memset(info->f_country, 0, sizeof(info->f_country));
    info->f_tld = (const char *) 0;
    info->f_offset = -1;
    info->f_tld_index = -1;
}
 
 
enum tld_result tld_load_tlds(char const * filename, int fallback)
{
    enum tld_file_error err;
 
    tld_file_free(&g_tld_file);
 
    if(filename == nullptr)
    {
        // first try a user updated version of the file
        //
        err = tld_file_load("/var/lib/libtld/tlds.tld", &g_tld_file);
        if(err == TLD_FILE_ERROR_NONE)
        {
            return TLD_RESULT_SUCCESS;
        }
        // else -- ignore any other error
 
        // second try the default installed version of the file
        //
        filename = "/usr/share/libtld/tlds.tld";
    }
    // else -- only try with the user defined version
 
    err = tld_file_load(filename, &g_tld_file);
    if(err == TLD_FILE_ERROR_NONE)
    {
        return TLD_RESULT_SUCCESS;
    }
 
    if(fallback != 0)
    {
        // use the descriptions from tld_data.c as fallback
        //
        std::stringstream in;
        in.write(reinterpret_cast<char const *>(tld_static_tlds), tld_get_static_tlds_buffer_size());
        err = tld_file_load_stream(&g_tld_file, in);
        if(err == TLD_FILE_ERROR_NONE)
        {
            return TLD_RESULT_SUCCESS;
        }
    }
 
    return err == TLD_FILE_ERROR_CANNOT_OPEN_FILE
                ? TLD_RESULT_NOT_FOUND
                : TLD_RESULT_INVALID;
}
 
 
const struct tld_file * tld_get_tlds()
{
    return g_tld_file;
}
 
 
void tld_free_tlds()
{
    tld_file_free(&g_tld_file);
}
 
 
enum tld_result tld_next_tld(struct tld_enumeration_state * state, struct tld_info * info)
{
    if(state == nullptr
    || info == nullptr)
    {
        return TLD_RESULT_NULL;
    }
 
    tld_clear_info(info);
 
    enum tld_result loaded = tld_load_tlds_if_not_loaded();
    if(loaded != TLD_RESULT_SUCCESS)
    {
        return loaded;
    }
 
    if(g_tld_file->f_header->f_tld_max_level > std::size(state->f_offset))
    {
        return TLD_RESULT_NO_TLD;
    }
 
    if(state->f_depth == 0
    && state->f_offset[0] == 0)
    {
        // set offset for the very first domain name
        //
        state->f_offset[0] = g_tld_file->f_header->f_tld_start_offset;
    }
 
    // did we reach the end?
    //
    if(state->f_offset[0] >= g_tld_file->f_header->f_tld_end_offset)
    {
        return TLD_RESULT_NOT_FOUND;
    }
 
    const struct tld_description * tld(nullptr);
 
    char * domain(state->f_domain + sizeof(state->f_domain));
    --domain;
    *domain = '\0';
    for(int d(0); d <= state->f_depth; ++d)
    {
        tld = tld_file_description(g_tld_file, state->f_offset[d]);
        //tld = g_tld_file->f_descriptions + state->f_offset[d];
        uint32_t length;
        char const * name = tld_file_string(g_tld_file, tld->f_tld, &length);
        if(name == nullptr)
        {
            return TLD_RESULT_BAD_URI;
        }
        while(length > 0)
        {
            char c('\0');
            --length;
            if(length >= 2
            && name[length - 2] == '%'
            && is_hex(name[length - 1])
            && is_hex(name[length - 0]))
            {
                // convert back to a byte
                //
                c = h2d(name[length - 1]) * 16 + h2d(name[length - 0]);
                length -= 2;
            }
            else
            {
                c = name[length];
            }
            --domain;
            if(domain < state->f_domain)
            {
                return TLD_RESULT_BAD_URI;
            }
            *domain = c;
        }
 
        // the period is not saved in this case
        //
        --domain;
        if(domain < state->f_domain)
        {
            return TLD_RESULT_BAD_URI;
        }
        *domain = '.';
    }
 
    info->f_tld = state->f_domain;
    info->f_offset = domain - state->f_domain;
    info->f_tld_index = state->f_offset[state->f_depth];
    info->f_status = static_cast<tld_status>(tld->f_status);
    tags_to_info(tld, info);
 
    // compute the next position now
    //
    if(tld->f_start_offset != 65535)
    {
        ++state->f_depth;
        state->f_offset[state->f_depth] = tld->f_start_offset;
    }
    else
    {
        ++state->f_offset[state->f_depth];
        while(state->f_depth > 0)
        {
            const struct tld_description * parent = g_tld_file->f_descriptions + state->f_offset[state->f_depth - 1];
            if(state->f_offset[state->f_depth] < parent->f_end_offset)
            {
                break;
            }
            --state->f_depth;
            ++state->f_offset[state->f_depth];
        }
    }
 
    return info->f_status == TLD_STATUS_VALID
                ? TLD_RESULT_SUCCESS
                : TLD_RESULT_INVALID;
}
 
 
enum tld_result tld(char const * const uri, struct tld_info * info)
{
    char const * end = uri;
    struct tld_description const * tld;
    int level = 0, max_level, start_level, i, r, p, offset;
    enum tld_result result;
 
    /* set defaults in the info structure */
    tld_clear_info(info);
 
    if(uri == nullptr || uri[0] == '\0')
    {
        return TLD_RESULT_NULL;
    }
 
    /* before we can go further, we want to load the TLDs file */
    result = tld_load_tlds_if_not_loaded();
    if(result != TLD_RESULT_SUCCESS)
    {
        return result;
    }
 
    max_level = g_tld_file->f_header->f_tld_max_level;
    std::vector<const char *> level_ptr(max_level);
    for(char const * previous_start(end); *end != '\0'; ++end)
    {
        if(*end == '.')
        {
            if(end - previous_start > LIBTLD_MAXIMUM_LABEL_LENGTH)
            {
                return TLD_RESULT_BAD_URI;
            }
            if(level >= max_level)
            {
                /* At this point the maximum number of levels in the
                 * TLDs is 7
                 */
                for(i = 1; i < max_level; ++i)
                {
                    level_ptr[i - 1] = level_ptr[i];
                }
                level_ptr[max_level - 1] = end;
            }
            else
            {
                level_ptr[level] = end;
                ++level;
            }
            if(level >= 2 && level_ptr[level - 2] + 1 == level_ptr[level - 1])
            {
                /* two periods one after another */
                return TLD_RESULT_BAD_URI;
            }
            previous_start = end + 1;
        }
    }
    if(end - uri > LIBTLD_MAXIMUM_URI_LENGTH)
    {
        return TLD_RESULT_BAD_URI;
    }
    /* if level is not at least 1 then there are no periods */
    if(level == 0)
    {
        /* no TLD */
        return TLD_RESULT_NO_TLD;
    }
 
    start_level = level;
    --level;
    r = search(g_tld_file->f_header->f_tld_start_offset,
                g_tld_file->f_header->f_tld_end_offset,
                level_ptr[level] + 1, (int) (end - level_ptr[level] - 1));
    if(r == -1)
    {
        /* unknown */
        return TLD_RESULT_NOT_FOUND;
    }
 
    /* check for the next level if there is one */
    for(p = r; level > 0; --level, p = r)
    {
        tld = tld_file_description(g_tld_file, r);
        if(tld == nullptr)
        {
            return TLD_RESULT_NOT_FOUND;
        }
        if(tld->f_start_offset == USHRT_MAX)
        {
            break;
        }
        r = search(tld->f_start_offset, tld->f_end_offset,
                level_ptr[level - 1] + 1,
                static_cast<int>(level_ptr[level] - level_ptr[level - 1] - 1));
        if(r == -1)
        {
            /* we are done, return the previous level */
            break;
        }
    }
    offset = (int) (level_ptr[level] - uri);
 
    /* if there are exceptions we may need to search those now if level is 0 */
    if(level == 0)
    {
        tld = tld_file_description(g_tld_file, p);
        if(tld == nullptr)
        {
            return TLD_RESULT_NOT_FOUND;
        }
        r = search(tld->f_start_offset,
                tld->f_end_offset,
                uri,
                static_cast<int>(level_ptr[0] - uri));
        if(r != -1)
        {
            p = r;
            offset = 0;
        }
    }
 
    tld = tld_file_description(g_tld_file, p);
    if(tld == nullptr)
    {
        return TLD_RESULT_NOT_FOUND;
    }
    info->f_status = static_cast<tld_status>(tld->f_status);
    info->f_tld_index = p;
    switch(info->f_status)
    {
    case TLD_STATUS_VALID:
        result = TLD_RESULT_SUCCESS;
        break;
 
    case TLD_STATUS_EXCEPTION:
        /* return the actual TLD and not the exception
         * i.e. "nacion.ar" is valid and the TLD is just ".ar"
         * even though top level ".ar" is forbidden by default
         */
        p = tld->f_exception_apply_to;
        tld = tld_file_description(g_tld_file, p);
        if(tld == nullptr)
        {
            return TLD_RESULT_NOT_FOUND;
        }
        level = start_level - tld->f_exception_level;
        offset = static_cast<int>(level_ptr[level] - uri);
        info->f_status = TLD_STATUS_VALID;
        result = TLD_RESULT_SUCCESS;
        break;
 
    default:
        result = TLD_RESULT_INVALID;
        break;
 
    }
 
    tags_to_info(tld, info);
 
    info->f_tld = level_ptr[level];
    info->f_offset = offset;
 
    return result;
}
 
 
enum tld_result tld_check_uri(const char * uri, struct tld_info * info, const char * protocols, int flags)
{
    const char      *p, *q, *username, *password, *host, *port, *n, *a, *query_string;
    char            domain[256];
    int             protocol_length, length, valid, c, i, j, anchor;
    enum tld_result result;
 
    /* set defaults in the info structure */
    tld_clear_info(info);
 
    if(uri == nullptr || uri[0] == '\0')
    {
        return TLD_RESULT_NULL;
    }
 
    /* check the protocol: [0-9A-Za-z_]+ */
    for(p = uri; *uri != '\0' && *uri != ':'; ++uri)
    {
        if((*uri < 'a' || *uri > 'z')
        && (*uri < 'A' || *uri > 'Z')
        && (*uri < '0' || *uri > '9')
        && *uri != '_')
        {
            return TLD_RESULT_BAD_URI;
        }
    }
    valid = 0;
    protocol_length = (int) (uri - p);
    c = tolower(*p);
    for(q = protocols; *q != '\0';)
    {
        if(q[0] == '*' && (q[1] == '\0' || q[1] == ','))
        {
            valid = 1;
            break;
        }
        if(tolower(*q) == c)
        {
            if(strncasecmp(p, q, protocol_length) == 0
            && (q[protocol_length] == '\0' || q[protocol_length] == ','))
            {
                valid = 1;
                break;
            }
        }
        /* move to the next protocol */
        for(; *q != '\0' && *q != ','; ++q);
        for(; *q == ','; ++q);
    }
    if(valid == 0)
    {
        return TLD_RESULT_BAD_URI;
    }
    if(uri[1] != '/' || uri[2] != '/')
    {
        return TLD_RESULT_BAD_URI;
    }
    uri += 3; /* skip the '://' */
 
    /* extract the complete domain name with sub-domains, etc. */
    username = nullptr;
    host = uri;
    for(; *uri != '/' && *uri != '\0'; ++uri)
    {
        if((unsigned char) *uri < ' ')
        {
            /* forbid control characters in domain name */
            return TLD_RESULT_BAD_URI;
        }
        if(*uri == '@')
        {
            if(username != nullptr)
            {
                /* two '@' signs is not possible */
                return TLD_RESULT_BAD_URI;
            }
            username = host;
            host = uri + 1;
        }
        else if((*uri & 0x80) != 0)
        {
            if((flags & VALID_URI_ASCII_ONLY) != 0)
            {
                /* only ASCII allowed by caller */
                return TLD_RESULT_BAD_URI;
            }
        }
        else if(*uri == ' ' || *uri == '+')
        {
            /* spaces not allowed in domain name */
            return TLD_RESULT_BAD_URI;
        }
        else if(*uri == '%')
        {
            /* the next two characters must be hex digits
             * note that the first digit must be at least 2 because
             * we do not allow control characters
             */
            if(((uri[1] < '2' || uri[1] > '9')
             && (uri[1] < 'a' || uri[1] > 'f')
             && (uri[1] < 'A' || uri[1] > 'F'))
            || ((uri[2] < '0' || uri[2] > '9')
             && (uri[2] < 'a' || uri[2] > 'f')
             && (uri[2] < 'A' || uri[2] > 'F')))
            {
                return TLD_RESULT_BAD_URI;
            }
            if(uri[1] == '2' && uri[2] == '0')
            {
                /* spaces not allowed in domain name */
                return TLD_RESULT_BAD_URI;
            }
            if(uri[1] >= '8' && (flags & VALID_URI_ASCII_ONLY) != 0)
            {
                /* only ASCII allowed by caller */
                return TLD_RESULT_BAD_URI;
            }
            /* skip the two digits right away */
            uri += 2;
        }
    }
    if(username != nullptr)
    {
        password = username;
        for(; *password != '@' && *password != ':'; ++password);
        if(*password == ':')
        {
            if((host - 1) - (password + 1) <= 0)
            {
                /* empty password are not acceptable */
                return TLD_RESULT_BAD_URI;
            }
        }
        if(password - username - 1 <= 0)
        {
            /* username cannot be empty */
            return TLD_RESULT_BAD_URI;
        }
    }
    for(port = host; *port != ':' && port < uri; ++port);
    if(*port == ':')
    {
        // we have a port, at this time it must be digits [0-9]+
        // (this is incorrect, a port could be a name such as "https";
        // also my current numeric test is invalid, it should make sure
        // it's in range: 0 to 65,535)
        //
        for(n = port + 1; *n >= '0' && *n <= '9'; ++n);
        if(n != uri || n == port + 1)
        {
            /* port is empty or includes invalid characters */
            return TLD_RESULT_BAD_URI;
        }
    }
 
    // check the path, query string, and anchor
    //
    query_string = nullptr;
    anchor = 0;
    for(a = uri; *a != '\0'; ++a)
    {
        if((unsigned char) *a < ' ')
        {
            // no control characters allowed
            //
            return TLD_RESULT_BAD_URI;
        }
        else if(*a == '+' || *a == ' ') // old space encoding is '+' (instead of %20)
        {
            if((flags & VALID_URI_NO_SPACES) != 0)
            {
                // spaces not allowed by caller
                //
                return TLD_RESULT_BAD_URI;
            }
        }
        else if(*a == '?')
        {
            if(anchor == 0)
            {
                if(query_string != nullptr)
                {
                    // ? cannot be used multiple times
                    //
                    return TLD_RESULT_BAD_URI;
                }
 
                query_string = a + 1;
            }
        }
        else if(*a == '&' && anchor == 0)
        {
            if(query_string == nullptr)
            {
                // '&' must be encoded if used before '?'
                //
                return TLD_RESULT_BAD_URI;
            }
 
            // the query_string pointer is used to verify that the variable
            // name is not empty
            //
            query_string = a + 1;
        }
        else if(*a == '=')
        {
            if(query_string != nullptr && a - query_string == 0)
            {
                // a query string variable name cannot be empty
                return TLD_RESULT_BAD_URI;
            }
        }
        else if(*a == '#')
        {
            query_string = nullptr;
            anchor = 1;
        }
        else if(*a == '%')
        {
            /* the next two digits must be hex
             * note that the first digit must be at least 2 because
             * we do not allow control characters
             */
            if(((a[1] < '2' || a[1] > '9')
             && (a[1] < 'a' || a[1] > 'f')
             && (a[1] < 'A' || a[1] > 'F'))
            || ((a[2] < '0' || a[2] > '9')
             && (a[2] < 'a' || a[2] > 'f')
             && (a[2] < 'A' || a[2] > 'F')))
            {
                return TLD_RESULT_BAD_URI;
            }
            if(a[1] == '2' && a[2] == '0' && (flags & VALID_URI_NO_SPACES) != 0)
            {
                /* spaces not allowed by caller */
                return TLD_RESULT_BAD_URI;
            }
            if(a[1] >= '8' && (flags & VALID_URI_ASCII_ONLY) != 0)
            {
                /* only ASCII allowed by caller */
                return TLD_RESULT_BAD_URI;
            }
            /* skip the two digits right away */
            a += 2;
        }
        else if((*a & 0x80) != 0)
        {
            if((flags & VALID_URI_ASCII_ONLY) != 0)
            {
                /* only ASCII allowed by caller */
                return TLD_RESULT_BAD_URI;
            }
        }
    }
 
    /* check the domain */
 
    length = (int) (port - host);
    if(length >= (int) (sizeof(domain) / sizeof(domain[0])))
    {
        /* sub-domains + domain + TLD is more than 255 characters?!
         * note that the host main include many %XX characters but
         * we ignore the fact here at this time; we could move this
         * test in the for() loop below though.
         */
        return TLD_RESULT_BAD_URI;
    }
    if(length == 0)
    {
        // although we could return TLD_RESULT_NULL it would not be
        // valid here because "http:///blah.com" is invalid, not nullptr
        //
        return TLD_RESULT_BAD_URI;
    }
    for(i = 0, j = 0; i < length; ++i, ++j)
    {
        if(host[i] == '%')
        {
            domain[j] = (char) (h2d(host[i + 1]) * 16 + h2d(host[i + 2]));
            i += 2; // skip the 2 digits
        }
        else
        {
            domain[j] = host[i];
        }
        /* TODO: check that characters are acceptable in a domain name (done above, right?) */
    }
    domain[j] = '\0';
    result = tld(domain, info);
    if(info->f_tld != nullptr)
    {
        if(info->f_offset == 0)
        {
            // if there is only a TLD, then it's invalid
            //
            return TLD_RESULT_BAD_URI;
        }
 
        // define the TLD inside the source string which "unfortunately"
        // is not null terminated by '\0'; also fix the offset since in
        // the complete URI the TLD is a bit further away
        //
        // note that `p` is the position at the start of the protocol
        // (at the start of 'uri' at the start)
        //
        info->f_tld = host + info->f_offset;
        info->f_offset = (int) (info->f_tld - p);
    }
    return result;
}
 
 
const char *tld_version()
{
    return LIBTLD_VERSION;
}
 
 
uint32_t tld_get_static_tlds_buffer_size()
{
    // The RIFF format saves the file size except the first 8 bytes in the
    // second uint32_t
    //
    // WARNING: the following fails if you are running on a big endian
    //          computer (the size will be swapped and the + 8 make it
    //          even harder to understand what happened...)
    //
    return reinterpret_cast<uint32_t const *>(tld_static_tlds)[1] + 8;
}
 
 
int tld_tag_count(struct tld_info *info)
{
    const struct tld_description *tld;
 
    if(info == nullptr
    || info->f_tld_index < 0)
    {
        return -1;
    }
 
    tld = tld_file_description(g_tld_file, info->f_tld_index);
    if(tld == nullptr)
    {
        return -1;
    }
 
    return tld->f_tags_count;
}
 
 
enum tld_result tld_get_tag(struct tld_info *info, int tag_idx, struct tld_tag_definition *tag)
{
    const struct tld_description *tld;
    const tld_tag *file_tag;
    enum tld_result result;
    uint32_t l;
 
    if(tag == nullptr)
    {
        return TLD_RESULT_NULL;
    }
    tag->f_name = nullptr;
    tag->f_name_length = 0;
    tag->f_value = nullptr;
    tag->f_value_length = 0;
 
    if(info == nullptr)
    {
        return TLD_RESULT_NULL;
    }
 
    if(info->f_tld_index < 0)
    {
        return TLD_RESULT_INVALID;
    }
 
    result = tld_load_tlds_if_not_loaded();
    if(result != TLD_RESULT_SUCCESS)
    {
        return result;
    }
 
    tld = tld_file_description(g_tld_file, info->f_tld_index);
    if(tld == nullptr)
    {
        return TLD_RESULT_NOT_FOUND;
    }
 
    file_tag = tld_file_tag(g_tld_file, tld->f_tags + tag_idx * 2);
    if(file_tag == nullptr)
    {
        return TLD_RESULT_NOT_FOUND;
    }
 
    tag->f_name = tld_file_string(g_tld_file, file_tag->f_tag_name, &l);
    tag->f_name_length = l;
 
    tag->f_value = tld_file_string(g_tld_file, file_tag->f_tag_value, &l);
    tag->f_value_length = l;
 
    if(tag->f_name == nullptr
    || tag->f_value == nullptr)
    {
        return TLD_RESULT_NOT_FOUND;
    }
 
    return TLD_RESULT_SUCCESS;
}
 
 
 
#ifdef __cplusplus
}
#endif
 
// vim: ts=4 sw=4 et