Quadrotor

// Arduino DNS client for WizNet5100-based Ethernet shield

// (c) Copyright 2009-2010 MCQN Ltd.

// Released under Apache License, version 2.0

#include "w5100.h"

#include "EthernetUdp.h"

#include "util.h"

#include "Dns.h"

#include <string.h>

//#include <stdlib.h>

#include "Arduino.h"

#define SOCKET_NONE        255

// Various flags and header field values for a DNS message

#define UDP_HEADER_SIZE        8

#define DNS_HEADER_SIZE        12

#define TTL_SIZE        4

#define QUERY_FLAG               (0)

#define RESPONSE_FLAG            (1<<15)

#define QUERY_RESPONSE_MASK      (1<<15)

#define OPCODE_STANDARD_QUERY    (0)

#define OPCODE_INVERSE_QUERY     (1<<11)

#define OPCODE_STATUS_REQUEST    (2<<11)

#define OPCODE_MASK              (15<<11)

#define AUTHORITATIVE_FLAG       (1<<10)

#define TRUNCATION_FLAG          (1<<9)

#define RECURSION_DESIRED_FLAG   (1<<8)

#define RECURSION_AVAILABLE_FLAG (1<<7)

#define RESP_NO_ERROR            (0)

#define RESP_FORMAT_ERROR        (1)

#define RESP_SERVER_FAILURE      (2)

#define RESP_NAME_ERROR          (3)

#define RESP_NOT_IMPLEMENTED     (4)

#define RESP_REFUSED             (5)

#define RESP_MASK                (15)

#define TYPE_A                   (0x0001)

#define CLASS_IN                 (0x0001)

#define LABEL_COMPRESSION_MASK   (0xC0)

// Port number that DNS servers listen on

#define DNS_PORT        53

// Possible return codes from ProcessResponse

#define SUCCESS          1

#define TIMED_OUT        -1

#define INVALID_SERVER   -2

#define TRUNCATED        -3

#define INVALID_RESPONSE -4

void DNSClient::begin(const IPAddress& aDNSServer)

{

    iDNSServer = aDNSServer;

    iRequestId = 0;

}

int DNSClient::inet_aton(const char* aIPAddrString, IPAddress& aResult)

{

    // See if we've been given a valid IP address

    const char* p =aIPAddrString;

    while (*p &&

           ( (*p == '.') || (*p >= '0') || (*p <= '9') ))

    {

        p++;

    }

    if (*p == '\0')

    {

        // It's looking promising, we haven't found any invalid characters

        p = aIPAddrString;

        int segment =0;

        int segmentValue =0;

        while (*p && (segment < 4))

        {

            if (*p == '.')

            {

                // We've reached the end of a segment

                if (segmentValue > 255)

                {

                    // You can't have IP address segments that don't fit in a byte

                    return 0;

                }

                else

                {

                    aResult[segment] = (byte)segmentValue;

                    segment++;

                    segmentValue = 0;

                }

            }

            else

            {

                // Next digit

                segmentValue = (segmentValue*10)+(*p - '0');

            }

            p++;

        }

        // We've reached the end of address, but there'll still be the last

        // segment to deal with

        if ((segmentValue > 255) || (segment > 3))

        {

            // You can't have IP address segments that don't fit in a byte,

            // or more than four segments

            return 0;

        }

        else

        {

            aResult[segment] = (byte)segmentValue;

            return 1;

        }

    }

    else

    {

        return 0;

    }

}

int DNSClient::getHostByName(const char* aHostname, IPAddress& aResult)

