lib/dns/byaddr.c

	byaddr.c revision 499b34cea04a46823d003d4c0520c8b03e8513cb
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews/*
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * Copyright (C) 2000, 2001  Internet Software Consortium.
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews *
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * Permission to use, copy, modify, and distribute this software for any
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * purpose with or without fee is hereby granted, provided that the above
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * copyright notice and this permission notice appear in all copies.
ffd297db793b3efa3854f32f443b9f79e0417f2cAutomatic Updater *
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt */
75b8de87879ad017c9cd2ffc328e5d2391d16e99Evan Hunt
/* $Id: byaddr.c,v 1.28 2001/01/09 21:50:39 bwelling Exp $ */

#include <config.h>

#include <isc/mem.h>
#include <isc/netaddr.h>
#include <isc/string.h>     /* Required for HP/UX (and others?) */
#include <isc/task.h>
#include <isc/util.h>

#include <dns/byaddr.h>
#include <dns/db.h>
#include <dns/events.h>
#include <dns/lookup.h>
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/resolver.h>
#include <dns/result.h>
#include <dns/view.h>

/*
 * XXXRTH  We could use a static event...
 */

struct dns_byaddr {
    /* Unlocked. */
    unsigned int        magic;
    isc_mem_t *     mctx;
    isc_mutex_t     lock;
    dns_fixedname_t     name;
    /* Locked by lock. */
    unsigned int        options;
    dns_lookup_t *      lookup;
    isc_task_t *        task;
    dns_byaddrevent_t * event;
    isc_boolean_t       canceled;
};

#define BYADDR_MAGIC            0x42794164U /* ByAd. */
#define VALID_BYADDR(b)         ((b) != NULL && \
                     (b)->magic == BYADDR_MAGIC)

#define MAX_RESTARTS 16

