NetClientDns.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "Net.hpp"
#include "NetClientDns.hpp"
#include "LibEndian.hpp"
#include "RtosInclude.hpp"
#include "LibStreamOutArray.hpp"

NetUdpSocket NetClientDns::sSocket;
RtosSemaphore NetClientDns::sSema(1, 1);

bool NetClientDns::resolve(const char* name, NetDefs::IP_ADDR* ipAddr) {
    sSema.take(Rtos::TICK_INFINITE);
    sSocket.open();

    NetUdpSocket::TX_PACKET* txPkt = sSocket.allocTxPacket(512);
    if (txPkt == 0) {
        sSema.give(Rtos::TICK_INFINITE);
        return false;
    }

    uint16_t id = Rtos::getTick();

    { //Send request
        NetDefs::DNS_PKT* dnsPkt = (NetDefs::DNS_PKT*) txPkt->data;

        dnsPkt->hdr.id = id;
        dnsPkt->hdr.flags.value = 0;
        dnsPkt->hdr.flags.bits.qr = true;
        dnsPkt->hdr.questionCount = 1;
        dnsPkt->hdr.answerRecordCount = 0;
        dnsPkt->hdr.authorityRecordCount = 0;
        dnsPkt->hdr.additionalRecordCount = 0;
        swapHeader(&dnsPkt->hdr);

        bool loop = true;
        LibStreamOutArray stream(dnsPkt->data, 512 - sizeof(dnsPkt->hdr));
        for (int i = 0; loop;) {
            int next = i;
            while (true) {
                char c = name[next++];
                if (c == '.') {
                    break;
                }
                else if (c == 0) {
                    loop = false;
                    break;
                }
                else if (next >= 64) {
                    loop = false;
                    break;
                }
            }
            uint8_t len = (next - i) - 1;
            stream.write(&len, 1);
            stream.write((uint8_t*) &name[i], len);
            i = next;
        }

        uint8_t trail[] = {
                0x00, 0x00, 0x01, 0x00, 0x01 };
        stream.write(trail, sizeof(trail));

        txPkt->hdr.port = 53;
        txPkt->hdr.ip = Net::getConfig().dnsIpAddr;
        sSocket.sendPacket(*txPkt, sizeof(dnsPkt->hdr) + stream.getPosition());
    }

    bool result = false;
    { //Recv Reply
        NetUdpSocket::RX_PACKET* rxPkt = sSocket.recvPacket(Rtos::convertMsToTick(5000));

        if (rxPkt != 0) {
            NetDefs::DNS_PKT* dnsPkt = (NetDefs::DNS_PKT*) rxPkt->data;
            swapHeader(&dnsPkt->hdr);
            if (dnsPkt->hdr.id == id && dnsPkt->hdr.answerRecordCount > 0 && dnsPkt->hdr.flags.bits.qr /*&& (dnsPkt->hdr.flags.bits.rcode == 0)*/) {

                int i = 0;
                bool exit = false;
                for (int count = 0; count < dnsPkt->hdr.questionCount; count++) {
                    if (dnsPkt->data[i] < 64) {
                        while (dnsPkt->data[i++] != 0) {
                        }
                        i += 4;
                    }
                    else if (dnsPkt->data[i] >= 192) {
                        i += 6;
                    }
                    else {
                        exit = true;
                        break;
                    }
                }

                //Iterate through responses
                for (int count = 0; !exit && count < dnsPkt->hdr.answerRecordCount; count++) {
                    if (dnsPkt->data[i] < 64) {
                        while (dnsPkt->data[i++] != 0) {
                        }
                    }
                    else if (dnsPkt->data[i] >= 192) {
                        i += 2;
                    }
                    else {
                        exit = true;
                        break;
                    }

                    if ((dnsPkt->data[i] == 0) && (dnsPkt->data[i + 1] == 1) && //Type == Type A
                            (dnsPkt->data[i + 2] == 0) && (dnsPkt->data[i + 3] == 1) && //Class = IN
                            (dnsPkt->data[i + 8] == 0) && (dnsPkt->data[i + 9] == 4)) { //Rdata len == 4
                        memcpy(ipAddr, &dnsPkt->data[i + 10], 4);
                        exit = true;
                        result = true;
                        break;
                    }
                    else {
                        //Skip type, class, TTL, Rdata len, Rdata
                        i += 10 + (uint16_t) dnsPkt->data[i + 8] + (uint16_t) dnsPkt->data[i + 9];
                    }
                }
            }
            sSocket.discardRxPacket(rxPkt);
        }
    }

    sSocket.close();
    sSema.give(Rtos::TICK_INFINITE);

    return result;
}

void NetClientDns::swapHeader(NetDefs::DNS_HEADER* header) {
    header->id = LibEndian::hwToBe(header->id);
    header->questionCount = LibEndian::hwToBe(header->questionCount);
    header->answerRecordCount = LibEndian::hwToBe(header->answerRecordCount);
    header->authorityRecordCount = LibEndian::hwToBe(header->authorityRecordCount);
    header->additionalRecordCount = LibEndian::hwToBe(header->additionalRecordCount);
}