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_hosts.h" 6 7 #include "testing/gtest/include/gtest/gtest.h" 8 9 namespace net { 10 11 namespace { 12 13 struct ExpectedHostsEntry { 14 const char* host; 15 AddressFamily family; 16 const char* ip; 17 }; 18 19 void PopulateExpectedHosts(const ExpectedHostsEntry* entries, 20 size_t num_entries, 21 DnsHosts* expected_hosts_out) { 22 for (size_t i = 0; i < num_entries; ++i) { 23 DnsHostsKey key(entries[i].host, entries[i].family); 24 IPAddressNumber& ip_ref = (*expected_hosts_out)[key]; 25 ASSERT_TRUE(ip_ref.empty()); 26 ASSERT_TRUE(ParseIPLiteralToNumber(entries[i].ip, &ip_ref)); 27 ASSERT_EQ(ip_ref.size(), 28 (entries[i].family == ADDRESS_FAMILY_IPV4) ? 4u : 16u); 29 } 30 } 31 32 TEST(DnsHostsTest, ParseHosts) { 33 const std::string kContents = 34 "127.0.0.1 localhost\tlocalhost.localdomain # standard\n" 35 "\n" 36 "1.0.0.1 localhost # ignored, first hit above\n" 37 "fe00::x example company # ignored, malformed IPv6\n" 38 "1.0.0.300 company # ignored, malformed IPv4\n" 39 "1.0.0.1 # ignored, missing hostname\n" 40 "1.0.0.1\t CoMpANy # normalized to 'company' \n" 41 "::1\tlocalhost ip6-localhost ip6-loopback # comment # within a comment\n" 42 "\t fe00::0 ip6-localnet\r\n" 43 "2048::2 example\n" 44 "2048::1 company example # ignored for 'example' \n" 45 "127.0.0.1 cache1\n" 46 "127.0.0.1 cache2 # should reuse parsed IP\n" 47 "256.0.0.0 cache3 # bogus IP should not clear parsed IP cache\n" 48 "127.0.0.1 cache4 # should still be reused\n" 49 "127.0.0.2 cache5\n" 50 "gibberish"; 51 52 const ExpectedHostsEntry kEntries[] = { 53 { "localhost", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 54 { "localhost.localdomain", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 55 { "company", ADDRESS_FAMILY_IPV4, "1.0.0.1" }, 56 { "localhost", ADDRESS_FAMILY_IPV6, "::1" }, 57 { "ip6-localhost", ADDRESS_FAMILY_IPV6, "::1" }, 58 { "ip6-loopback", ADDRESS_FAMILY_IPV6, "::1" }, 59 { "ip6-localnet", ADDRESS_FAMILY_IPV6, "fe00::0" }, 60 { "company", ADDRESS_FAMILY_IPV6, "2048::1" }, 61 { "example", ADDRESS_FAMILY_IPV6, "2048::2" }, 62 { "cache1", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 63 { "cache2", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 64 { "cache4", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 65 { "cache5", ADDRESS_FAMILY_IPV4, "127.0.0.2" }, 66 }; 67 68 DnsHosts expected_hosts, actual_hosts; 69 PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts); 70 ParseHosts(kContents, &actual_hosts); 71 ASSERT_EQ(expected_hosts, actual_hosts); 72 } 73 74 TEST(DnsHostsTest, ParseHosts_CommaIsToken) { 75 const std::string kContents = "127.0.0.1 comma1,comma2"; 76 77 const ExpectedHostsEntry kEntries[] = { 78 { "comma1,comma2", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 79 }; 80 81 DnsHosts expected_hosts, actual_hosts; 82 PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts); 83 ParseHostsWithCommaModeForTesting( 84 kContents, &actual_hosts, PARSE_HOSTS_COMMA_IS_TOKEN); 85 ASSERT_EQ(expected_hosts, actual_hosts); 86 } 87 88 TEST(DnsHostsTest, ParseHosts_CommaIsWhitespace) { 89 std::string kContents = "127.0.0.1 comma1,comma2"; 90 91 const ExpectedHostsEntry kEntries[] = { 92 { "comma1", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 93 { "comma2", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 94 }; 95 96 DnsHosts expected_hosts, actual_hosts; 97 PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts); 98 ParseHostsWithCommaModeForTesting( 99 kContents, &actual_hosts, PARSE_HOSTS_COMMA_IS_WHITESPACE); 100 ASSERT_EQ(expected_hosts, actual_hosts); 101 } 102 103 // Test that the right comma mode is used on each platform. 104 TEST(DnsHostsTest, ParseHosts_CommaModeByPlatform) { 105 std::string kContents = "127.0.0.1 comma1,comma2"; 106 107 #if defined(OS_MACOSX) 108 const ExpectedHostsEntry kEntries[] = { 109 { "comma1", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 110 { "comma2", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 111 }; 112 #else 113 const ExpectedHostsEntry kEntries[] = { 114 { "comma1,comma2", ADDRESS_FAMILY_IPV4, "127.0.0.1" }, 115 }; 116 #endif 117 118 DnsHosts expected_hosts, actual_hosts; 119 PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts); 120 ParseHosts(kContents, &actual_hosts); 121 ASSERT_EQ(expected_hosts, actual_hosts); 122 } 123 124 TEST(DnsHostsTest, HostsParser_Empty) { 125 DnsHosts hosts; 126 ParseHosts("", &hosts); 127 EXPECT_EQ(0u, hosts.size()); 128 } 129 130 TEST(DnsHostsTest, HostsParser_OnlyWhitespace) { 131 DnsHosts hosts; 132 ParseHosts(" ", &hosts); 133 EXPECT_EQ(0u, hosts.size()); 134 } 135 136 TEST(DnsHostsTest, HostsParser_EndsWithNothing) { 137 DnsHosts hosts; 138 ParseHosts("127.0.0.1 localhost", &hosts); 139 EXPECT_EQ(1u, hosts.size()); 140 } 141 142 TEST(DnsHostsTest, HostsParser_EndsWithWhitespace) { 143 DnsHosts hosts; 144 ParseHosts("127.0.0.1 localhost ", &hosts); 145 EXPECT_EQ(1u, hosts.size()); 146 } 147 148 TEST(DnsHostsTest, HostsParser_EndsWithComment) { 149 DnsHosts hosts; 150 ParseHosts("127.0.0.1 localhost # comment", &hosts); 151 EXPECT_EQ(1u, hosts.size()); 152 } 153 154 TEST(DnsHostsTest, HostsParser_EndsWithNewline) { 155 DnsHosts hosts; 156 ParseHosts("127.0.0.1 localhost\n", &hosts); 157 EXPECT_EQ(1u, hosts.size()); 158 } 159 160 TEST(DnsHostsTest, HostsParser_EndsWithTwoNewlines) { 161 DnsHosts hosts; 162 ParseHosts("127.0.0.1 localhost\n\n", &hosts); 163 EXPECT_EQ(1u, hosts.size()); 164 } 165 166 TEST(DnsHostsTest, HostsParser_EndsWithNewlineAndWhitespace) { 167 DnsHosts hosts; 168 ParseHosts("127.0.0.1 localhost\n ", &hosts); 169 EXPECT_EQ(1u, hosts.size()); 170 } 171 172 TEST(DnsHostsTest, HostsParser_EndsWithNewlineAndToken) { 173 DnsHosts hosts; 174 ParseHosts("127.0.0.1 localhost\ntoken", &hosts); 175 EXPECT_EQ(1u, hosts.size()); 176 } 177 178 } // namespace 179 180 } // namespace net 181 182