OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/dns/dns_client.h" | 5 #include "net/dns/dns_client.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
9 #include "net/base/big_endian.h" | 9 #include "net/base/big_endian.h" |
10 #include "net/base/net_log.h" | 10 #include "net/base/net_log.h" |
11 #include "net/base/sys_addrinfo.h" | 11 #include "net/base/sys_addrinfo.h" |
12 #include "net/dns/dns_response.h" | 12 #include "net/dns/dns_response.h" |
13 #include "net/dns/dns_session.h" | 13 #include "net/dns/dns_session.h" |
14 #include "net/dns/dns_test_util.h" | 14 #include "net/dns/dns_test_util.h" |
15 #include "net/socket/socket_test_util.h" | 15 #include "net/socket/socket_test_util.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 | 17 |
18 // TODO(szym): test DnsClient::Request::Start with synchronous failure | 18 // TODO(szym): test timeout. |
19 // TODO(szym): test suffix search and server fallback once implemented | 19 // TODO(szym): test server fallback. |
| 20 // TODO(szym): test suffix search. |
20 | 21 |
21 namespace net { | 22 namespace net { |
22 | 23 |
23 namespace { | 24 namespace { |
24 | 25 |
25 class DnsClientTest : public testing::Test { | 26 class DnsClientTest : public testing::Test { |
26 public: | 27 public: |
27 class TestRequestHelper { | 28 class TestHelper { |
28 public: | 29 public: |
29 // If |answer_count| < 0, it is the expected error code. | 30 // If |answer_count| < 0, it is the expected error code. |
30 TestRequestHelper(const char* name, | 31 TestHelper(const char* name, |
31 uint16 type, | 32 uint16 type, |
32 const MockWrite& write, | 33 const MockWrite& write, |
33 const MockRead& read, | 34 const MockRead& read, |
34 int answer_count) { | 35 int answer_count) |
35 // Must include the terminating \x00. | 36 : qname(name), |
36 qname = std::string(name, strlen(name) + 1); | 37 qtype(type), |
37 qtype = type; | 38 expected_answer_count(answer_count), |
38 expected_answer_count = answer_count; | 39 completed(false) { |
39 completed = false; | |
40 writes.push_back(write); | 40 writes.push_back(write); |
41 reads.push_back(read); | 41 reads.push_back(read); |
42 ReadBigEndian<uint16>(write.data, &transaction_id); | 42 ReadBigEndian<uint16>(write.data, &transaction_id); |
43 data.reset(new StaticSocketDataProvider(&reads[0], reads.size(), | 43 data.reset(new StaticSocketDataProvider(&reads[0], reads.size(), |
44 &writes[0], writes.size())); | 44 &writes[0], writes.size())); |
45 } | 45 } |
46 | 46 |
47 void MakeRequest(DnsClient* client) { | 47 void MakeRequest(DnsClient* client) { |
48 EXPECT_EQ(NULL, request.get()); | 48 EXPECT_EQ(NULL, transaction.get()); |
49 request.reset(client->CreateRequest( | 49 transaction = client->CreateTransaction( |
50 qname, | 50 qname, |
51 qtype, | 51 qtype, |
52 base::Bind(&TestRequestHelper::OnRequestComplete, | 52 base::Bind(&TestHelper::OnTransactionComplete, |
53 base::Unretained(this)), | 53 base::Unretained(this)), |
54 BoundNetLog())); | 54 BoundNetLog()); |
55 EXPECT_EQ(qname, request->qname()); | 55 EXPECT_EQ(qname, transaction->GetHostname()); |
56 EXPECT_EQ(qtype, request->qtype()); | 56 EXPECT_EQ(qtype, transaction->GetType()); |
57 EXPECT_EQ(ERR_IO_PENDING, request->Start()); | |
58 } | 57 } |
59 | 58 |
60 void Cancel() { | 59 void Cancel() { |
61 ASSERT_TRUE(request.get() != NULL); | 60 ASSERT_TRUE(transaction.get() != NULL); |
62 request.reset(NULL); | 61 transaction.reset(NULL); |
63 } | 62 } |
64 | 63 |
65 void OnRequestComplete(DnsClient::Request* req, | 64 void OnTransactionComplete(DnsTransaction* t, |
66 int rv, | 65 int rv, |
67 const DnsResponse* response) { | 66 const DnsResponse* response) { |
68 EXPECT_FALSE(completed); | 67 EXPECT_FALSE(completed); |
69 EXPECT_EQ(request.get(), req); | 68 EXPECT_EQ(transaction.get(), t); |
70 | 69 |
71 if (expected_answer_count >= 0) { | 70 if (expected_answer_count >= 0) { |
72 EXPECT_EQ(OK, rv); | 71 EXPECT_EQ(OK, rv); |
73 EXPECT_EQ(expected_answer_count, response->answer_count()); | 72 EXPECT_EQ(expected_answer_count, response->answer_count()); |
74 | 73 |
75 DnsRecordParser parser = response->Parser(); | 74 DnsRecordParser parser = response->Parser(); |
76 DnsResourceRecord record; | 75 DnsResourceRecord record; |
77 for (int i = 0; i < expected_answer_count; ++i) { | 76 for (int i = 0; i < expected_answer_count; ++i) { |
78 EXPECT_TRUE(parser.ParseRecord(&record)); | 77 EXPECT_TRUE(parser.ParseRecord(&record)); |
79 } | 78 } |
80 EXPECT_TRUE(parser.AtEnd()); | 79 EXPECT_TRUE(parser.AtEnd()); |
81 | 80 |
82 } else { | 81 } else { |
83 EXPECT_EQ(expected_answer_count, rv); | 82 EXPECT_EQ(expected_answer_count, rv); |
84 EXPECT_EQ(NULL, response); | 83 EXPECT_EQ(NULL, response); |
85 } | 84 } |
86 | 85 |
87 completed = true; | 86 completed = true; |
88 } | 87 } |
89 | 88 |
90 void CancelOnRequestComplete(DnsClient::Request* req, | 89 void CancelOnTransactionComplete(DnsTransaction* req, |
91 int rv, | 90 int rv, |
92 const DnsResponse* response) { | 91 const DnsResponse* response) { |
93 EXPECT_FALSE(completed); | 92 EXPECT_FALSE(completed); |
94 Cancel(); | 93 Cancel(); |
95 } | 94 } |
96 | 95 |
97 std::string qname; | 96 std::string qname; |
98 uint16 qtype; | 97 uint16 qtype; |
99 std::vector<MockWrite> writes; | 98 std::vector<MockWrite> writes; |
100 std::vector<MockRead> reads; | 99 std::vector<MockRead> reads; |
101 uint16 transaction_id; // Id from first write. | 100 uint16 transaction_id; // Id from first write. |
102 scoped_ptr<StaticSocketDataProvider> data; | 101 scoped_ptr<StaticSocketDataProvider> data; |
103 scoped_ptr<DnsClient::Request> request; | 102 scoped_ptr<DnsTransaction> transaction; |
104 int expected_answer_count; | 103 int expected_answer_count; |
105 | 104 |
106 bool completed; | 105 bool completed; |
107 }; | 106 }; |
108 | 107 |
109 virtual void SetUp() OVERRIDE { | 108 virtual void SetUp() OVERRIDE { |
110 helpers_.push_back(new TestRequestHelper( | 109 helpers_.push_back(new TestHelper( |
111 kT0DnsName, | 110 kT0HostName, |
112 kT0Qtype, | 111 kT0Qtype, |
113 MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram), | 112 MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram), |
114 arraysize(kT0QueryDatagram)), | 113 arraysize(kT0QueryDatagram)), |
115 MockRead(true, reinterpret_cast<const char*>(kT0ResponseDatagram), | 114 MockRead(true, reinterpret_cast<const char*>(kT0ResponseDatagram), |
116 arraysize(kT0ResponseDatagram)), | 115 arraysize(kT0ResponseDatagram)), |
117 arraysize(kT0IpAddresses) + 1)); // +1 for CNAME RR | 116 arraysize(kT0IpAddresses) + 1)); // +1 for CNAME RR |
118 | 117 |
119 helpers_.push_back(new TestRequestHelper( | 118 helpers_.push_back(new TestHelper( |
120 kT1DnsName, | 119 kT1HostName, |
121 kT1Qtype, | 120 kT1Qtype, |
122 MockWrite(true, reinterpret_cast<const char*>(kT1QueryDatagram), | 121 MockWrite(true, reinterpret_cast<const char*>(kT1QueryDatagram), |
123 arraysize(kT1QueryDatagram)), | 122 arraysize(kT1QueryDatagram)), |
124 MockRead(true, reinterpret_cast<const char*>(kT1ResponseDatagram), | 123 MockRead(true, reinterpret_cast<const char*>(kT1ResponseDatagram), |
125 arraysize(kT1ResponseDatagram)), | 124 arraysize(kT1ResponseDatagram)), |
126 arraysize(kT1IpAddresses) + 1)); // +1 for CNAME RR | 125 arraysize(kT1IpAddresses) + 1)); // +1 for CNAME RR |
127 | 126 |
128 helpers_.push_back(new TestRequestHelper( | 127 helpers_.push_back(new TestHelper( |
129 kT2DnsName, | 128 kT2HostName, |
130 kT2Qtype, | 129 kT2Qtype, |
131 MockWrite(true, reinterpret_cast<const char*>(kT2QueryDatagram), | 130 MockWrite(true, reinterpret_cast<const char*>(kT2QueryDatagram), |
132 arraysize(kT2QueryDatagram)), | 131 arraysize(kT2QueryDatagram)), |
133 MockRead(true, reinterpret_cast<const char*>(kT2ResponseDatagram), | 132 MockRead(true, reinterpret_cast<const char*>(kT2ResponseDatagram), |
134 arraysize(kT2ResponseDatagram)), | 133 arraysize(kT2ResponseDatagram)), |
135 arraysize(kT2IpAddresses) + 1)); // +1 for CNAME RR | 134 arraysize(kT2IpAddresses) + 1)); // +1 for CNAME RR |
136 | 135 |
137 helpers_.push_back(new TestRequestHelper( | 136 helpers_.push_back(new TestHelper( |
138 kT3DnsName, | 137 kT3HostName, |
139 kT3Qtype, | 138 kT3Qtype, |
140 MockWrite(true, reinterpret_cast<const char*>(kT3QueryDatagram), | 139 MockWrite(true, reinterpret_cast<const char*>(kT3QueryDatagram), |
141 arraysize(kT3QueryDatagram)), | 140 arraysize(kT3QueryDatagram)), |
142 MockRead(true, reinterpret_cast<const char*>(kT3ResponseDatagram), | 141 MockRead(true, reinterpret_cast<const char*>(kT3ResponseDatagram), |
143 arraysize(kT3ResponseDatagram)), | 142 arraysize(kT3ResponseDatagram)), |
144 arraysize(kT3IpAddresses) + 2)); // +2 for CNAME RR | 143 arraysize(kT3IpAddresses) + 2)); // +2 for CNAME RR |
145 | 144 |
146 CreateClient(); | 145 CreateClient(); |
147 } | 146 } |
148 | 147 |
(...skipping 14 matching lines...) Expand all Loading... |
163 EXPECT_TRUE(rv); | 162 EXPECT_TRUE(rv); |
164 } | 163 } |
165 config.nameservers.push_back(dns_server); | 164 config.nameservers.push_back(dns_server); |
166 | 165 |
167 DnsSession* session = new DnsSession( | 166 DnsSession* session = new DnsSession( |
168 config, | 167 config, |
169 factory, | 168 factory, |
170 base::Bind(&DnsClientTest::GetNextId, base::Unretained(this)), | 169 base::Bind(&DnsClientTest::GetNextId, base::Unretained(this)), |
171 NULL /* NetLog */); | 170 NULL /* NetLog */); |
172 | 171 |
173 client_.reset(DnsClient::CreateClient(session)); | 172 client_ = DnsClient::CreateClient(session); |
174 } | 173 } |
175 | 174 |
176 virtual void TearDown() OVERRIDE { | 175 virtual void TearDown() OVERRIDE { |
177 STLDeleteElements(&helpers_); | 176 STLDeleteElements(&helpers_); |
178 } | 177 } |
179 | 178 |
180 int GetNextId(int min, int max) { | 179 int GetNextId(int min, int max) { |
181 EXPECT_FALSE(transaction_ids_.empty()); | 180 EXPECT_FALSE(transaction_ids_.empty()); |
182 int id = transaction_ids_.front(); | 181 int id = transaction_ids_.front(); |
183 transaction_ids_.pop_front(); | 182 transaction_ids_.pop_front(); |
184 EXPECT_GE(id, min); | 183 EXPECT_GE(id, min); |
185 EXPECT_LE(id, max); | 184 EXPECT_LE(id, max); |
186 return id; | 185 return id; |
187 } | 186 } |
188 | 187 |
189 protected: | 188 protected: |
190 std::vector<TestRequestHelper*> helpers_; | 189 std::vector<TestHelper*> helpers_; |
191 std::deque<int> transaction_ids_; | 190 std::deque<int> transaction_ids_; |
192 scoped_ptr<DnsClient> client_; | 191 scoped_ptr<DnsClient> client_; |
193 }; | 192 }; |
194 | 193 |
195 TEST_F(DnsClientTest, Lookup) { | 194 TEST_F(DnsClientTest, Lookup) { |
196 helpers_[0]->MakeRequest(client_.get()); | 195 helpers_[0]->MakeRequest(client_.get()); |
197 | 196 |
198 // Wait until result. | 197 // Wait until result. |
199 MessageLoop::current()->RunAllPending(); | 198 MessageLoop::current()->RunAllPending(); |
200 | 199 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
239 | 238 |
240 MessageLoop::current()->RunAllPending(); | 239 MessageLoop::current()->RunAllPending(); |
241 | 240 |
242 for (unsigned i = 0; i < helpers_.size(); ++i) { | 241 for (unsigned i = 0; i < helpers_.size(); ++i) { |
243 EXPECT_TRUE(helpers_[i]->completed); | 242 EXPECT_TRUE(helpers_[i]->completed); |
244 } | 243 } |
245 } | 244 } |
246 | 245 |
247 TEST_F(DnsClientTest, DestroyRequestFromCallback) { | 246 TEST_F(DnsClientTest, DestroyRequestFromCallback) { |
248 // Custom callback to cancel the completing request. | 247 // Custom callback to cancel the completing request. |
249 helpers_[0]->request.reset(client_->CreateRequest( | 248 helpers_[0]->transaction = client_->CreateTransaction( |
250 helpers_[0]->qname, | 249 helpers_[0]->qname, |
251 helpers_[0]->qtype, | 250 helpers_[0]->qtype, |
252 base::Bind(&TestRequestHelper::CancelOnRequestComplete, | 251 base::Bind(&TestHelper::CancelOnTransactionComplete, |
253 base::Unretained(helpers_[0])), | 252 base::Unretained(helpers_[0])), |
254 BoundNetLog())); | 253 BoundNetLog()); |
255 helpers_[0]->request->Start(); | |
256 | 254 |
257 for (unsigned i = 1; i < helpers_.size(); ++i) { | 255 for (unsigned i = 1; i < helpers_.size(); ++i) { |
258 helpers_[i]->MakeRequest(client_.get()); | 256 helpers_[i]->MakeRequest(client_.get()); |
259 } | 257 } |
260 | 258 |
261 MessageLoop::current()->RunAllPending(); | 259 MessageLoop::current()->RunAllPending(); |
262 | 260 |
263 EXPECT_FALSE(helpers_[0]->completed); | 261 EXPECT_FALSE(helpers_[0]->completed); |
264 for (unsigned i = 1; i < helpers_.size(); ++i) { | 262 for (unsigned i = 1; i < helpers_.size(); ++i) { |
265 EXPECT_TRUE(helpers_[i]->completed); | 263 EXPECT_TRUE(helpers_[i]->completed); |
266 } | 264 } |
267 } | 265 } |
268 | 266 |
269 TEST_F(DnsClientTest, HandleFailure) { | 267 TEST_F(DnsClientTest, HandleFailure) { |
270 STLDeleteElements(&helpers_); | 268 STLDeleteElements(&helpers_); |
271 // Wrong question. | 269 // Wrong question. |
272 helpers_.push_back(new TestRequestHelper( | 270 helpers_.push_back(new TestHelper( |
273 kT0DnsName, | 271 kT0HostName, |
274 kT0Qtype, | 272 kT0Qtype, |
275 MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram), | 273 MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram), |
276 arraysize(kT0QueryDatagram)), | 274 arraysize(kT0QueryDatagram)), |
277 MockRead(true, reinterpret_cast<const char*>(kT1ResponseDatagram), | 275 MockRead(true, reinterpret_cast<const char*>(kT1ResponseDatagram), |
278 arraysize(kT1ResponseDatagram)), | 276 arraysize(kT1ResponseDatagram)), |
279 ERR_DNS_MALFORMED_RESPONSE)); | 277 ERR_DNS_MALFORMED_RESPONSE)); |
280 | 278 |
281 // Response with NXDOMAIN. | 279 // Response with NXDOMAIN. |
282 uint8 nxdomain_response[arraysize(kT0QueryDatagram)]; | 280 uint8 nxdomain_response[arraysize(kT0QueryDatagram)]; |
283 memcpy(nxdomain_response, kT0QueryDatagram, arraysize(nxdomain_response)); | 281 memcpy(nxdomain_response, kT0QueryDatagram, arraysize(nxdomain_response)); |
284 nxdomain_response[2] &= 0x80; // Response bit. | 282 nxdomain_response[2] &= 0x80; // Response bit. |
285 nxdomain_response[3] &= 0x03; // NXDOMAIN bit. | 283 nxdomain_response[3] &= 0x03; // NXDOMAIN bit. |
286 helpers_.push_back(new TestRequestHelper( | 284 helpers_.push_back(new TestHelper( |
287 kT0DnsName, | 285 kT0HostName, |
288 kT0Qtype, | 286 kT0Qtype, |
289 MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram), | 287 MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram), |
290 arraysize(kT0QueryDatagram)), | 288 arraysize(kT0QueryDatagram)), |
291 MockRead(true, reinterpret_cast<const char*>(nxdomain_response), | 289 MockRead(true, reinterpret_cast<const char*>(nxdomain_response), |
292 arraysize(nxdomain_response)), | 290 arraysize(nxdomain_response)), |
293 ERR_NAME_NOT_RESOLVED)); | 291 ERR_NAME_NOT_RESOLVED)); |
294 | 292 |
295 CreateClient(); | 293 CreateClient(); |
296 | 294 |
297 for (unsigned i = 0; i < helpers_.size(); ++i) { | 295 for (unsigned i = 0; i < helpers_.size(); ++i) { |
298 helpers_[i]->MakeRequest(client_.get()); | 296 helpers_[i]->MakeRequest(client_.get()); |
299 } | 297 } |
300 | 298 |
301 MessageLoop::current()->RunAllPending(); | 299 MessageLoop::current()->RunAllPending(); |
302 | 300 |
303 for (unsigned i = 0; i < helpers_.size(); ++i) { | 301 for (unsigned i = 0; i < helpers_.size(); ++i) { |
304 EXPECT_TRUE(helpers_[i]->completed); | 302 EXPECT_TRUE(helpers_[i]->completed); |
305 } | 303 } |
306 } | 304 } |
307 | 305 |
308 } // namespace | 306 } // namespace |
309 | 307 |
310 } // namespace net | 308 } // namespace net |
311 | 309 |
OLD | NEW |