libresolv-19.tar.gz

[apple/libresolv.git] / dns_util.c

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * "Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
 * Reserved.  This file contains Original Code and/or Modifications of
 * Original Code as defined in and that are subject to the Apple Public
 * Source License Version 1.0 (the 'License').  You may not use this file
 * except in compliance with the License.  Please obtain a copy of the
 * License at http://www.apple.com/publicsource and read it before using
 * this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License."
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <sys/dir.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <ifaddrs.h>
#include <net/if.h>
#include <pthread.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include "dns.h"
#include "dns_util.h"
#include "dns_private.h"
#include "res_private.h"

#define DNS_RESOLVER_DIR "/etc/resolver"

#define DNS_PRIVATE_HANDLE_TYPE_SUPER 0
#define DNS_PRIVATE_HANDLE_TYPE_PLAIN 1
#define DNS_DEFAULT_RECEIVE_SIZE 8192
#define DNS_MAX_RECEIVE_SIZE 65536

#define SDNS_DEFAULT_STAT_LATENCY 10

#define DNS_FLAGS_QR_MASK  0x8000
#define DNS_FLAGS_QR_QUERY 0x0000

#define DNS_FLAGS_OPCODE_MASK    0x7800

#define DNS_FLAGS_RCODE_MASK 0x000f

#define DNS_FLAGS_AA 0x0400
#define DNS_FLAGS_TC 0x0200
#define DNS_FLAGS_RD 0x0100
#define DNS_FLAGS_RA 0x0080

#define DNS_SOCK_UDP 0
#define DNS_SOCK_TCP_UNCONNECTED 1
#define DNS_SOCK_TCP_CONNECTED 2

#define INET_NTOP_AF_INET_OFFSET 4
#define INET_NTOP_AF_INET6_OFFSET 8

#define MAXPACKET 1024

extern void res_client_close(res_state res);
extern int __res_nquery(res_state statp, const char *name, int class, int type, u_char *answer, int anslen);
extern int dns_res_send(res_state statp, const u_char *buf, int buflen, u_char *ans, int *anssiz, struct sockaddr *from, int *fromlen);
extern void _check_cache(sdns_handle_t *sdns);
extern int _sdns_search(sdns_handle_t *sdns, const char *name, uint32_t class, uint32_t type, uint32_t fqdn, uint32_t recurse, char *buf, uint32_t len, struct sockaddr *from, uint32_t *fromlen, int *min);
extern int _pdns_search(sdns_handle_t *sdns, pdns_handle_t *pdns, const char *name, uint32_t class, uint32_t type, char *buf, uint32_t len, struct sockaddr *from, uint32_t *fromlen);
static pthread_mutex_t _dnsPrintLock = PTHREAD_MUTEX_INITIALIZER;

static void
_dns_print_lock(void)
{
        pthread_mutex_lock(&_dnsPrintLock);
}

static void
_dns_print_unlock(void)
{
        pthread_mutex_unlock(&_dnsPrintLock);
}


static uint8_t
_dns_parse_uint8(char **p)
{
        uint8_t v;

        v = (uint8_t)**p;
        *p += 1;
        return v;
}

static uint16_t
_dns_parse_uint16(char **p)
{
        uint16_t *x, v;

        x = (uint16_t *)*p;
        v = ntohs(*x);
        *p += 2;
        return v;
}

static uint32_t
_dns_parse_uint32(char **p)
{
        uint32_t *x, v;

        x = (uint32_t *)*p;
        v = ntohl(*x);
        *p += 4;
        return v;
}

static uint8_t
_dns_cname_length(char *s)
{
        uint8_t l;

        if (s == NULL) return 1;
        l = strlen(s);
        while ((s[l - 1] == '.') && (l > 1)) l--;
        return l;
}

static void
_dns_insert_cname(char *s, char *p)
{
        int i;
        uint8_t len, dlen;

        if (s == NULL)
        {
                *p = 0;
                return;
        }

        if (!strcmp(s, "."))
        {
                p[0] = 1;
                p[1] = '.';
                p[2] = 0;
                return;
        }

        len = _dns_cname_length(s);

        p[0] = '.';
        memmove(p + 1, s, len);
        p[len + 1] = '.';

        dlen = 0;

        for (i = len + 1; i >= 0; i--)
        {
                if (p[i] == '.')
                {
                        p[i] = dlen;
                        dlen = 0;
                }
                else dlen++;
        }
}

static char *
_dns_parse_string(const char *p, char **x, int32_t *remaining)
{
        char *str;
        uint8_t len;

        if (*remaining < 1) return NULL;
        *remaining -= 1;

        len = (uint8_t)**x;
        *x += 1;

        if (*remaining < len) return NULL;
        *remaining -= len;

        str = malloc(len + 1);
        memmove(str, *x, len);
        str[len] = '\0';
        *x += len;

        return str;
}

static char *
_dns_parse_domain_name(const char *p, char **x, int32_t *remaining)
{
        uint8_t *v8;
        uint16_t *v16, skip;
        uint16_t i, j, dlen, len;
        int more, compressed;
        char *name, *start, *y, *z;

        if (*remaining < 1) return NULL;

        z = *x + *remaining;
        start = *x;
        compressed = 0;
        more = 1;
        name = malloc(1);
        name[0] = '\0';
        len = 1;
        j = 0;
        skip = 0;

        while (more == 1)
        {
                if ((*x + 1) > z)
                {
                        free(name);
                        return NULL;
                }

                v8 = (uint8_t *)*x;
                dlen = *v8;

                if ((dlen & 0xc0) == 0xc0)
                {
                        if ((*x + 2) > z)
                        {
                                free(name);
                                return NULL;
                        }

                        v16 = (uint16_t *)*x;

                        y = (char *)p + (ntohs(*v16) & 0x3fff);
                        if ((*x == y) || (y > z))
                        {
                                free(name);
                                return NULL;
                        }

                        *x = y;
                        if (compressed == 0) skip += 2;
                        compressed = 1;
                        continue;
                }

                if ((*x + 1) > z)
                {
                        free(name);
                        return NULL;
                }

                *x += 1;

                if (dlen > 0)
                {
                        len += dlen;
                        name = realloc(name, len);
                }

                if ((*x + dlen) > z)
                {
                        free(name);
                        return NULL;
                }

                for (i = 0; i < dlen; i++)
                {
                        name[j++] = **x;
                        *x += 1;
                }

                name[j] = '\0';
                if (compressed == 0) skip += (dlen + 1);

                if (dlen == 0) more = 0;
                else
                {
                        if ((*x + 1) > z)
                        {
                                free(name);
                                return NULL;
                        }

                        v8 = (uint8_t *)*x;
                        if (*v8 != 0)
                        {
                                len += 1;
                                name = realloc(name, len);
                                name[j++] = '.';
                                name[j] = '\0';
                        }
                }
        }

        if ((start + skip) > z)
        {
                free(name);
                return NULL;
        }

        *x = start + skip;
        *remaining -= skip;

        return name;
}