{

    int ret =0;

    // See if it's a numeric IP address

    if (inet_aton(aHostname, aResult))

    {

        // It is, our work here is done

        return 1;

    }

    // Check we've got a valid DNS server to use

    if (iDNSServer == INADDR_NONE)

    {

        return INVALID_SERVER;

    }

    // Find a socket to use

    if (iUdp.begin(1024+(millis() & 0xF)) == 1)

    {

        // Try up to three times

        int retries = 0;

//        while ((retries < 3) && (ret <= 0))

        {

            // Send DNS request

            ret = iUdp.beginPacket(iDNSServer, DNS_PORT);

            if (ret != 0)

            {

                // Now output the request data

                ret = BuildRequest(aHostname);

                if (ret != 0)

                {

                    // And finally send the request

                    ret = iUdp.endPacket();

                    if (ret != 0)

                    {

                        // Now wait for a response

                        int wait_retries = 0;

                        ret = TIMED_OUT;

                        while ((wait_retries < 3) && (ret == TIMED_OUT))

                        {

                            ret = ProcessResponse(5000, aResult);

                            wait_retries++;

                        }

                    }

                }

            }

            retries++;

        }

        // We're done with the socket now

        iUdp.stop();

    }

    return ret;

}

uint16_t DNSClient::BuildRequest(const char* aName)

{

    // Build header

    //                                    1  1  1  1  1  1

    //      0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5

    //    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

    //    |                      ID                       |

    //    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

    //    |QR|   Opcode  |AA|TC|RD|RA|   Z    |   RCODE   |

    //    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

    //    |                    QDCOUNT                    |

    //    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

    //    |                    ANCOUNT                    |

    //    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

    //    |                    NSCOUNT                    |

    //    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

    //    |                    ARCOUNT                    |

    //    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

    // As we only support one request at a time at present, we can simplify

    // some of this header

    iRequestId = millis(); // generate a random ID

    uint16_t twoByteBuffer;

    // FIXME We should also check that there's enough space available to write to, rather

    // FIXME than assume there's enough space (as the code does at present)

    iUdp.write((uint8_t*)&iRequestId, sizeof(iRequestId));

    twoByteBuffer = htons(QUERY_FLAG | OPCODE_STANDARD_QUERY | RECURSION_DESIRED_FLAG);

    iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));

    twoByteBuffer = htons(1);  // One question record

    iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));

    twoByteBuffer = 0;  // Zero answer records

    iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));

    iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));

    // and zero additional records

    iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));

    // Build question

    const char* start =aName;

    const char* end =start;

    uint8_t len;

    // Run through the name being requested

    while (*end)

    {

        // Find out how long this section of the name is

        end = start;

        while (*end && (*end != '.') )

        {

            end++;

        }

        if (end-start > 0)

        {

            // Write out the size of this section

            len = end-start;

            iUdp.write(&len, sizeof(len));

            // And then write out the section

            iUdp.write((uint8_t*)start, end-start);

        }

        start = end+1;

    }

    // We've got to the end of the question name, so

    // terminate it with a zero-length section

    len = 0;

    iUdp.write(&len, sizeof(len));

    // Finally the type and class of question

    twoByteBuffer = htons(TYPE_A);

    iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));

    twoByteBuffer = htons(CLASS_IN);  // Internet class of question

    iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));

    // Success!  Everything buffered okay

    return 1;

}

uint16_t DNSClient::ProcessResponse(uint16_t aTimeout, IPAddress& aAddress)

