net/dns/dns_transaction_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/dns/dns_transaction.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/memory/scoped_vector.h"
  10 #include "base/rand_util.h"
  11 #include "base/sys_byteorder.h"
  12 #include "base/test/test_timeouts.h"
  13 #include "net/base/dns_util.h"
  14 #include "net/base/net_log.h"
  15 #include "net/dns/dns_protocol.h"
  16 #include "net/dns/dns_query.h"
  17 #include "net/dns/dns_response.h"
  18 #include "net/dns/dns_session.h"
  19 #include "net/dns/dns_test_util.h"
  20 #include "net/socket/socket_test_util.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 namespace net {
  24
  25 namespace {
  26
  27 std::string DomainFromDot(const base::StringPiece& dotted) {
  28   std::string out;
  29   EXPECT_TRUE(DNSDomainFromDot(dotted, &out));
  30   return out;
  31 }
  32
  33 // A SocketDataProvider builder.
  34 class DnsSocketData {
  35  public:
  36   // The ctor takes parameters for the DnsQuery.
  37   DnsSocketData(uint16 id,
  38                 const char* dotted_name,
  39                 uint16 qtype,
  40                 IoMode mode,
  41                 bool use_tcp)
  42       : query_(new DnsQuery(id, DomainFromDot(dotted_name), qtype)),
  43         use_tcp_(use_tcp) {
  44     if (use_tcp_) {
  45       scoped_ptr<uint16> length(new uint16);
  46       *length = base::HostToNet16(query_->io_buffer()->size());
  47       writes_.push_back(MockWrite(mode,
  48                                   reinterpret_cast<const char*>(length.get()),
  49                                   sizeof(uint16)));
  50       lengths_.push_back(length.release());
  51     }
  52     writes_.push_back(MockWrite(mode,
  53                                 query_->io_buffer()->data(),
  54                                 query_->io_buffer()->size()));
  55   }
  56   ~DnsSocketData() {}
  57
  58   // All responses must be added before GetProvider.
  59
  60   // Adds pre-built DnsResponse. |tcp_length| will be used in TCP mode only.
  61   void AddResponseWithLength(scoped_ptr<DnsResponse> response, IoMode mode,
  62                              uint16 tcp_length) {
  63     CHECK(!provider_.get());
  64     if (use_tcp_) {
  65       scoped_ptr<uint16> length(new uint16);
  66       *length = base::HostToNet16(tcp_length);
  67       reads_.push_back(MockRead(mode,
  68                                 reinterpret_cast<const char*>(length.get()),
  69                                 sizeof(uint16)));
  70       lengths_.push_back(length.release());
  71     }
  72     reads_.push_back(MockRead(mode,
  73                               response->io_buffer()->data(),
  74                               response->io_buffer()->size()));
  75     responses_.push_back(response.release());
  76   }
  77
  78   // Adds pre-built DnsResponse.
  79   void AddResponse(scoped_ptr<DnsResponse> response, IoMode mode) {
  80     uint16 tcp_length = response->io_buffer()->size();
  81     AddResponseWithLength(response.Pass(), mode, tcp_length);
  82   }
  83
  84   // Adds pre-built response from |data| buffer.
  85   void AddResponseData(const uint8* data, size_t length, IoMode mode) {
  86     CHECK(!provider_.get());
  87     AddResponse(make_scoped_ptr(
  88         new DnsResponse(reinterpret_cast<const char*>(data), length, 0)), mode);
  89   }
  90
  91   // Add no-answer (RCODE only) response matching the query.
  92   void AddRcode(int rcode, IoMode mode) {
  93     scoped_ptr<DnsResponse> response(
  94         new DnsResponse(query_->io_buffer()->data(),
  95                         query_->io_buffer()->size(),
  96                         0));
  97     dns_protocol::Header* header =
  98         reinterpret_cast<dns_protocol::Header*>(response->io_buffer()->data());
  99     header->flags |= base::HostToNet16(dns_protocol::kFlagResponse | rcode);
 100     AddResponse(response.Pass(), mode);
 101   }
 102
 103   // Add error response.
 104   void AddReadError(int error, IoMode mode) {
 105     reads_.push_back(MockRead(mode, error));
 106   }
 107
 108   // Build, if needed, and return the SocketDataProvider. No new responses
 109   // should be added afterwards.
 110   SocketDataProvider* GetProvider() {
 111     if (provider_.get())
 112       return provider_.get();
 113     // Terminate the reads with ERR_IO_PENDING to prevent overrun and default to
 114     // timeout.
 115     reads_.push_back(MockRead(ASYNC, ERR_IO_PENDING));
 116     provider_.reset(new DelayedSocketData(1, &reads_[0], reads_.size(),
 117                                           &writes_[0], writes_.size()));
 118     if (use_tcp_) {
 119       provider_->set_connect_data(MockConnect(reads_[0].mode, OK));
 120     }
 121     return provider_.get();
 122   }
 123
 124   uint16 query_id() const {
 125     return query_->id();
 126   }
 127
 128   // Returns true if the expected query was written to the socket.
 129   bool was_written() const {
 130     CHECK(provider_.get());
 131     return provider_->write_index() > 0;
 132   }
 133
 134  private:
 135   scoped_ptr<DnsQuery> query_;
 136   bool use_tcp_;
 137   ScopedVector<uint16> lengths_;
 138   ScopedVector<DnsResponse> responses_;
 139   std::vector<MockWrite> writes_;
 140   std::vector<MockRead> reads_;
 141   scoped_ptr<DelayedSocketData> provider_;
 142
 143   DISALLOW_COPY_AND_ASSIGN(DnsSocketData);
 144 };
 145
 146 class TestSocketFactory;
 147
 148 // A variant of MockUDPClientSocket which always fails to Connect.
 149 class FailingUDPClientSocket : public MockUDPClientSocket {
 150  public:
 151   FailingUDPClientSocket(SocketDataProvider* data,
 152                          net::NetLog* net_log)
 153       : MockUDPClientSocket(data, net_log) {
 154   }
 155   virtual ~FailingUDPClientSocket() {}
 156   virtual int Connect(const IPEndPoint& endpoint) OVERRIDE {
 157     return ERR_CONNECTION_REFUSED;
 158   }
 159
 160  private:
 161   DISALLOW_COPY_AND_ASSIGN(FailingUDPClientSocket);
 162 };
 163
 164 // A variant of MockUDPClientSocket which notifies the factory OnConnect.
 165 class TestUDPClientSocket : public MockUDPClientSocket {
 166  public:
 167   TestUDPClientSocket(TestSocketFactory* factory,
 168                       SocketDataProvider* data,
 169                       net::NetLog* net_log)
 170       : MockUDPClientSocket(data, net_log), factory_(factory) {
 171   }
 172   virtual ~TestUDPClientSocket() {}
 173   virtual int Connect(const IPEndPoint& endpoint) OVERRIDE;
 174
 175  private:
 176   TestSocketFactory* factory_;
 177
 178   DISALLOW_COPY_AND_ASSIGN(TestUDPClientSocket);
 179 };
 180
 181 // Creates TestUDPClientSockets and keeps endpoints reported via OnConnect.
 182 class TestSocketFactory : public MockClientSocketFactory {
 183  public:
 184   TestSocketFactory() : fail_next_socket_(false) {}
 185   virtual ~TestSocketFactory() {}
 186
 187   virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
 188       DatagramSocket::BindType bind_type,
 189       const RandIntCallback& rand_int_cb,
 190       net::NetLog* net_log,
 191       const net::NetLog::Source& source) OVERRIDE {
 192     if (fail_next_socket_) {
 193       fail_next_socket_ = false;
 194       return scoped_ptr<DatagramClientSocket>(
 195           new FailingUDPClientSocket(&empty_data_, net_log));
 196     }
 197     SocketDataProvider* data_provider = mock_data().GetNext();
 198     scoped_ptr<TestUDPClientSocket> socket(
 199         new TestUDPClientSocket(this, data_provider, net_log));
 200     data_provider->set_socket(socket.get());
 201     return socket.PassAs<DatagramClientSocket>();
 202   }
 203
 204   void OnConnect(const IPEndPoint& endpoint) {
 205     remote_endpoints_.push_back(endpoint);
 206   }
 207
 208   std::vector<IPEndPoint> remote_endpoints_;
 209   bool fail_next_socket_;
 210
 211  private:
 212   StaticSocketDataProvider empty_data_;
 213
 214   DISALLOW_COPY_AND_ASSIGN(TestSocketFactory);
 215 };
 216
 217 int TestUDPClientSocket::Connect(const IPEndPoint& endpoint) {
 218   factory_->OnConnect(endpoint);
 219   return MockUDPClientSocket::Connect(endpoint);
 220 }
 221
 222 // Helper class that holds a DnsTransaction and handles OnTransactionComplete.
 223 class TransactionHelper {
 224  public:
 225   // If |expected_answer_count| < 0 then it is the expected net error.
 226   TransactionHelper(const char* hostname,
 227                     uint16 qtype,
 228                     int expected_answer_count)
 229       : hostname_(hostname),
 230         qtype_(qtype),
 231         expected_answer_count_(expected_answer_count),
 232         cancel_in_callback_(false),
 233         quit_in_callback_(false),
 234         completed_(false) {
 235   }
 236
 237   // Mark that the transaction shall be destroyed immediately upon callback.
 238   void set_cancel_in_callback() {
 239     cancel_in_callback_ = true;
 240   }
 241
 242   // Mark to call MessageLoop::Quit() upon callback.
 243   void set_quit_in_callback() {
 244     quit_in_callback_ = true;
 245   }
 246
 247   void StartTransaction(DnsTransactionFactory* factory) {
 248     EXPECT_EQ(NULL, transaction_.get());
 249     transaction_ = factory->CreateTransaction(
 250         hostname_,
 251         qtype_,
 252         base::Bind(&TransactionHelper::OnTransactionComplete,
 253                    base::Unretained(this)),
 254         BoundNetLog());
 255     EXPECT_EQ(hostname_, transaction_->GetHostname());
 256     EXPECT_EQ(qtype_, transaction_->GetType());
 257     transaction_->Start();
 258   }
 259
 260   void Cancel() {
 261     ASSERT_TRUE(transaction_.get() != NULL);
 262     transaction_.reset(NULL);
 263   }
 264
 265   void OnTransactionComplete(DnsTransaction* t,
 266                              int rv,
 267                              const DnsResponse* response) {
 268     EXPECT_FALSE(completed_);
 269     EXPECT_EQ(transaction_.get(), t);
 270
 271     completed_ = true;
 272
 273     if (cancel_in_callback_) {
 274       Cancel();
 275       return;
 276     }
 277
 278     // Tell MessageLoop to quit now, in case any ASSERT_* fails.
 279     if (quit_in_callback_)
 280       base::MessageLoop::current()->Quit();
 281
 282     if (expected_answer_count_ >= 0) {
 283       ASSERT_EQ(OK, rv);
 284       ASSERT_TRUE(response != NULL);
 285       EXPECT_EQ(static_cast<unsigned>(expected_answer_count_),
 286                 response->answer_count());
 287       EXPECT_EQ(qtype_, response->qtype());
 288
 289       DnsRecordParser parser = response->Parser();
 290       DnsResourceRecord record;
 291       for (int i = 0; i < expected_answer_count_; ++i) {
 292         EXPECT_TRUE(parser.ReadRecord(&record));
 293       }
 294     } else {
 295       EXPECT_EQ(expected_answer_count_, rv);
 296     }
 297   }
 298
 299   bool has_completed() const {
 300     return completed_;
 301   }
 302
 303   // Shorthands for commonly used commands.
 304
 305   bool Run(DnsTransactionFactory* factory) {
 306     StartTransaction(factory);
 307     base::MessageLoop::current()->RunUntilIdle();
 308     return has_completed();
 309   }
 310
 311   // Use when some of the responses are timeouts.
 312   bool RunUntilDone(DnsTransactionFactory* factory) {
 313     set_quit_in_callback();
 314     StartTransaction(factory);
 315     base::MessageLoop::current()->Run();
 316     return has_completed();
 317   }
 318
 319  private:
 320   std::string hostname_;
 321   uint16 qtype_;
 322   scoped_ptr<DnsTransaction> transaction_;
 323   int expected_answer_count_;
 324   bool cancel_in_callback_;
 325   bool quit_in_callback_;
 326
 327   bool completed_;
 328 };
 329
 330 class DnsTransactionTest : public testing::Test {
 331  public:
 332   DnsTransactionTest() {}
 333
 334   // Generates |nameservers| for DnsConfig.
 335   void ConfigureNumServers(unsigned num_servers) {
 336     CHECK_LE(num_servers, 255u);
 337     config_.nameservers.clear();
 338     IPAddressNumber dns_ip;
 339     {
 340       bool rv = ParseIPLiteralToNumber("192.168.1.0", &dns_ip);
 341       EXPECT_TRUE(rv);
 342     }
 343     for (unsigned i = 0; i < num_servers; ++i) {
 344       dns_ip[3] = i;
 345       config_.nameservers.push_back(IPEndPoint(dns_ip,
 346                                                dns_protocol::kDefaultPort));
 347     }
 348   }
 349
 350   // Called after fully configuring |config|.
 351   void ConfigureFactory() {
 352     socket_factory_.reset(new TestSocketFactory());
 353     session_ = new DnsSession(
 354         config_,
 355         DnsSocketPool::CreateNull(socket_factory_.get()),
 356         base::Bind(&DnsTransactionTest::GetNextId, base::Unretained(this)),
 357         NULL /* NetLog */);
 358     transaction_factory_ = DnsTransactionFactory::CreateFactory(session_.get());
 359   }
 360
 361   void AddSocketData(scoped_ptr<DnsSocketData> data) {
 362     CHECK(socket_factory_.get());
 363     transaction_ids_.push_back(data->query_id());
 364     socket_factory_->AddSocketDataProvider(data->GetProvider());
 365     socket_data_.push_back(data.release());
 366   }
 367
 368   // Add expected query for |dotted_name| and |qtype| with |id| and response
 369   // taken verbatim from |data| of |data_length| bytes. The transaction id in
 370   // |data| should equal |id|, unless testing mismatched response.
 371   void AddQueryAndResponse(uint16 id,
 372                            const char* dotted_name,
 373                            uint16 qtype,
 374                            const uint8* response_data,
 375                            size_t response_length,
 376                            IoMode mode,
 377                            bool use_tcp) {
 378     CHECK(socket_factory_.get());
 379     scoped_ptr<DnsSocketData> data(
 380         new DnsSocketData(id, dotted_name, qtype, mode, use_tcp));
 381     data->AddResponseData(response_data, response_length, mode);
 382     AddSocketData(data.Pass());
 383   }
 384
 385   void AddAsyncQueryAndResponse(uint16 id,
 386                                 const char* dotted_name,
 387                                 uint16 qtype,
 388                                 const uint8* data,
 389                                 size_t data_length) {
 390     AddQueryAndResponse(id, dotted_name, qtype, data, data_length, ASYNC,
 391                         false);
 392   }
 393
 394   void AddSyncQueryAndResponse(uint16 id,
 395                                const char* dotted_name,
 396                                uint16 qtype,
 397                                const uint8* data,
 398                                size_t data_length) {
 399     AddQueryAndResponse(id, dotted_name, qtype, data, data_length, SYNCHRONOUS,
 400                         false);
 401   }
 402
 403   // Add expected query of |dotted_name| and |qtype| and no response.
 404   void AddQueryAndTimeout(const char* dotted_name, uint16 qtype) {
 405     uint16 id = base::RandInt(0, kuint16max);
 406     scoped_ptr<DnsSocketData> data(
 407         new DnsSocketData(id, dotted_name, qtype, ASYNC, false));
 408     AddSocketData(data.Pass());
 409   }
 410
 411   // Add expected query of |dotted_name| and |qtype| and matching response with
 412   // no answer and RCODE set to |rcode|. The id will be generated randomly.
 413   void AddQueryAndRcode(const char* dotted_name,
 414                         uint16 qtype,
 415                         int rcode,
 416                         IoMode mode,
 417                         bool use_tcp) {
 418     CHECK_NE(dns_protocol::kRcodeNOERROR, rcode);
 419     uint16 id = base::RandInt(0, kuint16max);
 420     scoped_ptr<DnsSocketData> data(
 421         new DnsSocketData(id, dotted_name, qtype, mode, use_tcp));
 422     data->AddRcode(rcode, mode);
 423     AddSocketData(data.Pass());
 424   }
 425
 426   void AddAsyncQueryAndRcode(const char* dotted_name, uint16 qtype, int rcode) {
 427     AddQueryAndRcode(dotted_name, qtype, rcode, ASYNC, false);
 428   }
 429
 430   void AddSyncQueryAndRcode(const char* dotted_name, uint16 qtype, int rcode) {
 431     AddQueryAndRcode(dotted_name, qtype, rcode, SYNCHRONOUS, false);
 432   }
 433
 434   // Checks if the sockets were connected in the order matching the indices in
 435   // |servers|.
 436   void CheckServerOrder(const unsigned* servers, size_t num_attempts) {
 437     ASSERT_EQ(num_attempts, socket_factory_->remote_endpoints_.size());
 438     for (size_t i = 0; i < num_attempts; ++i) {
 439       EXPECT_EQ(socket_factory_->remote_endpoints_[i],
 440                 session_->config().nameservers[servers[i]]);
 441     }
 442   }
 443
 444   virtual void SetUp() OVERRIDE {
 445     // By default set one server,
 446     ConfigureNumServers(1);
 447     // and no retransmissions,
 448     config_.attempts = 1;
 449     // but long enough timeout for memory tests.
 450     config_.timeout = TestTimeouts::action_timeout();
 451     ConfigureFactory();
 452   }
 453
 454   virtual void TearDown() OVERRIDE {
 455     // Check that all socket data was at least written to.
 456     for (size_t i = 0; i < socket_data_.size(); ++i) {
 457       EXPECT_TRUE(socket_data_[i]->was_written()) << i;
 458     }
 459   }
 460
 461  protected:
 462   int GetNextId(int min, int max) {
 463     EXPECT_FALSE(transaction_ids_.empty());
 464     int id = transaction_ids_.front();
 465     transaction_ids_.pop_front();
 466     EXPECT_GE(id, min);
 467     EXPECT_LE(id, max);
 468     return id;
 469   }
 470
 471   DnsConfig config_;
 472
 473   ScopedVector<DnsSocketData> socket_data_;
 474
 475   std::deque<int> transaction_ids_;
 476   scoped_ptr<TestSocketFactory> socket_factory_;
 477   scoped_refptr<DnsSession> session_;
 478   scoped_ptr<DnsTransactionFactory> transaction_factory_;
 479 };
 480
 481 TEST_F(DnsTransactionTest, Lookup) {
 482   AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 483                            kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 484
 485   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 486   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 487 }
 488
 489 // Concurrent lookup tests assume that DnsTransaction::Start immediately
 490 // consumes a socket from ClientSocketFactory.
 491 TEST_F(DnsTransactionTest, ConcurrentLookup) {
 492   AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 493                            kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 494   AddAsyncQueryAndResponse(1 /* id */, kT1HostName, kT1Qtype,
 495                            kT1ResponseDatagram, arraysize(kT1ResponseDatagram));
 496
 497   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 498   helper0.StartTransaction(transaction_factory_.get());
 499   TransactionHelper helper1(kT1HostName, kT1Qtype, kT1RecordCount);
 500   helper1.StartTransaction(transaction_factory_.get());
 501
 502   base::MessageLoop::current()->RunUntilIdle();
 503
 504   EXPECT_TRUE(helper0.has_completed());
 505   EXPECT_TRUE(helper1.has_completed());
 506 }
 507
 508 TEST_F(DnsTransactionTest, CancelLookup) {
 509   AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 510                            kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 511   AddAsyncQueryAndResponse(1 /* id */, kT1HostName, kT1Qtype,
 512                            kT1ResponseDatagram, arraysize(kT1ResponseDatagram));
 513
 514   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 515   helper0.StartTransaction(transaction_factory_.get());
 516   TransactionHelper helper1(kT1HostName, kT1Qtype, kT1RecordCount);
 517   helper1.StartTransaction(transaction_factory_.get());
 518
 519   helper0.Cancel();
 520
 521   base::MessageLoop::current()->RunUntilIdle();
 522
 523   EXPECT_FALSE(helper0.has_completed());
 524   EXPECT_TRUE(helper1.has_completed());
 525 }
 526
 527 TEST_F(DnsTransactionTest, DestroyFactory) {
 528   AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 529                            kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 530
 531   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 532   helper0.StartTransaction(transaction_factory_.get());
 533
 534   // Destroying the client does not affect running requests.
 535   transaction_factory_.reset(NULL);
 536
 537   base::MessageLoop::current()->RunUntilIdle();
 538
 539   EXPECT_TRUE(helper0.has_completed());
 540 }
 541
 542 TEST_F(DnsTransactionTest, CancelFromCallback) {
 543   AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 544                            kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 545
 546   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 547   helper0.set_cancel_in_callback();
 548   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 549 }
 550
 551 TEST_F(DnsTransactionTest, MismatchedResponseSync) {
 552   config_.attempts = 2;
 553   config_.timeout = TestTimeouts::tiny_timeout();
 554   ConfigureFactory();
 555
 556   // Attempt receives mismatched response followed by valid response.
 557   scoped_ptr<DnsSocketData> data(
 558       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, SYNCHRONOUS, false));
 559   data->AddResponseData(kT1ResponseDatagram,
 560                         arraysize(kT1ResponseDatagram), SYNCHRONOUS);
 561   data->AddResponseData(kT0ResponseDatagram,
 562                         arraysize(kT0ResponseDatagram), SYNCHRONOUS);
 563   AddSocketData(data.Pass());
 564
 565   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 566   EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
 567 }
 568
 569 TEST_F(DnsTransactionTest, MismatchedResponseAsync) {
 570   config_.attempts = 2;
 571   config_.timeout = TestTimeouts::tiny_timeout();
 572   ConfigureFactory();
 573
 574   // First attempt receives mismatched response followed by valid response.
 575   // Second attempt times out.
 576   scoped_ptr<DnsSocketData> data(
 577       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, false));
 578   data->AddResponseData(kT1ResponseDatagram,
 579                         arraysize(kT1ResponseDatagram), ASYNC);
 580   data->AddResponseData(kT0ResponseDatagram,
 581                         arraysize(kT0ResponseDatagram), ASYNC);
 582   AddSocketData(data.Pass());
 583   AddQueryAndTimeout(kT0HostName, kT0Qtype);
 584
 585   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 586   EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
 587 }
 588
 589 TEST_F(DnsTransactionTest, MismatchedResponseFail) {
 590   config_.timeout = TestTimeouts::tiny_timeout();
 591   ConfigureFactory();
 592
 593   // Attempt receives mismatched response but times out because only one attempt
 594   // is allowed.
 595   AddAsyncQueryAndResponse(1 /* id */, kT0HostName, kT0Qtype,
 596                            kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 597
 598   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_TIMED_OUT);
 599   EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
 600 }
 601
 602 TEST_F(DnsTransactionTest, ServerFail) {
 603   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
 604
 605   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_SERVER_FAILED);
 606   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 607 }
 608
 609 TEST_F(DnsTransactionTest, NoDomain) {
 610   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
 611
 612   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_NAME_NOT_RESOLVED);
 613   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 614 }
 615
 616 TEST_F(DnsTransactionTest, Timeout) {
 617   config_.attempts = 3;
 618   // Use short timeout to speed up the test.
 619   config_.timeout = TestTimeouts::tiny_timeout();
 620   ConfigureFactory();
 621
 622   AddQueryAndTimeout(kT0HostName, kT0Qtype);
 623   AddQueryAndTimeout(kT0HostName, kT0Qtype);
 624   AddQueryAndTimeout(kT0HostName, kT0Qtype);
 625
 626   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_TIMED_OUT);
 627   EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
 628   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 629 }
 630
 631 TEST_F(DnsTransactionTest, ServerFallbackAndRotate) {
 632   // Test that we fallback on both server failure and timeout.
 633   config_.attempts = 2;
 634   // The next request should start from the next server.
 635   config_.rotate = true;
 636   ConfigureNumServers(3);
 637   // Use short timeout to speed up the test.
 638   config_.timeout = TestTimeouts::tiny_timeout();
 639   ConfigureFactory();
 640
 641   // Responses for first request.
 642   AddQueryAndTimeout(kT0HostName, kT0Qtype);
 643   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
 644   AddQueryAndTimeout(kT0HostName, kT0Qtype);
 645   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
 646   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
 647   // Responses for second request.
 648   AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeSERVFAIL);
 649   AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeSERVFAIL);
 650   AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeNXDOMAIN);
 651
 652   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_NAME_NOT_RESOLVED);
 653   TransactionHelper helper1(kT1HostName, kT1Qtype, ERR_NAME_NOT_RESOLVED);
 654
 655   EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
 656   EXPECT_TRUE(helper1.Run(transaction_factory_.get()));
 657
 658   unsigned kOrder[] = {
 659       0, 1, 2, 0, 1,    // The first transaction.
 660       1, 2, 0,          // The second transaction starts from the next server.
 661   };
 662   CheckServerOrder(kOrder, arraysize(kOrder));
 663 }
 664
 665 TEST_F(DnsTransactionTest, SuffixSearchAboveNdots) {
 666   config_.ndots = 2;
 667   config_.search.push_back("a");
 668   config_.search.push_back("b");
 669   config_.search.push_back("c");
 670   config_.rotate = true;
 671   ConfigureNumServers(2);
 672   ConfigureFactory();
 673
 674   AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
 675                         dns_protocol::kRcodeNXDOMAIN);
 676   AddAsyncQueryAndRcode("x.y.z.a", dns_protocol::kTypeA,
 677                         dns_protocol::kRcodeNXDOMAIN);
 678   AddAsyncQueryAndRcode("x.y.z.b", dns_protocol::kTypeA,
 679                         dns_protocol::kRcodeNXDOMAIN);
 680   AddAsyncQueryAndRcode("x.y.z.c", dns_protocol::kTypeA,
 681                         dns_protocol::kRcodeNXDOMAIN);
 682
 683   TransactionHelper helper0("x.y.z", dns_protocol::kTypeA,
 684                             ERR_NAME_NOT_RESOLVED);
 685
 686   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 687
 688   // Also check if suffix search causes server rotation.
 689   unsigned kOrder0[] = { 0, 1, 0, 1 };
 690   CheckServerOrder(kOrder0, arraysize(kOrder0));
 691 }
 692
 693 TEST_F(DnsTransactionTest, SuffixSearchBelowNdots) {
 694   config_.ndots = 2;
 695   config_.search.push_back("a");
 696   config_.search.push_back("b");
 697   config_.search.push_back("c");
 698   ConfigureFactory();
 699
 700   // Responses for first transaction.
 701   AddAsyncQueryAndRcode("x.y.a", dns_protocol::kTypeA,
 702                         dns_protocol::kRcodeNXDOMAIN);
 703   AddAsyncQueryAndRcode("x.y.b", dns_protocol::kTypeA,
 704                         dns_protocol::kRcodeNXDOMAIN);
 705   AddAsyncQueryAndRcode("x.y.c", dns_protocol::kTypeA,
 706                         dns_protocol::kRcodeNXDOMAIN);
 707   AddAsyncQueryAndRcode("x.y", dns_protocol::kTypeA,
 708                         dns_protocol::kRcodeNXDOMAIN);
 709   // Responses for second transaction.
 710   AddAsyncQueryAndRcode("x.a", dns_protocol::kTypeA,
 711                         dns_protocol::kRcodeNXDOMAIN);
 712   AddAsyncQueryAndRcode("x.b", dns_protocol::kTypeA,
 713                         dns_protocol::kRcodeNXDOMAIN);
 714   AddAsyncQueryAndRcode("x.c", dns_protocol::kTypeA,
 715                         dns_protocol::kRcodeNXDOMAIN);
 716   // Responses for third transaction.
 717   AddAsyncQueryAndRcode("x", dns_protocol::kTypeAAAA,
 718                         dns_protocol::kRcodeNXDOMAIN);
 719
 720   TransactionHelper helper0("x.y", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
 721
 722   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 723
 724   // A single-label name.
 725   TransactionHelper helper1("x", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
 726
 727   EXPECT_TRUE(helper1.Run(transaction_factory_.get()));
 728
 729   // A fully-qualified name.
 730   TransactionHelper helper2("x.", dns_protocol::kTypeAAAA,
 731                             ERR_NAME_NOT_RESOLVED);
 732
 733   EXPECT_TRUE(helper2.Run(transaction_factory_.get()));
 734 }
 735
 736 TEST_F(DnsTransactionTest, EmptySuffixSearch) {
 737   // Responses for first transaction.
 738   AddAsyncQueryAndRcode("x", dns_protocol::kTypeA,
 739                         dns_protocol::kRcodeNXDOMAIN);
 740
 741   // A fully-qualified name.
 742   TransactionHelper helper0("x.", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
 743
 744   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 745
 746   // A single label name is not even attempted.
 747   TransactionHelper helper1("singlelabel", dns_protocol::kTypeA,
 748                             ERR_DNS_SEARCH_EMPTY);
 749
 750   helper1.Run(transaction_factory_.get());
 751   EXPECT_TRUE(helper1.has_completed());
 752 }
 753
 754 TEST_F(DnsTransactionTest, DontAppendToMultiLabelName) {
 755   config_.search.push_back("a");
 756   config_.search.push_back("b");
 757   config_.search.push_back("c");
 758   config_.append_to_multi_label_name = false;
 759   ConfigureFactory();
 760
 761   // Responses for first transaction.
 762   AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
 763                         dns_protocol::kRcodeNXDOMAIN);
 764   // Responses for second transaction.
 765   AddAsyncQueryAndRcode("x.y", dns_protocol::kTypeA,
 766                         dns_protocol::kRcodeNXDOMAIN);
 767   // Responses for third transaction.
 768   AddAsyncQueryAndRcode("x.a", dns_protocol::kTypeA,
 769                         dns_protocol::kRcodeNXDOMAIN);
 770   AddAsyncQueryAndRcode("x.b", dns_protocol::kTypeA,
 771                         dns_protocol::kRcodeNXDOMAIN);
 772   AddAsyncQueryAndRcode("x.c", dns_protocol::kTypeA,
 773                         dns_protocol::kRcodeNXDOMAIN);
 774
 775   TransactionHelper helper0("x.y.z", dns_protocol::kTypeA,
 776                             ERR_NAME_NOT_RESOLVED);
 777   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 778
 779   TransactionHelper helper1("x.y", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
 780   EXPECT_TRUE(helper1.Run(transaction_factory_.get()));
 781
 782   TransactionHelper helper2("x", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
 783   EXPECT_TRUE(helper2.Run(transaction_factory_.get()));
 784 }
 785
 786 const uint8 kResponseNoData[] = {
 787   0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 788   // Question
 789   0x01,  'x', 0x01,  'y', 0x01,  'z', 0x01,  'b', 0x00, 0x00, 0x01, 0x00, 0x01,
 790   // Authority section, SOA record, TTL 0x3E6
 791   0x01,  'z', 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x03, 0xE6,
 792   // Minimal RDATA, 18 bytes
 793   0x00, 0x12,
 794   0x00, 0x00,
 795   0x00, 0x00, 0x00, 0x00,
 796   0x00, 0x00, 0x00, 0x00,
 797   0x00, 0x00, 0x00, 0x00,
 798   0x00, 0x00, 0x00, 0x00,
 799 };
 800
 801 TEST_F(DnsTransactionTest, SuffixSearchStop) {
 802   config_.ndots = 2;
 803   config_.search.push_back("a");
 804   config_.search.push_back("b");
 805   config_.search.push_back("c");
 806   ConfigureFactory();
 807
 808   AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
 809                         dns_protocol::kRcodeNXDOMAIN);
 810   AddAsyncQueryAndRcode("x.y.z.a", dns_protocol::kTypeA,
 811                         dns_protocol::kRcodeNXDOMAIN);
 812   AddAsyncQueryAndResponse(0 /* id */, "x.y.z.b", dns_protocol::kTypeA,
 813                            kResponseNoData, arraysize(kResponseNoData));
 814
 815   TransactionHelper helper0("x.y.z", dns_protocol::kTypeA, 0 /* answers */);
 816
 817   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 818 }
 819
 820 TEST_F(DnsTransactionTest, SyncFirstQuery) {
 821   config_.search.push_back("lab.ccs.neu.edu");
 822   config_.search.push_back("ccs.neu.edu");
 823   ConfigureFactory();
 824
 825   AddSyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 826                           kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 827
 828   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 829   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 830 }
 831
 832 TEST_F(DnsTransactionTest, SyncFirstQueryWithSearch) {
 833   config_.search.push_back("lab.ccs.neu.edu");
 834   config_.search.push_back("ccs.neu.edu");
 835   ConfigureFactory();
 836
 837   AddSyncQueryAndRcode("www.lab.ccs.neu.edu", kT2Qtype,
 838                        dns_protocol::kRcodeNXDOMAIN);
 839   // "www.ccs.neu.edu"
 840   AddAsyncQueryAndResponse(2 /* id */, kT2HostName, kT2Qtype,
 841                            kT2ResponseDatagram, arraysize(kT2ResponseDatagram));
 842
 843   TransactionHelper helper0("www", kT2Qtype, kT2RecordCount);
 844   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 845 }
 846
 847 TEST_F(DnsTransactionTest, SyncSearchQuery) {
 848   config_.search.push_back("lab.ccs.neu.edu");
 849   config_.search.push_back("ccs.neu.edu");
 850   ConfigureFactory();
 851
 852   AddAsyncQueryAndRcode("www.lab.ccs.neu.edu", dns_protocol::kTypeA,
 853                         dns_protocol::kRcodeNXDOMAIN);
 854   AddSyncQueryAndResponse(2 /* id */, kT2HostName, kT2Qtype,
 855                           kT2ResponseDatagram, arraysize(kT2ResponseDatagram));
 856
 857   TransactionHelper helper0("www", kT2Qtype, kT2RecordCount);
 858   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 859 }
 860
 861 TEST_F(DnsTransactionTest, ConnectFailure) {
 862   socket_factory_->fail_next_socket_ = true;
 863   transaction_ids_.push_back(0);  // Needed to make a DnsUDPAttempt.
 864   TransactionHelper helper0("www.chromium.org", dns_protocol::kTypeA,
 865                             ERR_CONNECTION_REFUSED);
 866   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 867 }
 868
 869 TEST_F(DnsTransactionTest, ConnectFailureFollowedBySuccess) {
 870   // Retry after server failure.
 871   config_.attempts = 2;
 872   ConfigureFactory();
 873   // First server connection attempt fails.
 874   transaction_ids_.push_back(0);  // Needed to make a DnsUDPAttempt.
 875   socket_factory_->fail_next_socket_ = true;
 876   // Second DNS query succeeds.
 877   AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 878                            kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
 879   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 880   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 881 }
 882
 883 TEST_F(DnsTransactionTest, TCPLookup) {
 884   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 885                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 886   AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
 887                       kT0ResponseDatagram, arraysize(kT0ResponseDatagram),
 888                       ASYNC, true /* use_tcp */);
 889
 890   TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
 891   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 892 }
 893
 894 TEST_F(DnsTransactionTest, TCPFailure) {
 895   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 896                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 897   AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
 898                    ASYNC, true /* use_tcp */);
 899
 900   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_SERVER_FAILED);
 901   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 902 }
 903
 904 TEST_F(DnsTransactionTest, TCPMalformed) {
 905   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 906                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 907   scoped_ptr<DnsSocketData> data(
 908       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
 909   // Valid response but length too short.
 910   // This must be truncated in the question section. The DnsResponse doesn't
 911   // examine the answer section until asked to parse it, so truncating it in
 912   // the answer section would result in the DnsTransaction itself succeeding.
 913   data->AddResponseWithLength(
 914       make_scoped_ptr(
 915           new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram),
 916                           arraysize(kT0ResponseDatagram), 0)),
 917       ASYNC,
 918       static_cast<uint16>(kT0QuerySize - 1));
 919   AddSocketData(data.Pass());
 920
 921   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_MALFORMED_RESPONSE);
 922   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 923 }
 924
 925 TEST_F(DnsTransactionTest, TCPTimeout) {
 926   config_.timeout = TestTimeouts::tiny_timeout();
 927   ConfigureFactory();
 928   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 929                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 930   AddSocketData(make_scoped_ptr(
 931       new DnsSocketData(1 /* id */, kT0HostName, kT0Qtype, ASYNC, true)));
 932
 933   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_TIMED_OUT);
 934   EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
 935 }
 936
 937 TEST_F(DnsTransactionTest, TCPReadReturnsZeroAsync) {
 938   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 939                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 940   scoped_ptr<DnsSocketData> data(
 941       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
 942   // Return all but the last byte of the response.
 943   data->AddResponseWithLength(
 944       make_scoped_ptr(
 945           new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram),
 946                           arraysize(kT0ResponseDatagram) - 1, 0)),
 947       ASYNC,
 948       static_cast<uint16>(arraysize(kT0ResponseDatagram)));
 949   // Then return a 0-length read.
 950   data->AddReadError(0, ASYNC);
 951   AddSocketData(data.Pass());
 952
 953   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_CONNECTION_CLOSED);
 954   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 955 }
 956
 957 TEST_F(DnsTransactionTest, TCPReadReturnsZeroSynchronous) {
 958   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 959                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 960   scoped_ptr<DnsSocketData> data(
 961       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
 962   // Return all but the last byte of the response.
 963   data->AddResponseWithLength(
 964       make_scoped_ptr(
 965           new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram),
 966                           arraysize(kT0ResponseDatagram) - 1, 0)),
 967       SYNCHRONOUS,
 968       static_cast<uint16>(arraysize(kT0ResponseDatagram)));
 969   // Then return a 0-length read.
 970   data->AddReadError(0, SYNCHRONOUS);
 971   AddSocketData(data.Pass());
 972
 973   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_CONNECTION_CLOSED);
 974   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 975 }
 976
 977 TEST_F(DnsTransactionTest, TCPConnectionClosedAsync) {
 978   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 979                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 980   scoped_ptr<DnsSocketData> data(
 981       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
 982   data->AddReadError(ERR_CONNECTION_CLOSED, ASYNC);
 983   AddSocketData(data.Pass());
 984
 985   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_CONNECTION_CLOSED);
 986   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 987 }
 988
 989 TEST_F(DnsTransactionTest, TCPConnectionClosedSynchronous) {
 990   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
 991                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
 992   scoped_ptr<DnsSocketData> data(
 993       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
 994   data->AddReadError(ERR_CONNECTION_CLOSED, SYNCHRONOUS);
 995   AddSocketData(data.Pass());
 996
 997   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_CONNECTION_CLOSED);
 998   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 999 }
1000
1001 TEST_F(DnsTransactionTest, InvalidQuery) {
1002   config_.timeout = TestTimeouts::tiny_timeout();
1003   ConfigureFactory();
1004
1005   TransactionHelper helper0(".", dns_protocol::kTypeA, ERR_INVALID_ARGUMENT);
1006   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
1007 }
1008
1009 }  // namespace
1010
1011 }  // namespace net