dns_resource_record_t *
_dns_parse_resource_record_internal(const char *p, char **x, int32_t *remaining)
{
        uint32_t size, bx, mi;
        uint16_t rdlen;
        uint8_t byte, i;
        dns_resource_record_t *r;
        char *eor;

        if (*remaining < 1) return NULL;

        r = (dns_resource_record_t *)calloc(1, sizeof(dns_resource_record_t));

        r->name = _dns_parse_domain_name(p, x, remaining);
        if (r->name == NULL)
        {
                free(r);
                return NULL;
        }

        if (*remaining < 10)
        {
                free(r);
                return NULL;
        }

        r->dnstype = _dns_parse_uint16(x);
        r->dnsclass = _dns_parse_uint16(x);
        r->ttl = _dns_parse_uint32(x);
        rdlen = _dns_parse_uint16(x);

        *remaining -= 10;

        eor = *x;
        r->data.A = NULL;

        switch (r->dnstype)
        {
                case ns_t_a:
                        if (*remaining < 4)
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= 4;

                        size = sizeof(dns_address_record_t);
                        r->data.A = (dns_address_record_t *)calloc(1, size);
                        r->data.A->addr.s_addr = htonl(_dns_parse_uint32(x));
                        break;

                case ns_t_aaaa:
                        if (*remaining < 16)
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= 16;

                        size = sizeof(dns_in6_address_record_t);
                        r->data.AAAA = (dns_in6_address_record_t *)calloc(1, size);
                        r->data.AAAA->addr.__u6_addr.__u6_addr32[0] = htonl(_dns_parse_uint32(x));
                        r->data.AAAA->addr.__u6_addr.__u6_addr32[1] = htonl(_dns_parse_uint32(x));
                        r->data.AAAA->addr.__u6_addr.__u6_addr32[2] = htonl(_dns_parse_uint32(x));
                        r->data.AAAA->addr.__u6_addr.__u6_addr32[3] = htonl(_dns_parse_uint32(x));
                        break;

                case ns_t_ns:
                case ns_t_md:
                case ns_t_mf:
                case ns_t_cname:
                case ns_t_mb:
                case ns_t_mg:
                case ns_t_mr:
                case ns_t_ptr:
                        size = sizeof(dns_domain_name_record_t);
                        r->data.CNAME = (dns_domain_name_record_t *)calloc(1,size);
                        r->data.CNAME->name = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.CNAME->name == NULL)
                        {
                                free(r->data.CNAME);
                                free(r);
                                return NULL;
                        }
                        break;

                case ns_t_soa:
                        size = sizeof(dns_SOA_record_t);
                        r->data.SOA = (dns_SOA_record_t *)calloc(1, size);

                        r->data.SOA->mname = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.SOA->mname == NULL)
                        {
                                free(r->data.SOA);
                                free(r);
                                return NULL;
                        }

                        r->data.SOA->rname = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.SOA->rname == NULL)
                        {
                                free(r->data.SOA->mname);
                                free(r->data.SOA);
                                free(r);
                                return NULL;
                        }

                        if (*remaining < 20) 
                        {
                                free(r->data.SOA->mname);
                                free(r->data.SOA->rname);
                                free(r->data.SOA);
                                free(r);
                                return NULL;
                        }

                        *remaining -= 20;

                        r->data.SOA->serial = _dns_parse_uint32(x);
                        r->data.SOA->refresh = _dns_parse_uint32(x);
                        r->data.SOA->retry = _dns_parse_uint32(x);
                        r->data.SOA->expire = _dns_parse_uint32(x);
                        r->data.SOA->minimum = _dns_parse_uint32(x);
                        break;

                case ns_t_wks:
                        if (*remaining < 5) 
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= rdlen;

                        size = sizeof(dns_WKS_record_t);
                        r->data.WKS = (dns_WKS_record_t *)calloc(1, size);

                        r->data.WKS->addr.s_addr = htonl(_dns_parse_uint32(x));
                        r->data.WKS->protocol = _dns_parse_uint8(x);
                        size = rdlen - 5;
                        r->data.WKS->maplength = size * 8;
                        r->data.WKS->map = NULL;
                        if (size == 0) break;

                        r->data.WKS->map = (uint8_t *)calloc(1, r->data.WKS->maplength);
                        mi = 0;
                        for (bx = 0; bx < size; bx++)
                        {
                                byte = _dns_parse_uint8(x);
                                for (i = 128; i >= 1; i = i/2)
                                {
                                        if (byte & i) r->data.WKS->map[mi] = 0xff;
                                        else r->data.WKS->map[mi] = 0;
                                        mi++;
                                }
                        }
                        break;

                case ns_t_hinfo:
                        size = sizeof(dns_HINFO_record_t);
                        r->data.HINFO = (dns_HINFO_record_t *)calloc(1, size);

                        r->data.HINFO->cpu = _dns_parse_string(p, x, remaining);
                        if (r->data.HINFO->cpu == NULL)
                        {
                                free(r->data.HINFO);
                                free(r);
                                return NULL;
                        }

                        r->data.HINFO->os = _dns_parse_string(p, x, remaining);
                        if (r->data.HINFO->os == NULL)
                        {
                                free(r->data.HINFO->cpu);
                                free(r->data.HINFO);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_minfo:
                        size = sizeof(dns_MINFO_record_t);
                        r->data.MINFO = (dns_MINFO_record_t *)calloc(1, size);

                        r->data.MINFO->rmailbx = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.MINFO->rmailbx == NULL)
                        {
                                free(r->data.MINFO);
                                free(r);
                                return NULL;
                        }

                        r->data.MINFO->emailbx = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.MINFO->emailbx == NULL)
                        {
                                free(r->data.MINFO->rmailbx);
                                free(r->data.MINFO);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_mx:
                        if (*remaining < 2) 
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= 2;

                        size = sizeof(dns_MX_record_t);
                        r->data.MX = (dns_MX_record_t *)calloc(1, size);

                        r->data.MX->preference = _dns_parse_uint16(x);
                        r->data.MX->name = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.MX->name == NULL)
                        {
                                free(r->data.MX);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_txt:
                        size = sizeof(dns_TXT_record_t);
                        r->data.TXT = (dns_TXT_record_t *)malloc(size);
                        r->data.TXT->string_count = 0;
                        r->data.TXT->strings = NULL;

                        while (*x < (eor + rdlen))
                        {
                                if (r->data.TXT->string_count == 0)
                                {
                                        r->data.TXT->strings = (char **)calloc(1, sizeof(char *));
                                }
                                else
                                {
                                        r->data.TXT->strings = (char **)realloc(r->data.TXT->strings, (r->data.TXT->string_count + 1) * sizeof(char *));
                                }

                                r->data.TXT->strings[r->data.TXT->string_count] = _dns_parse_string(p, x, remaining);
                                if (r->data.TXT->strings[r->data.TXT->string_count] == NULL)
                                {
                                        free(r->data.TXT->strings);
                                        free(r->data.TXT);
                                        free(r);
                                        return NULL;
                                }
                                r->data.TXT->string_count++;
                        }

                        break;

                case ns_t_rp:
                        size = sizeof(dns_RP_record_t);
                        r->data.RP = (dns_RP_record_t *)calloc(1, size);

                        r->data.RP->mailbox = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.RP->mailbox == NULL)
                        {
                                free(r->data.RP);
                                free(r);
                                return NULL;
                        }

                        r->data.RP->txtdname = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.RP->txtdname == NULL)
                        {
                                free(r->data.RP->mailbox);
                                free(r->data.RP);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_afsdb:
                        if (*remaining < 4) 
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= 4;
                        size = sizeof(dns_AFSDB_record_t);
                        r->data.AFSDB = (dns_AFSDB_record_t *)calloc(1, size);

                        r->data.AFSDB->subtype = _dns_parse_uint32(x);
                        r->data.AFSDB->hostname = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.AFSDB->hostname == NULL)
                        {
                                free(r->data.AFSDB);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_x25:
                        size = sizeof(dns_X25_record_t);
                        r->data.X25 = (dns_X25_record_t *)calloc(1, size);

                        r->data.X25->psdn_address = _dns_parse_string(p, x, remaining);
                        if (r->data.X25->psdn_address == NULL)
                        {
                                free(r->data.X25);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_isdn:
                        size = sizeof(dns_ISDN_record_t);
                        r->data.ISDN = (dns_ISDN_record_t *)calloc(1, size);

                        r->data.ISDN->isdn_address = _dns_parse_string(p, x, remaining);
                        if (r->data.ISDN->isdn_address == NULL)
                        {
                                free(r->data.ISDN);
                                free(r);
                                return NULL;
                        }

                        if (*x < (eor + rdlen))
                        {
                                r->data.ISDN->subaddress = _dns_parse_string(p, x, remaining);
                                if (r->data.ISDN->subaddress == NULL)
                                {
                                        free(r->data.ISDN->isdn_address);
                                        free(r->data.ISDN);
                                        free(r);
                                        return NULL;
                                }
                        }
                        else
                        {
                                r->data.ISDN->subaddress = NULL;
                        }

                        break;

                case ns_t_rt:
                        if (*remaining < 2) 
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= 2;

                        size = sizeof(dns_RT_record_t);
                        r->data.RT = (dns_RT_record_t *)calloc(1, size);

                        r->data.RT->preference = _dns_parse_uint16(x);
                        r->data.RT->intermediate = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.RT->intermediate == NULL)
                        {
                                free(r->data.RT);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_loc:
                        if (*remaining < 16) 
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= 16;

                        size = sizeof(dns_LOC_record_t);
                        r->data.LOC = (dns_LOC_record_t *)calloc(1, size);

                        r->data.LOC->version = _dns_parse_uint8(x);
                        r->data.LOC->size = _dns_parse_uint8(x);
                        r->data.LOC->horizontal_precision = _dns_parse_uint8(x);
                        r->data.LOC->vertical_precision = _dns_parse_uint8(x);
                        r->data.LOC->latitude = _dns_parse_uint32(x);
                        r->data.LOC->longitude = _dns_parse_uint32(x);
                        r->data.LOC->altitude = _dns_parse_uint32(x);
                        break;

                case ns_t_srv:
                        if (*remaining < 6) 
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= 6;

                        size = sizeof(dns_SRV_record_t);
                        r->data.SRV = (dns_SRV_record_t *)calloc(1, size);

                        r->data.SRV->priority = _dns_parse_uint16(x);
                        r->data.SRV->weight = _dns_parse_uint16(x);
                        r->data.SRV->port = _dns_parse_uint16(x);
                        r->data.SRV->target = _dns_parse_domain_name(p, x, remaining);
                        if (r->data.SRV->target == NULL)
                        {
                                free(r->data.SRV);
                                free(r);
                                return NULL;
                        }

                        break;

                case ns_t_null:
                default:
                        if (*remaining < rdlen)
                        {
                                free(r);
                                return NULL;
                        }

                        *remaining -= rdlen;

                        size = sizeof(dns_raw_resource_record_t);
                        r->data.DNSNULL = (dns_raw_resource_record_t *)calloc(1, size);

                        r->data.DNSNULL->length = rdlen;
                        r->data.DNSNULL->data = calloc(1, rdlen);
                        memmove(r->data.DNSNULL->data, *x, rdlen);
                        *x += rdlen;
                        break;
        }

        *x = eor + rdlen;
        return r;
}

