spf_dns_zone.c

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of either:
 *
 *   a) The GNU Lesser General Public License as published by the Free
 *      Software Foundation; either version 2.1, or (at your option) any
 *      later version,
 *
 *   OR
 *
 *   b) The two-clause BSD license.
 *
 * These licenses can be found with the distribution in the file LICENSES
 */

#include "spf_sys_config.h"

#ifdef STDC_HEADERS
# include <stdio.h>        /* stdin / stdout */
# include <stdlib.h>       /* malloc / free */
#endif


#ifdef HAVE_STRING_H
# include <string.h>       /* strstr / strdup */
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>       /* strstr / strdup */
# endif
#endif

#ifdef HAVE_MEMORY_H
#include <memory.h>
#endif
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#ifdef HAVE_NETDB_H
# include <netdb.h>
#endif
#include <ctype.h>


#include "spf.h"
#include "spf_dns.h"
#include "spf_internal.h"
#include "spf_dns_internal.h"
#include "spf_dns_zone.h"


typedef struct
{
    SPF_dns_rr_t        **zone;
    int                           num_zone;
    int                           zone_buf_len;
    SPF_dns_rr_t         *nxdomain;
} SPF_dns_zone_config_t;



static inline SPF_dns_zone_config_t *SPF_voidp2spfhook( void *hook )
    { return (SPF_dns_zone_config_t *)hook; }
static inline void *SPF_spfhook2voidp( SPF_dns_zone_config_t *spfhook )
    { return (void *)spfhook; }




static SPF_dns_rr_t *
SPF_dns_zone_find(SPF_dns_server_t *spf_dns_server,
                                const char *domain, ns_type rr_type,
                                int exact)
{
    SPF_dns_zone_config_t       *spfhook;
    int         i;

        spfhook = SPF_voidp2spfhook(spf_dns_server->hook);

        if (spf_dns_server->debug)
                SPF_debugf("zone: Searching for RR %s (%d)", domain, rr_type);

        /* If the record we want or are adding starts with '*.' then it must match
         * exactly. */
    if (exact || strncmp(domain, "*.", 2) == 0) {
                for (i = 0; i < spfhook->num_zone; i++) {
                        if (spfhook->zone[i]->rr_type == rr_type
                                        && strcasecmp(spfhook->zone[i]->domain, domain) == 0)
                                return spfhook->zone[i];
                }
                if (spf_dns_server->debug)
                        SPF_debugf("zone: Exact not found");
    }
        else {
                /* We are looking up a record, so lookup-matching semantics apply. */
                size_t  domain_len = strlen(domain);
                /* Real resolver would strip trailing '.', so we have to.
                 * FIXME: doesn't handle wildcard cases - we don't use
                 * those in test suite. */
                if (domain_len && domain[domain_len - 1] == '.')
                        --domain_len;

                for (i = 0; i < spfhook->num_zone; i++) {
                        if (spfhook->zone[i]->rr_type != rr_type
                                        && spfhook->zone[i]->rr_type != ns_t_any) {
                                if (spf_dns_server->debug)
                                        SPF_debugf("zone: Ignoring record rrtype %d",
                                                        spfhook->zone[i]->rr_type);
                                continue;
                        }

                        if (strncmp(spfhook->zone[i]->domain, "*.", 2) == 0) {
                                size_t  zdomain_len = strlen(spfhook->zone[i]->domain) - 2;
                                if ((zdomain_len <= domain_len)
                                         && strncasecmp(
                                                                spfhook->zone[i]->domain + 2,
                                                                domain + (domain_len - zdomain_len),
                                                                zdomain_len) == 0)
                                        return spfhook->zone[i];
                        }
                        else if (strncasecmp(
                                                spfhook->zone[i]->domain,
                                                domain,
                                                domain_len) == 0 &&
                                        strlen(spfhook->zone[i]->domain) == domain_len) {
                                return spfhook->zone[i];
                        }
                }
                if (spf_dns_server->debug)
                        SPF_debugf("zone: Non-exact not found");
        }

    return NULL;
}



