[net] HostResolverImpl + DnsTransaction + DnsConfigService = Asynchronous DNS ready for experiments.

net/dns/dns_response.cc

 // Copyright (c) 2012 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/dns/dns_response.h"
 
+#include "base/string_util.h"
 #include "base/sys_byteorder.h"
+#include "net/base/address_list.h"
 #include "net/base/big_endian.h"
 #include "net/base/dns_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 
 namespace net {
 
 DnsResourceRecord::DnsResourceRecord() {
 }
 
 DnsResourceRecord::~DnsResourceRecord() {
 }
 
 DnsRecordParser::DnsRecordParser() : packet_(NULL), length_(0), cur_(0) {
 }
 
 DnsRecordParser::DnsRecordParser(const void* packet,
                                  size_t length,
                                  size_t offset)
     : packet_(reinterpret_cast<const char*>(packet)),
       length_(length),
       cur_(packet_ + offset) {
   DCHECK_LE(offset, length);
 }
 
-int DnsRecordParser::ParseName(const void* const vpos, std::string* out) const {
+unsigned DnsRecordParser::ReadName(const void* const vpos,
+                                   std::string* out) const {
   const char* const pos = reinterpret_cast<const char*>(vpos);
   DCHECK(packet_);
   DCHECK_LE(packet_, pos);
   DCHECK_LE(pos, packet_ + length_);
 
   const char* p = pos;
   const char* end = packet_ + length_;
   // Count number of seen bytes to detect loops.
-  size_t seen = 0;
+  unsigned seen = 0;
   // Remember how many bytes were consumed before first jump.
-  size_t consumed = 0;
+  unsigned consumed = 0;
 
   if (pos >= end)
     return 0;
 
   if (out) {
     out->clear();
     out->reserve(dns_protocol::kMaxNameLength);
   }
 
   for (;;) {
-    // The two couple of bits of the length give the type of the length. It's
+    // The first two bits of the length give the type of the length. It's
     // either a direct length or a pointer to the remainder of the name.
     switch (*p & dns_protocol::kLabelMask) {
       case dns_protocol::kLabelPointer: {
         if (p + sizeof(uint16) > end)
           return 0;
         if (consumed == 0) {
           consumed = p - pos + sizeof(uint16);
           if (!out)
             return consumed;  // If name is not stored, that's all we need.
         }
@@ skipping 30 matching lines @@
         seen += 1 + label_len;
         break;
       }
       default:
         // unhandled label type
         return 0;
     }
   }
 }
 
-bool DnsRecordParser::ParseRecord(DnsResourceRecord* out) {
+bool DnsRecordParser::ReadRecord(DnsResourceRecord* out) {
   DCHECK(packet_);
-  size_t consumed = ParseName(cur_, &out->name);
+  size_t consumed = ReadName(cur_, &out->name);
   if (!consumed)
     return false;
   BigEndianReader reader(cur_ + consumed,
                          packet_ + length_ - (cur_ + consumed));
   uint16 rdlen;
   if (reader.ReadU16(&out->type) &&
       reader.ReadU16(&out->klass) &&
       reader.ReadU32(&out->ttl) &&
       reader.ReadU16(&rdlen) &&
       reader.ReadPiece(&out->rdata, rdlen)) {
@@ skipping 54 matching lines @@
 uint16 DnsResponse::flags() const {
   DCHECK(parser_.IsValid());
   return ntohs(header()->flags) & ~(dns_protocol::kRcodeMask);
 }
 
 uint8 DnsResponse::rcode() const {
   DCHECK(parser_.IsValid());
   return ntohs(header()->flags) & dns_protocol::kRcodeMask;
 }
 
-int DnsResponse::answer_count() const {
+unsigned DnsResponse::answer_count() const {
   DCHECK(parser_.IsValid());
   return ntohs(header()->ancount);
 }
 
 base::StringPiece DnsResponse::qname() const {
   DCHECK(parser_.IsValid());
   // The response is HEADER QNAME QTYPE QCLASS ANSWER.
   // |parser_| is positioned at the beginning of ANSWER, so the end of QNAME is
   // two uint16s before it.
   const size_t hdr_size = sizeof(dns_protocol::Header);
@@ skipping 17 matching lines @@
 DnsRecordParser DnsResponse::Parser() const {
   DCHECK(parser_.IsValid());
   // Return a copy of the parser.
   return parser_;
 }
 
 const dns_protocol::Header* DnsResponse::header() const {
   return reinterpret_cast<const dns_protocol::Header*>(io_buffer_->data());
 }
 
+DnsResponse::Result DnsResponse::ParseToAddressList(
+    AddressList* addr_list,
+    base::TimeDelta* ttl) const {
+  DCHECK(IsValid());
+  // DnsTransaction already verified that |response| matches the issued query.
+  // We still need to determine if there is a valid chain of CNAMEs from the
+  // query name to the RR owner name.
+  // We err on the side of caution with the assumption that if we are too picky,
+  // we can always fall back to the system getaddrinfo.
+
+  // Expected owner of record. No trailing dot.
+  std::string expected_name = GetDottedName();
+
+  uint16 expected_type = qtype();
+  DCHECK(expected_type == dns_protocol::kTypeA ||
+         expected_type == dns_protocol::kTypeAAAA);
+
+  size_t expected_size = (expected_type == dns_protocol::kTypeAAAA)
+      ? kIPv6AddressSize : kIPv4AddressSize;
+
+  uint32 cname_ttl_sec = kuint32max;
+  uint32 addr_ttl_sec = kuint32max;
+  IPAddressList ip_addresses;
+  DnsRecordParser parser = Parser();
+  DnsResourceRecord record;
+  unsigned ancount = answer_count();
+  for (unsigned i = 0; i < ancount; ++i) {
+    if (!parser.ReadRecord(&record))
+      return DNS_MALFORMED_RESPONSE;
+
+    if (base::strcasecmp(record.name.c_str(), expected_name.c_str()) != 0)
+      return DNS_NAME_MISMATCH;
+    if (record.type == dns_protocol::kTypeCNAME) {
+      // Following the CNAME chain, only if no addresses seen.
+      if (!ip_addresses.empty())
+        return DNS_CNAME_AFTER_ADDRESS;
+
+      if (record.rdata.size() !=
+          parser.ReadName(record.rdata.begin(), &expected_name))
+        return DNS_MALFORMED_CNAME;
+
+      cname_ttl_sec = std::min(cname_ttl_sec, record.ttl);
+    } else if (record.type == expected_type) {
+      if (record.rdata.size() != expected_size)
+        return DNS_SIZE_MISMATCH;
+      if (ip_addresses.empty()) {
+        addr_ttl_sec = record.ttl;
+      } else {
+        if (addr_ttl_sec != record.ttl)
+          return DNS_ADDRESS_TTL_MISMATCH;
+      }
+      ip_addresses.push_back(IPAddressNumber(record.rdata.begin(),
+                                             record.rdata.end()));
+    }
+  }
+
+  if (ip_addresses.empty())
+    return DNS_NO_ADDRESSES;
+
+  // getcanonname in eglibc returns the first owner name of an A or AAAA RR.
+  // If the response passed all the checks so far, then |expected_name| is it.
+  *addr_list = AddressList::CreateFromIPAddressList(ip_addresses,
+                                                    expected_name);
+  *ttl = base::TimeDelta::FromSeconds(std::min(cname_ttl_sec, addr_ttl_sec));
+  return DNS_SUCCESS;
+}
+
 }  // namespace net