dns_resource_record_t *
dns_parse_resource_record(const char *buf, uint32_t len)
{
        char *x;
        int32_t remaining;

        remaining = len;
        x = (char *)buf;
        return _dns_parse_resource_record_internal(buf, &x, &remaining);
}

dns_question_t *
_dns_parse_question_internal(const char *p, char **x, int32_t *remaining)
{
        dns_question_t *q;

        if (x == NULL) return NULL;
        if (*x == NULL) return NULL;
        if (*remaining < 1) return NULL;

        q = (dns_question_t *)calloc(1, sizeof(dns_question_t));

        q->name = _dns_parse_domain_name(p, x, remaining);
        if (q->name == NULL)
        {
                free(q);
                return NULL;
        }

        if (*remaining < 4)
        {
                free(q->name);
                free(q);
                return NULL;
        }

        *remaining = *remaining - 4;

        q->dnstype = _dns_parse_uint16(x);
        q->dnsclass = _dns_parse_uint16(x);

        return q;
}

dns_question_t *
dns_parse_question(const char *buf, uint32_t len)
{
        char *x;
        int32_t remaining;

        remaining = len;
        x = (char *)buf;
        return _dns_parse_question_internal(buf, &x, &remaining);
}


dns_reply_t *
dns_parse_packet(const char *p, uint32_t len)
{
        dns_reply_t *r;
        dns_header_t *h;
        char *x;
        uint32_t i, size;
    int32_t remaining;

        if (p == NULL) return NULL;
        if (len < NS_HFIXEDSZ) return NULL;

        x = (char *)p;

        r = (dns_reply_t *)calloc(1, sizeof(dns_reply_t));

        r->header = (dns_header_t *)calloc(1, sizeof(dns_header_t));
        h = r->header;

        h->xid = _dns_parse_uint16(&x);
        h->flags = _dns_parse_uint16(&x);
        h->qdcount = _dns_parse_uint16(&x);
        h->ancount = _dns_parse_uint16(&x);
        h->nscount = _dns_parse_uint16(&x);
        h->arcount = _dns_parse_uint16(&x);

        remaining = len - NS_HFIXEDSZ;

        size = sizeof(dns_question_t *);
        r->question = (dns_question_t **)calloc(h->qdcount, size);
        for (i = 0; i < h->qdcount; i++)
        {
                r->question[i] = _dns_parse_question_internal(p, &x, &remaining);
                if (r->question[i] ==NULL)
                {
                        h->qdcount = 0;
                        if (i > 0) h->qdcount = i - 1;
                        h->ancount = 0;
                        h->nscount = 0;
                        h->arcount = 0;
                        dns_free_reply(r);
                        return NULL;
                }
        }

        size = sizeof(dns_resource_record_t *);

        r->answer = (dns_resource_record_t **)calloc(h->ancount, size);
        for (i = 0; i < h->ancount; i++)
        {
                r->answer[i] = _dns_parse_resource_record_internal(p, &x, &remaining);
                if (r->answer[i] == NULL)
                {
                        h->ancount = 0;
                        if (i > 0) h->ancount = i - 1;
                        h->nscount = 0;
                        h->arcount = 0;
                        dns_free_reply(r);
                        return NULL;
                }
        }

        r->authority = (dns_resource_record_t **)calloc(h->nscount, size);
        for (i = 0; i < h->nscount; i++)
        {
                r->authority[i] = _dns_parse_resource_record_internal(p, &x, &remaining);
                if (r->authority[i] == NULL)
                {
                        h->nscount = 0;
                        if (i > 0) h->nscount = i - 1;
                        h->arcount = 0;
                        dns_free_reply(r);
                        return NULL;
                }
        }

        r->additional = (dns_resource_record_t **)calloc(h->arcount, size);
        for (i = 0; i < h->arcount; i++)
        {
                r->additional[i] = _dns_parse_resource_record_internal(p, &x, &remaining);
                if (r->additional[i] == NULL)
                {
                        h->arcount = 0;
                        if (i > 0) h->arcount = i - 1;
                        dns_free_reply(r);
                        return NULL;
                }
        }

        return r;
}

void
dns_free_resource_record(dns_resource_record_t *r)
{
        int i;

        free(r->name);

        switch (r->dnstype)
        {
                case ns_t_a:
                        free(r->data.A);
                        break;

                case ns_t_aaaa:
                        free(r->data.AAAA);
                        break;

                case ns_t_ns:
                case ns_t_md:
                case ns_t_mf:
                case ns_t_cname:
                case ns_t_mb:
                case ns_t_mg:
                case ns_t_mr:
                case ns_t_ptr:
                        free(r->data.CNAME->name);
                        free(r->data.CNAME);
                        break;

                case ns_t_soa:
                        free(r->data.SOA->mname);
                        free(r->data.SOA->rname);
                        free(r->data.SOA);
                        break;

                case ns_t_wks:
                        free(r->data.WKS->map);
                        free(r->data.WKS);
                        break;

                case ns_t_hinfo:
                        free(r->data.HINFO->cpu);
                        free(r->data.HINFO->os);
                        free(r->data.HINFO);
                        break;

                case ns_t_minfo:
                        free(r->data.MINFO->rmailbx);
                        free(r->data.MINFO->emailbx);
                        free(r->data.MINFO);
                        break;

                case ns_t_mx:
                        free(r->data.MX->name);
                        free(r->data.MX);
                        break;


                case ns_t_txt:
                        for (i=0; i<r->data.TXT->string_count; i++)
                        {
                                free(r->data.TXT->strings[i]);
                        }
                        if (r->data.TXT->strings != NULL)
                                free(r->data.TXT->strings);
                        free(r->data.TXT);
                        break;

                case ns_t_rp:
                        free(r->data.RP->mailbox);
                        free(r->data.RP->txtdname);
                        free(r->data.RP);
                        break;

                case ns_t_afsdb:
                        free(r->data.AFSDB->hostname);
                        free(r->data.AFSDB);
                        break;

                case ns_t_x25:
                        free(r->data.X25->psdn_address);
                        free(r->data.X25);
                        break;

                case ns_t_isdn:
                        free(r->data.ISDN->isdn_address);
                        if (r->data.ISDN->subaddress != NULL)
                                free(r->data.ISDN->subaddress);
                        free(r->data.ISDN);
                        break;

                case ns_t_rt:
                        free(r->data.RT->intermediate);
                        free(r->data.RT);
                        break;

                case ns_t_loc:
                        free(r->data.LOC);
                        break;

                case ns_t_srv:
                        free(r->data.SRV->target);
                        free(r->data.SRV);
                        break;

                case ns_t_null:
                default:
                        free(r->data.DNSNULL->data);
                        free(r->data.DNSNULL);
                        break;
        }

        free(r);
}