static SPF_dns_rr_t *
SPF_dns_zone_lookup(SPF_dns_server_t *spf_dns_server,
                                const char *domain, ns_type rr_type, int should_cache)
{
    SPF_dns_zone_config_t       *spfhook;
    SPF_dns_rr_t                        *spfrr;

        spfrr = SPF_dns_zone_find(spf_dns_server, domain, rr_type, FALSE);
        if (spfrr) {
                SPF_dns_rr_dup(&spfrr, spfrr);
                return spfrr;
        }

        if (spf_dns_server->layer_below) {
                return SPF_dns_lookup(spf_dns_server->layer_below,
                                                domain, rr_type, should_cache);
        }

        spfhook = SPF_voidp2spfhook(spf_dns_server->hook);
        SPF_dns_rr_dup(&spfrr, spfhook->nxdomain);

        return spfrr;
}


SPF_errcode_t
SPF_dns_zone_add_str(SPF_dns_server_t *spf_dns_server,
                                const char *domain, ns_type rr_type,
                                SPF_dns_stat_t herrno, const char *data)
{
    SPF_dns_zone_config_t       *spfhook;
    SPF_dns_rr_t                        *spfrr;

    int         err;
    int         cnt;

        if (rr_type == ns_t_any) {
                if (data)
                        SPF_error("RR type ANY can not have data.");
                if (herrno == NETDB_SUCCESS)
                        SPF_error("RR type ANY must return a DNS error code.");
        }

        spfhook = SPF_voidp2spfhook(spf_dns_server->hook);

    /* try to find an existing record */
    spfrr = SPF_dns_zone_find(spf_dns_server, domain, rr_type, TRUE);

    /* create a new record */
        if ( spfrr == NULL ) {
                /* First make sure we have space for it. */
                if ( spfhook->num_zone == spfhook->zone_buf_len ) {
                        int                             new_len;
                        SPF_dns_rr_t    **new_zone;
                        int                             i;

                        new_len = spfhook->zone_buf_len
                                        + (spfhook->zone_buf_len >> 2) + 4;
                        new_zone = realloc( spfhook->zone,
                                        new_len * sizeof( *new_zone ) );
                        if ( new_zone == NULL )
                                return SPF_E_NO_MEMORY;

                        for( i = spfhook->zone_buf_len; i < new_len; i++ )
                                new_zone[i] = NULL;

                        spfhook->zone_buf_len = new_len;
                        spfhook->zone = new_zone;
                }

                /* Now make the new record. */
                spfrr = SPF_dns_rr_new_init(spf_dns_server,
                                                domain, rr_type, 24*60*60, herrno);
                if (spfrr == NULL)
                        return SPF_E_NO_MEMORY;
                spfhook->zone[spfhook->num_zone] = spfrr;
                spfhook->num_zone++;

                /* We succeeded with the add, but with no data. */
                if (herrno != NETDB_SUCCESS)
                        return SPF_E_SUCCESS;
        }

#define SPF_RR_TRY_REALLOC(rr, i, s) do { \
                        SPF_errcode_t __err = SPF_dns_rr_buf_realloc(rr, i, s); \
                        if (__err != SPF_E_SUCCESS) return __err; \
                } while(0)

    /*
     * initialize stuff
     */
    cnt = spfrr->num_rr;

        switch (rr_type) {
                case ns_t_a:
                        SPF_RR_TRY_REALLOC(spfrr, cnt, sizeof( spfrr->rr[cnt]->a ));
                        err = inet_pton( AF_INET, data, &spfrr->rr[cnt]->a );
                        if ( err <= 0 )
                                return SPF_E_INVALID_IP4;
                        break;

                case ns_t_aaaa:
                        SPF_RR_TRY_REALLOC(spfrr, cnt, sizeof( spfrr->rr[cnt]->aaaa ));
                        err = inet_pton( AF_INET6, data, &spfrr->rr[cnt]->aaaa );
                        if ( err <= 0 )
                                return SPF_E_INVALID_IP6;
                        break;

                case ns_t_mx:
                        /* Caller passes priority<sp>domain.  We don't use or
                         * store priority, so discard it. */
                        while (isdigit(*data)) data++;
                        while (isspace(*data)) data++;
                        SPF_RR_TRY_REALLOC(spfrr, cnt, strlen( data ) + 1);
                        strcpy( spfrr->rr[cnt]->mx, data );
                        break;

                case ns_t_txt:
                case ns_t_spf:
                        SPF_RR_TRY_REALLOC(spfrr, cnt, strlen( data ) + 1);
                        strcpy( spfrr->rr[cnt]->txt, data );
                        break;

                case ns_t_ptr:
                        SPF_RR_TRY_REALLOC(spfrr, cnt, strlen( data ) + 1);
                        strcpy( spfrr->rr[cnt]->ptr, data );
                        break;

                case ns_t_any:
                        if ( data )
                                SPF_error( "RR type ANY can not have data.");
                        if ( herrno == NETDB_SUCCESS )
                                SPF_error( "RR type ANY must return a DNS error code.");
                        SPF_error( "RR type ANY can not have multiple RR.");
                        break;

                default:
                        SPF_error( "Invalid RR type" );
                        break;
        }

    spfrr->num_rr = cnt + 1;

    return SPF_E_SUCCESS;
}



