Add simple non-response-based question parsing for mDNS passive listening

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 <climits>

[gene, 2013/04/17 02:05:38]

you probably don't need this any more

[Noam Samuel, 2013/04/17 20:39:08]

Done.

+
 #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"
 
@@ skipping 151 matching lines @@
     return false;
   }
 
   // Construct the parser.
   parser_ = DnsRecordParser(io_buffer_->data(),
                             nbytes,
                             hdr_size + question.size());
   return true;
 }
 
+bool DnsResponse::InitParse(int nbytes) {
+  if (nbytes >= io_buffer_->size())
+    return false;
+
+  // Construct the parser.
+  parser_ = DnsRecordParser(io_buffer_->data(),

[gene, 2013/04/17 02:04:02]

nit: you can fit this in one line now

[Noam Samuel, 2013/04/17 20:39:08]

Done.

+                            nbytes,
+                            GetResponseOffset());

[gene, 2013/04/17 02:04:02]

do you want to fail InitParse if GetResponseOffset() returns 0?

[Noam Samuel, 2013/04/17 20:39:08]

Yes.

+  return true;
+}
+
 bool DnsResponse::IsValid() const {
   return parser_.IsValid();
 }
 
 uint16 DnsResponse::flags() const {
   DCHECK(parser_.IsValid());
   return base::NetToHost16(header()->flags) & ~(dns_protocol::kRcodeMask);
 }
 
 uint8 DnsResponse::rcode() const {
@@ skipping 22 matching lines @@
   const size_t type_offset = parser_.GetOffset() - 2 * sizeof(uint16);
   uint16 type;
   ReadBigEndian<uint16>(io_buffer_->data() + type_offset, &type);
   return type;
 }
 
 std::string DnsResponse::GetDottedName() const {
   return DNSDomainToString(qname());
 }
 
+size_t DnsResponse::GetResponseOffset() const {
+  uint16 qdcount = base::NetToHost16(header()->qdcount);
+  const char* data = io_buffer_->data();
+  size_t data_size = io_buffer_->size();
+  size_t pos = sizeof(dns_protocol::Header);
+
+  for (uint16 i = 0; i < qdcount; i++) {
+    while (pos < data_size && data[pos] != 0) {
+      unsigned txt_len = static_cast<unsigned>(data[pos]);
+      // Traversal and checks adapted from DNSDomainToString.
+
+      // Handling pointers, which have both high bits set and an extra
+      // byte trailing them to indicate a location in the buffer.
+      if (txt_len >= 192) {
+        pos += 2;
+        continue;
+      }
+
+      if (txt_len > 63) {
+        return 0;
+      }
+
+      pos += txt_len + 1;
+    }
+
+    pos += 5;  // 1 for 0-length text, 2 for qtype, 2 for qclass
+  }
+
+  if (pos > data_size) return 0;
+
+  return pos;
+}
+
 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());
 }
 
@@ skipping 56 matching lines @@
 
   // 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(ttl_sec);
   return DNS_PARSE_OK;
 }
 
 }  // namespace net