void
dns_free_reply(dns_reply_t *r)
{
        uint32_t i;

        if (r == NULL) return;
        if (r->header != NULL)
        {
                for (i = 0; i < r->header->qdcount; i++)
                {
                        free(r->question[i]->name);
                        free(r->question[i]);
                }

                for (i = 0; i < r->header->ancount; i++) dns_free_resource_record(r->answer[i]);
                for (i = 0; i < r->header->nscount; i++) dns_free_resource_record(r->authority[i]);
                for (i = 0; i < r->header->arcount; i++) dns_free_resource_record(r->additional[i]);

                free(r->header);
        }

        if (r->question != NULL) free(r->question);
        if (r->answer != NULL) free(r->answer);
        if (r->authority != NULL) free(r->authority);
        if (r->additional != NULL) free(r->additional);

        if (r->server != NULL) free(r->server);

        free(r);
}

static void
_dns_append_question(dns_question_t *q, char **s, uint16_t *l)
{
        uint16_t len, *p;
        char *x;

        if (q == NULL) return;

        len = *l + _dns_cname_length(q->name) + 2 + 4;
        *s = realloc(*s, len);

        _dns_insert_cname(q->name, (char *)*s + *l);
        *l = len;

        x = *s + (len - 4);

        p = (uint16_t *)x;
        *p = htons(q->dnstype);
        x += 2;

        p = (uint16_t *)x;
        *p = htons(q->dnsclass);

}

static void
_dns_append_resource_record(dns_resource_record_t *r, char **s, uint16_t *l)
{
        uint16_t clen, len, *p, extra, rdlen;
        uint32_t *p2;
        char *x;

        if (r == NULL) return;

        extra = 10;
        switch (r->dnstype)
        {
                case ns_t_a:
                        extra += 4;
                        break;
                case ns_t_ptr:
                        extra += 2;
                        clen = _dns_cname_length(r->data.PTR->name);
                        extra += clen;
                        break;
                default: break;
        }

        len = *l + _dns_cname_length(r->name) + 2 + extra;
        *s = realloc(*s, len);

        _dns_insert_cname(r->name, (char *)*s + *l);
        *l = len;

        x = *s + (len - extra);

        p = (uint16_t *)x;
        *p = htons(r->dnstype);
        x += 2;

        p = (uint16_t *)x;
        *p = htons(r->dnsclass);
        x += 2;

        p2 = (uint32_t *)x;
        *p2 = htonl(r->ttl);
        x += 4;

        switch (r->dnstype)
        {
                case ns_t_a:
                        rdlen = 4;
                        p = (uint16_t *)x;
                        *p = htons(rdlen);
                        x += 2;

                        p2 = (uint32_t *)x;
                        *p2 = htons(r->data.A->addr.s_addr);
                        x += 4;
                        return;

                case ns_t_ptr:
                        clen = _dns_cname_length(r->data.PTR->name) + 2;
                        p = (uint16_t *)x;
                        *p = htons(clen);
                        x += 2;
                        _dns_insert_cname(r->data.PTR->name, x);
                        x += clen;
                        return;

                default: return;
        }
}

char *
dns_build_reply(dns_reply_t *dnsr, uint16_t *rl)
{
        uint16_t i, len;
        dns_header_t *h;
        char *s, *x;

        if (dnsr == NULL) return NULL;

        len = NS_HFIXEDSZ;

        s = malloc(len);
        x = s + len;

        memset(s, 0, len);
        *rl = len;

        h = (dns_header_t *)s;

        h->xid = htons(dnsr->header->xid);
        h->flags = htons(dnsr->header->flags);
        h->qdcount = htons(dnsr->header->qdcount);
        h->ancount = htons(dnsr->header->ancount);
        h->nscount = htons(dnsr->header->nscount);
        h->arcount = htons(dnsr->header->arcount);

        for (i = 0; i < dnsr->header->qdcount; i++)
        {
                _dns_append_question(dnsr->question[i], &s, rl);
        }

        for (i = 0; i < dnsr->header->ancount; i++)
        {
                _dns_append_resource_record(dnsr->answer[i], &s, rl);
        }

        for (i = 0; i < dnsr->header->nscount; i++)
        {
                _dns_append_resource_record(dnsr->authority[i], &s, rl);
        }

        for (i = 0; i < dnsr->header->arcount; i++)
        {
                _dns_append_resource_record(dnsr->additional[i], &s, rl);
        }

        return s;
}

void
dns_free_question(dns_question_t *q)
{
        if (q == NULL) return;
        if (q->name != NULL) free(q->name);
        free(q);
}

void
dns_set_buffer_size(dns_handle_t d, uint32_t len)
{
        dns_private_handle_t *dns;
        if (d == NULL) return;

        dns = (dns_private_handle_t *)d;
        if (dns->recvsize == len) return;

        if (dns->recvbuf != NULL)
        {
                free(dns->recvbuf);
                dns->recvbuf = NULL;
        }

        dns->recvsize = len;
        if (dns->recvsize > DNS_MAX_RECEIVE_SIZE) dns->recvsize = DNS_MAX_RECEIVE_SIZE;

        if (dns->recvsize > 0) dns->recvbuf = malloc(dns->recvsize);
}

uint32_t
dns_get_buffer_size(dns_handle_t d)
{
        dns_private_handle_t *dns;
        if (d == NULL) return 0;

        dns = (dns_private_handle_t *)d;
        return dns->recvsize;
}

dns_reply_t *
dns_lookup_soa_min(dns_handle_t d, const char *name, uint32_t class, uint32_t type, int *min)
{
        dns_private_handle_t *dns;
        dns_reply_t *r;
        int len;
        struct sockaddr_storage *from;
        uint32_t fromlen;

        if (d == NULL) return NULL;
        if (name == NULL) return NULL;

        dns = (dns_private_handle_t *)d;
        if (min != NULL) *min = -1;

        if (dns->recvbuf == NULL)
        {
                if (dns->recvsize == 0) dns->recvsize = DNS_DEFAULT_RECEIVE_SIZE;

                dns->recvbuf = malloc(dns->recvsize);
                if (dns->recvbuf == NULL) return NULL;
        }

        fromlen = sizeof(struct sockaddr_storage);
        from = (struct sockaddr_storage *)calloc(1, sizeof(struct sockaddr_storage));
        len = -1;

        if (dns->handle_type == DNS_PRIVATE_HANDLE_TYPE_SUPER)
        {
                _check_cache(dns->sdns);
                len = _sdns_search(dns->sdns, name, class, type, 0, 1,  dns->recvbuf, dns->recvsize, (struct sockaddr *)from, &fromlen, min);
        }
        else
        {
                /* NB.  Minumium SOA TTL values are NOT provided when the caller passes a DNS_PRIVATE_HANDLE_TYPE_PLAIN handle */
                len = _pdns_search(dns->sdns, dns->pdns, name, class, type,  dns->recvbuf, dns->recvsize, (struct sockaddr *)from, &fromlen);
        }

        if (len <= 0)
        {
                free(from);
                return NULL;
        }

        r = dns_parse_packet(dns->recvbuf, len);

        if (r == NULL) free(from);
        else r->server = (struct sockaddr *)from;

        return r;
}

