dns_resource_record.cpp

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "precomp.h"
#include "dns_resource_record.h"
#include "string_help.h"
#include "exception.h"
#ifdef WIN32
#include <winsock.h>
#else
#include <sys/types.h>
#include <netinet/in.h>
#endif

// CL_DNSResourceRecord Construction:

CL_DNSResourceRecord::CL_DNSResourceRecord()
: record_offset(0), rdata_offset(0), rdata_length(0)
{
}
        
CL_DNSResourceRecord::CL_DNSResourceRecord(const CL_DNSResourceRecord &other)
: record_offset(0), rdata_offset(0), rdata_length(0)
{
        packet = other.packet;
        record_offset = other.record_offset;
        rdata_offset = other.rdata_offset;
        rdata_length = other.rdata_length;
}

CL_DNSResourceRecord::~CL_DNSResourceRecord()
{
}

// CL_DNSResourceRecord Attributes:

CL_String CL_DNSResourceRecord::get_name() const
{
        return read_domain_name(packet, record_offset);
}

CL_String CL_DNSResourceRecord::get_type() const
{
        int type_offset = find_domain_name_end(packet, record_offset);
        int rr_data_offset = type_offset + 2 + 2 + 4 + 2;
        if (packet.get_size() < rr_data_offset)
                throw CL_Exception(TEXT("Premature end of DNS resource record"));
        unsigned short rr_type = ntohs(*(unsigned short *) (packet.get_data() + type_offset));
        unsigned short rr_class = ntohs(*(unsigned short *) (packet.get_data() + type_offset+2));
        unsigned int rr_ttl = ntohl(*(unsigned int *) (packet.get_data() + type_offset+4));
        unsigned short rr_data_length = ntohs(*(unsigned short *) (packet.get_data() + type_offset+8));
        return type_from_int(rr_type);
}

CL_String CL_DNSResourceRecord::get_class() const
{
        int type_offset = find_domain_name_end(packet, record_offset);
        int rr_data_offset = type_offset + 2 + 2 + 4 + 2;
        if (packet.get_size() < rr_data_offset)
                throw CL_Exception(TEXT("Premature end of DNS resource record"));
        unsigned short rr_type = ntohs(*(unsigned short *) (packet.get_data() + type_offset));
        unsigned short rr_class = ntohs(*(unsigned short *) (packet.get_data() + type_offset+2));
        unsigned int rr_ttl = ntohl(*(unsigned int *) (packet.get_data() + type_offset+4));
        unsigned short rr_data_length = ntohs(*(unsigned short *) (packet.get_data() + type_offset+8));
        return class_from_int(rr_class);
}

int CL_DNSResourceRecord::get_ttl() const
{
        int type_offset = find_domain_name_end(packet, record_offset);
        int rr_data_offset = type_offset + 2 + 2 + 4 + 2;
        if (packet.get_size() < rr_data_offset)
                throw CL_Exception(TEXT("Premature end of DNS resource record"));
        unsigned short rr_type = ntohs(*(unsigned short *) (packet.get_data() + type_offset));
        unsigned short rr_class = ntohs(*(unsigned short *) (packet.get_data() + type_offset+2));
        unsigned int rr_ttl = ntohl(*(unsigned int *) (packet.get_data() + type_offset+4));
        unsigned short rr_data_length = ntohs(*(unsigned short *) (packet.get_data() + type_offset+8));
        return rr_ttl;
}

const CL_ByteArray &CL_DNSResourceRecord::get_packet() const
{
        return packet;
}

int CL_DNSResourceRecord::get_record_offset() const
{
        return record_offset;
}

int CL_DNSResourceRecord::get_rdata_offset() const
{
        return rdata_offset;
}

int CL_DNSResourceRecord::get_rdata_length() const
{
        return rdata_length;
}

CL_String CL_DNSResourceRecord::get_cname_cname() const
{
        return read_domain_name(packet, rdata_offset);
}

int CL_DNSResourceRecord::get_mx_preference() const
{
        if (packet.get_size() < rdata_offset + 2)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        short *preference = (short *) (packet.get_data() + rdata_offset);
        return ntohs(*preference);
}
        
