blob: abfcf0739190e67b7c20868d1fb75dc582d9d2e6 [file] [log] [blame]
// 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"
#include "base/sys_byteorder.h"
#include "base/test/test_timeouts.h"
#include "net/base/big_endian.h"
#include "net/base/dns_util.h"
#include "net/base/net_log.h"
#include "net/dns/dns_protocol.h"
#include "net/dns/dns_query.h"
#include "net/dns/dns_response.h"
#include "net/dns/dns_session.h"
#include "net/dns/dns_test_util.h"
#include "net/socket/socket_test_util.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
std::string DomainFromDot(const base::StringPiece& dotted) {
std::string out;
EXPECT_TRUE(DNSDomainFromDot(dotted, &out));
return out;
}
// A SocketDataProvider builder for MockUDPClientSocket. Each socket used by a
// DnsTransaction expects only one write and zero or more reads.
class DnsSocketData {
public:
// The ctor takes parameters for the DnsQuery.
DnsSocketData(uint16 id, const char* dotted_name, uint16 qtype, IoMode mode)
: query_(new DnsQuery(id, DomainFromDot(dotted_name), qtype)),
write_(mode, query_->io_buffer()->data(), query_->io_buffer()->size()) {
}
~DnsSocketData() {}
// All responses must be added before GetProvider.
// Add pre-built DnsResponse.
void AddResponse(scoped_ptr<DnsResponse> response, IoMode mode) {
CHECK(!provider_.get());
reads_.push_back(MockRead(mode,
response->io_buffer()->data(),
response->io_buffer()->size()));
responses_.push_back(response.release());
}
// Adds pre-built response from |data| buffer.
void AddResponseData(const uint8* data, size_t length, IoMode mode) {
CHECK(!provider_.get());
AddResponse(make_scoped_ptr(
new DnsResponse(reinterpret_cast<const char*>(data), length, 0)), mode);
}
// Add no-answer (RCODE only) response matching the query.
void AddRcode(int rcode, IoMode mode) {
scoped_ptr<DnsResponse> response(
new DnsResponse(query_->io_buffer()->data(),
query_->io_buffer()->size(),
0));
dns_protocol::Header* header =
reinterpret_cast<dns_protocol::Header*>(response->io_buffer()->data());
header->flags |= base::HostToNet16(dns_protocol::kFlagResponse | rcode);
AddResponse(response.Pass(), mode);
}
// Build, if needed, and return the SocketDataProvider. No new responses
// should be added afterwards.
SocketDataProvider* GetProvider() {
if (provider_.get())
return provider_.get();
if (reads_.empty()) {
// Timeout.
provider_.reset(new DelayedSocketData(2, NULL, 0, &write_, 1));
} else {
// Terminate the reads with ERR_IO_PENDING to prevent overrun.
reads_.push_back(MockRead(ASYNC, ERR_IO_PENDING));
provider_.reset(new DelayedSocketData(1, &reads_[0], reads_.size(),
&write_, 1));
}
return provider_.get();
}
uint16 query_id() const {
return query_->id();
}
// Returns true if the expected query was written to the socket.
bool was_written() const {
CHECK(provider_.get());
return provider_->write_index() > 0;
}
private:
scoped_ptr<DnsQuery> query_;
ScopedVector<DnsResponse> responses_;
MockWrite write_;
std::vector<MockRead> reads_;
scoped_ptr<DelayedSocketData> provider_;
DISALLOW_COPY_AND_ASSIGN(DnsSocketData);
};
class TestSocketFactory;
// A variant of MockUDPClientSocket which always fails to Connect.
class FailingUDPClientSocket : public MockUDPClientSocket {
public:
FailingUDPClientSocket(SocketDataProvider* data,
net::NetLog* net_log)
: MockUDPClientSocket(data, net_log) {
}
virtual ~FailingUDPClientSocket() {}
virtual int Connect(const IPEndPoint& endpoint) OVERRIDE {
return ERR_CONNECTION_REFUSED;
}
private:
DISALLOW_COPY_AND_ASSIGN(FailingUDPClientSocket);
};
// A variant of MockUDPClientSocket which notifies the factory OnConnect.
class TestUDPClientSocket : public MockUDPClientSocket {
public:
TestUDPClientSocket(TestSocketFactory* factory,
SocketDataProvider* data,
net::NetLog* net_log)
: MockUDPClientSocket(data, net_log), factory_(factory) {
}
virtual ~TestUDPClientSocket() {}
virtual int Connect(const IPEndPoint& endpoint) OVERRIDE;
private:
TestSocketFactory* factory_;
DISALLOW_COPY_AND_ASSIGN(TestUDPClientSocket);
};
// Creates TestUDPClientSockets and keeps endpoints reported via OnConnect.
class TestSocketFactory : public MockClientSocketFactory {
public:
TestSocketFactory() : create_failing_sockets_(false) {}
virtual ~TestSocketFactory() {}
virtual DatagramClientSocket* CreateDatagramClientSocket(
DatagramSocket::BindType bind_type,
const RandIntCallback& rand_int_cb,
net::NetLog* net_log,
const net::NetLog::Source& source) OVERRIDE {
if (create_failing_sockets_)
return new FailingUDPClientSocket(&empty_data_, net_log);
SocketDataProvider* data_provider = mock_data().GetNext();
TestUDPClientSocket* socket = new TestUDPClientSocket(this,
data_provider,
net_log);
data_provider->set_socket(socket);
return socket;
}
void OnConnect(const IPEndPoint& endpoint) {
remote_endpoints_.push_back(endpoint);
}
std::vector<IPEndPoint> remote_endpoints_;
bool create_failing_sockets_;
private:
StaticSocketDataProvider empty_data_;
DISALLOW_COPY_AND_ASSIGN(TestSocketFactory);
};
int TestUDPClientSocket::Connect(const IPEndPoint& endpoint) {
factory_->OnConnect(endpoint);
return MockUDPClientSocket::Connect(endpoint);
}
// Helper class that holds a DnsTransaction and handles OnTransactionComplete.
class TransactionHelper {
public:
// If |expected_answer_count| < 0 then it is the expected net error.
TransactionHelper(const char* hostname,
uint16 qtype,
int expected_answer_count)
: hostname_(hostname),
qtype_(qtype),
expected_answer_count_(expected_answer_count),
cancel_in_callback_(false),
quit_in_callback_(false),
completed_(false) {
}
// Mark that the transaction shall be destroyed immediately upon callback.
void set_cancel_in_callback() {
cancel_in_callback_ = true;
}
// Mark to call MessageLoop::Quit() upon callback.
void set_quit_in_callback() {
quit_in_callback_ = true;
}
void StartTransaction(DnsTransactionFactory* factory) {
EXPECT_EQ(NULL, transaction_.get());
transaction_ = factory->CreateTransaction(
hostname_,
qtype_,
base::Bind(&TransactionHelper::OnTransactionComplete,
base::Unretained(this)),
BoundNetLog());
EXPECT_EQ(hostname_, transaction_->GetHostname());
EXPECT_EQ(qtype_, transaction_->GetType());
int rv = transaction_->Start();
if (rv != ERR_IO_PENDING) {
EXPECT_NE(OK, rv);
EXPECT_EQ(expected_answer_count_, rv);
completed_ = true;
}
}
void Cancel() {
ASSERT_TRUE(transaction_.get() != NULL);
transaction_.reset(NULL);
}
void OnTransactionComplete(DnsTransaction* t,
int rv,
const DnsResponse* response) {
EXPECT_FALSE(completed_);
EXPECT_EQ(transaction_.get(), t);
completed_ = true;
if (cancel_in_callback_) {
Cancel();
return;
}
// Tell MessageLoop to quit now, in case any ASSERT_* fails.
if (quit_in_callback_)
MessageLoop::current()->Quit();
if (expected_answer_count_ >= 0) {
ASSERT_EQ(OK, rv);
ASSERT_TRUE(response != NULL);
EXPECT_EQ(static_cast<unsigned>(expected_answer_count_),
response->answer_count());
EXPECT_EQ(qtype_, response->qtype());
DnsRecordParser parser = response->Parser();
DnsResourceRecord record;
for (int i = 0; i < expected_answer_count_; ++i) {
EXPECT_TRUE(parser.ReadRecord(&record));
}
} else {
EXPECT_EQ(expected_answer_count_, rv);
}
}
bool has_completed() const {
return completed_;
}
// Shorthands for commonly used commands.
bool Run(DnsTransactionFactory* factory) {
StartTransaction(factory);
MessageLoop::current()->RunUntilIdle();
return has_completed();
}
// Use when some of the responses are timeouts.
bool RunUntilDone(DnsTransactionFactory* factory) {
set_quit_in_callback();
StartTransaction(factory);
MessageLoop::current()->Run();
return has_completed();
}
private:
std::string hostname_;
uint16 qtype_;
scoped_ptr<DnsTransaction> transaction_;
int expected_answer_count_;
bool cancel_in_callback_;
bool quit_in_callback_;
bool completed_;
};
class DnsTransactionTest : public testing::Test {
public:
DnsTransactionTest() : socket_factory_(NULL) {}
// Generates |nameservers| for DnsConfig.
void ConfigureNumServers(unsigned num_servers) {
CHECK_LE(num_servers, 255u);
config_.nameservers.clear();
IPAddressNumber dns_ip;
{
bool rv = ParseIPLiteralToNumber("192.168.1.0", &dns_ip);
EXPECT_TRUE(rv);
}
for (unsigned i = 0; i < num_servers; ++i) {
dns_ip[3] = i;
config_.nameservers.push_back(IPEndPoint(dns_ip,
dns_protocol::kDefaultPort));
}
}
// Called after fully configuring |config|.
void ConfigureFactory() {
socket_factory_.reset(new TestSocketFactory());
session_ = new DnsSession(
config_,
DnsSocketPool::CreateNull(socket_factory_.get()),
base::Bind(&DnsTransactionTest::GetNextId, base::Unretained(this)),
NULL /* NetLog */);
transaction_factory_ = DnsTransactionFactory::CreateFactory(session_.get());
}
void AddSocketData(scoped_ptr<DnsSocketData> data) {
transaction_ids_.push_back(data->query_id());
socket_factory_->AddSocketDataProvider(data->GetProvider());
socket_data_.push_back(data.release());
}
// Add expected query for |dotted_name| and |qtype| with |id| and response
// taken verbatim from |data| of |data_length| bytes. The transaction id in
// |data| should equal |id|, unless testing mismatched response.
void AddQueryAndResponse(uint16 id,
const char* dotted_name,
uint16 qtype,
const uint8* response_data,
size_t response_length,
IoMode mode) {
CHECK(socket_factory_.get());
scoped_ptr<DnsSocketData> data(
new DnsSocketData(id, dotted_name, qtype, mode));
data->AddResponseData(response_data, response_length, mode);
AddSocketData(data.Pass());
}
void AddAsyncQueryAndResponse(uint16 id,
const char* dotted_name,
uint16 qtype,
const uint8* data,
size_t data_length) {
AddQueryAndResponse(id, dotted_name, qtype, data, data_length, ASYNC);
}
void AddSyncQueryAndResponse(uint16 id,
const char* dotted_name,
uint16 qtype,
const uint8* data,
size_t data_length) {
AddQueryAndResponse(id, dotted_name, qtype, data, data_length, SYNCHRONOUS);
}
// Add expected query of |dotted_name| and |qtype| and no response.
void AddQueryAndTimeout(const char* dotted_name, uint16 qtype) {
CHECK(socket_factory_.get());
uint16 id = base::RandInt(0, kuint16max);
scoped_ptr<DnsSocketData> data(
new DnsSocketData(id, dotted_name, qtype, ASYNC));
AddSocketData(data.Pass());
}
// Add expected query of |dotted_name| and |qtype| and matching response with
// no answer and RCODE set to |rcode|. The id will be generated randomly.
void AddQueryAndRcode(const char* dotted_name,
uint16 qtype,
int rcode,
IoMode mode) {
CHECK(socket_factory_.get());
CHECK_NE(dns_protocol::kRcodeNOERROR, rcode);
uint16 id = base::RandInt(0, kuint16max);
scoped_ptr<DnsSocketData> data(
new DnsSocketData(id, dotted_name, qtype, mode));
data->AddRcode(rcode, mode);
AddSocketData(data.Pass());
}
void AddAsyncQueryAndRcode(const char* dotted_name, uint16 qtype, int rcode) {
AddQueryAndRcode(dotted_name, qtype, rcode, ASYNC);
}
void AddSyncQueryAndRcode(const char* dotted_name, uint16 qtype, int rcode) {
AddQueryAndRcode(dotted_name, qtype, rcode, SYNCHRONOUS);
}
// Checks if the sockets were connected in the order matching the indices in
// |servers|.
void CheckServerOrder(const unsigned* servers, size_t num_attempts) {
ASSERT_EQ(num_attempts, socket_factory_->remote_endpoints_.size());
for (size_t i = 0; i < num_attempts; ++i) {
EXPECT_EQ(socket_factory_->remote_endpoints_[i],
session_->config().nameservers[servers[i]]);
}
}
void SetUp() OVERRIDE {
// By default set one server,
ConfigureNumServers(1);
// and no retransmissions,
config_.attempts = 1;
// but long enough timeout for memory tests.
config_.timeout = TestTimeouts::action_timeout();
ConfigureFactory();
}
void TearDown() OVERRIDE {
// Check that all socket data was at least written to.
for (size_t i = 0; i < socket_data_.size(); ++i) {
EXPECT_TRUE(socket_data_[i]->was_written()) << i;
}
}
protected:
int GetNextId(int min, int max) {
EXPECT_FALSE(transaction_ids_.empty());
int id = transaction_ids_.front();
transaction_ids_.pop_front();
EXPECT_GE(id, min);
EXPECT_LE(id, max);
return id;
}
DnsConfig config_;
ScopedVector<DnsSocketData> socket_data_;
std::deque<int> transaction_ids_;
scoped_ptr<TestSocketFactory> socket_factory_;
scoped_refptr<DnsSession> session_;
scoped_ptr<DnsTransactionFactory> transaction_factory_;
};
TEST_F(DnsTransactionTest, Lookup) {
AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
}
// Concurrent lookup tests assume that DnsTransaction::Start immediately
// consumes a socket from ClientSocketFactory.
TEST_F(DnsTransactionTest, ConcurrentLookup) {
AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
AddAsyncQueryAndResponse(1 /* id */, kT1HostName, kT1Qtype,
kT1ResponseDatagram, arraysize(kT1ResponseDatagram));
TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
helper0.StartTransaction(transaction_factory_.get());
TransactionHelper helper1(kT1HostName, kT1Qtype, kT1RecordCount);
helper1.StartTransaction(transaction_factory_.get());
MessageLoop::current()->RunUntilIdle();
EXPECT_TRUE(helper0.has_completed());
EXPECT_TRUE(helper1.has_completed());
}
TEST_F(DnsTransactionTest, CancelLookup) {
AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
AddAsyncQueryAndResponse(1 /* id */, kT1HostName, kT1Qtype,
kT1ResponseDatagram, arraysize(kT1ResponseDatagram));
TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
helper0.StartTransaction(transaction_factory_.get());
TransactionHelper helper1(kT1HostName, kT1Qtype, kT1RecordCount);
helper1.StartTransaction(transaction_factory_.get());
helper0.Cancel();
MessageLoop::current()->RunUntilIdle();
EXPECT_FALSE(helper0.has_completed());
EXPECT_TRUE(helper1.has_completed());
}
TEST_F(DnsTransactionTest, DestroyFactory) {
AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
helper0.StartTransaction(transaction_factory_.get());
// Destroying the client does not affect running requests.
transaction_factory_.reset(NULL);
MessageLoop::current()->RunUntilIdle();
EXPECT_TRUE(helper0.has_completed());
}
TEST_F(DnsTransactionTest, CancelFromCallback) {
AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
helper0.set_cancel_in_callback();
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, MismatchedResponseSync) {
config_.attempts = 2;
config_.timeout = TestTimeouts::tiny_timeout();
ConfigureFactory();
// Attempt receives mismatched response followed by valid response.
scoped_ptr<DnsSocketData> data(
new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, SYNCHRONOUS));
data->AddResponseData(kT1ResponseDatagram,
arraysize(kT1ResponseDatagram), SYNCHRONOUS);
data->AddResponseData(kT0ResponseDatagram,
arraysize(kT0ResponseDatagram), SYNCHRONOUS);
AddSocketData(data.Pass());
TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, MismatchedResponseAsync) {
config_.attempts = 2;
config_.timeout = TestTimeouts::tiny_timeout();
ConfigureFactory();
// First attempt receives mismatched response followed by valid response.
// Second attempt times out.
scoped_ptr<DnsSocketData> data(
new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC));
data->AddResponseData(kT1ResponseDatagram,
arraysize(kT1ResponseDatagram), ASYNC);
data->AddResponseData(kT0ResponseDatagram,
arraysize(kT0ResponseDatagram), ASYNC);
AddSocketData(data.Pass());
AddQueryAndTimeout(kT0HostName, kT0Qtype);
TransactionHelper helper0(kT0HostName, kT0Qtype, kT0RecordCount);
EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, MismatchedResponseFail) {
config_.timeout = TestTimeouts::tiny_timeout();
ConfigureFactory();
// Attempt receives mismatched response but times out because only one attempt
// is allowed.
AddAsyncQueryAndResponse(1 /* id */, kT0HostName, kT0Qtype,
kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_TIMED_OUT);
EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, ServerFail) {
AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_SERVER_FAILED);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, NoDomain) {
AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, Timeout) {
config_.attempts = 3;
// Use short timeout to speed up the test.
config_.timeout = TestTimeouts::tiny_timeout();
ConfigureFactory();
AddQueryAndTimeout(kT0HostName, kT0Qtype);
AddQueryAndTimeout(kT0HostName, kT0Qtype);
AddQueryAndTimeout(kT0HostName, kT0Qtype);
TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_TIMED_OUT);
EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
MessageLoop::current()->AssertIdle();
}
TEST_F(DnsTransactionTest, ServerFallbackAndRotate) {
// Test that we fallback on both server failure and timeout.
config_.attempts = 2;
// The next request should start from the next server.
config_.rotate = true;
ConfigureNumServers(3);
// Use short timeout to speed up the test.
config_.timeout = TestTimeouts::tiny_timeout();
ConfigureFactory();
// Responses for first request.
AddQueryAndTimeout(kT0HostName, kT0Qtype);
AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
AddQueryAndTimeout(kT0HostName, kT0Qtype);
AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
// Responses for second request.
AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeSERVFAIL);
AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeNXDOMAIN);
TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_NAME_NOT_RESOLVED);
TransactionHelper helper1(kT1HostName, kT1Qtype, ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
EXPECT_TRUE(helper1.Run(transaction_factory_.get()));
unsigned kOrder[] = {
0, 1, 2, 0, 1, // The first transaction.
1, 2, // The second transaction starts from the next server.
};
CheckServerOrder(kOrder, arraysize(kOrder));
}
TEST_F(DnsTransactionTest, SuffixSearchAboveNdots) {
config_.ndots = 2;
config_.search.push_back("a");
config_.search.push_back("b");
config_.search.push_back("c");
config_.rotate = true;
ConfigureNumServers(2);
ConfigureFactory();
AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.y.z.a", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.y.z.b", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.y.z.c", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
TransactionHelper helper0("x.y.z", dns_protocol::kTypeA,
ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
// Also check if suffix search causes server rotation.
unsigned kOrder0[] = { 0, 1, 0, 1 };
CheckServerOrder(kOrder0, arraysize(kOrder0));
}
TEST_F(DnsTransactionTest, SuffixSearchBelowNdots) {
config_.ndots = 2;
config_.search.push_back("a");
config_.search.push_back("b");
config_.search.push_back("c");
ConfigureFactory();
// Responses for first transaction.
AddAsyncQueryAndRcode("x.y.a", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.y.b", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.y.c", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.y", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
// Responses for second transaction.
AddAsyncQueryAndRcode("x.a", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.b", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.c", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
// Responses for third transaction.
AddAsyncQueryAndRcode("x", dns_protocol::kTypeAAAA,
dns_protocol::kRcodeNXDOMAIN);
TransactionHelper helper0("x.y", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
// A single-label name.
TransactionHelper helper1("x", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper1.Run(transaction_factory_.get()));
// A fully-qualified name.
TransactionHelper helper2("x.", dns_protocol::kTypeAAAA,
ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper2.Run(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, EmptySuffixSearch) {
// Responses for first transaction.
AddAsyncQueryAndRcode("x", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
// A fully-qualified name.
TransactionHelper helper0("x.", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
// A single label name is not even attempted.
TransactionHelper helper1("singlelabel", dns_protocol::kTypeA,
ERR_DNS_SEARCH_EMPTY);
helper1.StartTransaction(transaction_factory_.get());
EXPECT_TRUE(helper1.has_completed());
}
TEST_F(DnsTransactionTest, DontAppendToMultiLabelName) {
config_.search.push_back("a");
config_.search.push_back("b");
config_.search.push_back("c");
config_.append_to_multi_label_name = false;
ConfigureFactory();
// Responses for first transaction.
AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
// Responses for second transaction.
AddAsyncQueryAndRcode("x.y", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
// Responses for third transaction.
AddAsyncQueryAndRcode("x.a", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.b", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.c", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
TransactionHelper helper0("x.y.z", dns_protocol::kTypeA,
ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
TransactionHelper helper1("x.y", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper1.Run(transaction_factory_.get()));
TransactionHelper helper2("x", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
EXPECT_TRUE(helper2.Run(transaction_factory_.get()));
}
const uint8 kResponseNoData[] = {
0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
// Question
0x01, 'x', 0x01, 'y', 0x01, 'z', 0x01, 'b', 0x00, 0x00, 0x01, 0x00, 0x01,
// Authority section, SOA record, TTL 0x3E6
0x01, 'z', 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x03, 0xE6,
// Minimal RDATA, 18 bytes
0x00, 0x12,
0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
TEST_F(DnsTransactionTest, SuffixSearchStop) {
config_.ndots = 2;
config_.search.push_back("a");
config_.search.push_back("b");
config_.search.push_back("c");
ConfigureFactory();
AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndRcode("x.y.z.a", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddAsyncQueryAndResponse(0 /* id */, "x.y.z.b", dns_protocol::kTypeA,
kResponseNoData, arraysize(kResponseNoData));
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();
AddSyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
kT0ResponseDatagram, arraysize(kT0ResponseDatagram));
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();
AddSyncQueryAndRcode("www.lab.ccs.neu.edu", kT2Qtype,
dns_protocol::kRcodeNXDOMAIN);
// "www.ccs.neu.edu"
AddAsyncQueryAndResponse(2 /* id */, kT2HostName, kT2Qtype,
kT2ResponseDatagram, arraysize(kT2ResponseDatagram));
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();
AddAsyncQueryAndRcode("www.lab.ccs.neu.edu", dns_protocol::kTypeA,
dns_protocol::kRcodeNXDOMAIN);
AddSyncQueryAndResponse(2 /* id */, kT2HostName, kT2Qtype,
kT2ResponseDatagram, arraysize(kT2ResponseDatagram));
TransactionHelper helper0("www", kT2Qtype, kT2RecordCount);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
}
TEST_F(DnsTransactionTest, ConnectFailure) {
socket_factory_->create_failing_sockets_ = true;
transaction_ids_.push_back(0); // Needed to make a DnsUDPAttempt.
TransactionHelper helper0("www.chromium.org", dns_protocol::kTypeA,
ERR_CONNECTION_REFUSED);
EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
}
} // namespace
} // namespace net