dns_reply_t *
dns_lookup(dns_handle_t d, const char *name, uint32_t class, uint32_t type)
{
        int unused = 0;

        return dns_lookup_soa_min(d, name, class, type, &unused);
}

/*
 * DNS printing utilities
 */

static char *
coord_ntoa(int32_t coord, uint32_t islat)
{
        int32_t deg, min, sec, secfrac;
        static char buf[64];
        char dir;

        coord = coord - 0x80000000;
        dir = 'N';

        if ((islat == 1) && (coord < 0))
        {
                dir = 'S';
                coord = -coord;
        }

        if (islat == 0)
        {
                dir = 'E';
                if (coord < 0)
                {
                        dir = 'W';
                        coord = -coord;
                }
        }

        secfrac = coord % 1000;
        coord = coord / 1000;
        sec = coord % 60;
        coord = coord / 60;
        min = coord % 60;
        coord = coord / 60;
        deg = coord;

        sprintf(buf, "%d %.2d %.2d.%.3d %c", deg, min, sec, secfrac, dir);
        return buf;
}

static char *
alt_ntoa(int32_t alt)
{
        int32_t ref, m, frac, sign;
        static char buf[128];

        ref = 100000 * 100;
        sign = 1;

        if (alt < ref)
        {
                alt = ref - alt;
                sign = -1;
        }
        else
        {
                alt = alt - ref;
        }

        frac = alt % 100;
        m = (alt / 100) * sign;

        sprintf(buf, "%d.%.2d", m, frac);
        return buf;
}

static unsigned int
poweroften[10] =
{       1,
        10,
        100,
        1000,
        10000,
        100000,
        1000000,
        10000000,
        100000000,
        1000000000
};

static char *
precsize_ntoa(uint8_t prec)
{
        static char buf[19];
        unsigned long val;
        int mantissa, exponent;

        mantissa = (int)((prec >> 4) & 0x0f) % 10;
        exponent = (int)((prec >> 0) & 0x0f) % 10;

        val = mantissa * poweroften[exponent];

        sprintf(buf, "%ld.%.2ld", val/100, val%100);
        return buf;
}

const char *
dns_type_string(uint16_t t)
{
        switch (t)
        {
                case ns_t_a:     return "A    ";
                case ns_t_ns:    return "NS   ";
                case ns_t_md:    return "MD   ";
                case ns_t_mf:    return "MF   ";
                case ns_t_cname: return "CNAME";
                case ns_t_soa:   return "SOA  ";
                case ns_t_mb:    return "MB  ";
                case ns_t_mg:    return "MG   ";
                case ns_t_mr:    return "MR   ";
                case ns_t_null:  return "NULL ";
                case ns_t_wks:   return "WKS  ";
                case ns_t_ptr:   return "PTR  ";
                case ns_t_hinfo: return "HINFO";
                case ns_t_minfo: return "MINFO";
                case ns_t_mx:    return "MX   ";
                case ns_t_txt:   return "TXT  ";
                case ns_t_rp:    return "PR   ";
                case ns_t_afsdb: return "AFSDB";
                case ns_t_x25:   return "X25  ";
                case ns_t_isdn:  return "ISDN ";
                case ns_t_rt:    return "RT   ";
                case ns_t_nsap:  return "NSAP ";
                case ns_t_nsap_ptr: return "NSPTR";
                case ns_t_sig:   return "SIG  ";
                case ns_t_key:   return "KEY  ";
                case ns_t_px:    return "PX   ";
                case ns_t_gpos:  return "GPOS ";
                case ns_t_aaaa:  return "AAAA ";
                case ns_t_loc:   return "LOC  ";
                case ns_t_nxt:   return "NXT  ";
                case ns_t_eid:   return "EID  ";
                case ns_t_nimloc: return "NIMLC";
                case ns_t_srv:   return "SRV  ";
                case ns_t_atma:  return "ATMA ";
                case ns_t_naptr: return "NAPTR";
                case ns_t_kx:    return "KX   ";
                case ns_t_cert:  return "CERT ";
                case ns_t_a6:    return "A6   ";
                case ns_t_dname: return "DNAME";
                case ns_t_sink:  return "SINK ";
                case ns_t_opt:   return "OPT  ";
                case ns_t_tkey:  return "TKEY ";
                case ns_t_tsig:  return "TSIG ";
                case ns_t_ixfr:  return "IXFR ";
                case ns_t_axfr:  return "AXFR ";
                case ns_t_mailb: return "MAILB";
                case ns_t_maila: return "MAILA";
                case ns_t_any:   return "ANY  ";
                case ns_t_zxfr:  return "ZXFR ";
                default:         return "?????";
        }

        return "?????";
}

int32_t
dns_type_number(const char *t, uint16_t *n)
{
        if (t == NULL) return -1;

        if (!strcasecmp(t, "A"))       { *n = ns_t_a;        return 0; }
        if (!strcasecmp(t, "NS"))      { *n = ns_t_ns;       return 0; }
        if (!strcasecmp(t, "MD"))      { *n = ns_t_md;       return 0; }
        if (!strcasecmp(t, "MF"))      { *n = ns_t_mf;       return 0; }
        if (!strcasecmp(t, "CNAME"))   { *n = ns_t_cname;    return 0; }
        if (!strcasecmp(t, "SOA"))     { *n = ns_t_soa;      return 0; }
        if (!strcasecmp(t, "MB"))      { *n = ns_t_mb;       return 0; }
        if (!strcasecmp(t, "MG"))      { *n = ns_t_mg;       return 0; }
        if (!strcasecmp(t, "MR"))      { *n = ns_t_mr;       return 0; }
        if (!strcasecmp(t, "NULL"))    { *n = ns_t_null;     return 0; }
        if (!strcasecmp(t, "WKS"))     { *n = ns_t_wks;      return 0; }
        if (!strcasecmp(t, "PTR"))     { *n = ns_t_ptr;      return 0; }
        if (!strcasecmp(t, "HINFO"))   { *n = ns_t_hinfo;    return 0; }
        if (!strcasecmp(t, "MINFO"))   { *n = ns_t_minfo;    return 0; }
        if (!strcasecmp(t, "TXT"))     { *n = ns_t_txt;      return 0; }
        if (!strcasecmp(t, "RP"))      { *n = ns_t_rp;       return 0; }
        if (!strcasecmp(t, "AFSDB"))   { *n = ns_t_afsdb;    return 0; }
        if (!strcasecmp(t, "X25"))     { *n = ns_t_x25;      return 0; }
        if (!strcasecmp(t, "ISDN"))    { *n = ns_t_isdn;     return 0; }
        if (!strcasecmp(t, "RT"))      { *n = ns_t_rt;       return 0; }
        if (!strcasecmp(t, "NSAP"))    { *n = ns_t_nsap;     return 0; }
        if (!strcasecmp(t, "NSPTR"))   { *n = ns_t_nsap_ptr; return 0; }
        if (!strcasecmp(t, "NSAP_PTR")){ *n = ns_t_nsap_ptr; return 0; }
        if (!strcasecmp(t, "SIG"))     { *n = ns_t_sig;      return 0; }
        if (!strcasecmp(t, "KEY"))     { *n = ns_t_key;      return 0; }
        if (!strcasecmp(t, "PX"))      { *n = ns_t_px;       return 0; }
        if (!strcasecmp(t, "GPOS"))    { *n = ns_t_gpos;     return 0; }
        if (!strcasecmp(t, "AAAA"))    { *n = ns_t_aaaa;     return 0; }
        if (!strcasecmp(t, "LOC"))     { *n = ns_t_loc;      return 0; }
        if (!strcasecmp(t, "NXT"))     { *n = ns_t_nxt;      return 0; }
        if (!strcasecmp(t, "EID"))     { *n = ns_t_eid;      return 0; }
        if (!strcasecmp(t, "NIMLOC"))  { *n = ns_t_nimloc;   return 0; }
        if (!strcasecmp(t, "SRV"))     { *n = ns_t_srv;      return 0; }
        if (!strcasecmp(t, "ATMA"))    { *n = ns_t_atma;     return 0; }
        if (!strcasecmp(t, "NAPTR"))   { *n = ns_t_naptr;    return 0; }
        if (!strcasecmp(t, "KX"))      { *n = ns_t_kx;       return 0; }
        if (!strcasecmp(t, "CERT"))    { *n = ns_t_cert;     return 0; }
        if (!strcasecmp(t, "A6"))      { *n = ns_t_a6;       return 0; }
        if (!strcasecmp(t, "DNAME"))   { *n = ns_t_dname;    return 0; }
        if (!strcasecmp(t, "SINK"))    { *n = ns_t_sink;     return 0; }
        if (!strcasecmp(t, "OPT"))     { *n = ns_t_opt;      return 0; }
        if (!strcasecmp(t, "TKEY"))    { *n = ns_t_tkey;     return 0; }
        if (!strcasecmp(t, "TSIG"))    { *n = ns_t_tsig;     return 0; }
        if (!strcasecmp(t, "IXFR"))    { *n = ns_t_ixfr;     return 0; }
        if (!strcasecmp(t, "AXFR"))    { *n = ns_t_axfr;     return 0; }
        if (!strcasecmp(t, "MAILB"))   { *n = ns_t_mailb;    return 0; }
        if (!strcasecmp(t, "MAILA"))   { *n = ns_t_maila;    return 0; }
        if (!strcasecmp(t, "ANY"))     { *n = ns_t_any;      return 0; }
        if (!strcasecmp(t, "ZXFR"))    { *n = ns_t_zxfr;     return 0; }

        return -1;
}

