Add initial implementation of DNS Client (#1460)

* [DNS] Initial DNS Client implementation.

src/cli/README.md

@@ -20,6 +20,7 @@ OpenThread test scripts use the CLI to execute test cases.
 * [dataset](#dataset-help)
 * [delaytimermin](#delaytimermin)
 * [discover](#discover-channel)
+* [dns](#dns-resolve-hostname-dns-server-ip-dns-server-port)
 * [eidcache](#eidcache)
 * [eui64](#eui64)
 * [extaddr](#extaddr)
@@ -463,7 +464,7 @@ pendingtimestamp
 pskc
 securitypolicy
 Done
-> 
+>
 ```
 
 ### dataset active
@@ -686,6 +687,18 @@ Perform an MLE Discovery operation.
 Done
 ```
 
+### dns resolve \<hostname\> \[DNS server IP\] \[DNS server port\]
+
+Send DNS Query to obtain IPv6 address for given hostname.
+The latter two parameters have following default values:
+ * DNS server IP: 2001:4860:4860::8888 (Google DNS Server)
+ * DNS server port: 53
+
+```bash
+> dns resolve ipv6.google.com
+> DNS response for ipv6.google.com - [2a00:1450:401b:801:0:0:0:200e] TTL: 300
+```
+
 ### eidcache
 
 Print the EID-to-RLOC cache entries.

src/cli/cli.cpp

@@ -95,6 +95,9 @@ const struct Command Interpreter::sCommands[] =
     { "diag", &Interpreter::ProcessDiag },
 #endif
     { "discover", &Interpreter::ProcessDiscover },
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+    { "dns", &Interpreter::ProcessDns },
+#endif
     { "eidcache", &Interpreter::ProcessEidCache },
     { "eui64", &Interpreter::ProcessEui64 },
 #ifdef OPENTHREAD_EXAMPLES_POSIX
@@ -193,6 +196,9 @@ Interpreter::Interpreter(otInstance *aInstance):
     sCount(1),
     sInterval(1000),
     sPingTimer(aInstance->mIp6.mTimerScheduler, &Interpreter::s_HandlePingTimer, this),
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+    mResolvingInProgress(0),
+#endif
 #endif
     mInstance(aInstance)
 {
@@ -211,6 +217,11 @@ Interpreter::Interpreter(otInstance *aInstance):
 #if OPENTHREAD_ENABLE_DHCP6_CLIENT
     memset(mDhcpAddresses, 0, sizeof(mDhcpAddresses));
 #endif  // OPENTHREAD_ENABLE_DHCP6_CLIENT
+
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+    memset(mResolvingHostname, 0, sizeof(mResolvingHostname));
+#endif // OPENTHREAD_ENABLE_DNS_CLIENT
+
 #endif
 }
 
@@ -708,6 +719,96 @@ exit:
     AppendResult(error);
 }
 
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+void Interpreter::ProcessDns(int argc, char *argv[])
+{
+    ThreadError error = kThreadError_None;
+    long port = OT_DNS_DEFAULT_DNS_SERVER_PORT;
+    Ip6::MessageInfo messageInfo;
+    otDnsQuery query;
+
+    VerifyOrExit(argc > 0, error = kThreadError_InvalidArgs);
+
+    if (strcmp(argv[0], "resolve") == 0)
+    {
+        VerifyOrExit(!mResolvingInProgress, error = kThreadError_Busy);
+        VerifyOrExit(argc > 1, error = kThreadError_InvalidArgs);
+        VerifyOrExit(strlen(argv[1]) < OT_DNS_MAX_HOSTNAME_LENGTH, error = kThreadError_InvalidArgs);
+
+        strcpy(mResolvingHostname, argv[1]);
+
+        memset(&messageInfo, 0, sizeof(messageInfo));
+        messageInfo.mInterfaceId = OT_NETIF_INTERFACE_ID_THREAD;
+
+        if (argc > 2)
+        {
+            SuccessOrExit(error = messageInfo.GetPeerAddr().FromString(argv[2]));
+        }
+        else
+        {
+            // Use IPv6 address of default DNS server.
+            SuccessOrExit(error = messageInfo.GetPeerAddr().FromString(OT_DNS_DEFAULT_DNS_SERVER_IP));
+        }
+
+        if (argc > 3)
+        {
+            SuccessOrExit(error = ParseLong(argv[3], port));
+        }
+
+        messageInfo.SetPeerPort(static_cast<uint16_t>(port));
+
+        query.mHostname    = mResolvingHostname;
+        query.mMessageInfo = static_cast<const otMessageInfo *>(&messageInfo);
+        query.mNoRecursion = false;
+
+        SuccessOrExit(error = otDnsClientQuery(mInstance, &query, &Interpreter::s_HandleDnsResponse, this));
+
+        mResolvingInProgress = true;
+        return;
+    }
+    else
+    {
+        ExitNow(error = kThreadError_InvalidArgs);
+    }
+
+exit:
+    AppendResult(error);
+}
+
+void Interpreter::s_HandleDnsResponse(void *aContext, const char *aHostname, otIp6Address *aAddress,
+                                      uint32_t aTtl, ThreadError aResult)
+{
+    static_cast<Interpreter *>(aContext)->HandleDnsResponse(aHostname,
+                                                            *static_cast<Ip6::Address *>(aAddress),
+                                                            aTtl, aResult);
+}
+
+void Interpreter::HandleDnsResponse(const char *aHostname, Ip6::Address &aAddress, uint32_t aTtl, ThreadError aResult)
+{
+    sServer->OutputFormat("DNS response for %s - ", aHostname);
+
+    if (aResult == kThreadError_None)
+    {
+        sServer->OutputFormat("[%x:%x:%x:%x:%x:%x:%x:%x] TTL: %d\r\n",
+                              HostSwap16(aAddress.mFields.m16[0]),
+                              HostSwap16(aAddress.mFields.m16[1]),
+                              HostSwap16(aAddress.mFields.m16[2]),
+                              HostSwap16(aAddress.mFields.m16[3]),
+                              HostSwap16(aAddress.mFields.m16[4]),
+                              HostSwap16(aAddress.mFields.m16[5]),
+                              HostSwap16(aAddress.mFields.m16[6]),
+                              HostSwap16(aAddress.mFields.m16[7]),
+                              aTtl);
+    }
+    else
+    {
+        AppendResult(aResult);
+    }
+
+    mResolvingInProgress = false;
+}
+#endif
+
 void Interpreter::ProcessEidCache(int argc, char *argv[])
 {
     otEidCacheEntry entry;

src/cli/cli.hpp

@@ -53,6 +53,7 @@
 #include <net/icmp6.hpp>
 #include <common/timer.hpp>
 #include "openthread/dhcp6_client.h"
+#include "openthread/dns.h"
 #endif
 
 #ifdef OTDLL
@@ -172,6 +173,9 @@ private:
     void ProcessDiag(int argc, char *argv[]);
 #endif  // OPENTHREAD_ENABLE_DIAG
     void ProcessDiscover(int argc, char *argv[]);
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+    void ProcessDns(int argc, char *argv[]);
+#endif
     void ProcessEidCache(int argc, char *argv[]);
     void ProcessEui64(int argc, char *argv[]);
 #ifdef OPENTHREAD_EXAMPLES_POSIX
@@ -257,6 +261,11 @@ private:
 #endif
     static void OTCALL s_HandleJoinerCallback(ThreadError aError, void *aContext);
 
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+    static void s_HandleDnsResponse(void *aContext, const char *aHostname, otIp6Address *aAddress,
+                                    uint32_t aTtl, ThreadError aResult);
+#endif
+
 #ifndef OTDLL
     void HandleIcmpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo,
                            const Ip6::IcmpHeader &aIcmpHeader);
@@ -278,6 +287,10 @@ private:
 #endif
     void HandleJoinerCallback(ThreadError aError);
 
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+    void HandleDnsResponse(const char *aHostname, Ip6::Address &aAddress, uint32_t aTtl, ThreadError aResult);
+#endif
+
     static const struct Command sCommands[];
 
     Server *sServer;
@@ -312,6 +325,11 @@ private:
 #endif // OPENTHREAD_ENABLE_DHCP6_CLIENT
 
     otIcmp6Handler mIcmpHandler;
+#if OPENTHREAD_ENABLE_DNS_CLIENT
+    bool mResolvingInProgress;
+    char mResolvingHostname[OT_DNS_MAX_HOSTNAME_LENGTH];
+#endif
+
 #endif
 
     otInstance *mInstance;