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