const char *
dns_class_string(uint16_t c)
{
        switch (c)
        {
                case ns_c_in: return "IN";
                case ns_c_2: return "CS";
                case ns_c_chaos: return "CH";
                case ns_c_hs: return "HS";
                case ns_c_none: return "NONE";
                case ns_c_any: return "ANY";
                default: return "??";
        }

        return "??";
}

int32_t
dns_class_number(const char *c, uint16_t *n)
{
        if (c == NULL) return -1;

        if (!strcasecmp(c, "IN"))   { *n = ns_c_in;    return 0; }
        if (!strcasecmp(c, "CS"))   { *n = ns_c_2;     return 0; }
        if (!strcasecmp(c, "CH"))   { *n = ns_c_chaos; return 0; }
        if (!strcasecmp(c, "HS"))   { *n = ns_c_hs;    return 0; }
        if (!strcasecmp(c, "NONE")) { *n = ns_c_none;  return 0; }
        if (!strcasecmp(c, "ANY"))  { *n = ns_c_any;   return 0; }

        return -1;
}

static void
_dns_print_question_lock(const dns_question_t *q, FILE *f, int lockit)
{
        if (lockit != 0) _dns_print_lock();
        fprintf(f, "%s %s %s\n", q->name, dns_class_string(q->dnsclass), dns_type_string(q->dnstype));
        if (lockit != 0) _dns_print_unlock();
}

void
dns_print_question(const dns_question_t *q, FILE *f)
{
        _dns_print_question_lock(q, f, 1);
}

static void
_dns_print_resource_record_lock(const dns_resource_record_t *r, FILE *f, int lockit)
{
        struct protoent *p;
        struct servent *s;
        uint32_t i, len;
        uint8_t x;
        struct sockaddr_in6 s6;
        char pbuf[64];

        if (lockit != 0) _dns_print_lock();

        fprintf(f, "%s %s %s ", r->name, dns_class_string(r->dnsclass), dns_type_string(r->dnstype));
        fprintf(f, "%u", r->ttl);

        switch (r->dnstype)
        {
                case ns_t_a:
                        fprintf(f, " %s", inet_ntoa(r->data.A->addr));
                        break;

                case ns_t_aaaa:
                        memset(&s6, 0, sizeof(struct sockaddr_in6));
                        s6.sin6_len = sizeof(struct sockaddr_in6);
                        s6.sin6_family = AF_INET6;
                        s6.sin6_addr = r->data.AAAA->addr;
                        fprintf(f, " %s", inet_ntop(AF_INET6, (char *)(&s6) + INET_NTOP_AF_INET6_OFFSET, pbuf, 64));
                        break;

                case ns_t_md:
                case ns_t_mf:
                case ns_t_cname:
                case ns_t_mb:
                case ns_t_mg:
                case ns_t_mr:
                case ns_t_ptr:
                case ns_t_ns:
                        fprintf(f, " %s", r->data.CNAME->name);
                        break;

                case ns_t_soa:
                        fprintf(f, " %s %s %u %u %u %u %u",
                                r->data.SOA->mname, r->data.SOA->rname,
                                r->data.SOA->serial, r->data.SOA->refresh, r->data.SOA->retry,
                                r->data.SOA->expire, r->data.SOA->minimum);
                        break;

                case ns_t_wks:
                        fprintf(f, " %s", inet_ntoa(r->data.WKS->addr));
                        p = getprotobynumber(r->data.WKS->protocol);
                        if (p != NULL)
                        {
                                fprintf(f, " %s", p->p_name);

                                for (i = 0; i < r->data.WKS->maplength; i++)
                                {
                                        if (r->data.WKS->map[i])
                                        {
                                                s = getservbyport(i, p->p_name);
                                                if (s == NULL) fprintf(f, " %u", i);
                                                else fprintf(f, " %s", s->s_name);
                                        }
                                }
                        }
                        else fprintf(f, " UNKNOWN PROTOCOL %u", r->data.WKS->protocol);
                        break;

                case ns_t_hinfo:
                        fprintf(f, " %s %s", r->data.HINFO->cpu, r->data.HINFO->os);
                        break;

                case ns_t_minfo:
                        fprintf(f, " %s %s", r->data.MINFO->rmailbx, r->data.MINFO->emailbx);
                        break;

                case ns_t_mx:
                        fprintf(f, " %u %s", r->data.MX->preference, r->data.MX->name);
                        break;

                case ns_t_txt:
                        for (i = 0; i < r->data.TXT->string_count; i++)
                        {
                                fprintf(f, " \"%s\"", r->data.TXT->strings[i]);
                        }
                        break;

                case ns_t_rp:
                        fprintf(f, " %s %s", r->data.RP->mailbox, r->data.RP->txtdname);
                        break;

                case ns_t_afsdb:
                        fprintf(f, " %u %s", r->data.AFSDB->subtype,
                                r->data.AFSDB->hostname);
                        break;

                case ns_t_x25:
                        fprintf(f, " %s", r->data.X25->psdn_address);
                        break;

                case ns_t_isdn:
                        fprintf(f, " %s", r->data.ISDN->isdn_address);
                        if (r->data.ISDN->subaddress != NULL)
                                fprintf(f, " %s", r->data.ISDN->subaddress);
                        break;

                case ns_t_rt:
                        fprintf(f, " %hu %s", r->data.RT->preference,
                                r->data.RT->intermediate);
                        break;

                case ns_t_loc:
                        fprintf(f, " %s", coord_ntoa(r->data.LOC->latitude, 1));
                        fprintf(f, " %s", coord_ntoa(r->data.LOC->longitude, 0));
                        fprintf(f, " %sm", alt_ntoa(r->data.LOC->altitude));
                        fprintf(f, " %sm", precsize_ntoa(r->data.LOC->size));
                        fprintf(f, " %sm", precsize_ntoa(r->data.LOC->horizontal_precision));
                        fprintf(f, " %sm", precsize_ntoa(r->data.LOC->vertical_precision));
                        break;

                case ns_t_srv:
                        fprintf(f, " %hu %hu %hu %s",
                                r->data.SRV->priority, r->data.SRV->weight, 
                                r->data.SRV->port, r->data.SRV->target);
                        break;

                case ns_t_null:
                default:
                        len = r->data.DNSNULL->length;
                        fprintf(f, " %hu ", len);
                        for (i = 0; i < len; i++)
                        {
                                x = r->data.DNSNULL->data[i];
                                fprintf(f, "%x", x);
                        }

                        fprintf(f, " (");

                        len = r->data.DNSNULL->length;
                        for (i = 0; i < len; i++)
                        {
                                x = r->data.DNSNULL->data[i];
                                if (isascii(x)) fprintf(f, "%c", x);
                                else fprintf(f, " ");
                        }
                        fprintf(f, ")\n");

        }

        fprintf(f, "\n");

        if (lockit != 0) _dns_print_unlock();
}

