dns_resolver.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_resolver.h"
#include "udp_socket.h"
#include "tcp_connection.h"
#include "string_help.h"
#include "event.h"
#include "exception.h"
#include "logger.h"

// CL_DNSResolver Construction:

CL_DNSResolver::CL_DNSResolver()
: next_query_id(1)
{
}

CL_DNSResolver::~CL_DNSResolver()
{
}

// CL_DNSResolver Attributes:


// CL_DNSResolver Operations:

CL_DNSResolver::Status CL_DNSResolver::lookup_resource(
        const CL_String &domain_name,
        const CL_String &resource_type,
        std::vector<CL_DNSResourceRecord> &out_records,
        int timeout)
{
        CL_String dns_server_name = "198.41.0.4"; // "192.197.212.68"
        std::vector<CL_DNSResourceRecord> answers, authorities, additionals;
        for (int i=0; i<25; i++)
        {
//              cl_log_event("dns", "looking up %1 for %2, using dns server %3", resource_type, domain_name, dns_server_name);
                answers.clear();
                authorities.clear();
                additionals.clear();
                Status s = perform_query(
                        domain_name,
                        resource_type,
                        answers,
                        authorities,
                        additionals,
                        timeout,
                        dns_server_name);
                if (s == status_data_not_found)
                {
                        if (authorities.empty())
                                return status_data_not_found;
                        if (authorities[0].get_type() != TEXT("NS"))
                                return status_data_not_found;
                        dns_server_name = authorities[0].get_ns_nsdname();
                        continue;
                }
                out_records = answers;
                return s;
        }
        return status_error;
}

// CL_DNSResolver Implementation:

CL_DNSResolver::Status CL_DNSResolver::perform_query(
        const CL_String &domain_name,
        const CL_String &resource_type,
        std::vector<CL_DNSResourceRecord> &out_answer,
        std::vector<CL_DNSResourceRecord> &out_authority,
        std::vector<CL_DNSResourceRecord> &out_additional,
        int timeout,
        const CL_String &dns_server_name)
{
        #define FLAG_QR 1
        #define OPCODE_QUERY 0
        #define OPCODE_IQUERY 1
        #define OPCODE_STATUS 2
        #define FLAG_AA (1<<(15-5))
        #define FLAG_TC (1<<(15-6))
        #define FLAG_RD (1<<(15-7))
        #define FLAG_RA (1<<(15-8))
        #define RCODE_SUCCESS 0
        #define RCODE_FORMAT_ERROR 1
        #define RCODE_SERVER_FAILURE 2
        #define RCODE_NAME_ERROR 3
        #define RCODE_NOT_IMPLEMENTED 4
        #define RCODE_REFUSED 5

        struct Header
        {
                unsigned short id;
                unsigned short command;
                unsigned short qdcount;
                unsigned short ancount;
                unsigned short nscount;
                unsigned short arcount;
        };

        try
        {
                // Convert domain name to be a set of label's (.label1.label2.label3.)
                CL_StringA domain_name_local8 = CL_StringHelp::text_to_local8(domain_name);
                if (domain_name_local8.empty())
                {
                        cl_log_event("dns", "Malformed domain name %1", domain_name_local8);
                        return status_error;
                }
                if (domain_name_local8[0] != '.')
                        domain_name_local8 = "." + domain_name_local8;
                if (domain_name_local8[domain_name_local8.length()-1] != '.')
                        domain_name_local8 = domain_name_local8 + ".";
                if (domain_name_local8.length() == 1)
                {
                        cl_log_event("dns", "Malformed domain name %1", domain_name_local8);
                        return status_error;
                }

                // Query command:
                int query_id = next_query_id++;
                int opcode = OPCODE_QUERY;
                int flags = FLAG_RD;

                // Create packet:       
                int qname_length = domain_name_local8.length();
                int question_length = qname_length + 2 + 2;
                int header_length = 2 * 6;
                CL_ByteArray question_packet(header_length + question_length);
                memset(question_packet.get_data(), 0, question_packet.get_size());

                // Fill Header Section:
                Header *header = (Header *) question_packet.get_data();
                header->id = htons(query_id);
                header->command = htons(flags + (opcode << 11));
                header->qdcount = htons(1);
                header->ancount = htons(0);
                header->nscount = htons(0);
                header->arcount = htons(0);
                
                // Fill Question Section:
                char *qname = question_packet.get_data() + header_length;
                unsigned short &qtype = *(unsigned short *) (qname + qname_length);
                unsigned short &qclass = *(unsigned short *) (qname + qname_length + 2);
                memcpy(qname, domain_name_local8.data(), qname_length);
                int label_pos = 0;
                qname[0] = 0;
                for (int i = 1; i < qname_length; i++)
                {
                        if (qname[i] == '.')
                        {
                                int label_length = i - label_pos - 1;
                                if (label_length <= 0)
                                {
                                        cl_log_event("dns", "Fill Question Section error, i=%1, label_pos=%2, label_length=%3, name=%4", i, label_pos, label_length, domain_name_local8);
                                        return status_error;
                                }
                                qname[i] = 0;
                                qname[label_pos] = label_length;
                                label_pos = i;
                        }
                }
                qtype = htons(CL_DNSResourceRecord::type_to_int(resource_type));
                qclass = htons(CL_DNSResourceRecord::class_to_int(TEXT("IN")));

/*
                // Send packet:
                CL_IPAddress dns_server(dns_server_name, "53");
                CL_UDPSocket sock;
                int sent = sock.send(question_packet.get_data(), question_packet.get_size(), dns_server);
                if (sent < question_packet.get_size())
                        throw CL_Exception("Unable to send DNS udp packet");
*/
                CL_TCPConnection sock;
                sock.connect(dns_server_name, "53");
                unsigned short len = htons(question_packet.get_size());
                sock.send(&len, 2);
                int sent = sock.send(question_packet.get_data(), question_packet.get_size());
                if (sent < question_packet.get_size())
                        throw CL_Exception("Unable to send DNS tcp packet");
                
                while (timeout >= 0)
                {
                        // Wait for response:
                        if (sock.get_read_event()->wait(timeout) == false)
                                return status_timeout;
                                
/*                      
                        // Get answer packet:
                        CL_IPAddress from;
                        CL_ByteArray answer_packet(1024);
                        int bytes_received = sock.receive(answer_packet.get_data(), answer_packet.get_size(), from);
                        if (bytes_received < header_length)
                                return status_error;
                        answer_packet.set_size(bytes_received);
*/
                        sock.receive(&len, 2);
                        len = ntohs(len);
                        CL_ByteArray answer_packet(len);
                        int bytes_received = sock.receive(answer_packet.get_data(), answer_packet.get_size());

                        if (bytes_received < header_length)
                        {
                                cl_log_event("dns", "Invalid answer: bytes_received(%1 bytes) < header_length", bytes_received);
                                return status_error;
                        }
                
                        // Parse answer packet:
                        Header *answer_header = (Header *) answer_packet.get_data();
                        if (ntohs(answer_header->id) != query_id)
                        {
                                // Wrong packet. Go back on waiting.
                                timeout -= 250;
                                continue;
                        }
                        
                        int rcode = (ntohs(answer_header->command) & 0x000f);
                        switch (rcode)
                        {
                        case RCODE_SUCCESS:
                                break;
                        case RCODE_NAME_ERROR:
                                cl_log_event("dns", "RCODE_NAME_ERROR");
                                return status_name_not_found;
                        case RCODE_FORMAT_ERROR:
                                cl_log_event("dns", "RCODE_FORMAT_ERROR");
                                return status_error;
                        case RCODE_SERVER_FAILURE:
                                cl_log_event("dns", "RCODE_SERVER_FAILURE");
                                return status_error;
                        case RCODE_NOT_IMPLEMENTED:
                                cl_log_event("dns", "RCODE_NOT_IMPLEMENTED");
                                return status_error;
                        case RCODE_REFUSED:
                                cl_log_event("dns", "RCODE_REFUSED");
                                return status_error;
                        default:
                                cl_log_event("dns", "Unkown rcode %1", rcode);
                                return status_error;
                        }
                        
                        int question_count = ntohs(answer_header->qdcount);
                        int answer_count = ntohs(answer_header->ancount);
                        int authority_count = ntohs(answer_header->nscount);
                        int additional_count = ntohs(answer_header->arcount);
                        
                        int pos = header_length;
                        int size = answer_packet.get_size();
                        
                        // Read question section:                       
                        for (int index_question = 0; index_question < question_count; index_question++)
                        {
                                try
                                {
                                        pos = CL_DNSResourceRecord::find_domain_name_end(answer_packet, pos) + 2 + 2;
                                }
                                catch (CL_Exception e)
                                {
                                        cl_log_event("dns", "Read question section error [%1]: %2", index_question, e.message);
                                        return status_error;
                                }
                        }
                        
                        std::vector<CL_DNSResourceRecord> answers, authorities, additionals;

                        // Read answer section:
                        for (int index_answer = 0; index_answer < answer_count; index_answer++)
                        {
                                CL_DNSResourceRecord record;
                                bool result = read_record(answer_packet, pos, record);
                                if (result == false)
                                {
                                        cl_log_event("dns", "Read answer %1 section RR failed", index_answer);
                                        return status_error;
                                }
                                answers.push_back(record);
                        }

                        // Read authority section:
                        for (int index_authority = 0; index_authority < authority_count; index_authority++)
                        {
                                CL_DNSResourceRecord record;
                                bool result = read_record(answer_packet, pos, record);
                                if (result == false)
                                {
                                        cl_log_event("dns", "Read authority %1 section RR failed", index_authority);
                                        return status_error;
                                }
                                authorities.push_back(record);
                        }
                        
                        // Read additional section:
                        for (int index_additional = 0; index_additional < additional_count; index_additional++)
                        {
                                CL_DNSResourceRecord record;
                                bool result = read_record(answer_packet, pos, record);
                                if (result == false)
                                {
                                        cl_log_event("dns", "Read additional %1 section RR failed", index_additional);
                                        return status_error;
                                }
                                additionals.push_back(record);
                        }
                        
                        out_answer = answers;
                        out_authority = authorities;
                        out_additional = additionals;
                        
                        if (answer_count == 0)
                                return status_data_not_found;

                        return status_success;
                }

                return status_timeout;
        }
        catch (CL_Exception e)
        {
                cl_log_event("dns", "Exception: %1", e.message);
                return status_error;
        }
}

bool CL_DNSResolver::read_record(CL_ByteArray &packet, int &pos, CL_DNSResourceRecord &out_record)
{
        try
        {
                out_record.set_record(packet, pos);
                pos = out_record.get_rdata_offset() + out_record.get_rdata_length();
                return true;
        }
        catch (CL_Exception e)
        {
                return false;
        }
}

---