static char hex_digits[] = {
    '0', '1', '2', '3', '4', '5', '6', '7',
    '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};

isc_result_t
dns_byaddr_createptrname(isc_netaddr_t *address, isc_boolean_t nibble,
             dns_name_t *name)
{
    char textname[128];
    unsigned char *bytes;
    int i;
    char *cp;
    isc_buffer_t buffer;
    unsigned int len;

    REQUIRE(address != NULL);

    /*
     * We create the text representation and then convert to a
     * dns_name_t.  This is not maximally efficient, but it keeps all
     * of the knowledge of wire format in the dns_name_ routines.
     */

    bytes = (unsigned char *)(&address->type);
    if (address->family == AF_INET) {
        (void)sprintf(textname, "%u.%u.%u.%u.in-addr.arpa.",
                  (bytes[3] & 0xff),
                  (bytes[2] & 0xff),
                  (bytes[1] & 0xff),
                  (bytes[0] & 0xff));
    } else if (address->family == AF_INET6) {
        if (nibble) {
            cp = textname;
            for (i = 15; i >= 0; i--) {
                *cp++ = hex_digits[bytes[i] & 0x0f];
                *cp++ = '.';
                *cp++ = hex_digits[(bytes[i] >> 4) & 0x0f];
                *cp++ = '.';
            }
            strcpy(cp, "ip6.int.");
        } else {
            cp = textname;
            *cp++ = '\\';
            *cp++ = '[';
            *cp++ = 'x';
            for (i = 0; i < 16; i += 2) {
                *cp++ = hex_digits[(bytes[i] >> 4) & 0x0f];
                *cp++ = hex_digits[bytes[i] & 0x0f];
                *cp++ = hex_digits[(bytes[i+1] >> 4) & 0x0f];
                *cp++ = hex_digits[bytes[i+1] & 0x0f];
            }
            strcpy(cp, "].ip6.arpa.");
        }
    } else
        return (ISC_R_NOTIMPLEMENTED);

    len = (unsigned int)strlen(textname);
    isc_buffer_init(&buffer, textname, len);
    isc_buffer_add(&buffer, len);
    return (dns_name_fromtext(name, &buffer, dns_rootname,
                  ISC_FALSE, NULL));
}

static inline isc_result_t
copy_ptr_targets(dns_byaddr_t *byaddr, dns_rdataset_t *rdataset) {
    isc_result_t result;
    dns_name_t *name;
    dns_rdata_t rdata = DNS_RDATA_INIT;

    /*
     * The caller must be holding the byaddr's lock.
     */

    result = dns_rdataset_first(rdataset);
    while (result == ISC_R_SUCCESS) {
        dns_rdata_ptr_t ptr;
        dns_rdataset_current(rdataset, &rdata);
        result = dns_rdata_tostruct(&rdata, &ptr, NULL);
        if (result != ISC_R_SUCCESS)
            return (result);
        name = isc_mem_get(byaddr->mctx, sizeof *name);
        if (name == NULL) {
            dns_rdata_freestruct(&ptr);
            return (ISC_R_NOMEMORY);
        }
        dns_name_init(name, NULL);
        result = dns_name_dup(&ptr.ptr, byaddr->mctx, name);
        dns_rdata_freestruct(&ptr);
        if (result != ISC_R_SUCCESS) {
            isc_mem_put(byaddr->mctx, name, sizeof *name);
            return (ISC_R_NOMEMORY);
        }
        ISC_LIST_APPEND(byaddr->event->names, name, link);
        dns_rdata_reset(&rdata);
        result = dns_rdataset_next(rdataset);
    }
    if (result == ISC_R_NOMORE)
        result = ISC_R_SUCCESS;

    return (result);
}

static void
lookup_done(isc_task_t *task, isc_event_t *event) {
    dns_byaddr_t *byaddr = event->ev_arg;
    dns_lookupevent_t *levent;
    isc_result_t result;

    REQUIRE(event->ev_type == DNS_EVENT_LOOKUPDONE);
    REQUIRE(VALID_BYADDR(byaddr));
    REQUIRE(byaddr->task == task);

    UNUSED(task);

    levent = (dns_lookupevent_t *)event;

    if (levent->result == ISC_R_SUCCESS) {
        result = copy_ptr_targets(byaddr, levent->rdataset);
        byaddr->event->result = result;
    } else
        byaddr->event->result = levent->result;
    isc_event_free(&event);
    isc_task_sendanddetach(&byaddr->task, (isc_event_t **)&byaddr->event);
}

static void
bevent_destroy(isc_event_t *event) {
    dns_byaddrevent_t *bevent;
    dns_name_t *name, *next_name;
    isc_mem_t *mctx;

    REQUIRE(event->ev_type == DNS_EVENT_BYADDRDONE);
    mctx = event->ev_destroy_arg;
    bevent = (dns_byaddrevent_t *)event;

    for (name = ISC_LIST_HEAD(bevent->names);
         name != NULL;
         name = next_name) {
        next_name = ISC_LIST_NEXT(name, link);
        ISC_LIST_UNLINK(bevent->names, name, link);
        dns_name_free(name, mctx);
        isc_mem_put(mctx, name, sizeof *name);
    }
    isc_mem_put(mctx, event, event->ev_size);
}

isc_result_t
dns_byaddr_create(isc_mem_t *mctx, isc_netaddr_t *address, dns_view_t *view,
          unsigned int options, isc_task_t *task,
          isc_taskaction_t action, void *arg, dns_byaddr_t **byaddrp)
{
    isc_result_t result;
    dns_byaddr_t *byaddr;
    isc_event_t *ievent;

    byaddr = isc_mem_get(mctx, sizeof *byaddr);
    if (byaddr == NULL)
        return (ISC_R_NOMEMORY);
    byaddr->mctx = mctx;
    byaddr->options = options;

    byaddr->event = isc_mem_get(mctx, sizeof *byaddr->event);
    if (byaddr->event == NULL) {
        result = ISC_R_NOMEMORY;
        goto cleanup_byaddr;
    }
    ISC_EVENT_INIT(byaddr->event, sizeof *byaddr->event, 0, NULL,
               DNS_EVENT_BYADDRDONE, action, arg, byaddr,
               bevent_destroy, mctx);
    byaddr->event->result = ISC_R_FAILURE;
    ISC_LIST_INIT(byaddr->event->names);

    byaddr->task = NULL;
    isc_task_attach(task, &byaddr->task);

    result = isc_mutex_init(&byaddr->lock);
    if (result != ISC_R_SUCCESS)
        goto cleanup_event;

    dns_fixedname_init(&byaddr->name);

    result = dns_byaddr_createptrname(address,
              ISC_TF(byaddr->options & DNS_BYADDROPT_IPV6NIBBLE),
              dns_fixedname_name(&byaddr->name));
    if (result != ISC_R_SUCCESS)
        goto cleanup_lock;

    byaddr->lookup = NULL;
    result = dns_lookup_create(mctx, dns_fixedname_name(&byaddr->name),
                   dns_rdatatype_ptr, view, 0, task,
                   lookup_done, byaddr, &byaddr->lookup);
    if (result != ISC_R_SUCCESS)
        goto cleanup_lock;

    byaddr->canceled = ISC_FALSE;
    byaddr->magic = BYADDR_MAGIC;

    *byaddrp = byaddr;

    return (ISC_R_SUCCESS);

 cleanup_lock:
    DESTROYLOCK(&byaddr->lock);

 cleanup_event:
    ievent = (isc_event_t *)byaddr->event;
    isc_event_free(&ievent);
    byaddr->event = NULL;

    isc_task_detach(&byaddr->task);

 cleanup_byaddr:
    isc_mem_put(mctx, byaddr, sizeof *byaddr);

    return (result);
}

void
dns_byaddr_cancel(dns_byaddr_t *byaddr) {
    REQUIRE(VALID_BYADDR(byaddr));

    LOCK(&byaddr->lock);

    if (!byaddr->canceled) {
        byaddr->canceled = ISC_TRUE;
        if (byaddr->lookup != NULL)
            dns_lookup_cancel(byaddr->lookup);
    }

    UNLOCK(&byaddr->lock);
}

void
dns_byaddr_destroy(dns_byaddr_t **byaddrp) {
    dns_byaddr_t *byaddr;

    REQUIRE(byaddrp != NULL);
    byaddr = *byaddrp;
    REQUIRE(VALID_BYADDR(byaddr));
    REQUIRE(byaddr->event == NULL);
    REQUIRE(byaddr->task == NULL);
    dns_lookup_destroy(&byaddr->lookup);

    DESTROYLOCK(&byaddr->lock);
    byaddr->magic = 0;
    isc_mem_put(byaddr->mctx, byaddr, sizeof *byaddr);

    *byaddrp = NULL;
}