void
dns_print_resource_record(const dns_resource_record_t *r, FILE *f)
{
        _dns_print_resource_record_lock(r, f, 1);
}

void
dns_print_reply(const dns_reply_t *r, FILE *f, uint16_t mask)
{
        uint16_t i;
        dns_header_t *h;
        char scratch[1024];
        uint32_t offset, iface;

        _dns_print_lock();

        if (r == NULL)
        {
                fprintf(f, "-nil-\n");
                _dns_print_unlock();
                return;
        }

        if (r->status != DNS_STATUS_OK)
        {
                if (r->status == DNS_STATUS_TIMEOUT)
                        fprintf(f, "Timeout\n");
                else if (r->status == DNS_STATUS_SEND_FAILED)
                        fprintf(f, "Send failed\n");
                else if (r->status == DNS_STATUS_RECEIVE_FAILED)
                        fprintf(f, "Receive failed\n");
                else fprintf(f, "status %u\n", r->status);

                _dns_print_unlock();
                return;
        }

        h = r->header;

        if (mask & DNS_PRINT_XID)
        {
                fprintf(f, "Xid: %u\n", h->xid);
        }

        if (mask & DNS_PRINT_QR)
        {
                if ((h->flags & DNS_FLAGS_QR_MASK) == DNS_FLAGS_QR_QUERY)
                        fprintf(f, "QR: Query\n");
                else
                        fprintf(f, "QR: Reply\n");
        }

        if (mask & DNS_PRINT_SERVER)
        {
                if (r->server == NULL)
                {
                        fprintf(f, "Server: -nil-\n");
                }
                else
                {
                        offset = INET_NTOP_AF_INET_OFFSET;
                        if (r->server->sa_family == AF_INET6) offset = INET_NTOP_AF_INET6_OFFSET;

                        fprintf(f, "Server: %s", inet_ntop(r->server->sa_family, (char *)(r->server) + offset, scratch, 1024));
                        if (r->server->sa_family == AF_INET)
                        {
                                memcpy(&iface, (((struct sockaddr_in *)(r->server))->sin_zero), 4);
                                if (iface > 0) fprintf(f, "%%%s", if_indextoname(iface, scratch));
                        }
                        else if (r->server->sa_family == AF_INET6)
                        {
                                iface = ((struct sockaddr_in6 *)(r->server))->sin6_scope_id;
                                if (iface > 0) fprintf(f, "%%%s", if_indextoname(iface, scratch));
                        }
                        fprintf(f, "\n");
                }
        }

        if (mask & DNS_PRINT_OPCODE)
        {
                fprintf(f, "Opcode: ");
                switch (h->flags & DNS_FLAGS_OPCODE_MASK)
                {
                        case ns_o_query:  fprintf(f, "Standard\n"); break;
                        case ns_o_iquery: fprintf(f, "Inverse\n"); break;
                        case ns_o_status: fprintf(f, "Status\n"); break;
                        case ns_o_notify: fprintf(f, "Notify\n"); break;
                        case ns_o_update: fprintf(f, "Update\n"); break;
                        default:
                                fprintf(f, "Reserved (%hu)\n",
                                        (h->flags & DNS_FLAGS_OPCODE_MASK) >> 11);
                }
        }

        if (mask & DNS_PRINT_AA)
        {
                if (h->flags & DNS_FLAGS_AA) fprintf(f, "AA: Authoritative\n");
                else fprintf(f, "AA: Non-Authoritative\n");
        }

        if (mask & DNS_PRINT_TC)
        {
                if (h->flags & DNS_FLAGS_TC) fprintf(f, "TC: Truncated\n");
                else fprintf(f, "TC: Non-Truncated\n");
        }

        if (mask & DNS_PRINT_RD)
        {
                if (h->flags & DNS_FLAGS_RD) fprintf(f, "RD: Recursion desired\n");
                else fprintf(f, "RD: No recursion desired\n");
        }

        if (mask & DNS_PRINT_RA)
        {
                if (h->flags & DNS_FLAGS_RA) fprintf(f, "RA: Recursion available\n");
                else fprintf(f, "RA: No recursion available \n");
        }

        if (mask & DNS_PRINT_RCODE)
        {
                fprintf(f, "Rcode: ");
                switch (h->flags & DNS_FLAGS_RCODE_MASK)
                {
                        case ns_r_noerror:
                                fprintf(f, "No error\n");
                                break;
                        case ns_r_formerr:
                                fprintf(f, "Format error \n");
                                break;
                        case ns_r_servfail:
                                fprintf(f, "Server failure\n");
                                break;
                        case ns_r_nxdomain:
                                fprintf(f, "Name error \n");
                                break;
                        case ns_r_notimpl:
                                fprintf(f, "Not implemented\n");
                                break;
                        case ns_r_refused:
                                fprintf(f, "Refused\n");
                                break;
                        case ns_r_yxdomain:
                                fprintf(f, "Name exists\n");
                                break;
                        case ns_r_yxrrset:
                                fprintf(f, "RR Set exists\n");
                                break;
                        case ns_r_nxrrset:
                                fprintf(f, "RR Set does not exist\n");
                                break;
                        case ns_r_notauth:
                                fprintf(f, "Not authoritative\n");
                                break;
                        case ns_r_notzone:
                                fprintf(f, "Record zone does not match section zone\n");
                                break;
                        case ns_r_badvers:
                                fprintf(f, "Invalid EDNS version or TSIG signature\n");
                                break;
                        case ns_r_badkey:
                                fprintf(f, "Invalid key\n");
                                break;
                        case ns_r_badtime:
                                fprintf(f, "Invalid time\n");
                                break;
                        default:
                                fprintf(f, "Reserved (%hu)\n",h->flags & DNS_FLAGS_RCODE_MASK);
                }
        }

        if (mask & DNS_PRINT_QUESTION)
        {
                fprintf(f, "Question (%hu):\n", h->qdcount);
                for (i = 0; i < h->qdcount; i++)
                        _dns_print_question_lock(r->question[i], f, 0);
        }

        if (mask & DNS_PRINT_ANSWER)
        {
                fprintf(f, "Answer (%hu):\n", h->ancount);
                for (i = 0; i < h->ancount; i++)
                        _dns_print_resource_record_lock(r->answer[i], f, 0);
        }

        if (mask & DNS_PRINT_AUTHORITY)
        {
                fprintf(f, "Authority (%hu):\n", h->nscount);
                for (i = 0; i < h->nscount; i++)
                        _dns_print_resource_record_lock(r->authority[i], f, 0);
        }

        if (mask & DNS_PRINT_ADDITIONAL)
        {
                fprintf(f, "Additional records (%hu):\n", h->arcount);
                for (i = 0; i < h->arcount; i++)
                        _dns_print_resource_record_lock(r->additional[i], f, 0);
        }

        _dns_print_unlock();
}