CL_String CL_DNSResourceRecord::get_mx_exchange() const
{
        return read_domain_name(packet, rdata_offset + 2);
}
        
CL_String CL_DNSResourceRecord::get_ns_nsdname() const
{
        return read_domain_name(packet, rdata_offset);
}
        
CL_String CL_DNSResourceRecord::get_ptr_ptrdname() const
{
        return read_domain_name(packet, rdata_offset);
}
        
CL_String CL_DNSResourceRecord::get_soa_mname() const
{
        return read_domain_name(packet, rdata_offset);
}
        
CL_String CL_DNSResourceRecord::get_soa_rname() const
{
        int pos = find_domain_name_end(packet, rdata_offset);
        return read_domain_name(packet, pos);
}
        
unsigned int CL_DNSResourceRecord::get_soa_serial() const
{
        int pos = find_domain_name_end(packet, rdata_offset);
        pos = find_domain_name_end(packet, pos);
        if (packet.get_size() < pos + 4)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        unsigned int *serial = (unsigned int *) (packet.get_data() + pos);
        return ntohl(*serial);
}
        
int CL_DNSResourceRecord::get_soa_refresh() const
{
        int pos = find_domain_name_end(packet, rdata_offset);
        pos = find_domain_name_end(packet, pos) + 4;
        if (packet.get_size() < pos + 4)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        int *refresh = (int *) (packet.get_data() + pos);
        return ntohl(*refresh);
}
        
int CL_DNSResourceRecord::get_soa_retry() const
{
        int pos = find_domain_name_end(packet, rdata_offset);
        pos = find_domain_name_end(packet, pos) + 8;
        if (packet.get_size() < pos + 4)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        int *retry = (int *) (packet.get_data() + pos);
        return ntohl(*retry);
}
        
int CL_DNSResourceRecord::get_soa_expire() const
{
        int pos = find_domain_name_end(packet, rdata_offset);
        pos = find_domain_name_end(packet, pos) + 12;
        if (packet.get_size() < pos + 4)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        int *expire = (int *) (packet.get_data() + pos);
        return ntohl(*expire);
}
        
unsigned int CL_DNSResourceRecord::get_soa_minimum() const
{
        int pos = find_domain_name_end(packet, rdata_offset);
        pos = find_domain_name_end(packet, pos) + 16;
        if (packet.get_size() < pos + 4)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        unsigned int *minimum = (unsigned int *) (packet.get_data() + pos);
        return ntohl(*minimum);
}
        
unsigned int CL_DNSResourceRecord::get_wks_address() const
{
        if (packet.get_size() < rdata_offset + 4)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        unsigned int *address = (unsigned int *) (packet.get_data() + rdata_offset);
        return ntohs(*address);
}
        
unsigned char CL_DNSResourceRecord::get_wks_protocol() const
{
        if (packet.get_size() < rdata_offset + 5)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        unsigned char *protocol = (unsigned char *) (packet.get_data() + rdata_offset + 4);
        return *protocol;
}
        
CL_ByteArray CL_DNSResourceRecord::get_wks_bit_map() const
{
        int len = rdata_length - 5;
        if (len < 0)
                throw CL_Exception(TEXT("Premature end of resource data section"));
        CL_ByteArray bit_map(len);
        memcpy(bit_map.get_data(), packet.get_data() + rdata_offset + 5, len);
        return bit_map;
}

// CL_DNSResourceRecord Operation:

CL_DNSResourceRecord &CL_DNSResourceRecord::operator =(const CL_DNSResourceRecord &other)
{
        packet = other.packet;
        record_offset = other.record_offset;
        rdata_offset = other.rdata_offset;
        rdata_length = other.rdata_length;
        return *this;
}

