Added IPv6 support to DNS query

To avoid complications with unexpected IP versions, the wanted
IP version was added as an extra argument to DNS query functions
(defaults to NSAPI_IPv4).

Internal API changes:
m nsapi_dns_query
m nsapi_dns_query_multiple

Interestingly, though multiple questions can be encoded in a single
DNS packet, few, if any, nameservers respect any but the first
question. This makes support for coelescing DNS queries useless.

Author: geky

features/net/network-socket/nsapi_dns.cpp

@@ -65,7 +65,7 @@ static uint16_t dns_scan_word(const uint8_t **p)
 }
 
 
-static void dns_append_question(uint8_t **p, const char *host)
+static void dns_append_question(uint8_t **p, const char *host, nsapi_version_t version)
 {
     // fill the header
     dns_append_word(p, 1);      // id      = 1
@@ -85,8 +85,12 @@ static void dns_append_question(uint8_t **p, const char *host)
     dns_append_byte(p, 0);
 
     // fill out question footer
-    dns_append_word(p, 1); // qtype  = 1
-    dns_append_word(p, 1); // qclass = 1
+    if (version == NSAPI_IPv4) {
+        dns_append_word(p, 1);  // qtype  = ipv4
+    } else {
+        dns_append_word(p, 28); // qtype  = ipv6
+    }
+    dns_append_word(p, 1);      // qclass = 1
 }
 
 static int dns_scan_response(const uint8_t **p, nsapi_addr_t *addr, unsigned addr_count)
@@ -144,26 +148,37 @@ static int dns_scan_response(const uint8_t **p, nsapi_addr_t *addr, unsigned add
         *p += 4;                              // ttl
         uint16_t rdlength = dns_scan_word(p); // rdlength
 
-        // verify response is an A record
-        if (!(rtype == 1 && rclass == 1 && rdlength == NSAPI_IPv4_BYTES)) {
-            *p += rdlength;
-            continue;
-        }
+        if (rtype == 1 && rclass == 1 && rdlength == NSAPI_IPv4_BYTES) {
+            // accept A record
+            addr->version = NSAPI_IPv4;
+            for (int i = 0; i < NSAPI_IPv4_BYTES; i++) {
+                addr->bytes[i] = dns_scan_byte(p);
+            }
 
-        addr->version = NSAPI_IPv4;
-        for (int i = 0; i < NSAPI_IPv4_BYTES; i++) {
-            addr->bytes[i] = dns_scan_byte(p);
-        }
+            addr += 1;
+            count += 1;
+        } else if (rtype == 28 && rclass == 1 && rdlength == NSAPI_IPv6_BYTES) {
+            // accept AAAA record
+            addr->version = NSAPI_IPv6;
+            for (int i = 0; i < NSAPI_IPv6_BYTES; i++) {
+                addr->bytes[i] = dns_scan_byte(p);
+            }
 
-        addr += 1;
-        count += 1;
+            addr += 1;
+            count += 1;
+        } else {
+            // skip unrecognized records
+            *p += rdlength;
+        }
     }
 
     return count;
 }
 
 // core query function