static void
_pdns_print_handle(pdns_handle_t *pdns, FILE *f)
{
        uint32_t i, offset;
        struct in_addr a;
        char scratch[1024];
        struct sockaddr *sa;
        res_state r;

        if (pdns == NULL)
        {
                fprintf(f, "-nil-\n");
                return;
        }

        if (pdns->name == NULL) fprintf(f, "Name: -nil-\n");
        else fprintf(f, "Name: %s\n", pdns->name);

        fprintf(f, "Flags:");
        if (pdns->flags == 0) fprintf(f, " None\n");
        else 
        {
                if (pdns->flags & DNS_FLAG_DEBUG) fprintf(f, " Debug");
                if (pdns->flags & DNS_FLAG_CHECK_RESOLVER_DIR) fprintf(f, " DirCheck");
                if (pdns->flags & DNS_FLAG_HAVE_IPV6_SERVER) fprintf(f, " IPv6");
                if (pdns->flags & DNS_FLAG_OK_TO_SKIP_AAAA) fprintf(f, " SkipAAAA");
                if (pdns->flags & DNS_FLAG_DEFAULT_RESOLVER) fprintf(f, " Default");
                fprintf(f, "\n");
        }

        r = pdns->res;
        if (r == NULL) return;

        if (r->defdname[0] != '\0') fprintf(f, "Domain: %s\n", r->defdname);
        fprintf(f, "Search Order: %d\n", pdns->search_order);
        fprintf(f, "Total Timeout: %d\n", pdns->total_timeout);
        fprintf(f, "Retry Timeout: %d\n", pdns->res->retrans);
        fprintf(f, "Retry Attempts: %d\n", pdns->res->retry);

        fprintf(f, "Server%s:\n", (r->nscount == 1) ? "" : "s");
        for (i = 0; i < r->nscount; i++)
        {
                sa = get_nsaddr(r, i);
                offset = INET_NTOP_AF_INET_OFFSET;
                if (sa->sa_family == AF_INET6) offset = INET_NTOP_AF_INET6_OFFSET;
                fprintf(f, "  %u: %s", i, inet_ntop(sa->sa_family, (char *)sa + offset, scratch, 1024));
                fprintf(f, "\n");
        }

        if (pdns->search_count > 0)
        {
                fprintf(f, "Search List:\n");
                for (i = 0; i < pdns->search_count; i++)
                        fprintf(f, "  %u: %s\n", i, pdns->search_list[i]);
        }

        if (r->sort_list[0].addr.s_addr != 0)
        {
                fprintf(f, "Sortlist:\n");
                for (i = 0; (r->sort_list[i].addr.s_addr != 0); i++)
                {
                        fprintf(f, "  %u: ", i);
                        a.s_addr = r->sort_list[i].addr.s_addr;
                        fprintf(f, "%s/", inet_ntoa(a));
                        a.s_addr = r->sort_list[i].mask;
                        fprintf(f, "%s\n", inet_ntoa(a));
                }
        }
}

static void
_sdns_print_handle(sdns_handle_t *sdns, FILE *f)
{
        int i;

        if (sdns == NULL)
        {
                fprintf(f, "-nil-\n");
                return;
        }

        for (i = 0; i < sdns->client_count; i++)
        {
                fprintf(f, "DNS client %d\n", i);
                _pdns_print_handle(sdns->client[i], f);
                fprintf(f, "\n");
        }

        fprintf(f, "resolver dir mod time = %u\n", sdns->modtime);
        fprintf(f, "resolver dir stat time = %u\n", sdns->stattime);
        fprintf(f, "resolver dir stat latency = %u\n", sdns->stat_latency);
}

void
dns_print_handle(dns_handle_t d, FILE *f)
{
        dns_private_handle_t *dns;

        _dns_print_lock();

        if (d == NULL)
        {
                fprintf(f, "-nil-\n");
                _dns_print_unlock();
                return;
        }

        dns = (dns_private_handle_t *)d;

        if (dns->handle_type == DNS_PRIVATE_HANDLE_TYPE_SUPER)
        {
                _sdns_print_handle(dns->sdns, f);
        }
        else
        {
                _pdns_print_handle(dns->pdns, f);
        }

        _dns_print_unlock();
}

void
dns_all_server_addrs(dns_handle_t d, struct sockaddr ***addrs, uint32_t *count)
{
        int i, j, k, n, found;
        dns_private_handle_t *dns;
        pdns_handle_t *pdns;
        struct sockaddr *sa;
        struct sockaddr_storage **l;
        res_state r;

        *addrs = NULL;
        *count = 0;
        l = NULL;
        n = 0;

        if (d == NULL) return;

        dns = (dns_private_handle_t *)d;

        if (dns->handle_type != DNS_PRIVATE_HANDLE_TYPE_SUPER) return;

        if (dns->sdns == NULL) return;

        /* Just to initialize / validate clients */
        i = dns_search_list_count(d);

        for (i = 0; i < dns->sdns->client_count; i++)
        {
                pdns = dns->sdns->client[i];
                if (pdns == NULL) continue;

                r = pdns->res;
                if (r == NULL) continue;

                for (j = 0; j < r->nscount; j++)
                {
                        sa = get_nsaddr(r, j);
                        found = 0;
                        for (k = 0; (found == 0) && (k < n); k++)
                        {
                                if (memcmp(l[k], sa, sa->sa_len) == 0) found = 1;
                        }
                        if (found == 1) continue;

                        if (n == 0)
                        {
                                l = (struct sockaddr_storage **)calloc(1, sizeof(struct sockaddr_storage *));
                        }
                        else
                        {
                                l = (struct sockaddr_storage **)reallocf(l, (n + 1) * sizeof(struct sockaddr_storage *));
                        }

                        if (l == NULL) return;

                        l[n] = (struct sockaddr_storage *)calloc(1, sizeof(struct sockaddr_storage));
                        if (l[n] == NULL) return;

                        memset(l[n], 0, sizeof(struct sockaddr_storage));
                        memcpy(l[n], sa, sa->sa_len);
                        n++;
                }
        }

        *addrs = (struct sockaddr **)l;
        *count = n;
}

int
dns_res_once(struct sockaddr *server, struct timeval *timeout, int options, const char *name, int class, int type, u_char *res, int *reslen)
{
        res_state statp;
        int n, fromlen, status;
        struct sockaddr_storage from;
        u_char buf[MAXPACKET];

        if (server == NULL) return DNS_RES_STATUS_INVALID_ARGUMENT;
        if (name == NULL) return DNS_RES_STATUS_INVALID_ARGUMENT;
        if (res == NULL) return DNS_RES_STATUS_INVALID_ARGUMENT;
        if (reslen == NULL) return DNS_RES_STATUS_INVALID_ARGUMENT;

        fromlen = sizeof(struct sockaddr_storage);

        statp = res_state_new();
        statp->retry = 1;
        statp->options = options;
        statp->id = res_randomid();
        if (timeout == NULL) statp->retrans = 5;
        else statp->retrans = timeout->tv_sec;

        statp->ndots = 1;
        statp->_vcsock = -1;
        statp->nscount = 1;

        strcpy(statp->_u._ext.ext->nsuffix, "ip6.arpa");
        strcpy(statp->_u._ext.ext->nsuffix2, "ip6.int");
        strcpy(statp->_u._ext.ext->bsuffix, "ip6.arpa");

        if (server->sa_family == AF_INET6)
        {
                memcpy(&(statp->_u._ext.ext->nsaddrs[0]), server, sizeof(struct sockaddr_in6));
                statp->nsaddr_list[0].sin_family = 0;
        }
        else
        {
                memcpy(&(statp->_u._ext.ext->nsaddrs[0]), server, sizeof(struct sockaddr_in));
                memcpy(&(statp->nsaddr_list[0]), server, sizeof(struct sockaddr_in));
        }

        n = res_nmkquery(statp, ns_o_query, name, class, type, NULL, 0, NULL, buf, sizeof(buf));

        status = dns_res_send(statp, buf, n, res, reslen, (struct sockaddr *)&from, &fromlen);

        res_client_close(statp);

        return status;
}