void CL_DNSResourceRecord::set_record(const CL_ByteArray &new_packet, int new_record_offset)
{
        // Verify size sanity of generic record fields:
        
        int type_offset = find_domain_name_end(new_packet, new_record_offset);
        int rr_data_offset = type_offset + 2 + 2 + 4 + 2;
        if (new_packet.get_size() < rr_data_offset)
                throw CL_Exception(TEXT("Premature end of DNS resource record"));
        
        unsigned short rr_type = ntohs(*(unsigned short *) (new_packet.get_data() + type_offset));
        unsigned short rr_class = ntohs(*(unsigned short *) (new_packet.get_data() + type_offset+2));
        unsigned int rr_ttl = ntohl(*(unsigned int *) (new_packet.get_data() + type_offset+4));
        unsigned short rr_data_length = ntohs(*(unsigned short *) (new_packet.get_data() + type_offset+8));

        if (new_packet.get_size() < rr_data_offset + rr_data_length)
                throw CL_Exception(TEXT("Premature end of DNS resource record RDATA section"));

        // Generic record fields seem sane. Store record:

        packet = new_packet;
        rdata_offset = rr_data_offset;
        rdata_length = rr_data_length;
        record_offset = new_record_offset;
}

struct RRType
{
        char *name;
        int value;
        char *description;
};

static RRType rr_types[] =
{
        "A",     1,  "a host address",
        "NS",    2,  "an authoritative name server",
        "MD",    3,  "a mail destination (Obsolete - use MX)",
        "MF",    4,  "a mail forwarder (Obsolete - use MX)",
        "CNAME", 5,  "the canonical name for an alias",
        "SOA",   6,  "marks the start of a zone of authority",
        "MB",    7,  "a mailbox domain name (EXPERIMENTAL)",
        "MG",    8,  "a mail group member (EXPERIMENTAL)",
        "MR",    9,  "a mail rename domain name (EXPERIMENTAL)",
        "NULL",  10, "a null RR (EXPERIMENTAL)",
        "WKS",   11, "a well known service description",
        "PTR",   12, "a domain name pointer",
        "HINFO", 13, "host information",
        "MINFO", 14, "mailbox or mail list information",
        "MX",    15, "mail exchange",
        "TXT",   16, "text strings",
        "AXFR",  252, "qtype: A request for a transfer of an entire zone",
        "MAILB", 253, "qtype: A request for mailbox-related records (MB, MG or MR)",
        "MAILA", 254, "qtype: A request for mail agent RRs (Obsolete - see MX)",
        "*",     255, "qtype: A request for all records",
        0,       0,  0
};

struct ClassType
{
        char *name;
        int value;
        char *description;
};
        
static ClassType class_types[] =
{
        "IN",    1,   "the Internet",
        "CS",    2,   "the CSNET class (Obsolete)",
        "CH",    3,   "the CHAOS class",
        "HS",    4,   "Hesiod [Dyer 87]",
        "*",     255, "qclass: Any class",
        0,       0,   0
};

int CL_DNSResourceRecord::type_to_int(const CL_String &qtype)
{
        CL_StringA qtype_local8 = CL_StringHelp::text_to_local8(qtype);
        for (int index = 0; rr_types[index].name != 0; index++)
        {
                if (rr_types[index].name == qtype_local8)
                        return rr_types[index].value;
        }
        
        int value = CL_StringHelp::local8_to_int(qtype_local8);
        if (value <= 0)
                throw CL_Exception(TEXT("Unknown DNS resource record type ") + qtype);
        return value;
}

CL_String CL_DNSResourceRecord::type_from_int(int qtype)
{
        for (int index = 0; rr_types[index].name != 0; index++)
        {
                if (rr_types[index].value == qtype)
                        return CL_StringHelp::local8_to_text(rr_types[index].name);
        }
        return CL_StringHelp::int_to_text(qtype);
}

CL_String CL_DNSResourceRecord::type_description(const CL_String &qtype)
{
        CL_StringA qtype_local8 = CL_StringHelp::text_to_local8(qtype);
        for (int index = 0; rr_types[index].name != 0; index++)
        {
                if (rr_types[index].name == qtype_local8)
                        return CL_StringHelp::local8_to_text(rr_types[index].description);
        }
        return TEXT("Unknown type ") + qtype;
}

