[net/dns] Don't abandon a DnsUDPAttempt when the response does not match the query.

net/dns/dns_transaction_unittest.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_transaction.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/rand_util.h"
@@ skipping 240 matching lines @@
   }
 
   void AddAsyncResponse(const std::string& dotted_name,
                         uint16 qtype,
                         uint16 id,
                         const char* data,
                         size_t data_length) {
     AddResponse(dotted_name, qtype, id, data, data_length, ASYNC);
   }
 
+  void AddSyncResponse(const std::string& dotted_name,
+                        uint16 qtype,
+                        uint16 id,
+                        const char* data,
+                        size_t data_length) {
+    AddResponse(dotted_name, qtype, id, data, data_length, SYNCHRONOUS);
+  }
+
   // Add expected query of |dotted_name| and |qtype| and no response.
   void AddTimeout(const char* dotted_name, uint16 qtype) {
     CHECK(socket_factory_.get());
     uint16 id = base::RandInt(0, kuint16max);
     DnsQuery* query = new DnsQuery(id, DomainFromDot(dotted_name), qtype);
     queries_.push_back(query);
 
     writes_.push_back(MockWrite(ASYNC,
                                 query->io_buffer()->data(),
                                 query->io_buffer()->size()));
@@ skipping 25 matching lines @@
     reads_.push_back(MockRead(mode,
                               response->io_buffer()->data(),
                               query->io_buffer()->size()));
     transaction_ids_.push_back(id);
   }
 
   void AddAsyncRcode(const char* dotted_name, uint16 qtype, int rcode) {
     AddRcode(dotted_name, qtype, rcode, ASYNC);
   }
 
+  void AddSyncRcode(const char* dotted_name, uint16 qtype, int rcode) {
+    AddRcode(dotted_name, qtype, rcode, SYNCHRONOUS);
+  }
+
   // Call after all Add* calls to prepare data for |socket_factory_|.
   // This separation is necessary because the |reads_| and |writes_| vectors
   // could reallocate their data during those calls.
   void PrepareSockets() {
     CHECK_EQ(writes_.size(), reads_.size());
     for (size_t i = 0; i < writes_.size(); ++i) {
       DelayedSocketData* data;
       if (reads_[i].data) {
         data = new DelayedSocketData(1, &reads_[i], 1, &writes_[i], 1);
       } else {
@@ skipping 164 matching lines @@
                    arraysize(kT0ResponseDatagram));
   PrepareSockets();
 
   TransactionHelper helper0(kT0HostName,
                             kT0Qtype,
                             kT0RecordCount);
   helper0.set_cancel_in_callback();
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
+TEST_F(DnsTransactionTest, MalformedResponse) {
+  config_.attempts = 3;
+  ConfigureFactory();
+  AddAsyncResponse(kT0HostName, kT0Qtype,
+                   1 /* mismatched id */,
+                   reinterpret_cast<const char*>(kT0ResponseDatagram),
+                   arraysize(kT0ResponseDatagram));
+  AddSyncResponse(kT0HostName, kT0Qtype,
+                  2 /* mismatched id */,
+                  reinterpret_cast<const char*>(kT0ResponseDatagram),
+                  arraysize(kT0ResponseDatagram));
+  AddAsyncResponse(kT0HostName, kT0Qtype,
+                   0 /* matching id */,
+                   reinterpret_cast<const char*>(kT0ResponseDatagram),
+                   arraysize(kT0ResponseDatagram));
+  PrepareSockets();
+
+  TransactionHelper helper0(kT0HostName,
+                            kT0Qtype,
+                            kT0RecordCount);
+  EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
+}
+
 TEST_F(DnsTransactionTest, ServerFail) {
   AddAsyncRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
   PrepareSockets();
 
   TransactionHelper helper0(kT0HostName,
                             kT0Qtype,
                             ERR_DNS_SERVER_FAILED);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
@@ skipping 218 matching lines @@
   TransactionHelper helper0("x.y.z", dns_protocol::kTypeA, 0 /* answers */);
 
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 TEST_F(DnsTransactionTest, SyncFirstQuery) {
   config_.search.push_back("lab.ccs.neu.edu");
   config_.search.push_back("ccs.neu.edu");
   ConfigureFactory();
 
-  AddResponse(kT0HostName,
-              kT0Qtype,
-              0 /* id */,
-              reinterpret_cast<const char*>(kT0ResponseDatagram),
-              arraysize(kT0ResponseDatagram),
-              SYNCHRONOUS);
+  AddSyncResponse(kT0HostName,
+                  kT0Qtype,
+                  0 /* id */,
+                  reinterpret_cast<const char*>(kT0ResponseDatagram),
+                  arraysize(kT0ResponseDatagram));
   PrepareSockets();
 
   TransactionHelper helper0(kT0HostName,
                             kT0Qtype,
                             kT0RecordCount);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 TEST_F(DnsTransactionTest, SyncFirstQueryWithSearch) {
   config_.search.push_back("lab.ccs.neu.edu");
   config_.search.push_back("ccs.neu.edu");
   ConfigureFactory();
 
-  AddRcode("www.lab.ccs.neu.edu",
-           kT2Qtype,
-           dns_protocol::kRcodeNXDOMAIN,
-           SYNCHRONOUS);
-  AddResponse(kT2HostName,  // "www.ccs.neu.edu"
-              kT2Qtype,
-              2 /* id */,
-              reinterpret_cast<const char*>(kT2ResponseDatagram),
-              arraysize(kT2ResponseDatagram),
-              ASYNC);
+  AddSyncRcode("www.lab.ccs.neu.edu",
+               kT2Qtype,
+               dns_protocol::kRcodeNXDOMAIN);
+  AddAsyncResponse(kT2HostName,  // "www.ccs.neu.edu"
+                   kT2Qtype,
+                   2 /* id */,
+                   reinterpret_cast<const char*>(kT2ResponseDatagram),
+                   arraysize(kT2ResponseDatagram));
   PrepareSockets();
 
   TransactionHelper helper0("www",
                             kT2Qtype,
                             kT2RecordCount);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 TEST_F(DnsTransactionTest, SyncSearchQuery) {
   config_.search.push_back("lab.ccs.neu.edu");
   config_.search.push_back("ccs.neu.edu");
   ConfigureFactory();
 
-  AddRcode("www.lab.ccs.neu.edu",
-           dns_protocol::kTypeA,
-           dns_protocol::kRcodeNXDOMAIN,
-           ASYNC);
-  AddResponse(kT2HostName,
-              kT2Qtype,
-              2 /* id */,
-              reinterpret_cast<const char*>(kT2ResponseDatagram),
-              arraysize(kT2ResponseDatagram),
-              SYNCHRONOUS);
+  AddAsyncRcode("www.lab.ccs.neu.edu",
+                dns_protocol::kTypeA,
+               dns_protocol::kRcodeNXDOMAIN);
+  AddSyncResponse(kT2HostName,
+                  kT2Qtype,
+                  2 /* id */,
+                  reinterpret_cast<const char*>(kT2ResponseDatagram),
+                  arraysize(kT2ResponseDatagram));
   PrepareSockets();
 
   TransactionHelper helper0("www",
                             kT2Qtype,
                             kT2RecordCount);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 }  // namespace
 
 }  // namespace net