1 // Copyright 2012 The Chromium Authors
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_config_service_posix.h"
6
7 #include <resolv.h>
8
9 #include <memory>
10 #include <optional>
11
12 #include "base/cancelable_callback.h"
13 #include "base/files/file_util.h"
14 #include "base/functional/bind.h"
15 #include "base/run_loop.h"
16 #include "base/sys_byteorder.h"
17 #include "base/task/sequenced_task_runner.h"
18 #include "base/task/task_traits.h"
19 #include "base/task/thread_pool.h"
20 #include "base/test/task_environment.h"
21 #include "base/test/test_timeouts.h"
22 #include "build/build_config.h"
23 #include "net/base/ip_address.h"
24 #include "net/dns/dns_config.h"
25 #include "net/dns/public/dns_protocol.h"
26 #include "testing/gtest/include/gtest/gtest.h"
27
28 #if BUILDFLAG(IS_ANDROID)
29 #include "base/android/path_utils.h"
30 #endif // BUILDFLAG(IS_ANDROID)
31
32 // Required for inet_pton()
33 #if BUILDFLAG(IS_WIN)
34 #include <winsock2.h>
35 #else
36 #include <arpa/inet.h>
37 #endif
38
39 namespace net {
40
41 namespace {
42
43 // MAXNS is normally 3, but let's test 4 if possible.
44 const char* const kNameserversIPv4[] = {
45 "8.8.8.8",
46 "192.168.1.1",
47 "63.1.2.4",
48 "1.0.0.1",
49 };
50
51 #if BUILDFLAG(IS_CHROMEOS)
52 const char* const kNameserversIPv6[] = {
53 nullptr,
54 "2001:DB8:0::42",
55 nullptr,
56 "::FFFF:129.144.52.38",
57 };
58 #endif
59
DummyConfigCallback(const DnsConfig & config)60 void DummyConfigCallback(const DnsConfig& config) {
61 // Do nothing
62 }
63
64 // Fills in |res| with sane configuration.
InitializeResState(res_state res)65 void InitializeResState(res_state res) {
66 memset(res, 0, sizeof(*res));
67 res->options = RES_INIT | RES_RECURSE | RES_DEFNAMES | RES_DNSRCH |
68 RES_ROTATE;
69 res->ndots = 2;
70 res->retrans = 4;
71 res->retry = 7;
72
73 const char kDnsrch[] = "chromium.org" "\0" "example.com";
74 memcpy(res->defdname, kDnsrch, sizeof(kDnsrch));
75 res->dnsrch[0] = res->defdname;
76 res->dnsrch[1] = res->defdname + sizeof("chromium.org");
77
78 for (unsigned i = 0; i < std::size(kNameserversIPv4) && i < MAXNS; ++i) {
79 struct sockaddr_in sa;
80 sa.sin_family = AF_INET;
81 sa.sin_port = base::HostToNet16(NS_DEFAULTPORT + i);
82 inet_pton(AF_INET, kNameserversIPv4[i], &sa.sin_addr);
83 res->nsaddr_list[i] = sa;
84 ++res->nscount;
85 }
86
87 #if BUILDFLAG(IS_CHROMEOS)
88 // Install IPv6 addresses, replacing the corresponding IPv4 addresses.
89 unsigned nscount6 = 0;
90 for (unsigned i = 0; i < std::size(kNameserversIPv6) && i < MAXNS; ++i) {
91 if (!kNameserversIPv6[i])
92 continue;
93 // Must use malloc to mimick res_ninit.
94 struct sockaddr_in6 *sa6;
95 sa6 = (struct sockaddr_in6 *)malloc(sizeof(*sa6));
96 sa6->sin6_family = AF_INET6;
97 sa6->sin6_port = base::HostToNet16(NS_DEFAULTPORT - i);
98 inet_pton(AF_INET6, kNameserversIPv6[i], &sa6->sin6_addr);
99 res->_u._ext.nsaddrs[i] = sa6;
100 memset(&res->nsaddr_list[i], 0, sizeof res->nsaddr_list[i]);
101 ++nscount6;
102 }
103 res->_u._ext.nscount6 = nscount6;
104 #endif
105 }
106
CloseResState(res_state res)107 void CloseResState(res_state res) {
108 #if BUILDFLAG(IS_CHROMEOS)
109 for (int i = 0; i < res->nscount; ++i) {
110 if (res->_u._ext.nsaddrs[i] != nullptr)
111 free(res->_u._ext.nsaddrs[i]);
112 }
113 #endif
114 }
115
InitializeExpectedConfig(DnsConfig * config)116 void InitializeExpectedConfig(DnsConfig* config) {
117 config->ndots = 2;
118 config->fallback_period = base::Seconds(4);
119 config->attempts = 7;
120 config->rotate = true;
121 config->append_to_multi_label_name = true;
122 config->search.clear();
123 config->search.push_back("chromium.org");
124 config->search.push_back("example.com");
125
126 config->nameservers.clear();
127 for (unsigned i = 0; i < std::size(kNameserversIPv4) && i < MAXNS; ++i) {
128 IPAddress ip;
129 EXPECT_TRUE(ip.AssignFromIPLiteral(kNameserversIPv4[i]));
130 config->nameservers.push_back(IPEndPoint(ip, NS_DEFAULTPORT + i));
131 }
132
133 #if BUILDFLAG(IS_CHROMEOS)
134 for (unsigned i = 0; i < std::size(kNameserversIPv6) && i < MAXNS; ++i) {
135 if (!kNameserversIPv6[i])
136 continue;
137 IPAddress ip;
138 EXPECT_TRUE(ip.AssignFromIPLiteral(kNameserversIPv6[i]));
139 config->nameservers[i] = IPEndPoint(ip, NS_DEFAULTPORT - i);
140 }
141 #endif
142 }
143
TEST(DnsConfigServicePosixTest,CreateAndDestroy)144 TEST(DnsConfigServicePosixTest, CreateAndDestroy) {
145 // Regression test to verify crash does not occur if DnsConfigServicePosix
146 // instance is destroyed without calling WatchConfig()
147 base::test::TaskEnvironment task_environment(
148 base::test::TaskEnvironment::MainThreadType::IO);
149
150 auto service = std::make_unique<internal::DnsConfigServicePosix>();
151 service.reset();
152 task_environment.RunUntilIdle();
153 }
154
TEST(DnsConfigServicePosixTest,ConvertResStateToDnsConfig)155 TEST(DnsConfigServicePosixTest, ConvertResStateToDnsConfig) {
156 struct __res_state res;
157 InitializeResState(&res);
158 std::optional<DnsConfig> config = internal::ConvertResStateToDnsConfig(res);
159 CloseResState(&res);
160 ASSERT_TRUE(config.has_value());
161 EXPECT_TRUE(config->IsValid());
162
163 DnsConfig expected_config;
164 EXPECT_FALSE(expected_config.EqualsIgnoreHosts(config.value()));
165 InitializeExpectedConfig(&expected_config);
166 EXPECT_TRUE(expected_config.EqualsIgnoreHosts(config.value()));
167 }
168
TEST(DnsConfigServicePosixTest,RejectEmptyNameserver)169 TEST(DnsConfigServicePosixTest, RejectEmptyNameserver) {
170 struct __res_state res = {};
171 res.options = RES_INIT | RES_RECURSE | RES_DEFNAMES | RES_DNSRCH;
172 const char kDnsrch[] = "chromium.org";
173 memcpy(res.defdname, kDnsrch, sizeof(kDnsrch));
174 res.dnsrch[0] = res.defdname;
175
176 struct sockaddr_in sa = {};
177 sa.sin_family = AF_INET;
178 sa.sin_port = base::HostToNet16(NS_DEFAULTPORT);
179 sa.sin_addr.s_addr = INADDR_ANY;
180 res.nsaddr_list[0] = sa;
181 sa.sin_addr.s_addr = 0xCAFE1337;
182 res.nsaddr_list[1] = sa;
183 res.nscount = 2;
184
185 EXPECT_FALSE(internal::ConvertResStateToDnsConfig(res));
186
187 sa.sin_addr.s_addr = 0xDEADBEEF;
188 res.nsaddr_list[0] = sa;
189 EXPECT_TRUE(internal::ConvertResStateToDnsConfig(res));
190 }
191
TEST(DnsConfigServicePosixTest,DestroyWhileJobsWorking)192 TEST(DnsConfigServicePosixTest, DestroyWhileJobsWorking) {
193 // Regression test to verify crash does not occur if DnsConfigServicePosix
194 // instance is destroyed while SerialWorker jobs have posted to worker pool.
195 base::test::TaskEnvironment task_environment(
196 base::test::TaskEnvironment::MainThreadType::IO,
197 base::test::TaskEnvironment::TimeSource::MOCK_TIME);
198
199 auto service = std::make_unique<internal::DnsConfigServicePosix>();
200 // Call WatchConfig() which also tests ReadConfig().
201 service->WatchConfig(base::BindRepeating(&DummyConfigCallback));
202 service.reset();
203 task_environment.FastForwardUntilNoTasksRemain();
204 }
205
TEST(DnsConfigServicePosixTest,DestroyOnDifferentThread)206 TEST(DnsConfigServicePosixTest, DestroyOnDifferentThread) {
207 // Regression test to verify crash does not occur if DnsConfigServicePosix
208 // instance is destroyed on another thread.
209 base::test::TaskEnvironment task_environment;
210
211 scoped_refptr<base::SequencedTaskRunner> runner =
212 base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
213 std::unique_ptr<internal::DnsConfigServicePosix, base::OnTaskRunnerDeleter>
214 service(new internal::DnsConfigServicePosix(),
215 base::OnTaskRunnerDeleter(runner));
216
217 runner->PostTask(FROM_HERE,
218 base::BindOnce(&internal::DnsConfigServicePosix::WatchConfig,
219 base::Unretained(service.get()),
220 base::BindRepeating(&DummyConfigCallback)));
221 service.reset();
222 task_environment.RunUntilIdle();
223 }
224
225 } // namespace
226
227
228 } // namespace net
229