CL_String CL_DNSResourceRecord::type_description(int qtype)
{
        for (int index = 0; rr_types[index].name != 0; index++)
        {
                if (rr_types[index].value == qtype)
                        return CL_StringHelp::local8_to_text(rr_types[index].description);
        }
        return TEXT("Unknown type ") + CL_StringHelp::int_to_text(qtype);
}

int CL_DNSResourceRecord::class_to_int(const CL_String &qclass)
{
        CL_StringA qclass_local8 = CL_StringHelp::text_to_local8(qclass);
        for (int index = 0; class_types[index].name != 0; index++)
        {
                if (class_types[index].name == qclass_local8)
                        return class_types[index].value;
        }
        
        int value = CL_StringHelp::local8_to_int(qclass_local8);
        if (value <= 0)
                throw CL_Exception(TEXT("Unknown DNS resource record type ") + qclass);
        return value;
}

CL_String CL_DNSResourceRecord::class_from_int(int qclass)
{
        for (int index = 0; class_types[index].name != 0; index++)
        {
                if (class_types[index].value == qclass)
                        return CL_StringHelp::local8_to_text(class_types[index].name);
        }
        return CL_StringHelp::int_to_text(qclass);
}

CL_String CL_DNSResourceRecord::class_description(const CL_String &qclass)
{
        CL_StringA qclass_local8 = CL_StringHelp::text_to_local8(qclass);
        for (int index = 0; class_types[index].name != 0; index++)
        {
                if (class_types[index].name == qclass_local8)
                        return CL_StringHelp::local8_to_text(class_types[index].description);
        }
        return TEXT("Unknown class ") + qclass;
}

CL_String CL_DNSResourceRecord::class_description(int qclass)
{
        for (int index = 0; class_types[index].name != 0; index++)
        {
                if (class_types[index].value == qclass)
                        return CL_StringHelp::local8_to_text(class_types[index].description);
        }
        return TEXT("Unknown class ") + CL_StringHelp::int_to_text(qclass);
}

// CL_DNSResourceRecord Implementation:

int CL_DNSResourceRecord::find_domain_name_end(const CL_ByteArray &packet, int offset)
{
        const unsigned char *data = (const unsigned char *) packet.get_data();
        while (true)
        {
                if (offset >= packet.get_size())
                        throw CL_Exception(TEXT("Premature end of resource data domain name"));

                if (data[offset] > 0 && data[offset] < 64)
                {
                        offset += data[offset] + 1;
                }
                else if ((data[offset] & 0xc0) == 0xc0)
                {
                        offset += 2;
                        break;
                }
                else if (data[offset] == 0)
                {
                        offset++;
                        break;
                }
                else
                {
                        throw CL_Exception(TEXT("Malformed resource data domain name (find_domain_name_end)"));
                }
        }
        return offset;
}
        
CL_String CL_DNSResourceRecord::read_domain_name(const CL_ByteArray &packet, int offset)
{
        CL_String name;
        const unsigned char *data = (const unsigned char *) packet.get_data();
        while (true)
        {
                if (offset >= packet.get_size())
                        throw CL_Exception(TEXT("Premature end of resource data domain name"));
                        
                if (data[offset] > 0 && data[offset] < 64)
                {
                        if (offset+1+data[offset] >= packet.get_size())
                                throw CL_Exception(TEXT("Premature end of resource data domain name"));
                        
                        if (!name.empty())
                                name.append(TEXT("."));

                        name.append(CL_StringHelp::local8_to_text(CL_StringA((const char *) data+offset+1, data[offset])));
                        offset += data[offset] + 1;

                        if (name.length() > 512)
                                throw CL_Exception(TEXT("Domain name exceeds 512 characters!"));
                }
                else if ((data[offset] & 0xc0) == 0xc0)
                {
                        if (offset+1 >= packet.get_size())
                                throw CL_Exception(TEXT("Premature end of resource data domain name"));
                
                        offset = (int(data[offset] & 0x3f) << 8) + data[offset+1];
                }
                else if (data[offset] == 0)
                {
                        break;
                }
                else
                {
                        throw CL_Exception(TEXT("Malformed resource data domain name"));
                }
        }
        return name;
}

---