?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Probably broke Win7 Tests (dbg)(6). http://build.chromium.org/p/chromium.win/builders...
[chromium-blink-merge.git] / net / dns / dns_response_unittest.cc
blob12b0377fea602e222834ed7561dac999a09ed7bf
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_response.h"
6
7 #include "base/time/time.h"
8 #include "net/base/address_list.h"
9 #include "net/base/io_buffer.h"
10 #include "net/base/net_util.h"
11 #include "net/dns/dns_protocol.h"
12 #include "net/dns/dns_query.h"
13 #include "net/dns/dns_test_util.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace net {
17
18 namespace {
19
20 TEST(DnsRecordParserTest, Constructor) {
21 const char data[] = { 0 };
22
23 EXPECT_FALSE(DnsRecordParser().IsValid());
24 EXPECT_TRUE(DnsRecordParser(data, 1, 0).IsValid());
25 EXPECT_TRUE(DnsRecordParser(data, 1, 1).IsValid());
26
27 EXPECT_FALSE(DnsRecordParser(data, 1, 0).AtEnd());
28 EXPECT_TRUE(DnsRecordParser(data, 1, 1).AtEnd());
29 }
30
31 TEST(DnsRecordParserTest, ReadName) {
32 const uint8 data[] = {
33 // all labels "foo.example.com"
34 0x03, 'f', 'o', 'o',
35 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
36 0x03, 'c', 'o', 'm',
37 // byte 0x10
38 0x00,
39 // byte 0x11
40 // part label, part pointer, "bar.example.com"
41 0x03, 'b', 'a', 'r',
42 0xc0, 0x04,
43 // byte 0x17
44 // all pointer to "bar.example.com", 2 jumps
45 0xc0, 0x11,
46 // byte 0x1a
47 };
48
49 std::string out;
50 DnsRecordParser parser(data, sizeof(data), 0);
51 ASSERT_TRUE(parser.IsValid());
52
53 EXPECT_EQ(0x11u, parser.ReadName(data + 0x00, &out));
54 EXPECT_EQ("foo.example.com", out);
55 // Check that the last "." is never stored.
56 out.clear();
57 EXPECT_EQ(0x1u, parser.ReadName(data + 0x10, &out));
58 EXPECT_EQ("", out);
59 out.clear();
60 EXPECT_EQ(0x6u, parser.ReadName(data + 0x11, &out));
61 EXPECT_EQ("bar.example.com", out);
62 out.clear();
63 EXPECT_EQ(0x2u, parser.ReadName(data + 0x17, &out));
64 EXPECT_EQ("bar.example.com", out);
65
66 // Parse name without storing it.
67 EXPECT_EQ(0x11u, parser.ReadName(data + 0x00, NULL));
68 EXPECT_EQ(0x1u, parser.ReadName(data + 0x10, NULL));
69 EXPECT_EQ(0x6u, parser.ReadName(data + 0x11, NULL));
70 EXPECT_EQ(0x2u, parser.ReadName(data + 0x17, NULL));
71
72 // Check that it works even if initial position is different.
73 parser = DnsRecordParser(data, sizeof(data), 0x12);
74 EXPECT_EQ(0x6u, parser.ReadName(data + 0x11, NULL));
75 }
76
77 TEST(DnsRecordParserTest, ReadNameFail) {
78 const uint8 data[] = {
79 // label length beyond packet
80 0x30, 'x', 'x',
81 0x00,
82 // pointer offset beyond packet
83 0xc0, 0x20,
84 // pointer loop
85 0xc0, 0x08,
86 0xc0, 0x06,
87 // incorrect label type (currently supports only direct and pointer)
88 0x80, 0x00,
89 // truncated name (missing root label)
90 0x02, 'x', 'x',
91 };
92
93 DnsRecordParser parser(data, sizeof(data), 0);
94 ASSERT_TRUE(parser.IsValid());
95
96 std::string out;
97 EXPECT_EQ(0u, parser.ReadName(data + 0x00, &out));
98 EXPECT_EQ(0u, parser.ReadName(data + 0x04, &out));
99 EXPECT_EQ(0u, parser.ReadName(data + 0x08, &out));
100 EXPECT_EQ(0u, parser.ReadName(data + 0x0a, &out));
101 EXPECT_EQ(0u, parser.ReadName(data + 0x0c, &out));
102 EXPECT_EQ(0u, parser.ReadName(data + 0x0e, &out));
103 }
104
105 TEST(DnsRecordParserTest, ReadRecord) {
106 const uint8 data[] = {
107 // Type CNAME record.
108 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
109 0x03, 'c', 'o', 'm',
110 0x00,
111 0x00, 0x05, // TYPE is CNAME.
112 0x00, 0x01, // CLASS is IN.
113 0x00, 0x01, 0x24, 0x74, // TTL is 0x00012474.
114 0x00, 0x06, // RDLENGTH is 6 bytes.
115 0x03, 'f', 'o', 'o', // compressed name in record
116 0xc0, 0x00,
117 // Type A record.
118 0x03, 'b', 'a', 'r', // compressed owner name
119 0xc0, 0x00,
120 0x00, 0x01, // TYPE is A.
121 0x00, 0x01, // CLASS is IN.
122 0x00, 0x20, 0x13, 0x55, // TTL is 0x00201355.
123 0x00, 0x04, // RDLENGTH is 4 bytes.
124 0x7f, 0x02, 0x04, 0x01, // IP is 127.2.4.1
125 };
126
127 std::string out;
128 DnsRecordParser parser(data, sizeof(data), 0);
129
130 DnsResourceRecord record;
131 EXPECT_TRUE(parser.ReadRecord(&record));
132 EXPECT_EQ("example.com", record.name);
133 EXPECT_EQ(dns_protocol::kTypeCNAME, record.type);
134 EXPECT_EQ(dns_protocol::kClassIN, record.klass);
135 EXPECT_EQ(0x00012474u, record.ttl);
136 EXPECT_EQ(6u, record.rdata.length());
137 EXPECT_EQ(6u, parser.ReadName(record.rdata.data(), &out));
138 EXPECT_EQ("foo.example.com", out);
139 EXPECT_FALSE(parser.AtEnd());
140
141 EXPECT_TRUE(parser.ReadRecord(&record));
142 EXPECT_EQ("bar.example.com", record.name);
143 EXPECT_EQ(dns_protocol::kTypeA, record.type);
144 EXPECT_EQ(dns_protocol::kClassIN, record.klass);
145 EXPECT_EQ(0x00201355u, record.ttl);
146 EXPECT_EQ(4u, record.rdata.length());
147 EXPECT_EQ(base::StringPiece("\x7f\x02\x04\x01"), record.rdata);
148 EXPECT_TRUE(parser.AtEnd());
149
150 // Test truncated record.
151 parser = DnsRecordParser(data, sizeof(data) - 2, 0);
152 EXPECT_TRUE(parser.ReadRecord(&record));
153 EXPECT_FALSE(parser.AtEnd());
154 EXPECT_FALSE(parser.ReadRecord(&record));
155 }
156
157 TEST(DnsResponseTest, InitParse) {
158 // This includes \0 at the end.
159 const char qname_data[] = "\x0A""codereview""\x08""chromium""\x03""org";
160 const base::StringPiece qname(qname_data, sizeof(qname_data));
161 // Compilers want to copy when binding temporary to const &, so must use heap.
162 scoped_ptr<DnsQuery> query(new DnsQuery(0xcafe, qname, dns_protocol::kTypeA));
163
164 const uint8 response_data[] = {
165 // Header
166 0xca, 0xfe, // ID
167 0x81, 0x80, // Standard query response, RA, no error
168 0x00, 0x01, // 1 question
169 0x00, 0x02, // 2 RRs (answers)
170 0x00, 0x00, // 0 authority RRs
171 0x00, 0x00, // 0 additional RRs
172
173 // Question
174 // This part is echoed back from the respective query.
175 0x0a, 'c', 'o', 'd', 'e', 'r', 'e', 'v', 'i', 'e', 'w',
176 0x08, 'c', 'h', 'r', 'o', 'm', 'i', 'u', 'm',
177 0x03, 'o', 'r', 'g',
178 0x00,
179 0x00, 0x01, // TYPE is A.
180 0x00, 0x01, // CLASS is IN.
181
182 // Answer 1
183 0xc0, 0x0c, // NAME is a pointer to name in Question section.
184 0x00, 0x05, // TYPE is CNAME.
185 0x00, 0x01, // CLASS is IN.
186 0x00, 0x01, // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
187 0x24, 0x74,
188 0x00, 0x12, // RDLENGTH is 18 bytes.
189 // ghs.l.google.com in DNS format.
190 0x03, 'g', 'h', 's',
191 0x01, 'l',
192 0x06, 'g', 'o', 'o', 'g', 'l', 'e',
193 0x03, 'c', 'o', 'm',
194 0x00,
195
196 // Answer 2
197 0xc0, 0x35, // NAME is a pointer to name in Answer 1.
198 0x00, 0x01, // TYPE is A.
199 0x00, 0x01, // CLASS is IN.
200 0x00, 0x00, // TTL (4 bytes) is 53 seconds.
201 0x00, 0x35,
202 0x00, 0x04, // RDLENGTH is 4 bytes.
203 0x4a, 0x7d, // RDATA is the IP: 74.125.95.121
204 0x5f, 0x79,
205 };
206
207 DnsResponse resp;
208 memcpy(resp.io_buffer()->data(), response_data, sizeof(response_data));
209
210 // Reject too short.
211 EXPECT_FALSE(resp.InitParse(query->io_buffer()->size() - 1, *query));
212 EXPECT_FALSE(resp.IsValid());
213
214 // Reject wrong id.
215 scoped_ptr<DnsQuery> other_query(query->CloneWithNewId(0xbeef));
216 EXPECT_FALSE(resp.InitParse(sizeof(response_data), *other_query));
217 EXPECT_FALSE(resp.IsValid());
218
219 // Reject wrong question.
220 scoped_ptr<DnsQuery> wrong_query(
221 new DnsQuery(0xcafe, qname, dns_protocol::kTypeCNAME));
222 EXPECT_FALSE(resp.InitParse(sizeof(response_data), *wrong_query));
223 EXPECT_FALSE(resp.IsValid());
224
225 // Accept matching question.
226 EXPECT_TRUE(resp.InitParse(sizeof(response_data), *query));
227 EXPECT_TRUE(resp.IsValid());
228
229 // Check header access.
230 EXPECT_EQ(0x8180, resp.flags());
231 EXPECT_EQ(0x0, resp.rcode());
232 EXPECT_EQ(2u, resp.answer_count());
233
234 // Check question access.
235 EXPECT_EQ(query->qname(), resp.qname());
236 EXPECT_EQ(query->qtype(), resp.qtype());
237 EXPECT_EQ("codereview.chromium.org", resp.GetDottedName());
238
239 DnsResourceRecord record;
240 DnsRecordParser parser = resp.Parser();
241 EXPECT_TRUE(parser.ReadRecord(&record));
242 EXPECT_FALSE(parser.AtEnd());
243 EXPECT_TRUE(parser.ReadRecord(&record));
244 EXPECT_TRUE(parser.AtEnd());
245 EXPECT_FALSE(parser.ReadRecord(&record));
246 }
247
248 TEST(DnsResponseTest, InitParseWithoutQuery) {
249 DnsResponse resp;
250 memcpy(resp.io_buffer()->data(), kT0ResponseDatagram,
251 sizeof(kT0ResponseDatagram));
252
253 // Accept matching question.
254 EXPECT_TRUE(resp.InitParseWithoutQuery(sizeof(kT0ResponseDatagram)));
255 EXPECT_TRUE(resp.IsValid());
256
257 // Check header access.
258 EXPECT_EQ(0x8180, resp.flags());
259 EXPECT_EQ(0x0, resp.rcode());
260 EXPECT_EQ(kT0RecordCount, resp.answer_count());
261
262 // Check question access.
263 EXPECT_EQ(kT0Qtype, resp.qtype());
264 EXPECT_EQ(kT0HostName, resp.GetDottedName());
265
266 DnsResourceRecord record;
267 DnsRecordParser parser = resp.Parser();
268 for (unsigned i = 0; i < kT0RecordCount; i ++) {
269 EXPECT_FALSE(parser.AtEnd());
270 EXPECT_TRUE(parser.ReadRecord(&record));
271 }
272 EXPECT_TRUE(parser.AtEnd());
273 EXPECT_FALSE(parser.ReadRecord(&record));
274 }
275
276 TEST(DnsResponseTest, InitParseWithoutQueryNoQuestions) {
277 const uint8 response_data[] = {
278 // Header
279 0xca, 0xfe, // ID
280 0x81, 0x80, // Standard query response, RA, no error
281 0x00, 0x00, // No question
282 0x00, 0x01, // 2 RRs (answers)
283 0x00, 0x00, // 0 authority RRs
284 0x00, 0x00, // 0 additional RRs
285
286 // Answer 1
287 0x0a, 'c', 'o', 'd', 'e', 'r', 'e', 'v', 'i', 'e', 'w',
288 0x08, 'c', 'h', 'r', 'o', 'm', 'i', 'u', 'm',
289 0x03, 'o', 'r', 'g',
290 0x00,
291 0x00, 0x01, // TYPE is A.
292 0x00, 0x01, // CLASS is IN.
293 0x00, 0x00, // TTL (4 bytes) is 53 seconds.
294 0x00, 0x35,
295 0x00, 0x04, // RDLENGTH is 4 bytes.
296 0x4a, 0x7d, // RDATA is the IP: 74.125.95.121
297 0x5f, 0x79,
298 };
299
300 DnsResponse resp;
301 memcpy(resp.io_buffer()->data(), response_data, sizeof(response_data));
302
303 EXPECT_TRUE(resp.InitParseWithoutQuery(sizeof(response_data)));
304
305 // Check header access.
306 EXPECT_EQ(0x8180, resp.flags());
307 EXPECT_EQ(0x0, resp.rcode());
308 EXPECT_EQ(0x1u, resp.answer_count());
309
310 DnsResourceRecord record;
311 DnsRecordParser parser = resp.Parser();
312
313 EXPECT_FALSE(parser.AtEnd());
314 EXPECT_TRUE(parser.ReadRecord(&record));
315 EXPECT_EQ("codereview.chromium.org", record.name);
316 EXPECT_EQ(0x00000035u, record.ttl);
317 EXPECT_EQ(dns_protocol::kTypeA, record.type);
318
319 EXPECT_TRUE(parser.AtEnd());
320 EXPECT_FALSE(parser.ReadRecord(&record));
321 }
322
323 TEST(DnsResponseTest, InitParseWithoutQueryTwoQuestions) {
324 const uint8 response_data[] = {
325 // Header
326 0xca, 0xfe, // ID
327 0x81, 0x80, // Standard query response, RA, no error
328 0x00, 0x02, // 2 questions
329 0x00, 0x01, // 2 RRs (answers)
330 0x00, 0x00, // 0 authority RRs
331 0x00, 0x00, // 0 additional RRs
332
333 // Question 1
334 0x0a, 'c', 'o', 'd', 'e', 'r', 'e', 'v', 'i', 'e', 'w',
335 0x08, 'c', 'h', 'r', 'o', 'm', 'i', 'u', 'm',
336 0x03, 'o', 'r', 'g',
337 0x00,
338 0x00, 0x01, // TYPE is A.
339 0x00, 0x01, // CLASS is IN.
340
341 // Question 2
342 0x0b, 'c', 'o', 'd', 'e', 'r', 'e', 'v', 'i', 'e', 'w', '2',
343 0xc0, 0x18, // pointer to "chromium.org"
344 0x00, 0x01, // TYPE is A.
345 0x00, 0x01, // CLASS is IN.
346
347 // Answer 1
348 0xc0, 0x0c, // NAME is a pointer to name in Question section.
349 0x00, 0x01, // TYPE is A.
350 0x00, 0x01, // CLASS is IN.
351 0x00, 0x00, // TTL (4 bytes) is 53 seconds.
352 0x00, 0x35,
353 0x00, 0x04, // RDLENGTH is 4 bytes.
354 0x4a, 0x7d, // RDATA is the IP: 74.125.95.121
355 0x5f, 0x79,
356 };
357
358 DnsResponse resp;
359 memcpy(resp.io_buffer()->data(), response_data, sizeof(response_data));
360
361 EXPECT_TRUE(resp.InitParseWithoutQuery(sizeof(response_data)));
362
363 // Check header access.
364 EXPECT_EQ(0x8180, resp.flags());
365 EXPECT_EQ(0x0, resp.rcode());
366 EXPECT_EQ(0x01u, resp.answer_count());
367
368 DnsResourceRecord record;
369 DnsRecordParser parser = resp.Parser();
370
371 EXPECT_FALSE(parser.AtEnd());
372 EXPECT_TRUE(parser.ReadRecord(&record));
373 EXPECT_EQ("codereview.chromium.org", record.name);
374 EXPECT_EQ(0x35u, record.ttl);
375 EXPECT_EQ(dns_protocol::kTypeA, record.type);
376
377 EXPECT_TRUE(parser.AtEnd());
378 EXPECT_FALSE(parser.ReadRecord(&record));
379 }
380
381 TEST(DnsResponseTest, InitParseWithoutQueryPacketTooShort) {
382 const uint8 response_data[] = {
383 // Header
384 0xca, 0xfe, // ID
385 0x81, 0x80, // Standard query response, RA, no error
386 0x00, 0x00, // No question
387 };
388
389 DnsResponse resp;
390 memcpy(resp.io_buffer()->data(), response_data, sizeof(response_data));
391
392 EXPECT_FALSE(resp.InitParseWithoutQuery(sizeof(response_data)));
393 }
394
395 void VerifyAddressList(const std::vector<const char*>& ip_addresses,
396 const AddressList& addrlist) {
397 ASSERT_EQ(ip_addresses.size(), addrlist.size());
398
399 for (size_t i = 0; i < addrlist.size(); ++i) {
400 EXPECT_EQ(ip_addresses[i], addrlist[i].ToStringWithoutPort());
401 }
402 }
403
404 TEST(DnsResponseTest, ParseToAddressList) {
405 const struct TestCase {
406 size_t query_size;
407 const uint8* response_data;
408 size_t response_size;
409 const char* const* expected_addresses;
410 size_t num_expected_addresses;
411 const char* expected_cname;
412 int expected_ttl_sec;
413 } cases[] = {
414 {
415 kT0QuerySize,
416 kT0ResponseDatagram, arraysize(kT0ResponseDatagram),
417 kT0IpAddresses, arraysize(kT0IpAddresses),
418 kT0CanonName,
419 kT0TTL,
420 },
421 {
422 kT1QuerySize,
423 kT1ResponseDatagram, arraysize(kT1ResponseDatagram),
424 kT1IpAddresses, arraysize(kT1IpAddresses),
425 kT1CanonName,
426 kT1TTL,
427 },
428 {
429 kT2QuerySize,
430 kT2ResponseDatagram, arraysize(kT2ResponseDatagram),
431 kT2IpAddresses, arraysize(kT2IpAddresses),
432 kT2CanonName,
433 kT2TTL,
434 },
435 {
436 kT3QuerySize,
437 kT3ResponseDatagram, arraysize(kT3ResponseDatagram),
438 kT3IpAddresses, arraysize(kT3IpAddresses),
439 kT3CanonName,
440 kT3TTL,
441 },
442 };
443
444 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
445 const TestCase& t = cases[i];
446 DnsResponse response(t.response_data, t.response_size, t.query_size);
447 AddressList addr_list;
448 base::TimeDelta ttl;
449 EXPECT_EQ(DnsResponse::DNS_PARSE_OK,
450 response.ParseToAddressList(&addr_list, &ttl));
451 std::vector<const char*> expected_addresses(
452 t.expected_addresses,
453 t.expected_addresses + t.num_expected_addresses);
454 VerifyAddressList(expected_addresses, addr_list);
455 EXPECT_EQ(t.expected_cname, addr_list.canonical_name());
456 EXPECT_EQ(base::TimeDelta::FromSeconds(t.expected_ttl_sec), ttl);
457 }
458 }
459
460 const uint8 kResponseTruncatedRecord[] = {
461 // Header: 1 question, 1 answer RR
462 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
463 // Question: name = 'a', type = A (0x1)
464 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01,
465 // Answer: name = 'a', type = A, TTL = 0xFF, RDATA = 10.10.10.10
466 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
467 0x00, 0x04, 0x0A, 0x0A, 0x0A, // Truncated RDATA.
468 };
469
470 const uint8 kResponseTruncatedCNAME[] = {
471 // Header: 1 question, 1 answer RR
472 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
473 // Question: name = 'a', type = A (0x1)
474 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01,
475 // Answer: name = 'a', type = CNAME, TTL = 0xFF, RDATA = 'foo' (truncated)
476 0x01, 'a', 0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
477 0x00, 0x03, 0x03, 'f', 'o', // Truncated name.
478 };
479
480 const uint8 kResponseNameMismatch[] = {
481 // Header: 1 question, 1 answer RR
482 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
483 // Question: name = 'a', type = A (0x1)
484 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01,
485 // Answer: name = 'b', type = A, TTL = 0xFF, RDATA = 10.10.10.10
486 0x01, 'b', 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
487 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x0A,
488 };
489
490 const uint8 kResponseNameMismatchInChain[] = {
491 // Header: 1 question, 3 answer RR
492 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
493 // Question: name = 'a', type = A (0x1)
494 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01,
495 // Answer: name = 'a', type = CNAME, TTL = 0xFF, RDATA = 'b'
496 0x01, 'a', 0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
497 0x00, 0x03, 0x01, 'b', 0x00,
498 // Answer: name = 'b', type = A, TTL = 0xFF, RDATA = 10.10.10.10
499 0x01, 'b', 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
500 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x0A,
501 // Answer: name = 'c', type = A, TTL = 0xFF, RDATA = 10.10.10.11
502 0x01, 'c', 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
503 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x0B,
504 };
505
506 const uint8 kResponseSizeMismatch[] = {
507 // Header: 1 answer RR
508 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
509 // Question: name = 'a', type = AAAA (0x1c)
510 0x01, 'a', 0x00, 0x00, 0x1c, 0x00, 0x01,
511 // Answer: name = 'a', type = AAAA, TTL = 0xFF, RDATA = 10.10.10.10
512 0x01, 'a', 0x00, 0x00, 0x1c, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
513 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x0A,
514 };
515
516 const uint8 kResponseCNAMEAfterAddress[] = {
517 // Header: 2 answer RR
518 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
519 // Question: name = 'a', type = A (0x1)
520 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01,
521 // Answer: name = 'a', type = A, TTL = 0xFF, RDATA = 10.10.10.10.
522 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
523 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x0A,
524 // Answer: name = 'a', type = CNAME, TTL = 0xFF, RDATA = 'b'
525 0x01, 'a', 0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
526 0x00, 0x03, 0x01, 'b', 0x00,
527 };
528
529 const uint8 kResponseNoAddresses[] = {
530 // Header: 1 question, 1 answer RR, 1 authority RR
531 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
532 // Question: name = 'a', type = A (0x1)
533 0x01, 'a', 0x00, 0x00, 0x01, 0x00, 0x01,
534 // Answer: name = 'a', type = CNAME, TTL = 0xFF, RDATA = 'b'
535 0x01, 'a', 0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
536 0x00, 0x03, 0x01, 'b', 0x00,
537 // Authority section
538 // Answer: name = 'b', type = A, TTL = 0xFF, RDATA = 10.10.10.10
539 0x01, 'b', 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF,
540 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x0A,
541 };
542
543 TEST(DnsResponseTest, ParseToAddressListFail) {
544 const struct TestCase {
545 const uint8* data;
546 size_t size;
547 DnsResponse::Result expected_result;
548 } cases[] = {
549 { kResponseTruncatedRecord, arraysize(kResponseTruncatedRecord),
550 DnsResponse::DNS_MALFORMED_RESPONSE },
551 { kResponseTruncatedCNAME, arraysize(kResponseTruncatedCNAME),
552 DnsResponse::DNS_MALFORMED_CNAME },
553 { kResponseNameMismatch, arraysize(kResponseNameMismatch),
554 DnsResponse::DNS_NAME_MISMATCH },
555 { kResponseNameMismatchInChain, arraysize(kResponseNameMismatchInChain),
556 DnsResponse::DNS_NAME_MISMATCH },
557 { kResponseSizeMismatch, arraysize(kResponseSizeMismatch),
558 DnsResponse::DNS_SIZE_MISMATCH },
559 { kResponseCNAMEAfterAddress, arraysize(kResponseCNAMEAfterAddress),
560 DnsResponse::DNS_CNAME_AFTER_ADDRESS },
561 // Not actually a failure, just an empty result.
562 { kResponseNoAddresses, arraysize(kResponseNoAddresses),
563 DnsResponse::DNS_PARSE_OK },
564 };
565
566 const size_t kQuerySize = 12 + 7;
567
568 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
569 const TestCase& t = cases[i];
570
571 DnsResponse response(t.data, t.size, kQuerySize);
572 AddressList addr_list;
573 base::TimeDelta ttl;
574 EXPECT_EQ(t.expected_result,
575 response.ParseToAddressList(&addr_list, &ttl));
576 }
577 }
578
579 } // namespace
580
581 } // namespace net