static void
SPF_dns_zone_free(SPF_dns_server_t *spf_dns_server)
{
    SPF_dns_zone_config_t       *spfhook;
    int                         i;

        SPF_ASSERT_NOTNULL(spf_dns_server);
        spfhook = SPF_voidp2spfhook(spf_dns_server->hook);

        if (spfhook) {
                if (spfhook->zone) {
                        for (i = 0; i < spfhook->zone_buf_len; i++) {
                                if (spfhook->zone[i])
                                        SPF_dns_rr_free(spfhook->zone[i]);
                        }
                        free(spfhook->zone);
                }
                if (spfhook->nxdomain)
                        SPF_dns_rr_free(spfhook->nxdomain);
                free(spfhook);
        }

    free(spf_dns_server);
}

SPF_dns_server_t *
SPF_dns_zone_new(SPF_dns_server_t *layer_below,
                                const char *name, int debug)
{
        SPF_dns_server_t                *spf_dns_server;
    SPF_dns_zone_config_t       *spfhook;

    spf_dns_server = malloc(sizeof(SPF_dns_server_t));
    if (spf_dns_server == NULL)
                return NULL;
        memset(spf_dns_server, 0, sizeof(SPF_dns_server_t));

    spf_dns_server->hook = malloc(sizeof(SPF_dns_zone_config_t));
    if (spf_dns_server->hook == NULL) {
                free(spf_dns_server);
                return NULL;
    }
        memset(spf_dns_server->hook, 0, sizeof(SPF_dns_zone_config_t));

    if (name ==  NULL)
                name = "zone";

    spf_dns_server->destroy      = SPF_dns_zone_free;
    spf_dns_server->lookup       = SPF_dns_zone_lookup;
    spf_dns_server->get_spf      = NULL;
    spf_dns_server->get_exp      = NULL;
    spf_dns_server->add_cache    = NULL;
    spf_dns_server->layer_below  = layer_below;
        spf_dns_server->name         = name;
        spf_dns_server->debug        = debug;

    spfhook = SPF_voidp2spfhook(spf_dns_server->hook);

    spfhook->zone_buf_len = 32;
    spfhook->num_zone = 0;
    spfhook->zone = calloc(spfhook->zone_buf_len, sizeof(*spfhook->zone));

    if (spfhook->zone == NULL) {
                free(spfhook);
                free(spf_dns_server);
                return NULL;
    }

        /* XXX This might have to return NO_DATA sometimes. */
    spfhook->nxdomain = SPF_dns_rr_new_init(spf_dns_server,
                                        "", ns_t_any, 24 * 60 * 60, HOST_NOT_FOUND);
        if (spfhook->nxdomain == NULL) {
                free(spfhook->zone);
                free(spfhook);
                free(spf_dns_server);
                return NULL;
        }

    return spf_dns_server;
}

---