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 <memory>
6
7 #include "base/cancelable_callback.h"
8 #include "base/files/file_util.h"
9 #include "base/run_loop.h"
10 #include "base/sequenced_task_runner.h"
11 #include "base/stl_util.h"
12 #include "base/sys_byteorder.h"
13 #include "base/task/post_task.h"
14 #include "base/task/task_traits.h"
15 #include "base/test/task_environment.h"
16 #include "base/test/test_timeouts.h"
17 #include "base/threading/platform_thread.h"
18 #include "net/base/ip_address.h"
19 #include "net/dns/dns_config.h"
20 #include "net/dns/dns_config_service_posix.h"
21 #include "net/dns/public/dns_protocol.h"
22
23 #include "base/bind.h"
24 #include "base/task/thread_pool.h"
25 #include "testing/gtest/include/gtest/gtest.h"
26
27 #if defined(OS_ANDROID)
28 #include "base/android/path_utils.h"
29 #endif // defined(OS_ANDROID)
30
31 // Required for inet_pton()
32 #if defined(OS_WIN)
33 #include <winsock2.h>
34 #else
35 #include <arpa/inet.h>
36 #endif
37
38 namespace net {
39
40 #if !defined(OS_ANDROID)
41
42 namespace {
43
44 // MAXNS is normally 3, but let's test 4 if possible.
45 const char* const kNameserversIPv4[] = {
46 "8.8.8.8",
47 "192.168.1.1",
48 "63.1.2.4",
49 "1.0.0.1",
50 };
51
52 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
53 const char* const kNameserversIPv6[] = {
54 NULL,
55 "2001:DB8:0::42",
56 NULL,
57 "::FFFF:129.144.52.38",
58 };
59 #endif
60
DummyConfigCallback(const DnsConfig & config)61 void DummyConfigCallback(const DnsConfig& config) {
62 // Do nothing
63 }
64
65 // Fills in |res| with sane configuration.
InitializeResState(res_state res)66 void InitializeResState(res_state res) {
67 memset(res, 0, sizeof(*res));
68 res->options = RES_INIT | RES_RECURSE | RES_DEFNAMES | RES_DNSRCH |
69 RES_ROTATE;
70 res->ndots = 2;
71 res->retrans = 4;
72 res->retry = 7;
73
74 const char kDnsrch[] = "chromium.org" "\0" "example.com";
75 memcpy(res->defdname, kDnsrch, sizeof(kDnsrch));
76 res->dnsrch[0] = res->defdname;
77 res->dnsrch[1] = res->defdname + sizeof("chromium.org");
78
79 for (unsigned i = 0; i < base::size(kNameserversIPv4) && i < MAXNS; ++i) {
80 struct sockaddr_in sa;
81 sa.sin_family = AF_INET;
82 sa.sin_port = base::HostToNet16(NS_DEFAULTPORT + i);
83 inet_pton(AF_INET, kNameserversIPv4[i], &sa.sin_addr);
84 res->nsaddr_list[i] = sa;
85 ++res->nscount;
86 }
87
88 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
89 // Install IPv6 addresses, replacing the corresponding IPv4 addresses.
90 unsigned nscount6 = 0;
91 for (unsigned i = 0; i < base::size(kNameserversIPv6) && i < MAXNS; ++i) {
92 if (!kNameserversIPv6[i])
93 continue;
94 // Must use malloc to mimick res_ninit.
95 struct sockaddr_in6 *sa6;
96 sa6 = (struct sockaddr_in6 *)malloc(sizeof(*sa6));
97 sa6->sin6_family = AF_INET6;
98 sa6->sin6_port = base::HostToNet16(NS_DEFAULTPORT - i);
99 inet_pton(AF_INET6, kNameserversIPv6[i], &sa6->sin6_addr);
100 res->_u._ext.nsaddrs[i] = sa6;
101 memset(&res->nsaddr_list[i], 0, sizeof res->nsaddr_list[i]);
102 ++nscount6;
103 }
104 res->_u._ext.nscount6 = nscount6;
105 #endif
106 }
107
CloseResState(res_state res)108 void CloseResState(res_state res) {
109 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
110 for (int i = 0; i < res->nscount; ++i) {
111 if (res->_u._ext.nsaddrs[i] != NULL)
112 free(res->_u._ext.nsaddrs[i]);
113 }
114 #endif
115 }
116
InitializeExpectedConfig(DnsConfig * config)117 void InitializeExpectedConfig(DnsConfig* config) {
118 config->ndots = 2;
119 config->fallback_period = base::TimeDelta::FromSeconds(4);
120 config->attempts = 7;
121 config->rotate = true;
122 config->append_to_multi_label_name = true;
123 config->search.clear();
124 config->search.push_back("chromium.org");
125 config->search.push_back("example.com");
126
127 config->nameservers.clear();
128 for (unsigned i = 0; i < base::size(kNameserversIPv4) && i < MAXNS; ++i) {
129 IPAddress ip;
130 EXPECT_TRUE(ip.AssignFromIPLiteral(kNameserversIPv4[i]));
131 config->nameservers.push_back(IPEndPoint(ip, NS_DEFAULTPORT + i));
132 }
133
134 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
135 for (unsigned i = 0; i < base::size(kNameserversIPv6) && i < MAXNS; ++i) {
136 if (!kNameserversIPv6[i])
137 continue;
138 IPAddress ip;
139 EXPECT_TRUE(ip.AssignFromIPLiteral(kNameserversIPv6[i]));
140 config->nameservers[i] = IPEndPoint(ip, NS_DEFAULTPORT - i);
141 }
142 #endif
143 }
144
TEST(DnsConfigServicePosixTest,ConvertResStateToDnsConfig)145 TEST(DnsConfigServicePosixTest, ConvertResStateToDnsConfig) {
146 struct __res_state res;
147 DnsConfig config;
148 EXPECT_FALSE(config.IsValid());
149 InitializeResState(&res);
150 ASSERT_EQ(internal::CONFIG_PARSE_POSIX_OK,
151 internal::ConvertResStateToDnsConfig(res, &config));
152 CloseResState(&res);
153 EXPECT_TRUE(config.IsValid());
154
155 DnsConfig expected_config;
156 EXPECT_FALSE(expected_config.EqualsIgnoreHosts(config));
157 InitializeExpectedConfig(&expected_config);
158 EXPECT_TRUE(expected_config.EqualsIgnoreHosts(config));
159 }
160
TEST(DnsConfigServicePosixTest,RejectEmptyNameserver)161 TEST(DnsConfigServicePosixTest, RejectEmptyNameserver) {
162 struct __res_state res = {};
163 res.options = RES_INIT | RES_RECURSE | RES_DEFNAMES | RES_DNSRCH;
164 const char kDnsrch[] = "chromium.org";
165 memcpy(res.defdname, kDnsrch, sizeof(kDnsrch));
166 res.dnsrch[0] = res.defdname;
167
168 struct sockaddr_in sa = {};
169 sa.sin_family = AF_INET;
170 sa.sin_port = base::HostToNet16(NS_DEFAULTPORT);
171 sa.sin_addr.s_addr = INADDR_ANY;
172 res.nsaddr_list[0] = sa;
173 sa.sin_addr.s_addr = 0xCAFE1337;
174 res.nsaddr_list[1] = sa;
175 res.nscount = 2;
176
177 DnsConfig config;
178 EXPECT_EQ(internal::CONFIG_PARSE_POSIX_NULL_ADDRESS,
179 internal::ConvertResStateToDnsConfig(res, &config));
180
181 sa.sin_addr.s_addr = 0xDEADBEEF;
182 res.nsaddr_list[0] = sa;
183 EXPECT_EQ(internal::CONFIG_PARSE_POSIX_OK,
184 internal::ConvertResStateToDnsConfig(res, &config));
185 }
186
TEST(DnsConfigServicePosixTest,DestroyWhileJobsWorking)187 TEST(DnsConfigServicePosixTest, DestroyWhileJobsWorking) {
188 // Regression test to verify crash does not occur if DnsConfigServicePosix
189 // instance is destroyed while SerialWorker jobs have posted to worker pool.
190 base::test::TaskEnvironment task_environment(
191 base::test::TaskEnvironment::MainThreadType::IO);
192
193 std::unique_ptr<internal::DnsConfigServicePosix> service(
194 new internal::DnsConfigServicePosix());
195 // Call WatchConfig() which also tests ReadConfig().
196 service->WatchConfig(base::BindRepeating(&DummyConfigCallback));
197 service.reset();
198 task_environment.RunUntilIdle();
199 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1000));
200 }
201
TEST(DnsConfigServicePosixTest,DestroyOnDifferentThread)202 TEST(DnsConfigServicePosixTest, DestroyOnDifferentThread) {
203 // Regression test to verify crash does not occur if DnsConfigServicePosix
204 // instance is destroyed on another thread.
205 base::test::TaskEnvironment task_environment;
206
207 scoped_refptr<base::SequencedTaskRunner> runner =
208 base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
209 std::unique_ptr<internal::DnsConfigServicePosix, base::OnTaskRunnerDeleter>
210 service(new internal::DnsConfigServicePosix(),
211 base::OnTaskRunnerDeleter(runner));
212
213 runner->PostTask(FROM_HERE,
214 base::BindOnce(&internal::DnsConfigServicePosix::WatchConfig,
215 base::Unretained(service.get()),
216 base::BindRepeating(&DummyConfigCallback)));
217 service.reset();
218 task_environment.RunUntilIdle();
219 }
220
221 } // namespace
222
223 #else // OS_ANDROID
224
225 namespace internal {
226
227 class DnsConfigServicePosixTest : public testing::Test {
228 public:
229 DnsConfigServicePosixTest() : seen_config_(false) {}
230 ~DnsConfigServicePosixTest() override {}
231
232 void OnConfigChanged(const DnsConfig& config) {
233 EXPECT_TRUE(config.IsValid());
234 seen_config_ = true;
235 real_config_ = config;
236 }
237
238 void SetUp() override {
239 service_.reset(new DnsConfigServicePosix());
240 }
241
242 void TearDown() override { ASSERT_TRUE(base::DeleteFile(temp_file_)); }
243
244 base::test::TaskEnvironment task_environment_;
245 bool seen_config_;
246 base::FilePath temp_file_;
247 std::unique_ptr<DnsConfigServicePosix> service_;
248 DnsConfig real_config_;
249 };
250
251 // Regression test for https://crbug.com/704662.
252 TEST_F(DnsConfigServicePosixTest, ChangeConfigMultipleTimes) {
253 service_->WatchConfig(base::BindRepeating(
254 &DnsConfigServicePosixTest::OnConfigChanged, base::Unretained(this)));
255 task_environment_.RunUntilIdle();
256
257 for (int i = 0; i < 5; i++) {
258 service_->RefreshConfig();
259 // Wait for config read after the change. OnConfigChanged() will only be
260 // called if the new config is different from the old one, so this can't be
261 // ExpectChange().
262 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
263 task_environment_.RunUntilIdle();
264 }
265
266 // There should never be more than 4 nameservers in a real config.
267 EXPECT_GT(5u, real_config_.nameservers.size());
268 }
269
270 } // namespace internal
271
272 #endif // OS_ANDROID
273
274 } // namespace net
275