tld.c

Go to the documentation of this file.

/* TLD library -- TLD, domain name, and sub-domain extraction
 * Copyright (C) 2011  Made to Order Software Corp.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "tld.h"
#include "tld_data.h"
#include <malloc.h>
#include <limits.h>



int cmp(const char *a, const char *b, int n)
{
    /* n represents the maximum number of characters to check in b */
    while(n > 0 && *a != '\0')
    {
        if(*a < *b)
        {
            return -1;
        }
        if(*a > *b)
        {
            return 1;
        }
        ++a;
        ++b;
        --n;
    }
    if(*a == '\0')
    {
        if(n > 0)
        {
            return -1;
        }
        return 0;
    }
    /* in this case n == 0 so a is larger */
    return 1;
}

int search(int i, int j, const char *domain, int n)
{
    int p, r;

    while(i < j)
    {
        p = (j - i) / 2 + i;
        const struct tld_description *tld = tld_descriptions + p;
        r = cmp(tld->f_tld, domain, n);
        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 -1;
}


enum tld_result tld(const char *uri, struct tld_info *info)
{
    const char *end = uri;
    const char **level_ptr;
    int level = 0, start_level, i, r, p;

    /* set defaults in the info structure */
    info->f_category = TLD_CATEGORY_UNDEFINED;
    info->f_status = TLD_STATUS_UNDEFINED;
    info->f_country = (const char *) 0;
    info->f_tld = (const char *) 0;
    info->f_offset = -1;

    if(uri == (const char *) 0 || uri[0] == '\0')
    {
        return TLD_RESULT_NULL;
    }

    /* Note: We never free the pointer, not necessary since we
     *       just quit once we're done; it is released then. */
    level_ptr = malloc(sizeof(const char *) * tld_max_level);

    while(*end != '\0')
    {
        if(*end == '.')
        {
            if(level >= tld_max_level)
            {
                /* At this point the maximum number of levels in the
                 * TLDs is 5
                 */
                for(i = 1; i < tld_max_level; ++i)
                {
                    level_ptr[i - 1] = level_ptr[i];
                }
                level_ptr[tld_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;
            }
        }
        ++end;
    }
    /* if level is not at least 1 then there are no period */
    if(level == 0)
    {
        /* no TLD */
        return TLD_RESULT_NO_TLD;
    }

    start_level = level;
    --level;
    r = search(tld_start_offset, tld_end_offset,
                level_ptr[level] + 1, end - level_ptr[level] - 1);
    if(r == -1)
    {
        /* unknown */
        return TLD_RESULT_NOT_FOUND;
    }

    /* check for the next level if there is one */
    p = r;
    while(level > 0 && tld_descriptions[r].f_start_offset != USHRT_MAX)
    {
        r = search(tld_descriptions[r].f_start_offset,
                tld_descriptions[r].f_end_offset,
                level_ptr[level - 1] + 1,
                level_ptr[level] - level_ptr[level - 1] - 1);
        if(r == -1)
        {
            /* we are done, return the previous level */
            break;
        }
        p = r;
        --level;
    }

    /* did we hit an exception? */
    if(tld_descriptions[p].f_status == TLD_STATUS_EXCEPTION)
    {
        /* return the actual TLD and not the exception */
        p = tld_descriptions[p].f_exception_apply_to;
        ++level;
//fprintf(stderr, "returning %d/%d (%d/%d)\n", p, tld_descriptions[p].f_exception_level, level, start_level);
        level = start_level - tld_descriptions[p].f_exception_level;
    }

    /* return a valid result */
    info->f_category = tld_descriptions[p].f_category;
    info->f_status = tld_descriptions[p].f_status;
    info->f_country = tld_descriptions[p].f_country;
    info->f_tld = level_ptr[level];
    info->f_offset = level_ptr[level] - uri;

    return info->f_status == TLD_STATUS_VALID
                ? TLD_RESULT_SUCCESS
                : TLD_RESULT_INVALID;
}


const char *tld_version()
{
    return LIBTLD_VERSION;
}


/* vim: ts=4 sw=4
 */