-int nsapi_dns_query_multiple(NetworkStack *stack, nsapi_addr_t *addr, unsigned addr_count, const char *host)
+int nsapi_dns_query_multiple(NetworkStack *stack,
+        nsapi_addr_t *addr, unsigned addr_count,
+        const char *host, nsapi_version_t version)
 {
     // check for valid host name
     int host_len = host ? strlen(host) : 0;
@@ -192,7 +207,7 @@ int nsapi_dns_query_multiple(NetworkStack *stack, nsapi_addr_t *addr, unsigned a
     for (unsigned i = 0; i < DNS_SERVERS_LENGTH; i++) {
         // send the question
         uint8_t *p = packet;
-        dns_append_question(&p, host);
+        dns_append_question(&p, host, version);
 
         err = socket.sendto(SocketAddress(DNS_SERVERS[i], 53), packet, DNS_BUFFER_SIZE);
         if (err == NSAPI_ERROR_WOULD_BLOCK) {
@@ -234,15 +249,28 @@ int nsapi_dns_query_multiple(NetworkStack *stack, nsapi_addr_t *addr, unsigned a
 
 // convenience functions for other forms of queries
 NSAPI_C_LINKAGE
-int nsapi_dns_query_multiple(nsapi_stack_t *stack, nsapi_addr_t *addr, unsigned addr_count, const char *host)
+int nsapi_dns_query_multiple(nsapi_stack_t *stack,
+        nsapi_addr_t *addr, unsigned addr_count,
+        const char *host, nsapi_version_t version)
+{
+    NetworkStack *nstack = nsapi_create_stack(stack);
+    return nsapi_dns_query_multiple(nstack, addr, addr_count, host, version);
+}
+
+int nsapi_dns_query_multiple(nsapi_stack_t *stack,
+        nsapi_addr_t *addr, unsigned addr_count,
+        const char *host)
 {
-    return nsapi_dns_query_multiple(nsapi_create_stack(stack), addr, addr_count, host);
+    NetworkStack *nstack = nsapi_create_stack(stack);
+    return nsapi_dns_query_multiple(nstack, addr, addr_count, host, NSAPI_IPv4);
 }
 
-int nsapi_dns_query_multiple(NetworkStack *stack, SocketAddress *addresses, unsigned addr_count, const char *host)
+int nsapi_dns_query_multiple(NetworkStack *stack,
+        SocketAddress *addresses, unsigned addr_count,
+        const char *host, nsapi_version_t version)
 {
     nsapi_addr_t *addrs = new nsapi_addr_t[addr_count];
-    int result = nsapi_dns_query_multiple(stack, addrs, addr_count, host);
+    int result = nsapi_dns_query_multiple(stack, addrs, addr_count, host, version);
 
     if (result > 0) {
         for (int i = 0; i < result; i++) {
@@ -255,22 +283,34 @@ int nsapi_dns_query_multiple(NetworkStack *stack, SocketAddress *addresses, unsi
 }
 
 NSAPI_C_LINKAGE
-int nsapi_dns_query(nsapi_stack_t *stack, nsapi_addr_t *addr, const char *host)
+int nsapi_dns_query(nsapi_stack_t *stack,
+        nsapi_addr_t *addr, const char *host, nsapi_version_t version)
+{
+    NetworkStack *nstack = nsapi_create_stack(stack);
+    int result = nsapi_dns_query_multiple(nstack, addr, 1, host, version);
+    return (result > 0) ? 0 : result;
+}
+
+int nsapi_dns_query(nsapi_stack_t *stack,
+        nsapi_addr_t *addr, const char *host)
 {
-    int result = nsapi_dns_query_multiple(nsapi_create_stack(stack), addr, 1, host);
+    NetworkStack *nstack = nsapi_create_stack(stack);
+    int result = nsapi_dns_query_multiple(nstack, addr, 1, host, NSAPI_IPv4);
     return (result > 0) ? 0 : result;
 }
 
-int nsapi_dns_query(NetworkStack *stack, nsapi_addr_t *addr, const char *host)
+int nsapi_dns_query(NetworkStack *stack,
+        nsapi_addr_t *addr, const char *host, nsapi_version_t version)
 {
-    int result = nsapi_dns_query_multiple(stack, addr, 1, host);
+    int result = nsapi_dns_query_multiple(stack, addr, 1, host, version);
     return (result > 0) ? 0 : result;
 }
 
-int nsapi_dns_query(NetworkStack *stack, SocketAddress *address, const char *host)
+int nsapi_dns_query(NetworkStack *stack,
+        SocketAddress *address, const char *host, nsapi_version_t version)
 {
     nsapi_addr_t addr;
-    int result = nsapi_dns_query_multiple(stack, &addr, 1, host);
+    int result = nsapi_dns_query_multiple(stack, &addr, 1, host, version);
     address->set_addr(addr);
     return (result > 0) ? 0 : result;
 }

features/net/network-socket/nsapi_dns.h

@@ -26,26 +26,34 @@
  *  @param stack    Network stack as target for DNS query
  *  @param addr     Destination for the host address
  *  @param host     Hostname to resolve
+ *  @param version  IP version to resolve (defaults to NSAPI_IPv4)
  *  @return         0 on success, negative error code on failure
  *                  NSAPI_ERROR_DNS_FAILURE indicates the host could not be found
  */
 NSAPI_C_LINKAGE
-int nsapi_dns_query(nsapi_stack_t *stack, nsapi_addr_t *addr, const char *host);
+int nsapi_dns_query(nsapi_stack_t *stack, nsapi_addr_t *addr,
+        const char *host, nsapi_version_t version);
 
 #ifdef __cplusplus
-int nsapi_dns_query(NetworkStack *stack, nsapi_addr_t *addr, const char *host);
-int nsapi_dns_query(NetworkStack *stack, SocketAddress *addr, const char *host);
+int nsapi_dns_query(nsapi_stack_t *stack, nsapi_addr_t *addr,
+        const char *host);
+int nsapi_dns_query(NetworkStack *stack, nsapi_addr_t *addr,
+        const char *host, nsapi_version_t version = NSAPI_IPv4);
+int nsapi_dns_query(NetworkStack *stack, SocketAddress *addr,
+        const char *host, nsapi_version_t version = NSAPI_IPv4);
 
 template <typename S>
-int nsapi_dns_query(S *stack, nsapi_addr_t *addr, const char *host)
+int nsapi_dns_query(S *stack, nsapi_addr_t *addr,
+        const char *host, nsapi_version_t version = NSAPI_IPv4)
 {
-    return nsapi_dns_query(nsapi_create_stack(stack), addr, host);
+    return nsapi_dns_query(nsapi_create_stack(stack), addr, host, version);
 }
 
 template <typename S>
-int nsapi_dns_query(S *stack, SocketAddress *addr, const char *host)
+int nsapi_dns_query(S *stack, SocketAddress *addr,
+        const char *host, nsapi_version_t version = NSAPI_IPv4)
 {
-    return nsapi_dns_query(nsapi_create_stack(stack), addr, host);
+    return nsapi_dns_query(nsapi_create_stack(stack), addr, host, version);
 }
 #endif
 
@@ -56,26 +64,42 @@ int nsapi_dns_query(S *stack, SocketAddress *addr, const char *host)
  *  @param addr       Array for the host addresses
  *  @param addr_count Number of addresses allocated in the array
  *  @param host       Hostname to resolve
+ *  @param version    IP version to resolve (defaults to NSAPI_IPv4)
  *  @return           Number of addresses found on success, negative error code on failure
  *                    NSAPI_ERROR_DNS_FAILURE indicates the host could not be found
  */
 NSAPI_C_LINKAGE
-int nsapi_dns_query_multiple(nsapi_stack_t *stack, nsapi_addr_t *addr, unsigned addr_count, const char *host);
+int nsapi_dns_query_multiple(nsapi_stack_t *stack,
+        nsapi_addr_t *addr, unsigned addr_count,
+        const char *host, nsapi_version_t version);
 
 #ifdef __cplusplus
-int nsapi_dns_query_multiple(NetworkStack *stack, nsapi_addr_t *addr, unsigned addr_count, const char *host);
-int nsapi_dns_query_multiple(NetworkStack *stack, SocketAddress *addr, unsigned addr_count, const char *host);
+int nsapi_dns_query_multiple(nsapi_stack_t *stack,
+        nsapi_addr_t *addr, unsigned addr_count,
+        const char *host);
+int nsapi_dns_query_multiple(NetworkStack *stack,
+        nsapi_addr_t *addr, unsigned addr_count,
+        const char *host, nsapi_version_t version = NSAPI_IPv4);
+int nsapi_dns_query_multiple(NetworkStack *stack,
+        SocketAddress *addr, unsigned addr_count,
+        const char *host, nsapi_version_t version = NSAPI_IPv4);
 
 template <typename S>
-int nsapi_dns_query_multiple(S *stack, nsapi_addr_t *addr, unsigned addr_count, const char *host)
+int nsapi_dns_query_multiple(S *stack,
+        nsapi_addr_t *addr, unsigned addr_count,
+        const char *host, nsapi_version_t version = NSAPI_IPv4)
 {
-    return nsapi_dns_query_multiple(nsapi_create_stack(stack), addr, addr_count, host);
+    return nsapi_dns_query_multiple(nsapi_create_stack(stack),
+                addr, addr_count, host, version);
 }
 
 template <typename S>
-int nsapi_dns_query_multiple(S *stack, SocketAddress *addr, unsigned addr_count, const char *host)
+int nsapi_dns_query_multiple(S *stack,
+        SocketAddress *addr, unsigned addr_count,
+        const char *host, nsapi_version_t version = NSAPI_IPv4)
 {
-    return nsapi_dns_query_multiple(nsapi_create_stack(stack), addr, addr_count, host);
+    return nsapi_dns_query_multiple(nsapi_create_stack(stack),
+                addr, addr_count, host, version);
 }
 #endif