net: enable DnsRRResolver on Windows

net/base/dnsrr_resolver.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/dnsrr_resolver.h"
 
 #if defined(OS_POSIX)
 #include <resolv.h>
 #endif
 
+#if defined(OS_WIN)
+#include <windns.h>
+#endif
+
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/stl_util-inl.h"
 #include "base/string_piece.h"
 #include "base/task.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/dns_reload_timer.h"
 #include "net/base/dns_util.h"
@@ skipping 42 matching lines @@
 //   Resolve()
 //      |---->------------------------<creates>
 //      |
 //      |
 //   PostTask
 //
 // (MessageLoop cycles)
 //
 //                                      Post
 
+namespace net {
 
-
-namespace net {
+#if defined(OS_WIN)
+// DnsRRIsParsedByWindows returns true if Windows knows how to parse the given
+// RR type. RR data is returned in a DNS_RECORD structure which may be raw (if
+// Windows doesn't parse it) or may be a parse result. It's unclear how this
+// API is intended to evolve in the future. If Windows adds support for new RR
+// types in a future version a client which expected raw data will break.
+// See http://msdn.microsoft.com/en-us/library/ms682082(v=vs.85).aspx
+static bool DnsRRIsParsedByWindows(uint16 rrtype) {
+  // We only cover the types which are defined in dns_util.h
+  switch (rrtype) {
+    case kDNS_CNAME:
+    case kDNS_TXT:
+    case kDNS_DS:
+    case kDNS_RRSIG:
+    case kDNS_DNSKEY:
+      return true;
+    default:
+      return false;
+  }
+}
+#endif
 
 static const uint16 kClassIN = 1;
 // kMaxCacheEntries is the number of RRResponse objects that we'll cache.
 static const unsigned kMaxCacheEntries = 32;
 // kNegativeTTLSecs is the number of seconds for which we'll cache a negative
 // cache entry.
 static const unsigned kNegativeTTLSecs = 60;
 
 RRResponse::RRResponse()
     : ttl(0), dnssec(false), negative(false) {
@@ skipping 140 matching lines @@
   }
 
 #else  // OS_WIN
 
   void Run() {
     if (HandleTestCases()) {
       Finish();
       return;
     }
 
+    // See http://msdn.microsoft.com/en-us/library/ms682016(v=vs.85).aspx
+    PDNS_RECORD record = NULL;
+    DNS_STATUS status =
+        DnsQuery_A(name_.c_str(), rrtype_, DNS_QUERY_STANDARD,
+                   NULL /* pExtra (reserved) */, &record, NULL /* pReserved */);
     response_.fetch_time = base::Time::Now();
-    response_.negative = true;
-    result_ = ERR_NAME_NOT_RESOLVED;
+    response_.name = name_;
+    response_.dnssec = false;
+    response_.ttl = 0;
+
+    if (status != 0) {
+      response_.negative = true;
+      result_ = ERR_NAME_NOT_RESOLVED;
+    } else {
+      response_.negative = false;
+      result_ = OK;
+      for (DNS_RECORD* cur = record; cur; cur = cur->pNext) {
+        if (cur->wType == rrtype_) {
+          response_.ttl = record->dwTtl;
+          // Windows will parse some types of resource records. If we want one
+          // of these types then we have to reserialise the record.
+          switch (rrtype_) {
+            case kDNS_TXT: {
+              // http://msdn.microsoft.com/en-us/library/ms682109(v=vs.85).aspx
+              const DNS_TXT_DATA* txt = &cur->Data.TXT;
+              std::string rrdata;
+
+              for (DWORD i = 0; i < txt->dwStringCount; i++) {
+                // Although the string is typed as a PWSTR, it's actually just
+                // an ASCII byte-string.  Also, the string must be < 256
+                // elements because the length in the DNS packet is a single
+                // byte.
+                const char* s = reinterpret_cast<char*>(txt->pStringArray[i]);
+                size_t len = strlen(s);
+                DCHECK_LT(len, 256u);
+                char len8 = static_cast<char>(len);
+                rrdata.push_back(len8);
+                rrdata += s;
+              }
+              response_.rrdatas.push_back(rrdata);
+              break;
+            }
+            default:
+              if (DnsRRIsParsedByWindows(rrtype_)) {
+                // Windows parses this type, but we don't have code to unparse
+                // it.
+                NOTREACHED() << "you need to add code for the RR type here";
+                response_.negative = true;
+                result_ = ERR_INVALID_ARGUMENT;
+              } else {
+                // This type is given to us raw.
+                response_.rrdatas.push_back(
+                    std::string(reinterpret_cast<char*>(&cur->Data),
+                                cur->wDataLength));
+              }
+          }
+        }
+      }
+    }
+
+    DnsRecordListFree(record, DnsFreeRecordList);
     Finish();
   }
 
 #endif  // OS_WIN
 
   // HandleTestCases stuffs in magic test values in the event that the query is
   // from a unittest.
   bool HandleTestCases() {
     if (rrtype_ == kDNS_TESTING) {
       response_.fetch_time = base::Time::Now();
@@ skipping 478 matching lines @@
   inflight_.erase(j);
 
   job->HandleResult(result, response);
   delete job;
 }
 
 }  // namespace net
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(net::RRResolverHandle);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(net::RRResolverWorker);