{

    uint32_t startTime = millis();

    // Wait for a response packet

    while(iUdp.parsePacket() <= 0)

    {

        if((millis() - startTime) > aTimeout)

            return TIMED_OUT;

        delay(50);

    }

    // We've had a reply!

    // Read the UDP header

    uint8_t header[DNS_HEADER_SIZE]; // Enough space to reuse for the DNS header

    // Check that it's a response from the right server and the right port

    if ( (iDNSServer != iUdp.remoteIP()) || 

        (iUdp.remotePort() != DNS_PORT) )

    {

        // It's not from who we expected

        return INVALID_SERVER;

    }

    // Read through the rest of the response

    if (iUdp.available() < DNS_HEADER_SIZE)

    {

        return TRUNCATED;

    }

    iUdp.read(header, DNS_HEADER_SIZE);

    uint16_t header_flags = htons(*((uint16_t*)&header[2]));

    // Check that it's a response to this request

    if ( ( iRequestId != (*((uint16_t*)&header[0])) ) ||

        ((header_flags & QUERY_RESPONSE_MASK) != (uint16_t)RESPONSE_FLAG) )

    {

        // Mark the entire packet as read

        iUdp.flush();

        return INVALID_RESPONSE;

    }

    // Check for any errors in the response (or in our request)

    // although we don't do anything to get round these

    if ( (header_flags & TRUNCATION_FLAG) || (header_flags & RESP_MASK) )

    {

        // Mark the entire packet as read

        iUdp.flush();

        return -5; //INVALID_RESPONSE;

    }

    // And make sure we've got (at least) one answer

    uint16_t answerCount = htons(*((uint16_t*)&header[6]));

    if (answerCount == 0 )

    {

        // Mark the entire packet as read

        iUdp.flush();

        return -6; //INVALID_RESPONSE;

    }

    // Skip over any questions

    for (uint16_t i =0; i < htons(*((uint16_t*)&header[4])); i++)

    {

        // Skip over the name

        uint8_t len;

        do

        {

            iUdp.read(&len, sizeof(len));

            if (len > 0)

            {

                // Don't need to actually read the data out for the string, just

                // advance ptr to beyond it

                while(len--)

                {

                    iUdp.read(); // we don't care about the returned byte

                }

            }

        } while (len != 0);

        // Now jump over the type and class

        for (int i =0; i < 4; i++)

        {

            iUdp.read(); // we don't care about the returned byte

        }

    }

    // Now we're up to the bit we're interested in, the answer

    // There might be more than one answer (although we'll just use the first

    // type A answer) and some authority and additional resource records but

    // we're going to ignore all of them.

    for (uint16_t i =0; i < answerCount; i++)

    {

        // Skip the name

        uint8_t len;

        do

        {

            iUdp.read(&len, sizeof(len));

            if ((len & LABEL_COMPRESSION_MASK) == 0)

            {

                // It's just a normal label

                if (len > 0)

                {

                    // And it's got a length

                    // Don't need to actually read the data out for the string,

                    // just advance ptr to beyond it

                    while(len--)

                    {

                        iUdp.read(); // we don't care about the returned byte

                    }

                }

            }

            else

            {

                // This is a pointer to a somewhere else in the message for the

                // rest of the name.  We don't care about the name, and RFC1035

                // says that a name is either a sequence of labels ended with a

                // 0 length octet or a pointer or a sequence of labels ending in

                // a pointer.  Either way, when we get here we're at the end of

                // the name

                // Skip over the pointer

                iUdp.read(); // we don't care about the returned byte

                // And set len so that we drop out of the name loop

                len = 0;

            }

        } while (len != 0);

        // Check the type and class

        uint16_t answerType;

        uint16_t answerClass;

        iUdp.read((uint8_t*)&answerType, sizeof(answerType));

        iUdp.read((uint8_t*)&answerClass, sizeof(answerClass));

        // Ignore the Time-To-Live as we don't do any caching

        for (int i =0; i < TTL_SIZE; i++)

        {

            iUdp.read(); // we don't care about the returned byte

        }

        // And read out the length of this answer

        // Don't need header_flags anymore, so we can reuse it here

        iUdp.read((uint8_t*)&header_flags, sizeof(header_flags));

        if ( (htons(answerType) == TYPE_A) && (htons(answerClass) == CLASS_IN) )

        {

            if (htons(header_flags) != 4)

            {

                // It's a weird size

                // Mark the entire packet as read

                iUdp.flush();

                return -9;//INVALID_RESPONSE;

            }

            iUdp.read(aAddress.raw_address(), 4);

            return SUCCESS;

        }

        else

        {

            // This isn't an answer type we're after, move onto the next one

            for (uint16_t i =0; i < htons(header_flags); i++)

            {

                iUdp.read(); // we don't care about the returned byte

            }

        }

    }

    // Mark the entire packet as read

    iUdp.flush();

    // If we get here then we haven't found an answer

    return -10;//INVALID_RESPONSE;

}