DnsClient refactoring + features (timeout, suffix search, server rotation).

net/dns/dns_response.cc

 // Copyright (c) 2011 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/sys_byteorder.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() {
 }
 
@@ skipping 140 matching lines @@
     return false;
   }
 
   // Construct the parser.
   parser_ = DnsRecordParser(io_buffer_->data(),
                             nbytes,
                             hdr_size + question.size());
   return true;
 }
 
-uint8 DnsResponse::flags0() const {
-  return header()->flags[0];
+bool DnsResponse::is_valid() const {
+  return parser_.is_valid();
 }
 
-uint8 DnsResponse::flags1() const {
-  return header()->flags[1] & ~(dns_protocol::kRcodeMask);
+uint16 DnsResponse::flags() const {
+  DCHECK(parser_.is_valid());
+  return ntohs(header()->flags) & ~(dns_protocol::kRcodeMask);
 }
 
 uint8 DnsResponse::rcode() const {
-  return header()->flags[1] & dns_protocol::kRcodeMask;
+  DCHECK(parser_.is_valid());
+  return ntohs(header()->flags) & dns_protocol::kRcodeMask;
 }
 
 int DnsResponse::answer_count() const {
+  DCHECK(parser_.is_valid());
   return ntohs(header()->ancount);
 }
 
+base::StringPiece DnsResponse::qname() const {
+  DCHECK(parser_.is_valid());
+  const size_t hdr_size = sizeof(dns_protocol::Header);
+  const size_t qname_size = parser_.offset() - 2 * sizeof(uint16) - hdr_size;

[cbentzel, 2012/01/13 22:17:25]

This would benefit from an explanation - particularly why the parser_.offset is
what it is.

Another option is to reconstruct from io_buffer_->data() + hdr_size, which may
be more clear. 

Finally, you could just cache it in InitResponse from the query. 

+  return base::StringPiece(io_buffer_->data() + hdr_size,
+                           qname_size);
+}
+
+uint16 DnsResponse::qtype() const {
+  DCHECK(parser_.is_valid());
+  const size_t type_offset = parser_.offset() - 2 * sizeof(uint16);
+  uint16 type;
+  ReadBigEndian<uint16>(io_buffer_->data() + type_offset,
+                        &type);
+  return type;
+}
+
+std::string DnsResponse::GetDottedName() const {
+  return DNSDomainToString(qname());

[cbentzel, 2012/01/13 22:17:25]

[Note to self: Looks like the expansion is done by DnsResponseParser]

This doesn't handle the label compression case correctly (see 4.1.4 of RFC1035).
DNSDomainToString will return an empty string in that case.

Not sure if the expansion should be done in qname() or here.

It may not be a big issue in practice since it will typically done for response
names, but should be defensive about it.  

[szym, 2012/01/17 15:38:25]

The whole question section must be exactly as in the query, so the name in the
question cannot be compressed by the server.

+}
+
 DnsRecordParser DnsResponse::Parser() const {
-  DCHECK(parser_.IsValid());
+  DCHECK(parser_.is_valid());
+  // 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());
 }
 
 }  // namespace net