Diff: Dns.cpp

Revision:

0:5350a66d5279

Child:

2:049ce85163c5

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Dns.cpp	Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,454 @@
+// mbed DNS client for Enc28J60-based Ethernet shield
+// (c) Copyright 2009-2010 MCQN Ltd.
+// Released under Apache License, version 2.0
+#include "Udp.h"
+#include "util.h"
+
+#include "Dns.h"
+#include <string.h>
+//#include <stdlib.h>
+
+#include "mbed.h"
+#include "uip_clock.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
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void DNSClient::begin(const IPAddress& aDNSServer) {
+    iDNSServer = aDNSServer;
+    iRequestId = 0;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+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] = (uint8_t) 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] = (uint8_t) segmentValue;
+            return 1;
+        }
+    }
+    else {
+        return 0;
+    }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+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 + (clock_time() & 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;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+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 = clock_time();          // 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;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t DNSClient::ProcessResponse(uint16_t aTimeout, IPAddress& aAddress) {
+    uint32_t    startTime = clock_time();
+
+    // Wait for a response packet
+
+    while(iUdp.parsePacket() <= 0) {
+        if((clock_time() - startTime) > aTimeout)
+            return TIMED_OUT;
+        wait(0.050);
+    }
+
+    // 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;
+}
+