blob: e5850fd4d33a75a42f776e99583c4a250a55462e [file] [log] [blame]
Ken Chenb9fa2062018-11-13 21:51:13 +08001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
Lorenzo Colitti0a8b4aa2019-06-26 22:31:03 +090010 * Unless required by applicable law or agreed to in writing, software
Ken Chenb9fa2062018-11-13 21:51:13 +080011 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 */
17
Bernie Innocenti3952ccc2019-03-03 19:39:53 +090018#define LOG_TAG "resolv_integration_test"
Ken Chenb9fa2062018-11-13 21:51:13 +080019
Hungming Chen5bf09772019-04-25 11:16:13 +080020#include <android-base/logging.h>
Bernie Innocenti41b82c42019-06-05 22:38:25 +090021#include <android-base/parseint.h>
Mike Yu40e67072019-10-09 21:14:09 +080022#include <android-base/properties.h>
Bernie Innocenti41b82c42019-06-05 22:38:25 +090023#include <android-base/stringprintf.h>
24#include <android-base/unique_fd.h>
25#include <android/multinetwork.h> // ResNsendFlags
Ken Chenb9fa2062018-11-13 21:51:13 +080026#include <arpa/inet.h>
Luke Huang94b10b92018-11-21 20:13:38 +080027#include <arpa/nameser.h>
Hungming Chene8f970c2019-04-10 17:34:06 +080028#include <binder/ProcessState.h>
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +090029#include <bpf/BpfUtils.h>
Bernie Innocenti41b82c42019-06-05 22:38:25 +090030#include <cutils/sockets.h>
31#include <gmock/gmock-matchers.h>
32#include <gtest/gtest.h>
Ken Chenb9fa2062018-11-13 21:51:13 +080033#include <netdb.h>
Luke Huang9d2d25b2019-06-14 00:34:05 +080034#include <netdutils/InternetAddresses.h>
Luke Huang579ddc72019-06-14 00:59:39 +080035#include <netdutils/NetworkConstants.h> // SHA256_SIZE
Luke Huang9d2d25b2019-06-14 00:34:05 +080036#include <netdutils/ResponseCode.h>
Hungming Chen63779052019-10-30 15:06:13 +080037#include <netdutils/Slice.h>
Luke Huang9d2d25b2019-06-14 00:34:05 +080038#include <netdutils/SocketOption.h>
Mike Yu40e67072019-10-09 21:14:09 +080039#include <netdutils/Stopwatch.h>
Luke Huang94b10b92018-11-21 20:13:38 +080040#include <netinet/in.h>
41#include <poll.h> /* poll */
Bernie Innocenti41b82c42019-06-05 22:38:25 +090042#include <private/android_filesystem_config.h>
Luke Huang94b10b92018-11-21 20:13:38 +080043#include <resolv.h>
Ken Chenb9fa2062018-11-13 21:51:13 +080044#include <stdarg.h>
Ken Chenb9fa2062018-11-13 21:51:13 +080045#include <stdlib.h>
Luke Huang94b10b92018-11-21 20:13:38 +080046#include <sys/socket.h>
47#include <sys/un.h>
Ken Chenb9fa2062018-11-13 21:51:13 +080048#include <unistd.h>
49
50#include <algorithm>
51#include <chrono>
52#include <iterator>
53#include <numeric>
54#include <thread>
55
Luke Huangf8215372019-11-22 11:53:41 +080056#include <aidl/android/net/IDnsResolver.h>
57#include <android/binder_manager.h>
58#include <android/binder_process.h>
Bernie Innocenti41b82c42019-06-05 22:38:25 +090059#include "NetdClient.h"
Bernie Innocenti41b82c42019-06-05 22:38:25 +090060#include "ResolverStats.h"
Luke Huangf8215372019-11-22 11:53:41 +080061#include "netid_client.h" // NETID_UNSET
62#include "params.h" // MAXNS
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +090063#include "test_utils.h"
Hungming Chene8f970c2019-04-10 17:34:06 +080064#include "tests/dns_metrics_listener/dns_metrics_listener.h"
chenbruceb43ec752019-07-24 20:19:41 +080065#include "tests/dns_responder/dns_responder.h"
Luke Huangf8215372019-11-22 11:53:41 +080066#include "tests/dns_responder/dns_responder_client_ndk.h"
Hungming Chenc6556622019-10-02 16:01:07 +080067#include "tests/dns_responder/dns_tls_certificate.h"
chenbruceb43ec752019-07-24 20:19:41 +080068#include "tests/dns_responder/dns_tls_frontend.h"
Luke Huangfde82482019-06-04 01:04:53 +080069#include "tests/resolv_test_utils.h"
Ken Chenb9fa2062018-11-13 21:51:13 +080070
Luke Huang0d592bc2019-05-25 18:24:03 +080071// Valid VPN netId range is 100 ~ 65535
72constexpr int TEST_VPN_NETID = 65502;
Luke Huang94b10b92018-11-21 20:13:38 +080073constexpr int MAXPACKET = (8 * 1024);
Ken Chenb9fa2062018-11-13 21:51:13 +080074
Sehee Park2c118782019-05-07 13:02:45 +090075// Use maximum reserved appId for applications to avoid conflict with existing uids.
76static const int TEST_UID = 99999;
77
Ken Chenb9fa2062018-11-13 21:51:13 +080078// Semi-public Bionic hook used by the NDK (frameworks/base/native/android/net.c)
79// Tested here for convenience.
80extern "C" int android_getaddrinfofornet(const char* hostname, const char* servname,
81 const addrinfo* hints, unsigned netid, unsigned mark,
82 struct addrinfo** result);
83
Mike Yuc0000252020-03-19 07:14:23 +000084using namespace std::chrono_literals;
85
Luke Huang70070852019-11-25 18:25:50 +080086using aidl::android::net::IDnsResolver;
Luke Huangf8215372019-11-22 11:53:41 +080087using aidl::android::net::INetd;
Mike Yu8ac63402019-12-02 15:28:38 +080088using aidl::android::net::ResolverParamsParcel;
Luke Huang9807e6b2019-05-20 16:17:12 +080089using android::base::ParseInt;
Ken Chenb9fa2062018-11-13 21:51:13 +080090using android::base::StringPrintf;
Luke Huang9807e6b2019-05-20 16:17:12 +080091using android::base::unique_fd;
Ken Chenb9fa2062018-11-13 21:51:13 +080092using android::net::ResolverStats;
Hungming Chene8f970c2019-04-10 17:34:06 +080093using android::net::metrics::DnsMetricsListener;
Ken Chenb9fa2062018-11-13 21:51:13 +080094using android::netdutils::enableSockopt;
Hungming Chen63779052019-10-30 15:06:13 +080095using android::netdutils::makeSlice;
Luke Huang9807e6b2019-05-20 16:17:12 +080096using android::netdutils::ResponseCode;
Luke Huang9d2d25b2019-06-14 00:34:05 +080097using android::netdutils::ScopedAddrinfo;
Mike Yu40e67072019-10-09 21:14:09 +080098using android::netdutils::Stopwatch;
Hungming Chen63779052019-10-30 15:06:13 +080099using android::netdutils::toHex;
Ken Chenb9fa2062018-11-13 21:51:13 +0800100
101// TODO: move into libnetdutils?
102namespace {
Luke Huangfde82482019-06-04 01:04:53 +0800103
Ken Chenb9fa2062018-11-13 21:51:13 +0800104ScopedAddrinfo safe_getaddrinfo(const char* node, const char* service,
105 const struct addrinfo* hints) {
106 addrinfo* result = nullptr;
107 if (getaddrinfo(node, service, hints, &result) != 0) {
108 result = nullptr; // Should already be the case, but...
109 }
110 return ScopedAddrinfo(result);
111}
Luke Huangfde82482019-06-04 01:04:53 +0800112
Mike Yu40e67072019-10-09 21:14:09 +0800113std::pair<ScopedAddrinfo, int> safe_getaddrinfo_time_taken(const char* node, const char* service,
114 const addrinfo& hints) {
115 Stopwatch s;
116 ScopedAddrinfo result = safe_getaddrinfo(node, service, &hints);
117 return {std::move(result), s.timeTakenUs() / 1000};
118}
119
Mike Yuc0000252020-03-19 07:14:23 +0000120struct NameserverStats {
121 NameserverStats() = delete;
122 NameserverStats(const std::string server) : server(server) {}
123 NameserverStats& setSuccesses(int val) {
124 successes = val;
125 return *this;
126 }
127 NameserverStats& setErrors(int val) {
128 errors = val;
129 return *this;
130 }
131 NameserverStats& setTimeouts(int val) {
132 timeouts = val;
133 return *this;
134 }
135 NameserverStats& setInternalErrors(int val) {
136 internal_errors = val;
137 return *this;
138 }
139
140 const std::string server;
141 int successes = 0;
142 int errors = 0;
143 int timeouts = 0;
144 int internal_errors = 0;
145};
146
Ken Chenb9fa2062018-11-13 21:51:13 +0800147} // namespace
148
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900149class ResolverTest : public ::testing::Test {
Hungming Chene8f970c2019-04-10 17:34:06 +0800150 public:
Automerger Merge Worker19a291b2020-03-17 02:41:30 +0000151 static void SetUpTestSuite() {
Hungming Chen5bf09772019-04-25 11:16:13 +0800152 // Get binder service.
153 // Note that |mDnsClient| is not used for getting binder service in this static function.
154 // The reason is that wants to keep |mDnsClient| as a non-static data member. |mDnsClient|
155 // which sets up device network configuration could be independent from every test.
Luke Huangf8215372019-11-22 11:53:41 +0800156 // TODO: Perhaps add a static function in resolv_test_binder_utils.{cpp,h} to get binder
157 // service.
158
159 AIBinder* binder = AServiceManager_getService("dnsresolver");
160 ndk::SpAIBinder resolvBinder = ndk::SpAIBinder(binder);
161 auto resolvService = aidl::android::net::IDnsResolver::fromBinder(resolvBinder);
Hungming Chen5bf09772019-04-25 11:16:13 +0800162 ASSERT_NE(nullptr, resolvService.get());
163
164 // Subscribe the death recipient to the service IDnsResolver for detecting Netd death.
Luke Huang70070852019-11-25 18:25:50 +0800165 // GTEST assertion macros are not invoked for generating a test failure in the death
166 // recipient because the macros can't indicate failed test if Netd died between tests.
167 // Moreover, continuing testing may have no meaningful after Netd death. Therefore, the
168 // death recipient aborts process by GTEST_LOG_(FATAL) once Netd died.
Luke Huangf8215372019-11-22 11:53:41 +0800169 sResolvDeathRecipient = AIBinder_DeathRecipient_new([](void*) {
170 constexpr char errorMessage[] = "Netd died";
171 LOG(ERROR) << errorMessage;
172 GTEST_LOG_(FATAL) << errorMessage;
173 });
174 ASSERT_EQ(STATUS_OK, AIBinder_linkToDeath(binder, sResolvDeathRecipient, nullptr));
Hungming Chen5bf09772019-04-25 11:16:13 +0800175
176 // Subscribe the DNS listener for verifying DNS metrics event contents.
Luke Huangf8215372019-11-22 11:53:41 +0800177 sDnsMetricsListener = ndk::SharedRefBase::make<DnsMetricsListener>(
178 TEST_NETID /*monitor specific network*/);
Hungming Chen5bf09772019-04-25 11:16:13 +0800179 ASSERT_TRUE(resolvService->registerEventListener(sDnsMetricsListener).isOk());
180
181 // Start the binder thread pool for listening DNS metrics events and receiving death
182 // recipient.
Luke Huangf8215372019-11-22 11:53:41 +0800183 ABinderProcess_startThreadPool();
Hungming Chene8f970c2019-04-10 17:34:06 +0800184 }
Automerger Merge Worker19a291b2020-03-17 02:41:30 +0000185 static void TearDownTestSuite() { AIBinder_DeathRecipient_delete(sResolvDeathRecipient); }
Hungming Chene8f970c2019-04-10 17:34:06 +0800186
Ken Chenb9fa2062018-11-13 21:51:13 +0800187 protected:
Hungming Chen5bf09772019-04-25 11:16:13 +0800188 void SetUp() { mDnsClient.SetUp(); }
Mike Yu960243d2020-01-17 19:02:15 +0800189 void TearDown() {
190 // Ensure the dump works at the end of each test.
191 DumpResolverService();
192
193 mDnsClient.TearDown();
194 }
nuccachena26cc2a2018-07-17 18:07:23 +0800195
Luke Huang68fa5002020-04-23 15:48:47 +0000196 void resetNetwork() {
197 mDnsClient.TearDown();
198 mDnsClient.SetupOemNetwork();
199 }
200
Xiao Ma09b71022018-12-11 17:56:32 +0900201 void StartDns(test::DNSResponder& dns, const std::vector<DnsRecord>& records) {
202 for (const auto& r : records) {
203 dns.addMapping(r.host_name, r.type, r.addr);
204 }
205
206 ASSERT_TRUE(dns.startServer());
207 dns.clearQueries();
208 }
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900209
Mike Yu960243d2020-01-17 19:02:15 +0800210 void DumpResolverService() {
211 unique_fd fd(open("/dev/null", O_WRONLY));
212 EXPECT_EQ(mDnsClient.resolvService()->dump(fd, nullptr, 0), 0);
213
214 const char* querylogCmd[] = {"querylog"}; // Keep it sync with DnsQueryLog::DUMP_KEYWORD.
215 EXPECT_EQ(mDnsClient.resolvService()->dump(fd, querylogCmd, std::size(querylogCmd)), 0);
216 }
217
Hungming Chene8f970c2019-04-10 17:34:06 +0800218 bool WaitForNat64Prefix(ExpectNat64PrefixStatus status,
219 std::chrono::milliseconds timeout = std::chrono::milliseconds(1000)) {
Hungming Chen5bf09772019-04-25 11:16:13 +0800220 return sDnsMetricsListener->waitForNat64Prefix(status, timeout);
Hungming Chene8f970c2019-04-10 17:34:06 +0800221 }
222
Mike Yu724f77d2019-08-16 11:14:50 +0800223 bool WaitForPrivateDnsValidation(std::string serverAddr, bool validated) {
224 return sDnsMetricsListener->waitForPrivateDnsValidation(serverAddr, validated);
225 }
226
Mike Yuc0000252020-03-19 07:14:23 +0000227 bool hasUncaughtPrivateDnsValidation(const std::string& serverAddr) {
228 return sDnsMetricsListener->findValidationRecord(serverAddr);
229 }
230
231 bool expectStatsFromGetResolverInfo(const std::vector<NameserverStats>& nameserversStats) {
232 std::vector<std::string> res_servers;
233 std::vector<std::string> res_domains;
234 std::vector<std::string> res_tls_servers;
235 res_params res_params;
236 std::vector<ResolverStats> res_stats;
237 int wait_for_pending_req_timeout_count;
238
239 if (!DnsResponderClient::GetResolverInfo(mDnsClient.resolvService(), TEST_NETID,
240 &res_servers, &res_domains, &res_tls_servers,
241 &res_params, &res_stats,
242 &wait_for_pending_req_timeout_count)) {
243 ADD_FAILURE() << "GetResolverInfo failed";
244 return false;
245 }
246
247 if (res_servers.size() != res_stats.size()) {
248 ADD_FAILURE() << fmt::format("res_servers.size() != res_stats.size(): {} != {}",
249 res_servers.size(), res_stats.size());
250 return false;
251 }
252 if (res_servers.size() != nameserversStats.size()) {
253 ADD_FAILURE() << fmt::format("res_servers.size() != nameserversStats.size(): {} != {}",
254 res_servers.size(), nameserversStats.size());
255 return false;
256 }
257
258 for (const auto& stats : nameserversStats) {
259 SCOPED_TRACE(stats.server);
260 const auto it = std::find(res_servers.begin(), res_servers.end(), stats.server);
261 if (it == res_servers.end()) {
262 ADD_FAILURE() << fmt::format("nameserver {} not found in the list {{{}}}",
263 stats.server, fmt::join(res_servers, ", "));
264 return false;
265 }
266 const int index = std::distance(res_servers.begin(), it);
267
268 // The check excludes rtt_avg, last_sample_time, and usable since they will be obsolete
269 // after |res_stats| is retrieved from NetConfig.dnsStats rather than NetConfig.nsstats.
270 EXPECT_EQ(res_stats[index].successes, stats.successes);
271 EXPECT_EQ(res_stats[index].errors, stats.errors);
272 EXPECT_EQ(res_stats[index].timeouts, stats.timeouts);
273 EXPECT_EQ(res_stats[index].internal_errors, stats.internal_errors);
274 }
275
276 return true;
277 }
278
279 // Since there's no way to terminate private DNS validation threads at any time. Tests that
280 // focus on the results of private DNS validation can interfere with each other if they use the
281 // same IP address for test servers. getUniqueIPv4Address() is a workaround to reduce the
282 // possibility of tests being flaky. A feasible solution is to forbid the validation threads,
283 // which are considered as outdated (e.g. switch the resolver to private DNS OFF mode), updating
284 // the result to the PrivateDnsConfiguration instance.
285 static std::string getUniqueIPv4Address() {
286 static int counter = 0;
287 return fmt::format("127.0.100.{}", (++counter & 0xff));
288 }
289
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900290 DnsResponderClient mDnsClient;
Xiao Ma09b71022018-12-11 17:56:32 +0900291
Hungming Chen5bf09772019-04-25 11:16:13 +0800292 // Use a shared static DNS listener for all tests to avoid registering lots of listeners
293 // which may be released late until process terminated. Currently, registered DNS listener
294 // is removed by binder death notification which is fired when the process hosting an
295 // IBinder has gone away. If every test in ResolverTest registers its DNS listener, Netd
296 // may temporarily hold lots of dead listeners until the unit test process terminates.
297 // TODO: Perhaps add an unregistering listener binder call or fork a listener process which
298 // could be terminated earlier.
Luke Huangf8215372019-11-22 11:53:41 +0800299 static std::shared_ptr<DnsMetricsListener>
Automerger Merge Worker19a291b2020-03-17 02:41:30 +0000300 sDnsMetricsListener; // Initialized in SetUpTestSuite.
Hungming Chen5bf09772019-04-25 11:16:13 +0800301
302 // Use a shared static death recipient to monitor the service death. The static death
303 // recipient could monitor the death not only during the test but also between tests.
Automerger Merge Worker19a291b2020-03-17 02:41:30 +0000304 static AIBinder_DeathRecipient* sResolvDeathRecipient; // Initialized in SetUpTestSuite.
Ken Chenb9fa2062018-11-13 21:51:13 +0800305};
306
Hungming Chen5bf09772019-04-25 11:16:13 +0800307// Initialize static member of class.
Luke Huangf8215372019-11-22 11:53:41 +0800308std::shared_ptr<DnsMetricsListener> ResolverTest::sDnsMetricsListener;
309AIBinder_DeathRecipient* ResolverTest::sResolvDeathRecipient;
Hungming Chen5bf09772019-04-25 11:16:13 +0800310
Ken Chenb9fa2062018-11-13 21:51:13 +0800311TEST_F(ResolverTest, GetHostByName) {
Xiao Ma09b71022018-12-11 17:56:32 +0900312 constexpr char nonexistent_host_name[] = "nonexistent.example.com.";
313
314 test::DNSResponder dns;
315 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, "1.2.3.3"}});
316 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800317
318 const hostent* result;
Ken Chenb9fa2062018-11-13 21:51:13 +0800319 result = gethostbyname("nonexistent");
320 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, nonexistent_host_name));
321 ASSERT_TRUE(result == nullptr);
322 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
323
324 dns.clearQueries();
325 result = gethostbyname("hello");
Xiao Ma09b71022018-12-11 17:56:32 +0900326 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
Ken Chenb9fa2062018-11-13 21:51:13 +0800327 ASSERT_FALSE(result == nullptr);
328 ASSERT_EQ(4, result->h_length);
329 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
330 EXPECT_EQ("1.2.3.3", ToString(result));
331 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800332}
333
lifr4e4a2e02019-01-29 16:53:51 +0800334TEST_F(ResolverTest, GetHostByName_cnames) {
335 constexpr char host_name[] = "host.example.com.";
336 size_t cnamecount = 0;
337 test::DNSResponder dns;
338
339 const std::vector<DnsRecord> records = {
340 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
341 {"a.example.com.", ns_type::ns_t_cname, "b.example.com."},
342 {"b.example.com.", ns_type::ns_t_cname, "c.example.com."},
343 {"c.example.com.", ns_type::ns_t_cname, "d.example.com."},
344 {"d.example.com.", ns_type::ns_t_cname, "e.example.com."},
345 {"e.example.com.", ns_type::ns_t_cname, host_name},
346 {host_name, ns_type::ns_t_a, "1.2.3.3"},
347 {host_name, ns_type::ns_t_aaaa, "2001:db8::42"},
348 };
349 StartDns(dns, records);
350 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
351
352 // using gethostbyname2() to resolve ipv4 hello.example.com. to 1.2.3.3
353 // Ensure the v4 address and cnames are correct
354 const hostent* result;
355 result = gethostbyname2("hello", AF_INET);
356 ASSERT_FALSE(result == nullptr);
357
358 for (int i = 0; result != nullptr && result->h_aliases[i] != nullptr; i++) {
359 std::string domain_name = records[i].host_name.substr(0, records[i].host_name.size() - 1);
360 EXPECT_EQ(result->h_aliases[i], domain_name);
361 cnamecount++;
362 }
363 // The size of "Non-cname type" record in DNS records is 2
364 ASSERT_EQ(cnamecount, records.size() - 2);
365 ASSERT_EQ(4, result->h_length);
366 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
367 EXPECT_EQ("1.2.3.3", ToString(result));
368 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
369 EXPECT_EQ(1U, dns.queries().size()) << dns.dumpQueries();
370
371 // using gethostbyname2() to resolve ipv6 hello.example.com. to 2001:db8::42
372 // Ensure the v6 address and cnames are correct
373 cnamecount = 0;
374 dns.clearQueries();
375 result = gethostbyname2("hello", AF_INET6);
376 for (unsigned i = 0; result != nullptr && result->h_aliases[i] != nullptr; i++) {
377 std::string domain_name = records[i].host_name.substr(0, records[i].host_name.size() - 1);
378 EXPECT_EQ(result->h_aliases[i], domain_name);
379 cnamecount++;
380 }
381 // The size of "Non-cname type" DNS record in records is 2
382 ASSERT_EQ(cnamecount, records.size() - 2);
383 ASSERT_FALSE(result == nullptr);
384 ASSERT_EQ(16, result->h_length);
385 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
386 EXPECT_EQ("2001:db8::42", ToString(result));
387 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
388}
389
390TEST_F(ResolverTest, GetHostByName_cnamesInfiniteLoop) {
391 test::DNSResponder dns;
392 const std::vector<DnsRecord> records = {
393 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
394 {"a.example.com.", ns_type::ns_t_cname, kHelloExampleCom},
395 };
396 StartDns(dns, records);
397 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
398
399 const hostent* result;
400 result = gethostbyname2("hello", AF_INET);
401 ASSERT_TRUE(result == nullptr);
402
403 dns.clearQueries();
404 result = gethostbyname2("hello", AF_INET6);
405 ASSERT_TRUE(result == nullptr);
406}
407
Ken Chenb9fa2062018-11-13 21:51:13 +0800408TEST_F(ResolverTest, GetHostByName_localhost) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800409 constexpr char name_camelcase[] = "LocalHost";
Ken Chenb9fa2062018-11-13 21:51:13 +0800410 constexpr char name_ip6_dot[] = "ip6-localhost.";
411 constexpr char name_ip6_fqdn[] = "ip6-localhost.example.com.";
412
413 // Add a dummy nameserver which shouldn't receive any queries
Xiao Ma09b71022018-12-11 17:56:32 +0900414 test::DNSResponder dns;
415 StartDns(dns, {});
416 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800417
418 // Expect no DNS queries; localhost is resolved via /etc/hosts
Xiao Ma09b71022018-12-11 17:56:32 +0900419 const hostent* result = gethostbyname(kLocalHost);
Ken Chenb9fa2062018-11-13 21:51:13 +0800420 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
421 ASSERT_FALSE(result == nullptr);
422 ASSERT_EQ(4, result->h_length);
423 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900424 EXPECT_EQ(kLocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800425 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
426
427 // Ensure the hosts file resolver ignores case of hostnames
428 result = gethostbyname(name_camelcase);
429 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
430 ASSERT_FALSE(result == nullptr);
431 ASSERT_EQ(4, result->h_length);
432 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900433 EXPECT_EQ(kLocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800434 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
435
436 // The hosts file also contains ip6-localhost, but gethostbyname() won't
chenbruce018fdb22019-06-12 18:08:04 +0800437 // return it. This would be easy to
Ken Chenb9fa2062018-11-13 21:51:13 +0800438 // change, but there's no point in changing the legacy behavior; new code
439 // should be calling getaddrinfo() anyway.
440 // So we check the legacy behavior, which results in amusing A-record
441 // lookups for ip6-localhost, with and without search domains appended.
442 dns.clearQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900443 result = gethostbyname(kIp6LocalHost);
Sehee Parkbbca0202018-11-16 10:53:16 +0900444 EXPECT_EQ(2U, dns.queries().size()) << dns.dumpQueries();
445 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, name_ip6_dot)) << dns.dumpQueries();
446 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, name_ip6_fqdn)) << dns.dumpQueries();
Ken Chenb9fa2062018-11-13 21:51:13 +0800447 ASSERT_TRUE(result == nullptr);
448
449 // Finally, use gethostbyname2() to resolve ip6-localhost to ::1 from
450 // the hosts file.
451 dns.clearQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900452 result = gethostbyname2(kIp6LocalHost, AF_INET6);
Ken Chenb9fa2062018-11-13 21:51:13 +0800453 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
454 ASSERT_FALSE(result == nullptr);
455 ASSERT_EQ(16, result->h_length);
456 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900457 EXPECT_EQ(kIp6LocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800458 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800459}
460
461TEST_F(ResolverTest, GetHostByName_numeric) {
462 // Add a dummy nameserver which shouldn't receive any queries
Xiao Ma09b71022018-12-11 17:56:32 +0900463 test::DNSResponder dns;
464 StartDns(dns, {});
465 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800466
467 // Numeric v4 address: expect no DNS queries
468 constexpr char numeric_v4[] = "192.168.0.1";
Ken Chenb9fa2062018-11-13 21:51:13 +0800469 const hostent* result = gethostbyname(numeric_v4);
Sehee Parkbbca0202018-11-16 10:53:16 +0900470 EXPECT_EQ(0U, dns.queries().size());
Ken Chenb9fa2062018-11-13 21:51:13 +0800471 ASSERT_FALSE(result == nullptr);
472 ASSERT_EQ(4, result->h_length); // v4
473 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
474 EXPECT_EQ(numeric_v4, ToString(result));
475 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
476
477 // gethostbyname() recognizes a v6 address, and fails with no DNS queries
478 constexpr char numeric_v6[] = "2001:db8::42";
479 dns.clearQueries();
480 result = gethostbyname(numeric_v6);
Sehee Parkbbca0202018-11-16 10:53:16 +0900481 EXPECT_EQ(0U, dns.queries().size());
Ken Chenb9fa2062018-11-13 21:51:13 +0800482 EXPECT_TRUE(result == nullptr);
483
484 // Numeric v6 address with gethostbyname2(): succeeds with no DNS queries
485 dns.clearQueries();
486 result = gethostbyname2(numeric_v6, AF_INET6);
Sehee Parkbbca0202018-11-16 10:53:16 +0900487 EXPECT_EQ(0U, dns.queries().size());
Ken Chenb9fa2062018-11-13 21:51:13 +0800488 ASSERT_FALSE(result == nullptr);
489 ASSERT_EQ(16, result->h_length); // v6
490 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
491 EXPECT_EQ(numeric_v6, ToString(result));
492 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
493
494 // Numeric v6 address with scope work with getaddrinfo(),
495 // but gethostbyname2() does not understand them; it issues two dns
496 // queries, then fails. This hardly ever happens, there's no point
497 // in fixing this. This test simply verifies the current (bogus)
498 // behavior to avoid further regressions (like crashes, or leaks).
499 constexpr char numeric_v6_scope[] = "fe80::1%lo";
500 dns.clearQueries();
501 result = gethostbyname2(numeric_v6_scope, AF_INET6);
Sehee Parkbbca0202018-11-16 10:53:16 +0900502 EXPECT_EQ(2U, dns.queries().size()); // OUCH!
Ken Chenb9fa2062018-11-13 21:51:13 +0800503 ASSERT_TRUE(result == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800504}
505
506TEST_F(ResolverTest, BinderSerialization) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800507 std::vector<int> params_offsets = {
Luke Huang5bd827c2019-03-14 16:10:04 +0800508 IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY,
509 IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD,
510 IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES,
511 IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES,
512 IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC,
513 IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT,
Ken Chenb9fa2062018-11-13 21:51:13 +0800514 };
Bernie Innocentib102dd22018-12-04 14:57:48 +0900515 const int size = static_cast<int>(params_offsets.size());
Luke Huang5bd827c2019-03-14 16:10:04 +0800516 EXPECT_EQ(size, IDnsResolver::RESOLVER_PARAMS_COUNT);
Ken Chenb9fa2062018-11-13 21:51:13 +0800517 std::sort(params_offsets.begin(), params_offsets.end());
Bernie Innocentib102dd22018-12-04 14:57:48 +0900518 for (int i = 0; i < size; ++i) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800519 EXPECT_EQ(params_offsets[i], i);
520 }
521}
522
523TEST_F(ResolverTest, GetHostByName_Binder) {
Luke Huangf8215372019-11-22 11:53:41 +0800524 std::vector<std::string> domains = {"example.com"};
Ken Chenb9fa2062018-11-13 21:51:13 +0800525 std::vector<std::unique_ptr<test::DNSResponder>> dns;
526 std::vector<std::string> servers;
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900527 std::vector<DnsResponderClient::Mapping> mappings;
528 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupMappings(1, domains, &mappings));
529 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupDNSServers(4, mappings, &dns, &servers));
Ken Chenb9fa2062018-11-13 21:51:13 +0800530 ASSERT_EQ(1U, mappings.size());
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900531 const DnsResponderClient::Mapping& mapping = mappings[0];
Ken Chenb9fa2062018-11-13 21:51:13 +0800532
Xiao Ma09b71022018-12-11 17:56:32 +0900533 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains, kDefaultParams));
Ken Chenb9fa2062018-11-13 21:51:13 +0800534
535 const hostent* result = gethostbyname(mapping.host.c_str());
Bernie Innocentib102dd22018-12-04 14:57:48 +0900536 const size_t total_queries =
Luke Huangfde82482019-06-04 01:04:53 +0800537 std::accumulate(dns.begin(), dns.end(), 0, [&mapping](size_t total, auto& d) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800538 return total + GetNumQueriesForType(*d, ns_type::ns_t_a, mapping.entry.c_str());
539 });
540
541 EXPECT_LE(1U, total_queries);
542 ASSERT_FALSE(result == nullptr);
543 ASSERT_EQ(4, result->h_length);
544 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
545 EXPECT_EQ(mapping.ip4, ToString(result));
546 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
547
548 std::vector<std::string> res_servers;
549 std::vector<std::string> res_domains;
Mike Yu0a1c53d2018-11-26 13:26:21 +0900550 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +0900551 res_params res_params;
Ken Chenb9fa2062018-11-13 21:51:13 +0800552 std::vector<ResolverStats> res_stats;
Ken Chen92bed612018-12-22 21:46:55 +0800553 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +0800554 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
555 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
556 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chenb9fa2062018-11-13 21:51:13 +0800557 EXPECT_EQ(servers.size(), res_servers.size());
558 EXPECT_EQ(domains.size(), res_domains.size());
Mike Yu0a1c53d2018-11-26 13:26:21 +0900559 EXPECT_EQ(0U, res_tls_servers.size());
Luke Huang5bd827c2019-03-14 16:10:04 +0800560 ASSERT_EQ(static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT), kDefaultParams.size());
561 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY],
562 res_params.sample_validity);
563 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900564 res_params.success_threshold);
Luke Huang5bd827c2019-03-14 16:10:04 +0800565 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
566 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
567 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
Ken Chenb9fa2062018-11-13 21:51:13 +0800568 res_params.base_timeout_msec);
569 EXPECT_EQ(servers.size(), res_stats.size());
570
Bernie Innocenti0c067e42019-04-01 15:33:16 +0900571 EXPECT_THAT(res_servers, testing::UnorderedElementsAreArray(servers));
572 EXPECT_THAT(res_domains, testing::UnorderedElementsAreArray(domains));
Ken Chenb9fa2062018-11-13 21:51:13 +0800573}
574
575TEST_F(ResolverTest, GetAddrInfo) {
Xiao Ma09b71022018-12-11 17:56:32 +0900576 constexpr char listen_addr[] = "127.0.0.4";
577 constexpr char listen_addr2[] = "127.0.0.5";
578 constexpr char host_name[] = "howdy.example.com.";
Ken Chenb9fa2062018-11-13 21:51:13 +0800579
Xiao Ma09b71022018-12-11 17:56:32 +0900580 const std::vector<DnsRecord> records = {
581 {host_name, ns_type::ns_t_a, "1.2.3.4"},
582 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
583 };
584 test::DNSResponder dns(listen_addr);
585 test::DNSResponder dns2(listen_addr2);
586 StartDns(dns, records);
587 StartDns(dns2, records);
Ken Chenb9fa2062018-11-13 21:51:13 +0800588
Xiao Ma09b71022018-12-11 17:56:32 +0900589 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr}));
Ken Chenb9fa2062018-11-13 21:51:13 +0800590 dns.clearQueries();
591 dns2.clearQueries();
592
593 ScopedAddrinfo result = safe_getaddrinfo("howdy", nullptr, nullptr);
594 EXPECT_TRUE(result != nullptr);
595 size_t found = GetNumQueries(dns, host_name);
596 EXPECT_LE(1U, found);
597 // Could be A or AAAA
598 std::string result_str = ToString(result);
599 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
Luke Huangf8215372019-11-22 11:53:41 +0800600 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +0800601
602 // Verify that the name is cached.
603 size_t old_found = found;
604 result = safe_getaddrinfo("howdy", nullptr, nullptr);
605 EXPECT_TRUE(result != nullptr);
606 found = GetNumQueries(dns, host_name);
607 EXPECT_LE(1U, found);
608 EXPECT_EQ(old_found, found);
609 result_str = ToString(result);
Luke Huangf8215372019-11-22 11:53:41 +0800610 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4") << result_str;
Ken Chenb9fa2062018-11-13 21:51:13 +0800611
612 // Change the DNS resolver, ensure that queries are still cached.
Xiao Ma09b71022018-12-11 17:56:32 +0900613 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr2}));
Ken Chenb9fa2062018-11-13 21:51:13 +0800614 dns.clearQueries();
615 dns2.clearQueries();
616
617 result = safe_getaddrinfo("howdy", nullptr, nullptr);
618 EXPECT_TRUE(result != nullptr);
619 found = GetNumQueries(dns, host_name);
620 size_t found2 = GetNumQueries(dns2, host_name);
621 EXPECT_EQ(0U, found);
622 EXPECT_LE(0U, found2);
623
624 // Could be A or AAAA
625 result_str = ToString(result);
626 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
Luke Huangf8215372019-11-22 11:53:41 +0800627 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +0800628}
629
630TEST_F(ResolverTest, GetAddrInfoV4) {
Xiao Ma09b71022018-12-11 17:56:32 +0900631 test::DNSResponder dns;
632 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, "1.2.3.5"}});
633 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800634
Xiao Ma09b71022018-12-11 17:56:32 +0900635 const addrinfo hints = {.ai_family = AF_INET};
636 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
Ken Chenb9fa2062018-11-13 21:51:13 +0800637 EXPECT_TRUE(result != nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900638 EXPECT_EQ(1U, GetNumQueries(dns, kHelloExampleCom));
Ken Chenb9fa2062018-11-13 21:51:13 +0800639 EXPECT_EQ("1.2.3.5", ToString(result));
640}
641
642TEST_F(ResolverTest, GetAddrInfo_localhost) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800643 // Add a dummy nameserver which shouldn't receive any queries
Xiao Ma09b71022018-12-11 17:56:32 +0900644 test::DNSResponder dns;
645 StartDns(dns, {});
646 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800647
Xiao Ma09b71022018-12-11 17:56:32 +0900648 ScopedAddrinfo result = safe_getaddrinfo(kLocalHost, nullptr, nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800649 EXPECT_TRUE(result != nullptr);
650 // Expect no DNS queries; localhost is resolved via /etc/hosts
651 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900652 EXPECT_EQ(kLocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800653
Xiao Ma09b71022018-12-11 17:56:32 +0900654 result = safe_getaddrinfo(kIp6LocalHost, nullptr, nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800655 EXPECT_TRUE(result != nullptr);
656 // Expect no DNS queries; ip6-localhost is resolved via /etc/hosts
657 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900658 EXPECT_EQ(kIp6LocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800659}
660
Luke Huangd8ac4752019-06-18 17:05:47 +0800661TEST_F(ResolverTest, GetAddrInfo_InvalidSocketType) {
662 test::DNSResponder dns;
663 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, "1.2.3.5"}});
664 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
665
666 // TODO: Test other invalid socket types.
667 const addrinfo hints = {
668 .ai_family = AF_UNSPEC,
Luke Huangd8ac4752019-06-18 17:05:47 +0800669 .ai_socktype = SOCK_PACKET,
670 };
671 addrinfo* result = nullptr;
672 // This is a valid hint, but the query won't be sent because the socket type is
673 // not supported.
674 EXPECT_EQ(EAI_NODATA, getaddrinfo("hello", nullptr, &hints, &result));
675 ScopedAddrinfo result_cleanup(result);
676 EXPECT_EQ(nullptr, result);
677}
678
Ken Chen92bed612018-12-22 21:46:55 +0800679// Verify if the resolver correctly handle multiple queries simultaneously
680// step 1: set dns server#1 into deferred responding mode.
681// step 2: thread#1 query "hello.example.com." --> resolver send query to server#1.
682// step 3: thread#2 query "hello.example.com." --> resolver hold the request and wait for
683// response of previous pending query sent by thread#1.
684// step 4: thread#3 query "konbanha.example.com." --> resolver send query to server#3. Server
685// respond to resolver immediately.
686// step 5: check if server#1 get 1 query by thread#1, server#2 get 0 query, server#3 get 1 query.
687// step 6: resume dns server#1 to respond dns query in step#2.
688// step 7: thread#1 and #2 should get returned from DNS query after step#6. Also, check the
689// number of queries in server#2 is 0 to ensure thread#2 does not wake up unexpectedly
690// before signaled by thread#1.
691TEST_F(ResolverTest, GetAddrInfoV4_deferred_resp) {
692 const char* listen_addr1 = "127.0.0.9";
693 const char* listen_addr2 = "127.0.0.10";
694 const char* listen_addr3 = "127.0.0.11";
695 const char* listen_srv = "53";
696 const char* host_name_deferred = "hello.example.com.";
697 const char* host_name_normal = "konbanha.example.com.";
Mike Yufc125e42019-05-15 20:41:28 +0800698 test::DNSResponder dns1(listen_addr1, listen_srv, ns_rcode::ns_r_servfail);
699 test::DNSResponder dns2(listen_addr2, listen_srv, ns_rcode::ns_r_servfail);
700 test::DNSResponder dns3(listen_addr3, listen_srv, ns_rcode::ns_r_servfail);
Ken Chen92bed612018-12-22 21:46:55 +0800701 dns1.addMapping(host_name_deferred, ns_type::ns_t_a, "1.2.3.4");
702 dns2.addMapping(host_name_deferred, ns_type::ns_t_a, "1.2.3.4");
703 dns3.addMapping(host_name_normal, ns_type::ns_t_a, "1.2.3.5");
704 ASSERT_TRUE(dns1.startServer());
705 ASSERT_TRUE(dns2.startServer());
706 ASSERT_TRUE(dns3.startServer());
707 const std::vector<std::string> servers_for_t1 = {listen_addr1};
708 const std::vector<std::string> servers_for_t2 = {listen_addr2};
709 const std::vector<std::string> servers_for_t3 = {listen_addr3};
710 addrinfo hints = {.ai_family = AF_INET};
711 const std::vector<int> params = {300, 25, 8, 8, 5000};
712 bool t3_task_done = false;
713
714 dns1.setDeferredResp(true);
715 std::thread t1([&, this]() {
716 ASSERT_TRUE(
717 mDnsClient.SetResolversForNetwork(servers_for_t1, kDefaultSearchDomains, params));
718 ScopedAddrinfo result = safe_getaddrinfo(host_name_deferred, nullptr, &hints);
719 // t3's dns query should got returned first
720 EXPECT_TRUE(t3_task_done);
721 EXPECT_EQ(1U, GetNumQueries(dns1, host_name_deferred));
722 EXPECT_TRUE(result != nullptr);
723 EXPECT_EQ("1.2.3.4", ToString(result));
724 });
725
726 // ensuring t1 and t2 handler functions are processed in order
727 usleep(100 * 1000);
728 std::thread t2([&, this]() {
729 ASSERT_TRUE(
730 mDnsClient.SetResolversForNetwork(servers_for_t2, kDefaultSearchDomains, params));
731 ScopedAddrinfo result = safe_getaddrinfo(host_name_deferred, nullptr, &hints);
732 EXPECT_TRUE(t3_task_done);
733 EXPECT_EQ(0U, GetNumQueries(dns2, host_name_deferred));
734 EXPECT_TRUE(result != nullptr);
735 EXPECT_EQ("1.2.3.4", ToString(result));
736
737 std::vector<std::string> res_servers;
738 std::vector<std::string> res_domains;
739 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +0900740 res_params res_params;
Ken Chen92bed612018-12-22 21:46:55 +0800741 std::vector<ResolverStats> res_stats;
742 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +0800743 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
744 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
745 &res_tls_servers, &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chen92bed612018-12-22 21:46:55 +0800746 EXPECT_EQ(0, wait_for_pending_req_timeout_count);
747 });
748
749 // ensuring t2 and t3 handler functions are processed in order
750 usleep(100 * 1000);
751 std::thread t3([&, this]() {
752 ASSERT_TRUE(
753 mDnsClient.SetResolversForNetwork(servers_for_t3, kDefaultSearchDomains, params));
754 ScopedAddrinfo result = safe_getaddrinfo(host_name_normal, nullptr, &hints);
755 EXPECT_EQ(1U, GetNumQueries(dns1, host_name_deferred));
756 EXPECT_EQ(0U, GetNumQueries(dns2, host_name_deferred));
757 EXPECT_EQ(1U, GetNumQueries(dns3, host_name_normal));
758 EXPECT_TRUE(result != nullptr);
759 EXPECT_EQ("1.2.3.5", ToString(result));
760
761 t3_task_done = true;
762 dns1.setDeferredResp(false);
763 });
764 t3.join();
765 t1.join();
766 t2.join();
767}
768
lifr4e4a2e02019-01-29 16:53:51 +0800769TEST_F(ResolverTest, GetAddrInfo_cnames) {
770 constexpr char host_name[] = "host.example.com.";
771 test::DNSResponder dns;
772 const std::vector<DnsRecord> records = {
773 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
774 {"a.example.com.", ns_type::ns_t_cname, "b.example.com."},
775 {"b.example.com.", ns_type::ns_t_cname, "c.example.com."},
776 {"c.example.com.", ns_type::ns_t_cname, "d.example.com."},
777 {"d.example.com.", ns_type::ns_t_cname, "e.example.com."},
778 {"e.example.com.", ns_type::ns_t_cname, host_name},
779 {host_name, ns_type::ns_t_a, "1.2.3.3"},
780 {host_name, ns_type::ns_t_aaaa, "2001:db8::42"},
781 };
782 StartDns(dns, records);
783 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
784
785 addrinfo hints = {.ai_family = AF_INET};
786 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
787 EXPECT_TRUE(result != nullptr);
788 EXPECT_EQ("1.2.3.3", ToString(result));
789
790 dns.clearQueries();
791 hints = {.ai_family = AF_INET6};
792 result = safe_getaddrinfo("hello", nullptr, &hints);
793 EXPECT_TRUE(result != nullptr);
794 EXPECT_EQ("2001:db8::42", ToString(result));
795}
796
797TEST_F(ResolverTest, GetAddrInfo_cnamesNoIpAddress) {
798 test::DNSResponder dns;
799 const std::vector<DnsRecord> records = {
800 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
801 };
802 StartDns(dns, records);
803 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
804
805 addrinfo hints = {.ai_family = AF_INET};
806 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
807 EXPECT_TRUE(result == nullptr);
808
809 dns.clearQueries();
810 hints = {.ai_family = AF_INET6};
811 result = safe_getaddrinfo("hello", nullptr, &hints);
812 EXPECT_TRUE(result == nullptr);
813}
814
815TEST_F(ResolverTest, GetAddrInfo_cnamesIllegalRdata) {
816 test::DNSResponder dns;
817 const std::vector<DnsRecord> records = {
818 {kHelloExampleCom, ns_type::ns_t_cname, ".!#?"},
819 };
820 StartDns(dns, records);
821 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
822
823 addrinfo hints = {.ai_family = AF_INET};
824 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
825 EXPECT_TRUE(result == nullptr);
826
827 dns.clearQueries();
828 hints = {.ai_family = AF_INET6};
829 result = safe_getaddrinfo("hello", nullptr, &hints);
830 EXPECT_TRUE(result == nullptr);
831}
832
Ken Chenb9fa2062018-11-13 21:51:13 +0800833TEST_F(ResolverTest, MultidomainResolution) {
Xiao Ma09b71022018-12-11 17:56:32 +0900834 constexpr char host_name[] = "nihao.example2.com.";
Luke Huangf8215372019-11-22 11:53:41 +0800835 std::vector<std::string> searchDomains = {"example1.com", "example2.com", "example3.com"};
Ken Chenb9fa2062018-11-13 21:51:13 +0800836
Xiao Ma09b71022018-12-11 17:56:32 +0900837 test::DNSResponder dns("127.0.0.6");
838 StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.3"}});
839 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({"127.0.0.6"}, searchDomains));
840
Ken Chenb9fa2062018-11-13 21:51:13 +0800841 const hostent* result = gethostbyname("nihao");
Xiao Ma09b71022018-12-11 17:56:32 +0900842
Ken Chenb9fa2062018-11-13 21:51:13 +0800843 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
844 ASSERT_FALSE(result == nullptr);
845 ASSERT_EQ(4, result->h_length);
846 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
847 EXPECT_EQ("1.2.3.3", ToString(result));
848 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800849}
850
851TEST_F(ResolverTest, GetAddrInfoV6_numeric) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800852 constexpr char host_name[] = "ohayou.example.com.";
853 constexpr char numeric_addr[] = "fe80::1%lo";
854
Xiao Ma09b71022018-12-11 17:56:32 +0900855 test::DNSResponder dns;
Ken Chenb9fa2062018-11-13 21:51:13 +0800856 dns.setResponseProbability(0.0);
Xiao Ma09b71022018-12-11 17:56:32 +0900857 StartDns(dns, {{host_name, ns_type::ns_t_aaaa, "2001:db8::5"}});
858 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800859
860 addrinfo hints = {.ai_family = AF_INET6};
861 ScopedAddrinfo result = safe_getaddrinfo(numeric_addr, nullptr, &hints);
862 EXPECT_TRUE(result != nullptr);
863 EXPECT_EQ(numeric_addr, ToString(result));
864 EXPECT_TRUE(dns.queries().empty()); // Ensure no DNS queries were sent out
865
866 // Now try a non-numeric hostname query with the AI_NUMERICHOST flag set.
867 // We should fail without sending out a DNS query.
868 hints.ai_flags |= AI_NUMERICHOST;
869 result = safe_getaddrinfo(host_name, nullptr, &hints);
870 EXPECT_TRUE(result == nullptr);
871 EXPECT_TRUE(dns.queries().empty()); // Ensure no DNS queries were sent out
872}
873
874TEST_F(ResolverTest, GetAddrInfoV6_failing) {
Xiao Ma09b71022018-12-11 17:56:32 +0900875 constexpr char listen_addr0[] = "127.0.0.7";
876 constexpr char listen_addr1[] = "127.0.0.8";
Ken Chenb9fa2062018-11-13 21:51:13 +0800877 const char* host_name = "ohayou.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +0900878
879 test::DNSResponder dns0(listen_addr0);
880 test::DNSResponder dns1(listen_addr1);
Ken Chenb9fa2062018-11-13 21:51:13 +0800881 dns0.setResponseProbability(0.0);
Xiao Ma09b71022018-12-11 17:56:32 +0900882 StartDns(dns0, {{host_name, ns_type::ns_t_aaaa, "2001:db8::5"}});
883 StartDns(dns1, {{host_name, ns_type::ns_t_aaaa, "2001:db8::6"}});
884
Luke Huangf8215372019-11-22 11:53:41 +0800885 std::vector<std::string> servers = {listen_addr0, listen_addr1};
Ken Chenb9fa2062018-11-13 21:51:13 +0800886 // <sample validity in s> <success threshold in percent> <min samples> <max samples>
887 int sample_count = 8;
Luke Huangf8215372019-11-22 11:53:41 +0800888 const std::vector<int> params = {300, 25, sample_count, sample_count};
Xiao Ma09b71022018-12-11 17:56:32 +0900889 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, kDefaultSearchDomains, params));
Ken Chenb9fa2062018-11-13 21:51:13 +0800890
891 // Repeatedly perform resolutions for non-existing domains until MAXNSSAMPLES resolutions have
892 // reached the dns0, which is set to fail. No more requests should then arrive at that server
893 // for the next sample_lifetime seconds.
894 // TODO: This approach is implementation-dependent, change once metrics reporting is available.
Xiao Ma09b71022018-12-11 17:56:32 +0900895 const addrinfo hints = {.ai_family = AF_INET6};
Bernie Innocentib102dd22018-12-04 14:57:48 +0900896 for (int i = 0; i < sample_count; ++i) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800897 std::string domain = StringPrintf("nonexistent%d", i);
898 ScopedAddrinfo result = safe_getaddrinfo(domain.c_str(), nullptr, &hints);
899 }
900 // Due to 100% errors for all possible samples, the server should be ignored from now on and
901 // only the second one used for all following queries, until NSSAMPLE_VALIDITY is reached.
902 dns0.clearQueries();
903 dns1.clearQueries();
904 ScopedAddrinfo result = safe_getaddrinfo("ohayou", nullptr, &hints);
905 EXPECT_TRUE(result != nullptr);
906 EXPECT_EQ(0U, GetNumQueries(dns0, host_name));
907 EXPECT_EQ(1U, GetNumQueries(dns1, host_name));
908}
909
910TEST_F(ResolverTest, GetAddrInfoV6_nonresponsive) {
Xiao Ma09b71022018-12-11 17:56:32 +0900911 constexpr char listen_addr0[] = "127.0.0.7";
912 constexpr char listen_addr1[] = "127.0.0.8";
913 constexpr char listen_srv[] = "53";
914 constexpr char host_name1[] = "ohayou.example.com.";
915 constexpr char host_name2[] = "ciao.example.com.";
Luke Huang483cf332019-06-03 17:24:51 +0800916 const std::vector<std::string> defaultSearchDomain = {"example.com"};
917 // The minimal timeout is 1000ms, so we can't decrease timeout
918 // So reduce retry count.
919 const std::vector<int> reduceRetryParams = {
920 300, // sample validity in seconds
921 25, // success threshod in percent
922 8, 8, // {MIN,MAX}_SAMPLES
923 1000, // BASE_TIMEOUT_MSEC
924 1, // retry count
925 };
Xiao Ma09b71022018-12-11 17:56:32 +0900926 const std::vector<DnsRecord> records0 = {
927 {host_name1, ns_type::ns_t_aaaa, "2001:db8::5"},
928 {host_name2, ns_type::ns_t_aaaa, "2001:db8::5"},
929 };
930 const std::vector<DnsRecord> records1 = {
931 {host_name1, ns_type::ns_t_aaaa, "2001:db8::6"},
932 {host_name2, ns_type::ns_t_aaaa, "2001:db8::6"},
933 };
Ken Chenb9fa2062018-11-13 21:51:13 +0800934
935 // dns0 does not respond with 100% probability, while
936 // dns1 responds normally, at least initially.
Mike Yufc125e42019-05-15 20:41:28 +0800937 test::DNSResponder dns0(listen_addr0, listen_srv, static_cast<ns_rcode>(-1));
938 test::DNSResponder dns1(listen_addr1, listen_srv, static_cast<ns_rcode>(-1));
Ken Chenb9fa2062018-11-13 21:51:13 +0800939 dns0.setResponseProbability(0.0);
Xiao Ma09b71022018-12-11 17:56:32 +0900940 StartDns(dns0, records0);
941 StartDns(dns1, records1);
Luke Huang483cf332019-06-03 17:24:51 +0800942 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr0, listen_addr1}, defaultSearchDomain,
943 reduceRetryParams));
Ken Chenb9fa2062018-11-13 21:51:13 +0800944
Luke Huang483cf332019-06-03 17:24:51 +0800945 // Specify ai_socktype to make getaddrinfo will only query 1 time
946 const addrinfo hints = {.ai_family = AF_INET6, .ai_socktype = SOCK_STREAM};
Ken Chenb9fa2062018-11-13 21:51:13 +0800947
948 // dns0 will ignore the request, and we'll fallback to dns1 after the first
949 // retry.
950 ScopedAddrinfo result = safe_getaddrinfo(host_name1, nullptr, &hints);
951 EXPECT_TRUE(result != nullptr);
952 EXPECT_EQ(1U, GetNumQueries(dns0, host_name1));
953 EXPECT_EQ(1U, GetNumQueries(dns1, host_name1));
954
955 // Now make dns1 also ignore 100% requests... The resolve should alternate
Luke Huang483cf332019-06-03 17:24:51 +0800956 // queries between the nameservers and fail
Ken Chenb9fa2062018-11-13 21:51:13 +0800957 dns1.setResponseProbability(0.0);
958 addrinfo* result2 = nullptr;
959 EXPECT_EQ(EAI_NODATA, getaddrinfo(host_name2, nullptr, &hints, &result2));
960 EXPECT_EQ(nullptr, result2);
Luke Huang483cf332019-06-03 17:24:51 +0800961 EXPECT_EQ(1U, GetNumQueries(dns0, host_name2));
962 EXPECT_EQ(1U, GetNumQueries(dns1, host_name2));
Ken Chenb9fa2062018-11-13 21:51:13 +0800963}
964
965TEST_F(ResolverTest, GetAddrInfoV6_concurrent) {
Xiao Ma09b71022018-12-11 17:56:32 +0900966 constexpr char listen_addr0[] = "127.0.0.9";
967 constexpr char listen_addr1[] = "127.0.0.10";
968 constexpr char listen_addr2[] = "127.0.0.11";
969 constexpr char host_name[] = "konbanha.example.com.";
970
971 test::DNSResponder dns0(listen_addr0);
972 test::DNSResponder dns1(listen_addr1);
973 test::DNSResponder dns2(listen_addr2);
974 StartDns(dns0, {{host_name, ns_type::ns_t_aaaa, "2001:db8::5"}});
975 StartDns(dns1, {{host_name, ns_type::ns_t_aaaa, "2001:db8::6"}});
976 StartDns(dns2, {{host_name, ns_type::ns_t_aaaa, "2001:db8::7"}});
977
Luke Huangf8215372019-11-22 11:53:41 +0800978 const std::vector<std::string> servers = {listen_addr0, listen_addr1, listen_addr2};
Ken Chenb9fa2062018-11-13 21:51:13 +0800979 std::vector<std::thread> threads(10);
980 for (std::thread& thread : threads) {
Luke Huangf8215372019-11-22 11:53:41 +0800981 thread = std::thread([this, &servers]() {
982 unsigned delay = arc4random_uniform(1 * 1000 * 1000); // <= 1s
Ken Chenb9fa2062018-11-13 21:51:13 +0800983 usleep(delay);
984 std::vector<std::string> serverSubset;
985 for (const auto& server : servers) {
986 if (arc4random_uniform(2)) {
987 serverSubset.push_back(server);
988 }
989 }
990 if (serverSubset.empty()) serverSubset = servers;
Xiao Ma09b71022018-12-11 17:56:32 +0900991 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(serverSubset));
992 const addrinfo hints = {.ai_family = AF_INET6};
Ken Chenb9fa2062018-11-13 21:51:13 +0800993 addrinfo* result = nullptr;
994 int rv = getaddrinfo("konbanha", nullptr, &hints, &result);
995 EXPECT_EQ(0, rv) << "error [" << rv << "] " << gai_strerror(rv);
996 if (result) {
997 freeaddrinfo(result);
998 result = nullptr;
999 }
1000 });
1001 }
1002 for (std::thread& thread : threads) {
1003 thread.join();
1004 }
Ken Chen92bed612018-12-22 21:46:55 +08001005
1006 std::vector<std::string> res_servers;
1007 std::vector<std::string> res_domains;
1008 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +09001009 res_params res_params;
Ken Chen92bed612018-12-22 21:46:55 +08001010 std::vector<ResolverStats> res_stats;
1011 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001012 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
1013 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
1014 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chen92bed612018-12-22 21:46:55 +08001015 EXPECT_EQ(0, wait_for_pending_req_timeout_count);
Ken Chenb9fa2062018-11-13 21:51:13 +08001016}
1017
Mike Yu8ac63402019-12-02 15:28:38 +08001018TEST_F(ResolverTest, SkipBadServersDueToInternalError) {
1019 constexpr char listen_addr1[] = "fe80::1";
1020 constexpr char listen_addr2[] = "255.255.255.255";
1021 constexpr char listen_addr3[] = "127.0.0.3";
1022
1023 test::DNSResponder dns(listen_addr3);
1024 ASSERT_TRUE(dns.startServer());
1025
1026 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
1027 parcel.servers = {listen_addr1, listen_addr2, listen_addr3};
1028
1029 // Bad servers can be distinguished after two attempts.
1030 parcel.minSamples = 2;
1031 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
1032
1033 // Start querying five times.
1034 for (int i = 0; i < 5; i++) {
1035 std::string hostName = StringPrintf("hello%d.com.", i);
1036 dns.addMapping(hostName, ns_type::ns_t_a, "1.2.3.4");
1037 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
1038 EXPECT_TRUE(safe_getaddrinfo(hostName.c_str(), nullptr, &hints) != nullptr);
1039 }
1040
Mike Yuc0000252020-03-19 07:14:23 +00001041 const std::vector<NameserverStats> expectedCleartextDnsStats = {
1042 NameserverStats(listen_addr1).setInternalErrors(2),
1043 NameserverStats(listen_addr2).setInternalErrors(2),
1044 NameserverStats(listen_addr3).setSuccesses(5),
1045 };
1046 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
Mike Yu8ac63402019-12-02 15:28:38 +08001047}
1048
1049TEST_F(ResolverTest, SkipBadServersDueToTimeout) {
1050 constexpr char listen_addr1[] = "127.0.0.3";
1051 constexpr char listen_addr2[] = "127.0.0.4";
1052
1053 // Set dns1 non-responsive and dns2 workable.
1054 test::DNSResponder dns1(listen_addr1, test::kDefaultListenService, static_cast<ns_rcode>(-1));
1055 test::DNSResponder dns2(listen_addr2);
1056 dns1.setResponseProbability(0.0);
1057 ASSERT_TRUE(dns1.startServer());
1058 ASSERT_TRUE(dns2.startServer());
1059
1060 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
1061 parcel.servers = {listen_addr1, listen_addr2};
1062
1063 // Bad servers can be distinguished after two attempts.
1064 parcel.minSamples = 2;
1065 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
1066
1067 // Start querying five times.
1068 for (int i = 0; i < 5; i++) {
1069 std::string hostName = StringPrintf("hello%d.com.", i);
1070 dns1.addMapping(hostName, ns_type::ns_t_a, "1.2.3.4");
1071 dns2.addMapping(hostName, ns_type::ns_t_a, "1.2.3.5");
1072 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
1073 EXPECT_TRUE(safe_getaddrinfo(hostName.c_str(), nullptr, &hints) != nullptr);
1074 }
1075
Mike Yuc0000252020-03-19 07:14:23 +00001076 const std::vector<NameserverStats> expectedCleartextDnsStats = {
1077 NameserverStats(listen_addr1).setTimeouts(2),
1078 NameserverStats(listen_addr2).setSuccesses(5),
1079 };
1080 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
Mike Yu8ac63402019-12-02 15:28:38 +08001081 EXPECT_EQ(dns1.queries().size(), 2U);
1082 EXPECT_EQ(dns2.queries().size(), 5U);
1083}
1084
chenbrucefd837fa2019-10-29 18:35:36 +08001085TEST_F(ResolverTest, GetAddrInfoFromCustTable_InvalidInput) {
1086 constexpr char hostnameNoip[] = "noip.example.com.";
1087 constexpr char hostnameInvalidip[] = "invalidip.example.com.";
1088 const std::vector<aidl::android::net::ResolverHostsParcel> invalidCustHosts = {
1089 {"", hostnameNoip},
1090 {"wrong IP", hostnameInvalidip},
1091 };
1092 test::DNSResponder dns;
1093 StartDns(dns, {});
1094 auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
Ken Chen05420812020-04-07 18:58:38 +00001095 resolverParams.resolverOptions.hosts = invalidCustHosts;
chenbrucefd837fa2019-10-29 18:35:36 +08001096 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1097 for (const auto& hostname : {hostnameNoip, hostnameInvalidip}) {
1098 // The query won't get data from customized table because of invalid customized table
1099 // and DNSResponder also has no records. hostnameNoip has never registered and
1100 // hostnameInvalidip has registered but wrong IP.
1101 const addrinfo hints = {.ai_family = AF_UNSPEC};
1102 ScopedAddrinfo result = safe_getaddrinfo(hostname, nullptr, &hints);
1103 ASSERT_TRUE(result == nullptr);
1104 EXPECT_EQ(4U, GetNumQueries(dns, hostname));
1105 }
1106}
1107
1108TEST_F(ResolverTest, GetAddrInfoFromCustTable) {
1109 constexpr char hostnameV4[] = "v4only.example.com.";
1110 constexpr char hostnameV6[] = "v6only.example.com.";
1111 constexpr char hostnameV4V6[] = "v4v6.example.com.";
1112 constexpr char custAddrV4[] = "1.2.3.4";
1113 constexpr char custAddrV6[] = "::1.2.3.4";
1114 constexpr char dnsSvAddrV4[] = "1.2.3.5";
1115 constexpr char dnsSvAddrV6[] = "::1.2.3.5";
1116 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV4 = {
1117 {custAddrV4, hostnameV4},
1118 };
1119 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV6 = {
1120 {custAddrV6, hostnameV6},
1121 };
1122 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV4V6 = {
1123 {custAddrV4, hostnameV4V6},
1124 {custAddrV6, hostnameV4V6},
1125 };
1126 const std::vector<DnsRecord> dnsSvHostV4 = {
1127 {hostnameV4, ns_type::ns_t_a, dnsSvAddrV4},
1128 };
1129 const std::vector<DnsRecord> dnsSvHostV6 = {
1130 {hostnameV6, ns_type::ns_t_aaaa, dnsSvAddrV6},
1131 };
1132 const std::vector<DnsRecord> dnsSvHostV4V6 = {
1133 {hostnameV4V6, ns_type::ns_t_a, dnsSvAddrV4},
1134 {hostnameV4V6, ns_type::ns_t_aaaa, dnsSvAddrV6},
1135 };
1136 struct TestConfig {
1137 const std::string name;
1138 const std::vector<aidl::android::net::ResolverHostsParcel> customizedHosts;
1139 const std::vector<DnsRecord> dnsserverHosts;
1140 const std::vector<std::string> queryResult;
1141 std::string asParameters() const {
1142 return StringPrintf("name: %s, customizedHosts: %s, dnsserverHosts: %s", name.c_str(),
1143 customizedHosts.empty() ? "No" : "Yes",
1144 dnsserverHosts.empty() ? "No" : "Yes");
1145 }
1146 } testConfigs[]{
1147 // clang-format off
1148 {hostnameV4, {}, {}, {}},
1149 {hostnameV4, {}, dnsSvHostV4, {dnsSvAddrV4}},
1150 {hostnameV4, custHostV4, {}, {custAddrV4}},
1151 {hostnameV4, custHostV4, dnsSvHostV4, {custAddrV4}},
1152 {hostnameV6, {}, {}, {}},
1153 {hostnameV6, {}, dnsSvHostV6, {dnsSvAddrV6}},
1154 {hostnameV6, custHostV6, {}, {custAddrV6}},
1155 {hostnameV6, custHostV6, dnsSvHostV6, {custAddrV6}},
1156 {hostnameV4V6, {}, {}, {}},
1157 {hostnameV4V6, {}, dnsSvHostV4V6, {dnsSvAddrV4, dnsSvAddrV6}},
1158 {hostnameV4V6, custHostV4V6, {}, {custAddrV4, custAddrV6}},
1159 {hostnameV4V6, custHostV4V6, dnsSvHostV4V6, {custAddrV4, custAddrV6}},
1160 // clang-format on
1161 };
1162
1163 for (const auto& config : testConfigs) {
1164 SCOPED_TRACE(config.asParameters());
1165
1166 test::DNSResponder dns;
1167 StartDns(dns, config.dnsserverHosts);
1168
1169 auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
Ken Chen05420812020-04-07 18:58:38 +00001170 resolverParams.resolverOptions.hosts = config.customizedHosts;
chenbrucefd837fa2019-10-29 18:35:36 +08001171 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1172 const addrinfo hints = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM};
1173 ScopedAddrinfo result = safe_getaddrinfo(config.name.c_str(), nullptr, &hints);
1174 if (config.customizedHosts.empty() && config.dnsserverHosts.empty()) {
1175 ASSERT_TRUE(result == nullptr);
1176 EXPECT_EQ(2U, GetNumQueries(dns, config.name.c_str()));
1177 } else {
1178 ASSERT_TRUE(result != nullptr);
1179 EXPECT_THAT(ToStrings(result), testing::UnorderedElementsAreArray(config.queryResult));
1180 EXPECT_EQ(config.customizedHosts.empty() ? 2U : 0U,
1181 GetNumQueries(dns, config.name.c_str()));
1182 }
1183
1184 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
1185 }
1186}
1187
1188TEST_F(ResolverTest, GetAddrInfoFromCustTable_Modify) {
1189 constexpr char hostnameV4V6[] = "v4v6.example.com.";
1190 constexpr char custAddrV4[] = "1.2.3.4";
1191 constexpr char custAddrV6[] = "::1.2.3.4";
1192 constexpr char dnsSvAddrV4[] = "1.2.3.5";
1193 constexpr char dnsSvAddrV6[] = "::1.2.3.5";
1194 const std::vector<DnsRecord> dnsSvHostV4V6 = {
1195 {hostnameV4V6, ns_type::ns_t_a, dnsSvAddrV4},
1196 {hostnameV4V6, ns_type::ns_t_aaaa, dnsSvAddrV6},
1197 };
1198 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV4V6 = {
1199 {custAddrV4, hostnameV4V6},
1200 {custAddrV6, hostnameV4V6},
1201 };
1202 test::DNSResponder dns;
1203 StartDns(dns, dnsSvHostV4V6);
1204 auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
1205
Ken Chen05420812020-04-07 18:58:38 +00001206 resolverParams.resolverOptions.hosts = custHostV4V6;
chenbrucefd837fa2019-10-29 18:35:36 +08001207 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1208 const addrinfo hints = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM};
1209 ScopedAddrinfo result = safe_getaddrinfo(hostnameV4V6, nullptr, &hints);
1210 ASSERT_TRUE(result != nullptr);
1211 EXPECT_THAT(ToStrings(result), testing::UnorderedElementsAreArray({custAddrV4, custAddrV6}));
1212 EXPECT_EQ(0U, GetNumQueries(dns, hostnameV4V6));
1213
Ken Chen05420812020-04-07 18:58:38 +00001214 resolverParams.resolverOptions.hosts = {};
chenbrucefd837fa2019-10-29 18:35:36 +08001215 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1216 result = safe_getaddrinfo(hostnameV4V6, nullptr, &hints);
1217 ASSERT_TRUE(result != nullptr);
1218 EXPECT_THAT(ToStrings(result), testing::UnorderedElementsAreArray({dnsSvAddrV4, dnsSvAddrV6}));
1219 EXPECT_EQ(2U, GetNumQueries(dns, hostnameV4V6));
1220}
1221
Ken Chenb9fa2062018-11-13 21:51:13 +08001222TEST_F(ResolverTest, EmptySetup) {
Ken Chenb9fa2062018-11-13 21:51:13 +08001223 std::vector<std::string> servers;
1224 std::vector<std::string> domains;
Xiao Ma09b71022018-12-11 17:56:32 +09001225 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
Ken Chenb9fa2062018-11-13 21:51:13 +08001226 std::vector<std::string> res_servers;
1227 std::vector<std::string> res_domains;
Mike Yu0a1c53d2018-11-26 13:26:21 +09001228 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +09001229 res_params res_params;
Ken Chenb9fa2062018-11-13 21:51:13 +08001230 std::vector<ResolverStats> res_stats;
Ken Chen92bed612018-12-22 21:46:55 +08001231 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001232 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
1233 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
1234 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chenb9fa2062018-11-13 21:51:13 +08001235 EXPECT_EQ(0U, res_servers.size());
1236 EXPECT_EQ(0U, res_domains.size());
Mike Yu0a1c53d2018-11-26 13:26:21 +09001237 EXPECT_EQ(0U, res_tls_servers.size());
Luke Huang5bd827c2019-03-14 16:10:04 +08001238 ASSERT_EQ(static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT), kDefaultParams.size());
1239 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY],
1240 res_params.sample_validity);
1241 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +09001242 res_params.success_threshold);
Luke Huang5bd827c2019-03-14 16:10:04 +08001243 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
1244 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
1245 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
Ken Chenb9fa2062018-11-13 21:51:13 +08001246 res_params.base_timeout_msec);
Luke Huang5bd827c2019-03-14 16:10:04 +08001247 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT], res_params.retry_count);
Ken Chenb9fa2062018-11-13 21:51:13 +08001248}
1249
1250TEST_F(ResolverTest, SearchPathChange) {
Xiao Ma09b71022018-12-11 17:56:32 +09001251 constexpr char listen_addr[] = "127.0.0.13";
1252 constexpr char host_name1[] = "test13.domain1.org.";
1253 constexpr char host_name2[] = "test13.domain2.org.";
Luke Huangf8215372019-11-22 11:53:41 +08001254 std::vector<std::string> servers = {listen_addr};
1255 std::vector<std::string> domains = {"domain1.org"};
Xiao Ma09b71022018-12-11 17:56:32 +09001256
1257 const std::vector<DnsRecord> records = {
1258 {host_name1, ns_type::ns_t_aaaa, "2001:db8::13"},
1259 {host_name2, ns_type::ns_t_aaaa, "2001:db8::1:13"},
1260 };
1261 test::DNSResponder dns(listen_addr);
1262 StartDns(dns, records);
1263 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
Ken Chenb9fa2062018-11-13 21:51:13 +08001264
1265 const addrinfo hints = {.ai_family = AF_INET6};
1266 ScopedAddrinfo result = safe_getaddrinfo("test13", nullptr, &hints);
1267 EXPECT_TRUE(result != nullptr);
1268 EXPECT_EQ(1U, dns.queries().size());
1269 EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
1270 EXPECT_EQ("2001:db8::13", ToString(result));
1271
1272 // Test that changing the domain search path on its own works.
Luke Huangf8215372019-11-22 11:53:41 +08001273 domains = {"domain2.org"};
Xiao Ma09b71022018-12-11 17:56:32 +09001274 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
Ken Chenb9fa2062018-11-13 21:51:13 +08001275 dns.clearQueries();
1276
1277 result = safe_getaddrinfo("test13", nullptr, &hints);
1278 EXPECT_TRUE(result != nullptr);
1279 EXPECT_EQ(1U, dns.queries().size());
1280 EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
1281 EXPECT_EQ("2001:db8::1:13", ToString(result));
1282}
1283
Luke Huang2dac4382019-06-24 13:28:44 +08001284namespace {
1285
Luke Huangf8215372019-11-22 11:53:41 +08001286std::vector<std::string> getResolverDomains(aidl::android::net::IDnsResolver* dnsResolverService,
Luke Huang2dac4382019-06-24 13:28:44 +08001287 unsigned netId) {
1288 std::vector<std::string> res_servers;
1289 std::vector<std::string> res_domains;
1290 std::vector<std::string> res_tls_servers;
1291 res_params res_params;
1292 std::vector<ResolverStats> res_stats;
1293 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001294 DnsResponderClient::GetResolverInfo(dnsResolverService, netId, &res_servers, &res_domains,
1295 &res_tls_servers, &res_params, &res_stats,
1296 &wait_for_pending_req_timeout_count);
Luke Huang2dac4382019-06-24 13:28:44 +08001297 return res_domains;
1298}
1299
1300} // namespace
1301
1302TEST_F(ResolverTest, SearchPathPrune) {
1303 constexpr size_t DUPLICATED_DOMAIN_NUM = 3;
1304 constexpr char listen_addr[] = "127.0.0.13";
1305 constexpr char domian_name1[] = "domain13.org.";
1306 constexpr char domian_name2[] = "domain14.org.";
1307 constexpr char host_name1[] = "test13.domain13.org.";
1308 constexpr char host_name2[] = "test14.domain14.org.";
1309 std::vector<std::string> servers = {listen_addr};
1310
1311 std::vector<std::string> testDomains1;
1312 std::vector<std::string> testDomains2;
1313 // Domain length should be <= 255
1314 // Max number of domains in search path is 6
1315 for (size_t i = 0; i < MAXDNSRCH + 1; i++) {
1316 // Fill up with invalid domain
1317 testDomains1.push_back(std::string(300, i + '0'));
1318 // Fill up with valid but duplicated domain
1319 testDomains2.push_back(StringPrintf("domain%zu.org", i % DUPLICATED_DOMAIN_NUM));
1320 }
1321
1322 // Add valid domain used for query.
1323 testDomains1.push_back(domian_name1);
1324
1325 // Add valid domain twice used for query.
1326 testDomains2.push_back(domian_name2);
1327 testDomains2.push_back(domian_name2);
1328
1329 const std::vector<DnsRecord> records = {
1330 {host_name1, ns_type::ns_t_aaaa, "2001:db8::13"},
1331 {host_name2, ns_type::ns_t_aaaa, "2001:db8::1:13"},
1332 };
1333 test::DNSResponder dns(listen_addr);
1334 StartDns(dns, records);
1335 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, testDomains1));
1336
1337 const addrinfo hints = {.ai_family = AF_INET6};
1338 ScopedAddrinfo result = safe_getaddrinfo("test13", nullptr, &hints);
1339
1340 EXPECT_TRUE(result != nullptr);
1341
1342 EXPECT_EQ(1U, dns.queries().size());
1343 EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
1344 EXPECT_EQ("2001:db8::13", ToString(result));
1345
1346 const auto& res_domains1 = getResolverDomains(mDnsClient.resolvService(), TEST_NETID);
1347 // Expect 1 valid domain, invalid domains are removed.
1348 ASSERT_EQ(1U, res_domains1.size());
1349 EXPECT_EQ(domian_name1, res_domains1[0]);
1350
1351 dns.clearQueries();
1352
1353 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, testDomains2));
1354
1355 result = safe_getaddrinfo("test14", nullptr, &hints);
1356 EXPECT_TRUE(result != nullptr);
1357
1358 // (3 domains * 2 retries) + 1 success query = 7
1359 EXPECT_EQ(7U, dns.queries().size());
1360 EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
1361 EXPECT_EQ("2001:db8::1:13", ToString(result));
1362
1363 const auto& res_domains2 = getResolverDomains(mDnsClient.resolvService(), TEST_NETID);
1364 // Expect 4 valid domain, duplicate domains are removed.
1365 EXPECT_EQ(DUPLICATED_DOMAIN_NUM + 1U, res_domains2.size());
1366 EXPECT_THAT(
1367 std::vector<std::string>({"domain0.org", "domain1.org", "domain2.org", domian_name2}),
1368 testing::ElementsAreArray(res_domains2));
1369}
1370
Mike Yu0a1c53d2018-11-26 13:26:21 +09001371// If we move this function to dns_responder_client, it will complicate the dependency need of
1372// dns_tls_frontend.h.
1373static void setupTlsServers(const std::vector<std::string>& servers,
waynema0e73c2e2019-07-31 15:04:08 +08001374 std::vector<std::unique_ptr<test::DnsTlsFrontend>>* tls) {
Xiao Ma09b71022018-12-11 17:56:32 +09001375 constexpr char listen_udp[] = "53";
1376 constexpr char listen_tls[] = "853";
Mike Yu0a1c53d2018-11-26 13:26:21 +09001377
1378 for (const auto& server : servers) {
1379 auto t = std::make_unique<test::DnsTlsFrontend>(server, listen_tls, server, listen_udp);
1380 t = std::make_unique<test::DnsTlsFrontend>(server, listen_tls, server, listen_udp);
1381 t->startServer();
Mike Yu0a1c53d2018-11-26 13:26:21 +09001382 tls->push_back(std::move(t));
1383 }
1384}
1385
Mike Yu0a1c53d2018-11-26 13:26:21 +09001386TEST_F(ResolverTest, MaxServerPrune_Binder) {
Mike Yu0a1c53d2018-11-26 13:26:21 +09001387 std::vector<std::string> domains;
1388 std::vector<std::unique_ptr<test::DNSResponder>> dns;
1389 std::vector<std::unique_ptr<test::DnsTlsFrontend>> tls;
1390 std::vector<std::string> servers;
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +09001391 std::vector<DnsResponderClient::Mapping> mappings;
Mike Yu0a1c53d2018-11-26 13:26:21 +09001392
1393 for (unsigned i = 0; i < MAXDNSRCH + 1; i++) {
1394 domains.push_back(StringPrintf("example%u.com", i));
1395 }
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +09001396 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupMappings(1, domains, &mappings));
1397 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupDNSServers(MAXNS + 1, mappings, &dns, &servers));
waynema0e73c2e2019-07-31 15:04:08 +08001398 ASSERT_NO_FATAL_FAILURE(setupTlsServers(servers, &tls));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001399
waynema0e73c2e2019-07-31 15:04:08 +08001400 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, domains, kDefaultParams,
1401 kDefaultPrivateDnsHostName));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001402
Mike Yu383855b2019-01-15 17:53:27 +08001403 // If the private DNS validation hasn't completed yet before backend DNS servers stop,
1404 // TLS servers will get stuck in handleOneRequest(), which causes this test stuck in
1405 // ~DnsTlsFrontend() because the TLS server loop threads can't be terminated.
1406 // So, wait for private DNS validation done before stopping backend DNS servers.
1407 for (int i = 0; i < MAXNS; i++) {
chenbruceaff85842019-05-31 15:46:42 +08001408 LOG(INFO) << "Waiting for private DNS validation on " << tls[i]->listen_address() << ".";
Mike Yu724f77d2019-08-16 11:14:50 +08001409 EXPECT_TRUE(WaitForPrivateDnsValidation(tls[i]->listen_address(), true));
chenbruceaff85842019-05-31 15:46:42 +08001410 LOG(INFO) << "private DNS validation on " << tls[i]->listen_address() << " done.";
Mike Yu383855b2019-01-15 17:53:27 +08001411 }
1412
Mike Yu0a1c53d2018-11-26 13:26:21 +09001413 std::vector<std::string> res_servers;
1414 std::vector<std::string> res_domains;
1415 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +09001416 res_params res_params;
Mike Yu0a1c53d2018-11-26 13:26:21 +09001417 std::vector<ResolverStats> res_stats;
Ken Chen92bed612018-12-22 21:46:55 +08001418 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001419 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
1420 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
1421 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001422
1423 // Check the size of the stats and its contents.
1424 EXPECT_EQ(static_cast<size_t>(MAXNS), res_servers.size());
1425 EXPECT_EQ(static_cast<size_t>(MAXNS), res_tls_servers.size());
1426 EXPECT_EQ(static_cast<size_t>(MAXDNSRCH), res_domains.size());
1427 EXPECT_TRUE(std::equal(servers.begin(), servers.begin() + MAXNS, res_servers.begin()));
1428 EXPECT_TRUE(std::equal(servers.begin(), servers.begin() + MAXNS, res_tls_servers.begin()));
1429 EXPECT_TRUE(std::equal(domains.begin(), domains.begin() + MAXDNSRCH, res_domains.begin()));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001430}
1431
1432TEST_F(ResolverTest, ResolverStats) {
Xiao Ma09b71022018-12-11 17:56:32 +09001433 constexpr char listen_addr1[] = "127.0.0.4";
1434 constexpr char listen_addr2[] = "127.0.0.5";
1435 constexpr char listen_addr3[] = "127.0.0.6";
Mike Yu0a1c53d2018-11-26 13:26:21 +09001436
1437 // Set server 1 timeout.
Mike Yufc125e42019-05-15 20:41:28 +08001438 test::DNSResponder dns1(listen_addr1, "53", static_cast<ns_rcode>(-1));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001439 dns1.setResponseProbability(0.0);
1440 ASSERT_TRUE(dns1.startServer());
1441
1442 // Set server 2 responding server failure.
Xiao Ma09b71022018-12-11 17:56:32 +09001443 test::DNSResponder dns2(listen_addr2);
Mike Yu0a1c53d2018-11-26 13:26:21 +09001444 dns2.setResponseProbability(0.0);
1445 ASSERT_TRUE(dns2.startServer());
1446
1447 // Set server 3 workable.
Xiao Ma09b71022018-12-11 17:56:32 +09001448 test::DNSResponder dns3(listen_addr3);
1449 dns3.addMapping(kHelloExampleCom, ns_type::ns_t_a, "1.2.3.4");
Mike Yu0a1c53d2018-11-26 13:26:21 +09001450 ASSERT_TRUE(dns3.startServer());
1451
1452 std::vector<std::string> servers = {listen_addr1, listen_addr2, listen_addr3};
Xiao Ma09b71022018-12-11 17:56:32 +09001453 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001454
1455 dns3.clearQueries();
Xiao Ma09b71022018-12-11 17:56:32 +09001456 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
Mike Yu0a1c53d2018-11-26 13:26:21 +09001457 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
Xiao Ma09b71022018-12-11 17:56:32 +09001458 size_t found = GetNumQueries(dns3, kHelloExampleCom);
Mike Yu0a1c53d2018-11-26 13:26:21 +09001459 EXPECT_LE(1U, found);
1460 std::string result_str = ToString(result);
1461 EXPECT_TRUE(result_str == "1.2.3.4") << ", result_str='" << result_str << "'";
1462
Mike Yuc0000252020-03-19 07:14:23 +00001463 const std::vector<NameserverStats> expectedCleartextDnsStats = {
1464 NameserverStats(listen_addr1).setTimeouts(1),
1465 NameserverStats(listen_addr2).setErrors(1),
1466 NameserverStats(listen_addr3).setSuccesses(1),
1467 };
1468 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001469}
1470
Mike Yu15791832020-02-11 13:38:48 +08001471TEST_F(ResolverTest, AlwaysUseLatestSetupParamsInLookups) {
1472 constexpr char listen_addr1[] = "127.0.0.3";
1473 constexpr char listen_addr2[] = "255.255.255.255";
1474 constexpr char listen_addr3[] = "127.0.0.4";
1475 constexpr char hostname[] = "hello";
1476 constexpr char fqdn_with_search_domain[] = "hello.domain2.com.";
1477
1478 test::DNSResponder dns1(listen_addr1, test::kDefaultListenService, static_cast<ns_rcode>(-1));
1479 dns1.setResponseProbability(0.0);
1480 ASSERT_TRUE(dns1.startServer());
1481
1482 test::DNSResponder dns3(listen_addr3);
1483 StartDns(dns3, {{fqdn_with_search_domain, ns_type::ns_t_a, "1.2.3.4"}});
1484
1485 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
1486 parcel.tlsServers.clear();
1487 parcel.servers = {listen_addr1, listen_addr2};
1488 parcel.domains = {"domain1.com", "domain2.com"};
1489 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
1490
1491 // Expect the things happening in t1:
1492 // 1. The lookup starts using the first domain for query. It sends queries to the populated
1493 // nameserver list {listen_addr1, listen_addr2} for the hostname "hello.domain1.com".
1494 // 2. A different list of nameservers is updated to the resolver. Revision ID is incremented.
1495 // 3. The query for the hostname times out. The lookup fails to add the timeout record to the
1496 // the stats because of the unmatched revision ID.
1497 // 4. The lookup starts using the second domain for query. It sends queries to the populated
1498 // nameserver list {listen_addr3, listen_addr1, listen_addr2} for another hostname
1499 // "hello.domain2.com".
1500 // 5. The lookup gets the answer and updates a success record to the stats.
1501 std::thread t1([&hostname]() {
1502 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
1503 ScopedAddrinfo result = safe_getaddrinfo(hostname, nullptr, &hints);
1504 EXPECT_NE(result.get(), nullptr);
1505 EXPECT_EQ(ToString(result), "1.2.3.4");
1506 });
1507
1508 // Wait for t1 to start the step 1.
1509 while (dns1.queries().size() == 0) {
1510 usleep(1000);
1511 }
1512
1513 // Update the resolver with three nameservers. This will increment the revision ID.
1514 parcel.servers = {listen_addr3, listen_addr1, listen_addr2};
1515 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
1516
1517 t1.join();
1518 EXPECT_EQ(0U, GetNumQueriesForType(dns3, ns_type::ns_t_aaaa, fqdn_with_search_domain));
1519 EXPECT_EQ(1U, GetNumQueriesForType(dns3, ns_type::ns_t_a, fqdn_with_search_domain));
1520
Mike Yuc0000252020-03-19 07:14:23 +00001521 const std::vector<NameserverStats> expectedCleartextDnsStats = {
1522 NameserverStats(listen_addr1),
1523 NameserverStats(listen_addr2),
1524 NameserverStats(listen_addr3).setSuccesses(1),
1525 };
1526 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
Mike Yu15791832020-02-11 13:38:48 +08001527}
1528
Ken Chenb9fa2062018-11-13 21:51:13 +08001529// Test what happens if the specified TLS server is nonexistent.
1530TEST_F(ResolverTest, GetHostByName_TlsMissing) {
Xiao Ma09b71022018-12-11 17:56:32 +09001531 constexpr char listen_addr[] = "127.0.0.3";
1532 constexpr char host_name[] = "tlsmissing.example.com.";
1533
1534 test::DNSResponder dns;
1535 StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.3"}});
Luke Huangf8215372019-11-22 11:53:41 +08001536 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001537
1538 // There's nothing listening on this address, so validation will either fail or
1539 /// hang. Either way, queries will continue to flow to the DNSResponder.
waynema0e73c2e2019-07-31 15:04:08 +08001540 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Ken Chenb9fa2062018-11-13 21:51:13 +08001541
1542 const hostent* result;
1543
1544 result = gethostbyname("tlsmissing");
1545 ASSERT_FALSE(result == nullptr);
1546 EXPECT_EQ("1.2.3.3", ToString(result));
1547
1548 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001549 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001550}
1551
1552// Test what happens if the specified TLS server replies with garbage.
1553TEST_F(ResolverTest, GetHostByName_TlsBroken) {
Xiao Ma09b71022018-12-11 17:56:32 +09001554 constexpr char listen_addr[] = "127.0.0.3";
1555 constexpr char host_name1[] = "tlsbroken1.example.com.";
1556 constexpr char host_name2[] = "tlsbroken2.example.com.";
1557 const std::vector<DnsRecord> records = {
1558 {host_name1, ns_type::ns_t_a, "1.2.3.1"},
1559 {host_name2, ns_type::ns_t_a, "1.2.3.2"},
1560 };
1561
1562 test::DNSResponder dns;
1563 StartDns(dns, records);
Luke Huangf8215372019-11-22 11:53:41 +08001564 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001565
1566 // Bind the specified private DNS socket but don't respond to any client sockets yet.
1567 int s = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_TCP);
1568 ASSERT_TRUE(s >= 0);
1569 struct sockaddr_in tlsServer = {
Luke Huangf8215372019-11-22 11:53:41 +08001570 .sin_family = AF_INET,
1571 .sin_port = htons(853),
Ken Chenb9fa2062018-11-13 21:51:13 +08001572 };
1573 ASSERT_TRUE(inet_pton(AF_INET, listen_addr, &tlsServer.sin_addr));
1574 ASSERT_TRUE(enableSockopt(s, SOL_SOCKET, SO_REUSEPORT).ok());
1575 ASSERT_TRUE(enableSockopt(s, SOL_SOCKET, SO_REUSEADDR).ok());
1576 ASSERT_FALSE(bind(s, reinterpret_cast<struct sockaddr*>(&tlsServer), sizeof(tlsServer)));
1577 ASSERT_FALSE(listen(s, 1));
1578
1579 // Trigger TLS validation.
waynema0e73c2e2019-07-31 15:04:08 +08001580 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Ken Chenb9fa2062018-11-13 21:51:13 +08001581
1582 struct sockaddr_storage cliaddr;
1583 socklen_t sin_size = sizeof(cliaddr);
Luke Huangf8215372019-11-22 11:53:41 +08001584 int new_fd = accept4(s, reinterpret_cast<struct sockaddr*>(&cliaddr), &sin_size, SOCK_CLOEXEC);
Ken Chenb9fa2062018-11-13 21:51:13 +08001585 ASSERT_TRUE(new_fd > 0);
1586
1587 // We've received the new file descriptor but not written to it or closed, so the
1588 // validation is still pending. Queries should still flow correctly because the
1589 // server is not used until validation succeeds.
1590 const hostent* result;
1591 result = gethostbyname("tlsbroken1");
1592 ASSERT_FALSE(result == nullptr);
1593 EXPECT_EQ("1.2.3.1", ToString(result));
1594
1595 // Now we cause the validation to fail.
1596 std::string garbage = "definitely not a valid TLS ServerHello";
1597 write(new_fd, garbage.data(), garbage.size());
1598 close(new_fd);
1599
1600 // Validation failure shouldn't interfere with lookups, because lookups won't be sent
1601 // to the TLS server unless validation succeeds.
1602 result = gethostbyname("tlsbroken2");
1603 ASSERT_FALSE(result == nullptr);
1604 EXPECT_EQ("1.2.3.2", ToString(result));
1605
1606 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001607 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001608 close(s);
1609}
1610
1611TEST_F(ResolverTest, GetHostByName_Tls) {
Xiao Ma09b71022018-12-11 17:56:32 +09001612 constexpr char listen_addr[] = "127.0.0.3";
1613 constexpr char listen_udp[] = "53";
1614 constexpr char listen_tls[] = "853";
1615 constexpr char host_name1[] = "tls1.example.com.";
1616 constexpr char host_name2[] = "tls2.example.com.";
1617 constexpr char host_name3[] = "tls3.example.com.";
1618 const std::vector<DnsRecord> records = {
1619 {host_name1, ns_type::ns_t_a, "1.2.3.1"},
1620 {host_name2, ns_type::ns_t_a, "1.2.3.2"},
1621 {host_name3, ns_type::ns_t_a, "1.2.3.3"},
1622 };
1623
1624 test::DNSResponder dns;
1625 StartDns(dns, records);
Luke Huangf8215372019-11-22 11:53:41 +08001626 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001627
1628 test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
1629 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08001630 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08001631 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Ken Chenb9fa2062018-11-13 21:51:13 +08001632
Mike Yu724f77d2019-08-16 11:14:50 +08001633 const hostent* result = gethostbyname("tls1");
Ken Chenb9fa2062018-11-13 21:51:13 +08001634 ASSERT_FALSE(result == nullptr);
1635 EXPECT_EQ("1.2.3.1", ToString(result));
1636
1637 // Wait for query to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001638 EXPECT_TRUE(tls.waitForQueries(2));
Ken Chenb9fa2062018-11-13 21:51:13 +08001639
1640 // Stop the TLS server. Since we're in opportunistic mode, queries will
1641 // fall back to the locally-assigned (clear text) nameservers.
1642 tls.stopServer();
1643
1644 dns.clearQueries();
1645 result = gethostbyname("tls2");
1646 EXPECT_FALSE(result == nullptr);
1647 EXPECT_EQ("1.2.3.2", ToString(result));
1648 const auto queries = dns.queries();
1649 EXPECT_EQ(1U, queries.size());
waynema29253052019-08-20 11:26:08 +08001650 EXPECT_EQ("tls2.example.com.", queries[0].name);
1651 EXPECT_EQ(ns_t_a, queries[0].type);
Ken Chenb9fa2062018-11-13 21:51:13 +08001652
1653 // Reset the resolvers without enabling TLS. Queries should still be routed
1654 // to the UDP endpoint.
Xiao Ma09b71022018-12-11 17:56:32 +09001655 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001656
1657 result = gethostbyname("tls3");
1658 ASSERT_FALSE(result == nullptr);
1659 EXPECT_EQ("1.2.3.3", ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +08001660}
1661
Ken Chenb9fa2062018-11-13 21:51:13 +08001662TEST_F(ResolverTest, GetHostByName_TlsFailover) {
Xiao Ma09b71022018-12-11 17:56:32 +09001663 constexpr char listen_addr1[] = "127.0.0.3";
1664 constexpr char listen_addr2[] = "127.0.0.4";
1665 constexpr char listen_udp[] = "53";
1666 constexpr char listen_tls[] = "853";
1667 constexpr char host_name1[] = "tlsfailover1.example.com.";
1668 constexpr char host_name2[] = "tlsfailover2.example.com.";
1669 const std::vector<DnsRecord> records1 = {
1670 {host_name1, ns_type::ns_t_a, "1.2.3.1"},
1671 {host_name2, ns_type::ns_t_a, "1.2.3.2"},
1672 };
1673 const std::vector<DnsRecord> records2 = {
1674 {host_name1, ns_type::ns_t_a, "1.2.3.3"},
1675 {host_name2, ns_type::ns_t_a, "1.2.3.4"},
1676 };
1677
1678 test::DNSResponder dns1(listen_addr1);
1679 test::DNSResponder dns2(listen_addr2);
1680 StartDns(dns1, records1);
1681 StartDns(dns2, records2);
1682
Luke Huangf8215372019-11-22 11:53:41 +08001683 std::vector<std::string> servers = {listen_addr1, listen_addr2};
Ken Chenb9fa2062018-11-13 21:51:13 +08001684
1685 test::DnsTlsFrontend tls1(listen_addr1, listen_tls, listen_addr1, listen_udp);
1686 test::DnsTlsFrontend tls2(listen_addr2, listen_tls, listen_addr2, listen_udp);
1687 ASSERT_TRUE(tls1.startServer());
1688 ASSERT_TRUE(tls2.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08001689 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
1690 kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08001691 EXPECT_TRUE(WaitForPrivateDnsValidation(tls1.listen_address(), true));
1692 EXPECT_TRUE(WaitForPrivateDnsValidation(tls2.listen_address(), true));
Ken Chenb9fa2062018-11-13 21:51:13 +08001693
Mike Yu724f77d2019-08-16 11:14:50 +08001694 const hostent* result = gethostbyname("tlsfailover1");
Ken Chenb9fa2062018-11-13 21:51:13 +08001695 ASSERT_FALSE(result == nullptr);
1696 EXPECT_EQ("1.2.3.1", ToString(result));
1697
1698 // Wait for query to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001699 EXPECT_TRUE(tls1.waitForQueries(2));
Ken Chenb9fa2062018-11-13 21:51:13 +08001700 // No new queries should have reached tls2.
Luke Huang3caa42b2020-04-23 14:18:04 +00001701 EXPECT_TRUE(tls2.waitForQueries(1));
Ken Chenb9fa2062018-11-13 21:51:13 +08001702
1703 // Stop tls1. Subsequent queries should attempt to reach tls1, fail, and retry to tls2.
1704 tls1.stopServer();
1705
1706 result = gethostbyname("tlsfailover2");
1707 EXPECT_EQ("1.2.3.4", ToString(result));
1708
1709 // Wait for query to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001710 EXPECT_TRUE(tls2.waitForQueries(2));
Ken Chenb9fa2062018-11-13 21:51:13 +08001711
1712 // No additional queries should have reached the insecure servers.
1713 EXPECT_EQ(2U, dns1.queries().size());
1714 EXPECT_EQ(2U, dns2.queries().size());
1715
1716 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001717 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Ken Chenb9fa2062018-11-13 21:51:13 +08001718}
1719
1720TEST_F(ResolverTest, GetHostByName_BadTlsName) {
Xiao Ma09b71022018-12-11 17:56:32 +09001721 constexpr char listen_addr[] = "127.0.0.3";
1722 constexpr char listen_udp[] = "53";
1723 constexpr char listen_tls[] = "853";
1724 constexpr char host_name[] = "badtlsname.example.com.";
1725
1726 test::DNSResponder dns;
1727 StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.1"}});
Luke Huangf8215372019-11-22 11:53:41 +08001728 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001729
1730 test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
1731 ASSERT_TRUE(tls.startServer());
Xiao Ma09b71022018-12-11 17:56:32 +09001732 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
waynema0e73c2e2019-07-31 15:04:08 +08001733 kDefaultIncorrectPrivateDnsHostName));
Ken Chenb9fa2062018-11-13 21:51:13 +08001734
waynema0e73c2e2019-07-31 15:04:08 +08001735 // The TLS handshake would fail because the name of TLS server doesn't
1736 // match with TLS server's certificate.
Mike Yu724f77d2019-08-16 11:14:50 +08001737 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), false));
Ken Chenb9fa2062018-11-13 21:51:13 +08001738
1739 // The query should fail hard, because a name was specified.
1740 EXPECT_EQ(nullptr, gethostbyname("badtlsname"));
1741
1742 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001743 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001744}
1745
1746TEST_F(ResolverTest, GetAddrInfo_Tls) {
Xiao Ma09b71022018-12-11 17:56:32 +09001747 constexpr char listen_addr[] = "127.0.0.3";
1748 constexpr char listen_udp[] = "53";
1749 constexpr char listen_tls[] = "853";
1750 constexpr char host_name[] = "addrinfotls.example.com.";
1751 const std::vector<DnsRecord> records = {
1752 {host_name, ns_type::ns_t_a, "1.2.3.4"},
1753 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
1754 };
1755
1756 test::DNSResponder dns;
1757 StartDns(dns, records);
Luke Huangf8215372019-11-22 11:53:41 +08001758 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001759
1760 test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
1761 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08001762 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
1763 kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08001764 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Ken Chenb9fa2062018-11-13 21:51:13 +08001765
1766 dns.clearQueries();
1767 ScopedAddrinfo result = safe_getaddrinfo("addrinfotls", nullptr, nullptr);
1768 EXPECT_TRUE(result != nullptr);
1769 size_t found = GetNumQueries(dns, host_name);
1770 EXPECT_LE(1U, found);
1771 // Could be A or AAAA
1772 std::string result_str = ToString(result);
1773 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
Luke Huangf8215372019-11-22 11:53:41 +08001774 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +08001775 // Wait for both A and AAAA queries to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001776 EXPECT_TRUE(tls.waitForQueries(3));
Ken Chenb9fa2062018-11-13 21:51:13 +08001777
1778 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001779 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001780}
1781
1782TEST_F(ResolverTest, TlsBypass) {
1783 const char OFF[] = "off";
1784 const char OPPORTUNISTIC[] = "opportunistic";
1785 const char STRICT[] = "strict";
1786
1787 const char GETHOSTBYNAME[] = "gethostbyname";
1788 const char GETADDRINFO[] = "getaddrinfo";
1789 const char GETADDRINFOFORNET[] = "getaddrinfofornet";
1790
1791 const unsigned BYPASS_NETID = NETID_USE_LOCAL_NAMESERVERS | TEST_NETID;
1792
Ken Chenb9fa2062018-11-13 21:51:13 +08001793 const char ADDR4[] = "192.0.2.1";
1794 const char ADDR6[] = "2001:db8::1";
1795
1796 const char cleartext_addr[] = "127.0.0.53";
1797 const char cleartext_port[] = "53";
1798 const char tls_port[] = "853";
Luke Huangf8215372019-11-22 11:53:41 +08001799 const std::vector<std::string> servers = {cleartext_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001800
Xiao Ma09b71022018-12-11 17:56:32 +09001801 test::DNSResponder dns(cleartext_addr);
Ken Chenb9fa2062018-11-13 21:51:13 +08001802 ASSERT_TRUE(dns.startServer());
1803
1804 test::DnsTlsFrontend tls(cleartext_addr, tls_port, cleartext_addr, cleartext_port);
Mike Yudd4ac2d2019-05-31 16:52:11 +08001805 ASSERT_TRUE(tls.startServer());
Ken Chenb9fa2062018-11-13 21:51:13 +08001806
Luke Huangf8215372019-11-22 11:53:41 +08001807 // clang-format off
Ken Chenb9fa2062018-11-13 21:51:13 +08001808 struct TestConfig {
1809 const std::string mode;
1810 const bool withWorkingTLS;
1811 const std::string method;
1812
1813 std::string asHostName() const {
Luke Huangf8215372019-11-22 11:53:41 +08001814 return StringPrintf("%s.%s.%s.", mode.c_str(), withWorkingTLS ? "tlsOn" : "tlsOff",
Ken Chenb9fa2062018-11-13 21:51:13 +08001815 method.c_str());
1816 }
1817 } testConfigs[]{
Ken Chenb9fa2062018-11-13 21:51:13 +08001818 {OFF, true, GETHOSTBYNAME},
1819 {OPPORTUNISTIC, true, GETHOSTBYNAME},
1820 {STRICT, true, GETHOSTBYNAME},
Ken Chenb9fa2062018-11-13 21:51:13 +08001821 {OFF, true, GETADDRINFO},
1822 {OPPORTUNISTIC, true, GETADDRINFO},
1823 {STRICT, true, GETADDRINFO},
Ken Chenb9fa2062018-11-13 21:51:13 +08001824 {OFF, true, GETADDRINFOFORNET},
1825 {OPPORTUNISTIC, true, GETADDRINFOFORNET},
1826 {STRICT, true, GETADDRINFOFORNET},
Mike Yudd4ac2d2019-05-31 16:52:11 +08001827 {OFF, false, GETHOSTBYNAME},
1828 {OPPORTUNISTIC, false, GETHOSTBYNAME},
1829 {STRICT, false, GETHOSTBYNAME},
1830 {OFF, false, GETADDRINFO},
1831 {OPPORTUNISTIC, false, GETADDRINFO},
1832 {STRICT, false, GETADDRINFO},
1833 {OFF, false, GETADDRINFOFORNET},
1834 {OPPORTUNISTIC, false, GETADDRINFOFORNET},
1835 {STRICT, false, GETADDRINFOFORNET},
Ken Chenb9fa2062018-11-13 21:51:13 +08001836 };
Luke Huangf8215372019-11-22 11:53:41 +08001837 // clang-format on
Ken Chenb9fa2062018-11-13 21:51:13 +08001838
1839 for (const auto& config : testConfigs) {
1840 const std::string testHostName = config.asHostName();
1841 SCOPED_TRACE(testHostName);
1842
1843 // Don't tempt test bugs due to caching.
1844 const char* host_name = testHostName.c_str();
1845 dns.addMapping(host_name, ns_type::ns_t_a, ADDR4);
1846 dns.addMapping(host_name, ns_type::ns_t_aaaa, ADDR6);
1847
Mike Yudd4ac2d2019-05-31 16:52:11 +08001848 if (config.withWorkingTLS) {
1849 if (!tls.running()) {
1850 ASSERT_TRUE(tls.startServer());
1851 }
1852 } else {
1853 if (tls.running()) {
1854 ASSERT_TRUE(tls.stopServer());
1855 }
1856 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001857
1858 if (config.mode == OFF) {
Xiao Ma09b71022018-12-11 17:56:32 +09001859 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, kDefaultSearchDomains,
1860 kDefaultParams));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001861 } else /* OPPORTUNISTIC or STRICT */ {
1862 const char* tls_hostname = (config.mode == STRICT) ? kDefaultPrivateDnsHostName : "";
Xiao Ma09b71022018-12-11 17:56:32 +09001863 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001864 kDefaultParams, tls_hostname));
Mike Yu724f77d2019-08-16 11:14:50 +08001865
1866 // Wait for the validation event. If the server is running, the validation should
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001867 // succeed; otherwise, the validation should fail.
Mike Yu724f77d2019-08-16 11:14:50 +08001868 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), config.withWorkingTLS));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001869 if (config.withWorkingTLS) {
1870 EXPECT_TRUE(tls.waitForQueries(1));
1871 tls.clearQueries();
1872 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001873 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001874
1875 const hostent* h_result = nullptr;
1876 ScopedAddrinfo ai_result;
1877
1878 if (config.method == GETHOSTBYNAME) {
1879 ASSERT_EQ(0, setNetworkForResolv(BYPASS_NETID));
1880 h_result = gethostbyname(host_name);
1881
1882 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
1883 ASSERT_FALSE(h_result == nullptr);
1884 ASSERT_EQ(4, h_result->h_length);
1885 ASSERT_FALSE(h_result->h_addr_list[0] == nullptr);
1886 EXPECT_EQ(ADDR4, ToString(h_result));
1887 EXPECT_TRUE(h_result->h_addr_list[1] == nullptr);
1888 } else if (config.method == GETADDRINFO) {
1889 ASSERT_EQ(0, setNetworkForResolv(BYPASS_NETID));
1890 ai_result = safe_getaddrinfo(host_name, nullptr, nullptr);
1891 EXPECT_TRUE(ai_result != nullptr);
1892
1893 EXPECT_LE(1U, GetNumQueries(dns, host_name));
1894 // Could be A or AAAA
1895 const std::string result_str = ToString(ai_result);
1896 EXPECT_TRUE(result_str == ADDR4 || result_str == ADDR6)
Luke Huangf8215372019-11-22 11:53:41 +08001897 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +08001898 } else if (config.method == GETADDRINFOFORNET) {
1899 addrinfo* raw_ai_result = nullptr;
1900 EXPECT_EQ(0, android_getaddrinfofornet(host_name, /*servname=*/nullptr,
1901 /*hints=*/nullptr, BYPASS_NETID, MARK_UNSET,
1902 &raw_ai_result));
1903 ai_result.reset(raw_ai_result);
1904
1905 EXPECT_LE(1U, GetNumQueries(dns, host_name));
1906 // Could be A or AAAA
1907 const std::string result_str = ToString(ai_result);
1908 EXPECT_TRUE(result_str == ADDR4 || result_str == ADDR6)
Luke Huangf8215372019-11-22 11:53:41 +08001909 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +08001910 }
1911
Mike Yudd4ac2d2019-05-31 16:52:11 +08001912 EXPECT_EQ(0, tls.queries());
Ken Chenb9fa2062018-11-13 21:51:13 +08001913
1914 // Clear per-process resolv netid.
1915 ASSERT_EQ(0, setNetworkForResolv(NETID_UNSET));
Ken Chenb9fa2062018-11-13 21:51:13 +08001916 dns.clearQueries();
1917 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001918}
1919
1920TEST_F(ResolverTest, StrictMode_NoTlsServers) {
Xiao Ma09b71022018-12-11 17:56:32 +09001921 constexpr char cleartext_addr[] = "127.0.0.53";
Luke Huangf8215372019-11-22 11:53:41 +08001922 const std::vector<std::string> servers = {cleartext_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09001923 constexpr char host_name[] = "strictmode.notlsips.example.com.";
1924 const std::vector<DnsRecord> records = {
1925 {host_name, ns_type::ns_t_a, "1.2.3.4"},
1926 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
1927 };
Ken Chenb9fa2062018-11-13 21:51:13 +08001928
Xiao Ma09b71022018-12-11 17:56:32 +09001929 test::DNSResponder dns(cleartext_addr);
1930 StartDns(dns, records);
Ken Chenb9fa2062018-11-13 21:51:13 +08001931
waynema0e73c2e2019-07-31 15:04:08 +08001932 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
1933 kDefaultIncorrectPrivateDnsHostName));
Ken Chenb9fa2062018-11-13 21:51:13 +08001934
1935 addrinfo* ai_result = nullptr;
1936 EXPECT_NE(0, getaddrinfo(host_name, nullptr, nullptr, &ai_result));
1937 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
1938}
Luke Huang94b10b92018-11-21 20:13:38 +08001939
1940namespace {
1941
Luke Huang70931aa2019-01-31 11:57:41 +08001942int getAsyncResponse(int fd, int* rcode, uint8_t* buf, int bufLen) {
Luke Huang94b10b92018-11-21 20:13:38 +08001943 struct pollfd wait_fd[1];
1944 wait_fd[0].fd = fd;
1945 wait_fd[0].events = POLLIN;
1946 short revents;
1947 int ret;
1948
1949 ret = poll(wait_fd, 1, -1);
1950 revents = wait_fd[0].revents;
1951 if (revents & POLLIN) {
1952 int n = resNetworkResult(fd, rcode, buf, bufLen);
Luke Huangba7bef92018-12-26 16:53:03 +08001953 // Verify that resNetworkResult() closed the fd
1954 char dummy;
1955 EXPECT_EQ(-1, read(fd, &dummy, sizeof dummy));
1956 EXPECT_EQ(EBADF, errno);
Luke Huang94b10b92018-11-21 20:13:38 +08001957 return n;
1958 }
1959 return -1;
1960}
1961
Luke Huang70931aa2019-01-31 11:57:41 +08001962std::string toString(uint8_t* buf, int bufLen, int ipType) {
Luke Huang94b10b92018-11-21 20:13:38 +08001963 ns_msg handle;
1964 int ancount, n = 0;
1965 ns_rr rr;
1966
Luke Huangf8215372019-11-22 11:53:41 +08001967 if (ns_initparse((const uint8_t*)buf, bufLen, &handle) >= 0) {
Luke Huang94b10b92018-11-21 20:13:38 +08001968 ancount = ns_msg_count(handle, ns_s_an);
1969 if (ns_parserr(&handle, ns_s_an, n, &rr) == 0) {
Luke Huang70931aa2019-01-31 11:57:41 +08001970 const uint8_t* rdata = ns_rr_rdata(rr);
Luke Huang94b10b92018-11-21 20:13:38 +08001971 char buffer[INET6_ADDRSTRLEN];
Luke Huangf8215372019-11-22 11:53:41 +08001972 if (inet_ntop(ipType, (const char*)rdata, buffer, sizeof(buffer))) {
Luke Huang94b10b92018-11-21 20:13:38 +08001973 return buffer;
1974 }
1975 }
1976 }
1977 return "";
1978}
1979
1980int dns_open_proxy() {
1981 int s = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
1982 if (s == -1) {
1983 return -1;
1984 }
1985 const int one = 1;
1986 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1987
1988 static const struct sockaddr_un proxy_addr = {
1989 .sun_family = AF_UNIX,
1990 .sun_path = "/dev/socket/dnsproxyd",
1991 };
1992
Luke Huangf8215372019-11-22 11:53:41 +08001993 if (TEMP_FAILURE_RETRY(connect(s, (const struct sockaddr*)&proxy_addr, sizeof(proxy_addr))) !=
Luke Huang94b10b92018-11-21 20:13:38 +08001994 0) {
1995 close(s);
1996 return -1;
1997 }
1998
1999 return s;
2000}
2001
Luke Huangba7bef92018-12-26 16:53:03 +08002002void expectAnswersValid(int fd, int ipType, const std::string& expectedAnswer) {
2003 int rcode = -1;
2004 uint8_t buf[MAXPACKET] = {};
2005
2006 int res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2007 EXPECT_GT(res, 0);
2008 EXPECT_EQ(expectedAnswer, toString(buf, res, ipType));
2009}
2010
2011void expectAnswersNotValid(int fd, int expectedErrno) {
2012 int rcode = -1;
2013 uint8_t buf[MAXPACKET] = {};
2014
2015 int res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2016 EXPECT_EQ(expectedErrno, res);
2017}
2018
Luke Huang94b10b92018-11-21 20:13:38 +08002019} // namespace
2020
2021TEST_F(ResolverTest, Async_NormalQueryV4V6) {
Xiao Ma09b71022018-12-11 17:56:32 +09002022 constexpr char listen_addr[] = "127.0.0.4";
2023 constexpr char host_name[] = "howdy.example.com.";
2024 const std::vector<DnsRecord> records = {
2025 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2026 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2027 };
2028
2029 test::DNSResponder dns(listen_addr);
2030 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08002031 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002032 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08002033
Luke Huangba7bef92018-12-26 16:53:03 +08002034 int fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2035 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002036 EXPECT_TRUE(fd1 != -1);
2037 EXPECT_TRUE(fd2 != -1);
2038
Luke Huang70931aa2019-01-31 11:57:41 +08002039 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002040 int rcode;
2041 int res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
2042 EXPECT_GT(res, 0);
2043 EXPECT_EQ("::1.2.3.4", toString(buf, res, AF_INET6));
2044
2045 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
2046 EXPECT_GT(res, 0);
2047 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2048
2049 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
2050
2051 // Re-query verify cache works
Luke Huangba7bef92018-12-26 16:53:03 +08002052 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2053 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002054
2055 EXPECT_TRUE(fd1 != -1);
2056 EXPECT_TRUE(fd2 != -1);
2057
2058 res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
2059 EXPECT_GT(res, 0);
2060 EXPECT_EQ("::1.2.3.4", toString(buf, res, AF_INET6));
2061
2062 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
2063 EXPECT_GT(res, 0);
2064 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2065
2066 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
2067}
2068
2069TEST_F(ResolverTest, Async_BadQuery) {
Xiao Ma09b71022018-12-11 17:56:32 +09002070 constexpr char listen_addr[] = "127.0.0.4";
2071 constexpr char host_name[] = "howdy.example.com.";
2072 const std::vector<DnsRecord> records = {
2073 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2074 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2075 };
2076
2077 test::DNSResponder dns(listen_addr);
2078 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08002079 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002080 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08002081
2082 static struct {
2083 int fd;
2084 const char* dname;
2085 const int queryType;
2086 const int expectRcode;
2087 } kTestData[] = {
Luke Huangba7bef92018-12-26 16:53:03 +08002088 {-1, "", ns_t_aaaa, 0},
2089 {-1, "as65ass46", ns_t_aaaa, 0},
2090 {-1, "454564564564", ns_t_aaaa, 0},
2091 {-1, "h645235", ns_t_a, 0},
2092 {-1, "www.google.com", ns_t_a, 0},
Luke Huang94b10b92018-11-21 20:13:38 +08002093 };
2094
2095 for (auto& td : kTestData) {
2096 SCOPED_TRACE(td.dname);
Luke Huangba7bef92018-12-26 16:53:03 +08002097 td.fd = resNetworkQuery(TEST_NETID, td.dname, ns_c_in, td.queryType, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002098 EXPECT_TRUE(td.fd != -1);
2099 }
2100
2101 // dns_responder return empty resp(packet only contains query part) with no error currently
2102 for (const auto& td : kTestData) {
Luke Huang70931aa2019-01-31 11:57:41 +08002103 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002104 int rcode;
2105 SCOPED_TRACE(td.dname);
2106 int res = getAsyncResponse(td.fd, &rcode, buf, MAXPACKET);
2107 EXPECT_GT(res, 0);
2108 EXPECT_EQ(rcode, td.expectRcode);
2109 }
2110}
2111
2112TEST_F(ResolverTest, Async_EmptyAnswer) {
Xiao Ma09b71022018-12-11 17:56:32 +09002113 constexpr char listen_addr[] = "127.0.0.4";
2114 constexpr char host_name[] = "howdy.example.com.";
2115 const std::vector<DnsRecord> records = {
2116 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2117 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2118 };
2119
2120 test::DNSResponder dns(listen_addr);
2121 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08002122 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002123 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08002124
Luke Huang9c264bb2018-12-18 16:44:41 +08002125 // TODO: Disable retry to make this test explicit.
2126 auto& cv = dns.getCv();
2127 auto& cvMutex = dns.getCvMutex();
2128 int fd1;
2129 // Wait on the condition variable to ensure that the DNS server has handled our first query.
2130 {
2131 std::unique_lock lk(cvMutex);
Luke Huangba7bef92018-12-26 16:53:03 +08002132 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
Luke Huang9c264bb2018-12-18 16:44:41 +08002133 EXPECT_TRUE(fd1 != -1);
2134 EXPECT_EQ(std::cv_status::no_timeout, cv.wait_for(lk, std::chrono::seconds(1)));
2135 }
Luke Huang94b10b92018-11-21 20:13:38 +08002136
Luke Huang94b10b92018-11-21 20:13:38 +08002137 dns.setResponseProbability(0.0);
Luke Huang94b10b92018-11-21 20:13:38 +08002138
Luke Huangba7bef92018-12-26 16:53:03 +08002139 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002140 EXPECT_TRUE(fd2 != -1);
2141
Luke Huangba7bef92018-12-26 16:53:03 +08002142 int fd3 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002143 EXPECT_TRUE(fd3 != -1);
2144
Luke Huang9c264bb2018-12-18 16:44:41 +08002145 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002146 int rcode;
2147
Luke Huang9c264bb2018-12-18 16:44:41 +08002148 // expect no response
2149 int res = getAsyncResponse(fd3, &rcode, buf, MAXPACKET);
2150 EXPECT_EQ(-ETIMEDOUT, res);
Luke Huang94b10b92018-11-21 20:13:38 +08002151
Luke Huang9c264bb2018-12-18 16:44:41 +08002152 // expect no response
Luke Huang94b10b92018-11-21 20:13:38 +08002153 memset(buf, 0, MAXPACKET);
Luke Huang9c264bb2018-12-18 16:44:41 +08002154 res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
2155 EXPECT_EQ(-ETIMEDOUT, res);
Luke Huang94b10b92018-11-21 20:13:38 +08002156
Luke Huang94b10b92018-11-21 20:13:38 +08002157 dns.setResponseProbability(1.0);
Luke Huang94b10b92018-11-21 20:13:38 +08002158
Luke Huangba7bef92018-12-26 16:53:03 +08002159 int fd4 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002160 EXPECT_TRUE(fd4 != -1);
2161
2162 memset(buf, 0, MAXPACKET);
2163 res = getAsyncResponse(fd4, &rcode, buf, MAXPACKET);
2164 EXPECT_GT(res, 0);
2165 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2166
2167 memset(buf, 0, MAXPACKET);
2168 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
2169 EXPECT_GT(res, 0);
2170 EXPECT_EQ("::1.2.3.4", toString(buf, res, AF_INET6));
2171}
2172
2173TEST_F(ResolverTest, Async_MalformedQuery) {
Xiao Ma09b71022018-12-11 17:56:32 +09002174 constexpr char listen_addr[] = "127.0.0.4";
2175 constexpr char host_name[] = "howdy.example.com.";
2176 const std::vector<DnsRecord> records = {
2177 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2178 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2179 };
2180
2181 test::DNSResponder dns(listen_addr);
2182 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08002183 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002184 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08002185
2186 int fd = dns_open_proxy();
2187 EXPECT_TRUE(fd > 0);
2188
2189 const std::string badMsg = "16-52512#";
Xiao Ma09b71022018-12-11 17:56:32 +09002190 static const struct {
Luke Huang94b10b92018-11-21 20:13:38 +08002191 const std::string cmd;
2192 const int expectErr;
2193 } kTestData[] = {
Luke Huangba7bef92018-12-26 16:53:03 +08002194 // Too few arguments
Luke Huang94b10b92018-11-21 20:13:38 +08002195 {"resnsend " + badMsg + '\0', -EINVAL},
2196 // Bad netId
Luke Huangba7bef92018-12-26 16:53:03 +08002197 {"resnsend badnetId 0 " + badMsg + '\0', -EINVAL},
Luke Huang94b10b92018-11-21 20:13:38 +08002198 // Bad raw data
Luke Huangba7bef92018-12-26 16:53:03 +08002199 {"resnsend " + std::to_string(TEST_NETID) + " 0 " + badMsg + '\0', -EILSEQ},
Luke Huang94b10b92018-11-21 20:13:38 +08002200 };
2201
2202 for (unsigned int i = 0; i < std::size(kTestData); i++) {
2203 auto& td = kTestData[i];
2204 SCOPED_TRACE(td.cmd);
2205 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, td.cmd.c_str(), td.cmd.size()));
2206 EXPECT_EQ(rc, static_cast<ssize_t>(td.cmd.size()));
2207
2208 int32_t tmp;
2209 rc = TEMP_FAILURE_RETRY(read(fd, &tmp, sizeof(tmp)));
2210 EXPECT_TRUE(rc > 0);
2211 EXPECT_EQ(static_cast<int>(ntohl(tmp)), td.expectErr);
2212 }
2213 // Normal query with answer buffer
2214 // This is raw data of query "howdy.example.com" type 1 class 1
2215 std::string query = "81sBAAABAAAAAAAABWhvd2R5B2V4YW1wbGUDY29tAAABAAE=";
Luke Huangba7bef92018-12-26 16:53:03 +08002216 std::string cmd = "resnsend " + std::to_string(TEST_NETID) + " 0 " + query + '\0';
Luke Huang94b10b92018-11-21 20:13:38 +08002217 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size()));
2218 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size()));
2219
Luke Huang70931aa2019-01-31 11:57:41 +08002220 uint8_t smallBuf[1] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002221 int rcode;
2222 rc = getAsyncResponse(fd, &rcode, smallBuf, 1);
Luke Huangba7bef92018-12-26 16:53:03 +08002223 EXPECT_EQ(-EMSGSIZE, rc);
Luke Huang94b10b92018-11-21 20:13:38 +08002224
2225 // Do the normal test with large buffer again
2226 fd = dns_open_proxy();
2227 EXPECT_TRUE(fd > 0);
2228 rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size()));
2229 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size()));
Luke Huang70931aa2019-01-31 11:57:41 +08002230 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002231 rc = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2232 EXPECT_EQ("1.2.3.4", toString(buf, rc, AF_INET));
Mike Yu4f3747b2018-12-02 17:54:29 +09002233}
2234
Luke Huangba7bef92018-12-26 16:53:03 +08002235TEST_F(ResolverTest, Async_CacheFlags) {
Xiao Ma09b71022018-12-11 17:56:32 +09002236 constexpr char listen_addr[] = "127.0.0.4";
2237 constexpr char host_name[] = "howdy.example.com.";
Luke Huang40f5f492019-05-09 19:37:35 +08002238 constexpr char another_host_name[] = "howdy.example2.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002239 const std::vector<DnsRecord> records = {
2240 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2241 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
Luke Huang40f5f492019-05-09 19:37:35 +08002242 {another_host_name, ns_type::ns_t_a, "1.2.3.5"},
2243 {another_host_name, ns_type::ns_t_aaaa, "::1.2.3.5"},
Xiao Ma09b71022018-12-11 17:56:32 +09002244 };
2245
2246 test::DNSResponder dns(listen_addr);
2247 StartDns(dns, records);
Luke Huangba7bef92018-12-26 16:53:03 +08002248 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002249 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huangba7bef92018-12-26 16:53:03 +08002250
2251 // ANDROID_RESOLV_NO_CACHE_STORE
2252 int fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2253 ANDROID_RESOLV_NO_CACHE_STORE);
2254 EXPECT_TRUE(fd1 != -1);
2255 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2256 ANDROID_RESOLV_NO_CACHE_STORE);
2257 EXPECT_TRUE(fd2 != -1);
2258 int fd3 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2259 ANDROID_RESOLV_NO_CACHE_STORE);
2260 EXPECT_TRUE(fd3 != -1);
2261
2262 expectAnswersValid(fd3, AF_INET, "1.2.3.4");
2263 expectAnswersValid(fd2, AF_INET, "1.2.3.4");
2264 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2265
2266 // No cache exists, expect 3 queries
2267 EXPECT_EQ(3U, GetNumQueries(dns, host_name));
2268
2269 // Re-query and cache
2270 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2271
2272 EXPECT_TRUE(fd1 != -1);
2273
2274 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2275
2276 // Now we have cache, expect 4 queries
2277 EXPECT_EQ(4U, GetNumQueries(dns, host_name));
2278
2279 // ANDROID_RESOLV_NO_CACHE_LOOKUP
2280 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2281 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2282 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2283 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2284
2285 EXPECT_TRUE(fd1 != -1);
2286 EXPECT_TRUE(fd2 != -1);
2287
2288 expectAnswersValid(fd2, AF_INET, "1.2.3.4");
2289 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2290
2291 // Skip cache, expect 6 queries
2292 EXPECT_EQ(6U, GetNumQueries(dns, host_name));
2293
2294 // Re-query verify cache works
2295 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2296 ANDROID_RESOLV_NO_CACHE_STORE);
2297 EXPECT_TRUE(fd1 != -1);
2298 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2299
2300 // Cache hits, expect still 6 queries
2301 EXPECT_EQ(6U, GetNumQueries(dns, host_name));
Luke Huanga1d74182019-03-19 17:30:36 +08002302
2303 // Start to verify if ANDROID_RESOLV_NO_CACHE_LOOKUP does write response into cache
2304 dns.clearQueries();
2305
2306 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa,
2307 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2308 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa,
2309 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2310
2311 EXPECT_TRUE(fd1 != -1);
2312 EXPECT_TRUE(fd2 != -1);
2313
2314 expectAnswersValid(fd2, AF_INET6, "::1.2.3.4");
2315 expectAnswersValid(fd1, AF_INET6, "::1.2.3.4");
2316
2317 // Skip cache, expect 2 queries
2318 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
2319
2320 // Re-query without flags
2321 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
2322 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
2323
2324 EXPECT_TRUE(fd1 != -1);
2325 EXPECT_TRUE(fd2 != -1);
2326
2327 expectAnswersValid(fd2, AF_INET6, "::1.2.3.4");
2328 expectAnswersValid(fd1, AF_INET6, "::1.2.3.4");
2329
2330 // Cache hits, expect still 2 queries
2331 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
Luke Huang40f5f492019-05-09 19:37:35 +08002332
2333 // Test both ANDROID_RESOLV_NO_CACHE_STORE and ANDROID_RESOLV_NO_CACHE_LOOKUP are set
2334 dns.clearQueries();
2335
2336 // Make sure that the cache of "howdy.example2.com" exists.
2337 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_aaaa, 0);
2338 EXPECT_TRUE(fd1 != -1);
2339 expectAnswersValid(fd1, AF_INET6, "::1.2.3.5");
2340 EXPECT_EQ(1U, GetNumQueries(dns, another_host_name));
2341
2342 // Re-query with testFlags
2343 const int testFlag = ANDROID_RESOLV_NO_CACHE_STORE | ANDROID_RESOLV_NO_CACHE_LOOKUP;
2344 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_aaaa, testFlag);
2345 EXPECT_TRUE(fd1 != -1);
2346 expectAnswersValid(fd1, AF_INET6, "::1.2.3.5");
2347 // Expect cache lookup is skipped.
2348 EXPECT_EQ(2U, GetNumQueries(dns, another_host_name));
2349
2350 // Do another query with testFlags
2351 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_a, testFlag);
2352 EXPECT_TRUE(fd1 != -1);
2353 expectAnswersValid(fd1, AF_INET, "1.2.3.5");
2354 // Expect cache lookup is skipped.
2355 EXPECT_EQ(3U, GetNumQueries(dns, another_host_name));
2356
2357 // Re-query with no flags
2358 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_a, 0);
2359 EXPECT_TRUE(fd1 != -1);
2360 expectAnswersValid(fd1, AF_INET, "1.2.3.5");
2361 // Expect no cache hit because cache storing is also skipped in previous query.
2362 EXPECT_EQ(4U, GetNumQueries(dns, another_host_name));
Luke Huangba7bef92018-12-26 16:53:03 +08002363}
2364
Luke Huang08b13d22020-02-05 14:46:21 +08002365TEST_F(ResolverTest, Async_NoCacheStoreFlagDoesNotRefreshStaleCacheEntry) {
2366 constexpr char listen_addr[] = "127.0.0.4";
2367 constexpr char host_name[] = "howdy.example.com.";
2368 const std::vector<DnsRecord> records = {
2369 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2370 };
2371
2372 test::DNSResponder dns(listen_addr);
2373 StartDns(dns, records);
2374 std::vector<std::string> servers = {listen_addr};
2375 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
2376
2377 const unsigned SHORT_TTL_SEC = 1;
2378 dns.setTtl(SHORT_TTL_SEC);
2379
2380 // Refer to b/148842821 for the purpose of below test steps.
2381 // Basically, this test is used to ensure stale cache case is handled
2382 // correctly with ANDROID_RESOLV_NO_CACHE_STORE.
2383 int fd = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2384 EXPECT_TRUE(fd != -1);
2385 expectAnswersValid(fd, AF_INET, "1.2.3.4");
2386
2387 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2388 dns.clearQueries();
2389
2390 // Wait until cache expired
2391 sleep(SHORT_TTL_SEC + 0.5);
2392
2393 // Now request the same hostname again.
2394 // We should see a new DNS query because the entry in cache has become stale.
2395 // Due to ANDROID_RESOLV_NO_CACHE_STORE, this query must *not* refresh that stale entry.
2396 fd = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2397 ANDROID_RESOLV_NO_CACHE_STORE);
2398 EXPECT_TRUE(fd != -1);
2399 expectAnswersValid(fd, AF_INET, "1.2.3.4");
2400 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2401 dns.clearQueries();
2402
2403 // If the cache is still stale, we expect to see one more DNS query
2404 // (this time the cache will be refreshed, but we're not checking for it).
2405 fd = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2406 EXPECT_TRUE(fd != -1);
2407 expectAnswersValid(fd, AF_INET, "1.2.3.4");
2408 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2409}
2410
Luke Huangba7bef92018-12-26 16:53:03 +08002411TEST_F(ResolverTest, Async_NoRetryFlag) {
Luke Huang70931aa2019-01-31 11:57:41 +08002412 constexpr char listen_addr0[] = "127.0.0.4";
2413 constexpr char listen_addr1[] = "127.0.0.6";
Xiao Ma09b71022018-12-11 17:56:32 +09002414 constexpr char host_name[] = "howdy.example.com.";
2415 const std::vector<DnsRecord> records = {
2416 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2417 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2418 };
2419
Luke Huang70931aa2019-01-31 11:57:41 +08002420 test::DNSResponder dns0(listen_addr0);
2421 test::DNSResponder dns1(listen_addr1);
2422 StartDns(dns0, records);
2423 StartDns(dns1, records);
2424 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr0, listen_addr1}));
Luke Huangba7bef92018-12-26 16:53:03 +08002425
Luke Huang70931aa2019-01-31 11:57:41 +08002426 dns0.clearQueries();
2427 dns1.clearQueries();
2428
2429 dns0.setResponseProbability(0.0);
2430 dns1.setResponseProbability(0.0);
Luke Huangba7bef92018-12-26 16:53:03 +08002431
2432 int fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2433 ANDROID_RESOLV_NO_RETRY);
2434 EXPECT_TRUE(fd1 != -1);
2435
2436 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa,
2437 ANDROID_RESOLV_NO_RETRY);
2438 EXPECT_TRUE(fd2 != -1);
2439
2440 // expect no response
2441 expectAnswersNotValid(fd1, -ETIMEDOUT);
2442 expectAnswersNotValid(fd2, -ETIMEDOUT);
2443
Luke Huang70931aa2019-01-31 11:57:41 +08002444 // No retry case, expect total 2 queries. The server is selected randomly.
2445 EXPECT_EQ(2U, GetNumQueries(dns0, host_name) + GetNumQueries(dns1, host_name));
Luke Huangba7bef92018-12-26 16:53:03 +08002446
Luke Huang70931aa2019-01-31 11:57:41 +08002447 dns0.clearQueries();
2448 dns1.clearQueries();
Luke Huangba7bef92018-12-26 16:53:03 +08002449
2450 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2451 EXPECT_TRUE(fd1 != -1);
2452
2453 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
2454 EXPECT_TRUE(fd2 != -1);
2455
2456 // expect no response
2457 expectAnswersNotValid(fd1, -ETIMEDOUT);
2458 expectAnswersNotValid(fd2, -ETIMEDOUT);
2459
2460 // Retry case, expect 4 queries
Luke Huang70931aa2019-01-31 11:57:41 +08002461 EXPECT_EQ(4U, GetNumQueries(dns0, host_name));
2462 EXPECT_EQ(4U, GetNumQueries(dns1, host_name));
2463}
2464
2465TEST_F(ResolverTest, Async_VerifyQueryID) {
2466 constexpr char listen_addr[] = "127.0.0.4";
2467 constexpr char host_name[] = "howdy.example.com.";
2468 const std::vector<DnsRecord> records = {
2469 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2470 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2471 };
2472
2473 test::DNSResponder dns(listen_addr);
2474 StartDns(dns, records);
2475 std::vector<std::string> servers = {listen_addr};
2476 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
2477
2478 const uint8_t queryBuf1[] = {
2479 /* Header */
2480 0x55, 0x66, /* Transaction ID */
2481 0x01, 0x00, /* Flags */
2482 0x00, 0x01, /* Questions */
2483 0x00, 0x00, /* Answer RRs */
2484 0x00, 0x00, /* Authority RRs */
2485 0x00, 0x00, /* Additional RRs */
2486 /* Queries */
2487 0x05, 0x68, 0x6f, 0x77, 0x64, 0x79, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
2488 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name */
2489 0x00, 0x01, /* Type */
2490 0x00, 0x01 /* Class */
2491 };
2492
2493 int fd = resNetworkSend(TEST_NETID, queryBuf1, sizeof(queryBuf1), 0);
2494 EXPECT_TRUE(fd != -1);
2495
2496 uint8_t buf[MAXPACKET] = {};
2497 int rcode;
2498
2499 int res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2500 EXPECT_GT(res, 0);
2501 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2502
2503 auto hp = reinterpret_cast<HEADER*>(buf);
2504 EXPECT_EQ(21862U, htons(hp->id));
2505
2506 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2507
2508 const uint8_t queryBuf2[] = {
2509 /* Header */
2510 0x00, 0x53, /* Transaction ID */
2511 0x01, 0x00, /* Flags */
2512 0x00, 0x01, /* Questions */
2513 0x00, 0x00, /* Answer RRs */
2514 0x00, 0x00, /* Authority RRs */
2515 0x00, 0x00, /* Additional RRs */
2516 /* Queries */
2517 0x05, 0x68, 0x6f, 0x77, 0x64, 0x79, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
2518 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name */
2519 0x00, 0x01, /* Type */
2520 0x00, 0x01 /* Class */
2521 };
2522
2523 // Re-query verify cache works and query id is correct
2524 fd = resNetworkSend(TEST_NETID, queryBuf2, sizeof(queryBuf2), 0);
2525
2526 EXPECT_TRUE(fd != -1);
2527
2528 res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2529 EXPECT_GT(res, 0);
2530 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2531
2532 EXPECT_EQ(0x0053U, htons(hp->id));
2533
2534 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
Luke Huangba7bef92018-12-26 16:53:03 +08002535}
2536
Mike Yu4f3747b2018-12-02 17:54:29 +09002537// This test checks that the resolver should not generate the request containing OPT RR when using
Ken Chen0a015532019-01-02 14:59:38 +08002538// cleartext DNS. If we query the DNS server not supporting EDNS0 and it reponds with
2539// FORMERR_ON_EDNS, we will fallback to no EDNS0 and try again. If the server does no response, we
2540// won't retry so that we get no answer.
Mike Yu4f3747b2018-12-02 17:54:29 +09002541TEST_F(ResolverTest, BrokenEdns) {
2542 typedef test::DNSResponder::Edns Edns;
2543 enum ExpectResult { EXPECT_FAILURE, EXPECT_SUCCESS };
2544
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002545 // Perform cleartext query in off mode.
Mike Yu4f3747b2018-12-02 17:54:29 +09002546 const char OFF[] = "off";
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002547
2548 // Perform cleartext query when there's no private DNS server validated in opportunistic mode.
Mike Yu4f3747b2018-12-02 17:54:29 +09002549 const char OPPORTUNISTIC_UDP[] = "opportunistic_udp";
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002550
2551 // Perform cleartext query when there is a private DNS server validated in opportunistic mode.
2552 const char OPPORTUNISTIC_FALLBACK_UDP[] = "opportunistic_fallback_udp";
2553
2554 // Perform cyphertext query in opportunistic mode.
Mike Yu4f3747b2018-12-02 17:54:29 +09002555 const char OPPORTUNISTIC_TLS[] = "opportunistic_tls";
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002556
2557 // Perform cyphertext query in strict mode.
Mike Yu4f3747b2018-12-02 17:54:29 +09002558 const char STRICT[] = "strict";
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002559
Mike Yu4f3747b2018-12-02 17:54:29 +09002560 const char GETHOSTBYNAME[] = "gethostbyname";
2561 const char GETADDRINFO[] = "getaddrinfo";
Mike Yu4f3747b2018-12-02 17:54:29 +09002562 const char ADDR4[] = "192.0.2.1";
2563 const char CLEARTEXT_ADDR[] = "127.0.0.53";
2564 const char CLEARTEXT_PORT[] = "53";
2565 const char TLS_PORT[] = "853";
Luke Huangf8215372019-11-22 11:53:41 +08002566 const std::vector<std::string> servers = {CLEARTEXT_ADDR};
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002567 ResolverParamsParcel paramsForCleanup = DnsResponderClient::GetDefaultResolverParamsParcel();
2568 paramsForCleanup.servers.clear();
2569 paramsForCleanup.tlsServers.clear();
Mike Yu4f3747b2018-12-02 17:54:29 +09002570
Mike Yufc125e42019-05-15 20:41:28 +08002571 test::DNSResponder dns(CLEARTEXT_ADDR, CLEARTEXT_PORT, ns_rcode::ns_r_servfail);
Mike Yu4f3747b2018-12-02 17:54:29 +09002572 ASSERT_TRUE(dns.startServer());
2573
2574 test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
2575
Luke Huangf8215372019-11-22 11:53:41 +08002576 // clang-format off
Mike Yu4f3747b2018-12-02 17:54:29 +09002577 static const struct TestConfig {
2578 std::string mode;
2579 std::string method;
2580 Edns edns;
2581 ExpectResult expectResult;
2582
2583 std::string asHostName() const {
2584 const char* ednsString;
2585 switch (edns) {
2586 case Edns::ON:
2587 ednsString = "ednsOn";
2588 break;
Ken Chen0a015532019-01-02 14:59:38 +08002589 case Edns::FORMERR_ON_EDNS:
Mike Yu4f3747b2018-12-02 17:54:29 +09002590 ednsString = "ednsFormerr";
2591 break;
2592 case Edns::DROP:
2593 ednsString = "ednsDrop";
2594 break;
2595 default:
2596 ednsString = "";
2597 break;
2598 }
2599 return StringPrintf("%s.%s.%s.", mode.c_str(), method.c_str(), ednsString);
2600 }
2601 } testConfigs[] = {
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002602 // In OPPORTUNISTIC_TLS, if the DNS server doesn't support EDNS0 but TLS, the lookup
2603 // fails. Could such server exist? if so, we might need to fix it to fallback to
2604 // cleartext query. If the server still make no response for the queries with EDNS0, we
2605 // might also need to fix it to retry without EDNS0.
Mike Yu4f3747b2018-12-02 17:54:29 +09002606 // Another thing is that {OPPORTUNISTIC_TLS, Edns::DROP} and {STRICT, Edns::DROP} are
2607 // commented out since TLS timeout is not configurable.
2608 // TODO: Uncomment them after TLS timeout is configurable.
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002609 {OFF, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2610 {OPPORTUNISTIC_UDP, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2611 {OPPORTUNISTIC_FALLBACK_UDP, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2612 {OPPORTUNISTIC_TLS, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2613 {STRICT, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2614 {OFF, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2615 {OPPORTUNISTIC_UDP, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2616 {OPPORTUNISTIC_FALLBACK_UDP, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2617 {OPPORTUNISTIC_TLS, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
2618 {STRICT, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
2619 {OFF, GETHOSTBYNAME, Edns::DROP, EXPECT_SUCCESS},
2620 {OPPORTUNISTIC_UDP, GETHOSTBYNAME, Edns::DROP, EXPECT_SUCCESS},
2621
2622 // The failure is due to no retry on timeout. Maybe fix it?
2623 {OPPORTUNISTIC_FALLBACK_UDP, GETHOSTBYNAME, Edns::DROP, EXPECT_FAILURE},
2624
2625 //{OPPORTUNISTIC_TLS, GETHOSTBYNAME, Edns::DROP, EXPECT_FAILURE},
2626 //{STRICT, GETHOSTBYNAME, Edns::DROP, EXPECT_FAILURE},
2627 {OFF, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2628 {OPPORTUNISTIC_UDP, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2629 {OPPORTUNISTIC_FALLBACK_UDP, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2630 {OPPORTUNISTIC_TLS, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2631 {STRICT, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2632 {OFF, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2633 {OPPORTUNISTIC_UDP, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2634 {OPPORTUNISTIC_FALLBACK_UDP, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2635 {OPPORTUNISTIC_TLS, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
2636 {STRICT, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
2637 {OFF, GETADDRINFO, Edns::DROP, EXPECT_SUCCESS},
2638 {OPPORTUNISTIC_UDP, GETADDRINFO, Edns::DROP, EXPECT_SUCCESS},
2639
2640 // The failure is due to no retry on timeout. Maybe fix it?
2641 {OPPORTUNISTIC_FALLBACK_UDP, GETADDRINFO, Edns::DROP, EXPECT_FAILURE},
2642
Mike Yu4f3747b2018-12-02 17:54:29 +09002643 //{OPPORTUNISTIC_TLS, GETADDRINFO, Edns::DROP, EXPECT_FAILURE},
2644 //{STRICT, GETADDRINFO, Edns::DROP, EXPECT_FAILURE},
2645 };
Luke Huangf8215372019-11-22 11:53:41 +08002646 // clang-format on
Mike Yu4f3747b2018-12-02 17:54:29 +09002647
2648 for (const auto& config : testConfigs) {
2649 const std::string testHostName = config.asHostName();
2650 SCOPED_TRACE(testHostName);
2651
2652 const char* host_name = testHostName.c_str();
2653 dns.addMapping(host_name, ns_type::ns_t_a, ADDR4);
2654 dns.setEdns(config.edns);
2655
2656 if (config.mode == OFF) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002657 if (tls.running()) {
2658 ASSERT_TRUE(tls.stopServer());
2659 }
Xiao Ma09b71022018-12-11 17:56:32 +09002660 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Mike Yu4f3747b2018-12-02 17:54:29 +09002661 } else if (config.mode == OPPORTUNISTIC_UDP) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002662 if (tls.running()) {
2663 ASSERT_TRUE(tls.stopServer());
2664 }
Xiao Ma09b71022018-12-11 17:56:32 +09002665 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
waynema0e73c2e2019-07-31 15:04:08 +08002666 kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002667 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), false));
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002668 } else if (config.mode == OPPORTUNISTIC_TLS || config.mode == OPPORTUNISTIC_FALLBACK_UDP) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002669 if (!tls.running()) {
2670 ASSERT_TRUE(tls.startServer());
2671 }
Xiao Ma09b71022018-12-11 17:56:32 +09002672 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
waynema0e73c2e2019-07-31 15:04:08 +08002673 kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002674 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002675
2676 if (config.mode == OPPORTUNISTIC_FALLBACK_UDP) {
2677 // Force the resolver to fallback to cleartext queries.
2678 ASSERT_TRUE(tls.stopServer());
2679 }
Mike Yu4f3747b2018-12-02 17:54:29 +09002680 } else if (config.mode == STRICT) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002681 if (!tls.running()) {
2682 ASSERT_TRUE(tls.startServer());
2683 }
Xiao Ma09b71022018-12-11 17:56:32 +09002684 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
waynema0e73c2e2019-07-31 15:04:08 +08002685 kDefaultParams, kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08002686 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Mike Yu4f3747b2018-12-02 17:54:29 +09002687 }
2688
2689 if (config.method == GETHOSTBYNAME) {
2690 const hostent* h_result = gethostbyname(host_name);
2691 if (config.expectResult == EXPECT_SUCCESS) {
2692 EXPECT_LE(1U, GetNumQueries(dns, host_name));
2693 ASSERT_TRUE(h_result != nullptr);
2694 ASSERT_EQ(4, h_result->h_length);
2695 ASSERT_FALSE(h_result->h_addr_list[0] == nullptr);
2696 EXPECT_EQ(ADDR4, ToString(h_result));
2697 EXPECT_TRUE(h_result->h_addr_list[1] == nullptr);
2698 } else {
2699 EXPECT_EQ(0U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
2700 ASSERT_TRUE(h_result == nullptr);
2701 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
2702 }
2703 } else if (config.method == GETADDRINFO) {
2704 ScopedAddrinfo ai_result;
2705 addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
2706 ai_result = safe_getaddrinfo(host_name, nullptr, &hints);
2707 if (config.expectResult == EXPECT_SUCCESS) {
2708 EXPECT_TRUE(ai_result != nullptr);
2709 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2710 const std::string result_str = ToString(ai_result);
2711 EXPECT_EQ(ADDR4, result_str);
2712 } else {
2713 EXPECT_TRUE(ai_result == nullptr);
2714 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
2715 }
2716 } else {
2717 FAIL() << "Unsupported query method: " << config.method;
2718 }
2719
Mike Yudd4ac2d2019-05-31 16:52:11 +08002720 tls.clearQueries();
Mike Yu4f3747b2018-12-02 17:54:29 +09002721 dns.clearQueries();
Automerger Merge Worker9a495be2020-03-05 14:07:09 +00002722
2723 // Clear the setup to force the resolver to validate private DNS servers in every test.
2724 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(paramsForCleanup));
Mike Yu4f3747b2018-12-02 17:54:29 +09002725 }
Mike Yu4f3747b2018-12-02 17:54:29 +09002726}
nuccachena26cc2a2018-07-17 18:07:23 +08002727
Ken Chen0a015532019-01-02 14:59:38 +08002728// DNS-over-TLS validation success, but server does not respond to TLS query after a while.
2729// Resolver should have a reasonable number of retries instead of spinning forever. We don't have
2730// an efficient way to know if resolver is stuck in an infinite loop. However, test case will be
2731// failed due to timeout.
2732TEST_F(ResolverTest, UnstableTls) {
2733 const char CLEARTEXT_ADDR[] = "127.0.0.53";
2734 const char CLEARTEXT_PORT[] = "53";
2735 const char TLS_PORT[] = "853";
2736 const char* host_name1 = "nonexistent1.example.com.";
2737 const char* host_name2 = "nonexistent2.example.com.";
2738 const std::vector<std::string> servers = {CLEARTEXT_ADDR};
2739
Mike Yufc125e42019-05-15 20:41:28 +08002740 test::DNSResponder dns(CLEARTEXT_ADDR, CLEARTEXT_PORT, ns_rcode::ns_r_servfail);
Ken Chen0a015532019-01-02 14:59:38 +08002741 ASSERT_TRUE(dns.startServer());
2742 dns.setEdns(test::DNSResponder::Edns::FORMERR_ON_EDNS);
2743 test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
2744 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08002745 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002746 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
2747
Ken Chen0a015532019-01-02 14:59:38 +08002748 // Shutdown TLS server to get an error. It's similar to no response case but without waiting.
2749 tls.stopServer();
2750
2751 const hostent* h_result = gethostbyname(host_name1);
2752 EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
2753 ASSERT_TRUE(h_result == nullptr);
2754 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
2755
2756 addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
2757 ScopedAddrinfo ai_result = safe_getaddrinfo(host_name2, nullptr, &hints);
2758 EXPECT_TRUE(ai_result == nullptr);
2759 EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
2760}
2761
2762// DNS-over-TLS validation success, but server does not respond to TLS query after a while.
2763// Moreover, server responds RCODE=FORMERR even on non-EDNS query.
2764TEST_F(ResolverTest, BogusDnsServer) {
2765 const char CLEARTEXT_ADDR[] = "127.0.0.53";
2766 const char CLEARTEXT_PORT[] = "53";
2767 const char TLS_PORT[] = "853";
2768 const char* host_name1 = "nonexistent1.example.com.";
2769 const char* host_name2 = "nonexistent2.example.com.";
2770 const std::vector<std::string> servers = {CLEARTEXT_ADDR};
2771
Mike Yufc125e42019-05-15 20:41:28 +08002772 test::DNSResponder dns(CLEARTEXT_ADDR, CLEARTEXT_PORT, ns_rcode::ns_r_servfail);
Ken Chen0a015532019-01-02 14:59:38 +08002773 ASSERT_TRUE(dns.startServer());
2774 test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
2775 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08002776 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002777 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
2778
Ken Chen0a015532019-01-02 14:59:38 +08002779 // Shutdown TLS server to get an error. It's similar to no response case but without waiting.
2780 tls.stopServer();
2781 dns.setEdns(test::DNSResponder::Edns::FORMERR_UNCOND);
2782
2783 const hostent* h_result = gethostbyname(host_name1);
2784 EXPECT_EQ(0U, GetNumQueries(dns, host_name1));
2785 ASSERT_TRUE(h_result == nullptr);
2786 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
2787
2788 addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
2789 ScopedAddrinfo ai_result = safe_getaddrinfo(host_name2, nullptr, &hints);
2790 EXPECT_TRUE(ai_result == nullptr);
2791 EXPECT_EQ(0U, GetNumQueries(dns, host_name2));
2792}
2793
nuccachena26cc2a2018-07-17 18:07:23 +08002794TEST_F(ResolverTest, GetAddrInfo_Dns64Synthesize) {
2795 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002796 constexpr char dns64_name[] = "ipv4only.arpa.";
2797 constexpr char host_name[] = "v4only.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002798 const std::vector<DnsRecord> records = {
2799 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2800 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2801 };
nuccachena26cc2a2018-07-17 18:07:23 +08002802
Xiao Ma09b71022018-12-11 17:56:32 +09002803 test::DNSResponder dns(listen_addr);
Xiao Ma09b71022018-12-11 17:56:32 +09002804 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002805
2806 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002807 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002808
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002809 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002810 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002811 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002812
2813 // hints are necessary in order to let netd know which type of addresses the caller is
2814 // interested in.
Xiao Ma09b71022018-12-11 17:56:32 +09002815 const addrinfo hints = {.ai_family = AF_UNSPEC};
nuccachena26cc2a2018-07-17 18:07:23 +08002816 ScopedAddrinfo result = safe_getaddrinfo("v4only", nullptr, &hints);
2817 EXPECT_TRUE(result != nullptr);
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002818 // TODO: BUG: there should only be two queries, one AAAA (which returns no records) and one A
2819 // (which returns 1.2.3.4). But there is an extra AAAA.
2820 EXPECT_EQ(3U, GetNumQueries(dns, host_name));
nuccachena26cc2a2018-07-17 18:07:23 +08002821
2822 std::string result_str = ToString(result);
2823 EXPECT_EQ(result_str, "64:ff9b::102:304");
2824
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002825 // Stopping NAT64 prefix discovery disables synthesis.
Luke Huang5bd827c2019-03-14 16:10:04 +08002826 EXPECT_TRUE(mDnsClient.resolvService()->stopPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002827 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_NOT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002828
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002829 dns.clearQueries();
nuccachena26cc2a2018-07-17 18:07:23 +08002830
2831 result = safe_getaddrinfo("v4only", nullptr, &hints);
2832 EXPECT_TRUE(result != nullptr);
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002833 // TODO: BUG: there should only be one query, an AAAA (which returns no records), because the
2834 // A is already cached. But there is an extra AAAA.
2835 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
nuccachena26cc2a2018-07-17 18:07:23 +08002836
2837 result_str = ToString(result);
2838 EXPECT_EQ(result_str, "1.2.3.4");
2839}
2840
nuccachena26cc2a2018-07-17 18:07:23 +08002841TEST_F(ResolverTest, GetAddrInfo_Dns64QuerySpecified) {
2842 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002843 constexpr char dns64_name[] = "ipv4only.arpa.";
2844 constexpr char host_name[] = "v4only.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002845 const std::vector<DnsRecord> records = {
2846 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2847 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2848 };
nuccachena26cc2a2018-07-17 18:07:23 +08002849
Xiao Ma09b71022018-12-11 17:56:32 +09002850 test::DNSResponder dns(listen_addr);
2851 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002852 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002853 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002854
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002855 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002856 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002857 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002858
2859 // Ensure to synthesize AAAA if AF_INET6 is specified, and not to synthesize AAAA
2860 // in AF_INET case.
2861 addrinfo hints;
2862 memset(&hints, 0, sizeof(hints));
2863 hints.ai_family = AF_INET6;
2864 ScopedAddrinfo result = safe_getaddrinfo("v4only", nullptr, &hints);
2865 EXPECT_TRUE(result != nullptr);
2866 std::string result_str = ToString(result);
2867 EXPECT_EQ(result_str, "64:ff9b::102:304");
2868
2869 hints.ai_family = AF_INET;
2870 result = safe_getaddrinfo("v4only", nullptr, &hints);
2871 EXPECT_TRUE(result != nullptr);
2872 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2873 result_str = ToString(result);
2874 EXPECT_EQ(result_str, "1.2.3.4");
2875}
nuccachena26cc2a2018-07-17 18:07:23 +08002876
2877TEST_F(ResolverTest, GetAddrInfo_Dns64QueryUnspecifiedV6) {
2878 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002879 constexpr char dns64_name[] = "ipv4only.arpa.";
2880 constexpr char host_name[] = "v4v6.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002881 const std::vector<DnsRecord> records = {
2882 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2883 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2884 {host_name, ns_type::ns_t_aaaa, "2001:db8::1.2.3.4"},
2885 };
nuccachena26cc2a2018-07-17 18:07:23 +08002886
Xiao Ma09b71022018-12-11 17:56:32 +09002887 test::DNSResponder dns(listen_addr);
2888 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002889 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002890 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002891
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002892 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002893 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002894 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002895
Xiao Ma09b71022018-12-11 17:56:32 +09002896 const addrinfo hints = {.ai_family = AF_UNSPEC};
nuccachena26cc2a2018-07-17 18:07:23 +08002897 ScopedAddrinfo result = safe_getaddrinfo("v4v6", nullptr, &hints);
2898 EXPECT_TRUE(result != nullptr);
2899 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2900
2901 // In AF_UNSPEC case, do not synthesize AAAA if there's at least one AAAA answer.
Xiao Ma09b71022018-12-11 17:56:32 +09002902 const std::vector<std::string> result_strs = ToStrings(result);
nuccachena26cc2a2018-07-17 18:07:23 +08002903 for (const auto& str : result_strs) {
2904 EXPECT_TRUE(str == "1.2.3.4" || str == "2001:db8::102:304")
2905 << ", result_str='" << str << "'";
2906 }
2907}
2908
2909TEST_F(ResolverTest, GetAddrInfo_Dns64QueryUnspecifiedNoV6) {
2910 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002911 constexpr char dns64_name[] = "ipv4only.arpa.";
2912 constexpr char host_name[] = "v4v6.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002913 const std::vector<DnsRecord> records = {
2914 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2915 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2916 };
nuccachena26cc2a2018-07-17 18:07:23 +08002917
Xiao Ma09b71022018-12-11 17:56:32 +09002918 test::DNSResponder dns(listen_addr);
2919 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002920 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002921 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002922
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002923 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002924 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002925 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002926
Xiao Ma09b71022018-12-11 17:56:32 +09002927 const addrinfo hints = {.ai_family = AF_UNSPEC};
nuccachena26cc2a2018-07-17 18:07:23 +08002928 ScopedAddrinfo result = safe_getaddrinfo("v4v6", nullptr, &hints);
2929 EXPECT_TRUE(result != nullptr);
2930 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2931
2932 // In AF_UNSPEC case, synthesize AAAA if there's no AAAA answer.
2933 std::string result_str = ToString(result);
2934 EXPECT_EQ(result_str, "64:ff9b::102:304");
2935}
2936
2937TEST_F(ResolverTest, GetAddrInfo_Dns64QuerySpecialUseIPv4Addresses) {
2938 constexpr char THIS_NETWORK[] = "this_network";
2939 constexpr char LOOPBACK[] = "loopback";
2940 constexpr char LINK_LOCAL[] = "link_local";
2941 constexpr char MULTICAST[] = "multicast";
2942 constexpr char LIMITED_BROADCAST[] = "limited_broadcast";
2943
2944 constexpr char ADDR_THIS_NETWORK[] = "0.0.0.1";
2945 constexpr char ADDR_LOOPBACK[] = "127.0.0.1";
2946 constexpr char ADDR_LINK_LOCAL[] = "169.254.0.1";
2947 constexpr char ADDR_MULTICAST[] = "224.0.0.1";
2948 constexpr char ADDR_LIMITED_BROADCAST[] = "255.255.255.255";
2949
2950 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002951 constexpr char dns64_name[] = "ipv4only.arpa.";
2952
Xiao Ma09b71022018-12-11 17:56:32 +09002953 test::DNSResponder dns(listen_addr);
2954 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::"}});
nuccachena26cc2a2018-07-17 18:07:23 +08002955 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002956 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002957
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002958 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002959 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002960 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002961
Luke Huangf8215372019-11-22 11:53:41 +08002962 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08002963 static const struct TestConfig {
2964 std::string name;
2965 std::string addr;
2966
2967 std::string asHostName() const { return StringPrintf("%s.example.com.", name.c_str()); }
2968 } testConfigs[]{
2969 {THIS_NETWORK, ADDR_THIS_NETWORK},
2970 {LOOPBACK, ADDR_LOOPBACK},
2971 {LINK_LOCAL, ADDR_LINK_LOCAL},
2972 {MULTICAST, ADDR_MULTICAST},
2973 {LIMITED_BROADCAST, ADDR_LIMITED_BROADCAST}
2974 };
Luke Huangf8215372019-11-22 11:53:41 +08002975 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08002976
2977 for (const auto& config : testConfigs) {
2978 const std::string testHostName = config.asHostName();
2979 SCOPED_TRACE(testHostName);
2980
2981 const char* host_name = testHostName.c_str();
2982 dns.addMapping(host_name, ns_type::ns_t_a, config.addr.c_str());
2983
2984 addrinfo hints;
2985 memset(&hints, 0, sizeof(hints));
2986 hints.ai_family = AF_INET6;
2987 ScopedAddrinfo result = safe_getaddrinfo(config.name.c_str(), nullptr, &hints);
2988 // In AF_INET6 case, don't return IPv4 answers
2989 EXPECT_TRUE(result == nullptr);
2990 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2991 dns.clearQueries();
2992
2993 memset(&hints, 0, sizeof(hints));
2994 hints.ai_family = AF_UNSPEC;
2995 result = safe_getaddrinfo(config.name.c_str(), nullptr, &hints);
2996 EXPECT_TRUE(result != nullptr);
2997 // Expect IPv6 query only. IPv4 answer has been cached in previous query.
2998 EXPECT_LE(1U, GetNumQueries(dns, host_name));
2999 // In AF_UNSPEC case, don't synthesize special use IPv4 address.
3000 std::string result_str = ToString(result);
3001 EXPECT_EQ(result_str, config.addr.c_str());
3002 dns.clearQueries();
3003 }
3004}
3005
3006TEST_F(ResolverTest, GetAddrInfo_Dns64QueryWithNullArgumentHints) {
3007 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003008 constexpr char dns64_name[] = "ipv4only.arpa.";
3009 constexpr char host_name[] = "v4only.example.com.";
3010 constexpr char host_name2[] = "v4v6.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09003011 const std::vector<DnsRecord> records = {
3012 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3013 {host_name, ns_type::ns_t_a, "1.2.3.4"},
3014 {host_name2, ns_type::ns_t_a, "1.2.3.4"},
3015 {host_name2, ns_type::ns_t_aaaa, "2001:db8::1.2.3.4"},
3016 };
nuccachena26cc2a2018-07-17 18:07:23 +08003017
Xiao Ma09b71022018-12-11 17:56:32 +09003018 test::DNSResponder dns(listen_addr);
3019 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003020 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003021 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003022
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003023 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003024 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003025 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003026
3027 // Assign argument hints of getaddrinfo() as null is equivalent to set ai_family AF_UNSPEC.
3028 // In AF_UNSPEC case, synthesize AAAA if there has A answer only.
3029 ScopedAddrinfo result = safe_getaddrinfo("v4only", nullptr, nullptr);
3030 EXPECT_TRUE(result != nullptr);
3031 EXPECT_LE(2U, GetNumQueries(dns, host_name));
3032 std::string result_str = ToString(result);
3033 EXPECT_EQ(result_str, "64:ff9b::102:304");
3034 dns.clearQueries();
3035
3036 // In AF_UNSPEC case, do not synthesize AAAA if there's at least one AAAA answer.
3037 result = safe_getaddrinfo("v4v6", nullptr, nullptr);
3038 EXPECT_TRUE(result != nullptr);
3039 EXPECT_LE(2U, GetNumQueries(dns, host_name2));
3040 std::vector<std::string> result_strs = ToStrings(result);
3041 for (const auto& str : result_strs) {
3042 EXPECT_TRUE(str == "1.2.3.4" || str == "2001:db8::102:304")
3043 << ", result_str='" << str << "'";
3044 }
3045}
3046
3047TEST_F(ResolverTest, GetAddrInfo_Dns64QueryNullArgumentNode) {
3048 constexpr char ADDR_ANYADDR_V4[] = "0.0.0.0";
3049 constexpr char ADDR_ANYADDR_V6[] = "::";
3050 constexpr char ADDR_LOCALHOST_V4[] = "127.0.0.1";
3051 constexpr char ADDR_LOCALHOST_V6[] = "::1";
3052
3053 constexpr char PORT_NAME_HTTP[] = "http";
3054 constexpr char PORT_NUMBER_HTTP[] = "80";
3055
3056 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003057 constexpr char dns64_name[] = "ipv4only.arpa.";
3058
Xiao Ma09b71022018-12-11 17:56:32 +09003059 test::DNSResponder dns(listen_addr);
3060 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::"}});
nuccachena26cc2a2018-07-17 18:07:23 +08003061 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003062 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003063
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003064 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003065 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003066 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003067
Luke Huangf8215372019-11-22 11:53:41 +08003068 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08003069 // If node is null, return address is listed by libc/getaddrinfo.c as follows.
3070 // - passive socket -> anyaddr (0.0.0.0 or ::)
3071 // - non-passive socket -> localhost (127.0.0.1 or ::1)
3072 static const struct TestConfig {
3073 int flag;
3074 std::string addr_v4;
3075 std::string addr_v6;
3076
3077 std::string asParameters() const {
3078 return StringPrintf("flag=%d, addr_v4=%s, addr_v6=%s", flag, addr_v4.c_str(),
3079 addr_v6.c_str());
3080 }
3081 } testConfigs[]{
3082 {0 /* non-passive */, ADDR_LOCALHOST_V4, ADDR_LOCALHOST_V6},
3083 {AI_PASSIVE, ADDR_ANYADDR_V4, ADDR_ANYADDR_V6}
3084 };
Luke Huangf8215372019-11-22 11:53:41 +08003085 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08003086
3087 for (const auto& config : testConfigs) {
3088 SCOPED_TRACE(config.asParameters());
3089
Xiao Ma09b71022018-12-11 17:56:32 +09003090 addrinfo hints = {
Nick Desaulnierscd6395a2019-10-11 09:15:24 -07003091 .ai_flags = config.flag,
Xiao Ma09b71022018-12-11 17:56:32 +09003092 .ai_family = AF_UNSPEC, // any address family
3093 .ai_socktype = 0, // any type
3094 .ai_protocol = 0, // any protocol
Xiao Ma09b71022018-12-11 17:56:32 +09003095 };
nuccachena26cc2a2018-07-17 18:07:23 +08003096
3097 // Assign hostname as null and service as port name.
3098 ScopedAddrinfo result = safe_getaddrinfo(nullptr, PORT_NAME_HTTP, &hints);
3099 ASSERT_TRUE(result != nullptr);
3100
3101 // Can't be synthesized because it should not get into Netd.
3102 std::vector<std::string> result_strs = ToStrings(result);
3103 for (const auto& str : result_strs) {
3104 EXPECT_TRUE(str == config.addr_v4 || str == config.addr_v6)
3105 << ", result_str='" << str << "'";
3106 }
3107
3108 // Assign hostname as null and service as numeric port number.
3109 hints.ai_flags = config.flag | AI_NUMERICSERV;
3110 result = safe_getaddrinfo(nullptr, PORT_NUMBER_HTTP, &hints);
3111 ASSERT_TRUE(result != nullptr);
3112
3113 // Can't be synthesized because it should not get into Netd.
3114 result_strs = ToStrings(result);
3115 for (const auto& str : result_strs) {
3116 EXPECT_TRUE(str == config.addr_v4 || str == config.addr_v6)
3117 << ", result_str='" << str << "'";
3118 }
3119 }
3120}
3121
3122TEST_F(ResolverTest, GetHostByAddr_ReverseDnsQueryWithHavingNat64Prefix) {
3123 struct hostent* result = nullptr;
3124 struct in_addr v4addr;
3125 struct in6_addr v6addr;
3126
3127 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003128 constexpr char dns64_name[] = "ipv4only.arpa.";
3129 constexpr char ptr_name[] = "v4v6.example.com.";
3130 // PTR record for IPv4 address 1.2.3.4
3131 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
3132 // PTR record for IPv6 address 2001:db8::102:304
3133 constexpr char ptr_addr_v6[] =
3134 "4.0.3.0.2.0.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.";
Xiao Ma09b71022018-12-11 17:56:32 +09003135 const std::vector<DnsRecord> records = {
3136 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3137 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
3138 {ptr_addr_v6, ns_type::ns_t_ptr, ptr_name},
3139 };
nuccachena26cc2a2018-07-17 18:07:23 +08003140
Xiao Ma09b71022018-12-11 17:56:32 +09003141 test::DNSResponder dns(listen_addr);
3142 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003143 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003144 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003145
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003146 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003147 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003148 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003149
3150 // Reverse IPv4 DNS query. Prefix should have no effect on it.
3151 inet_pton(AF_INET, "1.2.3.4", &v4addr);
3152 result = gethostbyaddr(&v4addr, sizeof(v4addr), AF_INET);
3153 ASSERT_TRUE(result != nullptr);
3154 std::string result_str = result->h_name ? result->h_name : "null";
3155 EXPECT_EQ(result_str, "v4v6.example.com");
3156
3157 // Reverse IPv6 DNS query. Prefix should have no effect on it.
3158 inet_pton(AF_INET6, "2001:db8::102:304", &v6addr);
3159 result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
3160 ASSERT_TRUE(result != nullptr);
3161 result_str = result->h_name ? result->h_name : "null";
3162 EXPECT_EQ(result_str, "v4v6.example.com");
3163}
3164
3165TEST_F(ResolverTest, GetHostByAddr_ReverseDns64Query) {
3166 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003167 constexpr char dns64_name[] = "ipv4only.arpa.";
3168 constexpr char ptr_name[] = "v4only.example.com.";
3169 // PTR record for IPv4 address 1.2.3.4
3170 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
3171 // PTR record for IPv6 address 64:ff9b::1.2.3.4
3172 constexpr char ptr_addr_v6_nomapping[] =
3173 "4.0.3.0.2.0.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.b.9.f.f.4.6.0.0.ip6.arpa.";
3174 constexpr char ptr_name_v6_synthesis[] = "v6synthesis.example.com.";
3175 // PTR record for IPv6 address 64:ff9b::5.6.7.8
3176 constexpr char ptr_addr_v6_synthesis[] =
3177 "8.0.7.0.6.0.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.b.9.f.f.4.6.0.0.ip6.arpa.";
Xiao Ma09b71022018-12-11 17:56:32 +09003178 const std::vector<DnsRecord> records = {
3179 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3180 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
3181 {ptr_addr_v6_synthesis, ns_type::ns_t_ptr, ptr_name_v6_synthesis},
3182 };
nuccachena26cc2a2018-07-17 18:07:23 +08003183
Xiao Ma09b71022018-12-11 17:56:32 +09003184 test::DNSResponder dns(listen_addr);
3185 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003186 // "ptr_addr_v6_nomapping" is not mapped in DNS server
nuccachena26cc2a2018-07-17 18:07:23 +08003187 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003188 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003189
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003190 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003191 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003192 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003193
3194 // Synthesized PTR record doesn't exist on DNS server
3195 // Reverse IPv6 DNS64 query while DNS server doesn't have an answer for synthesized address.
3196 // After querying synthesized address failed, expect that prefix is removed from IPv6
3197 // synthesized address and do reverse IPv4 query instead.
3198 struct in6_addr v6addr;
3199 inet_pton(AF_INET6, "64:ff9b::1.2.3.4", &v6addr);
3200 struct hostent* result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
3201 ASSERT_TRUE(result != nullptr);
3202 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_nomapping)); // PTR record not exist
3203 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v4)); // PTR record exist
3204 std::string result_str = result->h_name ? result->h_name : "null";
3205 EXPECT_EQ(result_str, "v4only.example.com");
3206 // Check that return address has been mapped from IPv4 to IPv6 address because Netd
3207 // removes NAT64 prefix and does IPv4 DNS reverse lookup in this case. Then, Netd
3208 // fakes the return IPv4 address as original queried IPv6 address.
3209 result_str = ToString(result);
3210 EXPECT_EQ(result_str, "64:ff9b::102:304");
3211 dns.clearQueries();
3212
3213 // Synthesized PTR record exists on DNS server
3214 // Reverse IPv6 DNS64 query while DNS server has an answer for synthesized address.
3215 // Expect to Netd pass through synthesized address for DNS queries.
3216 inet_pton(AF_INET6, "64:ff9b::5.6.7.8", &v6addr);
3217 result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
3218 ASSERT_TRUE(result != nullptr);
3219 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_synthesis));
3220 result_str = result->h_name ? result->h_name : "null";
3221 EXPECT_EQ(result_str, "v6synthesis.example.com");
3222}
3223
3224TEST_F(ResolverTest, GetHostByAddr_ReverseDns64QueryFromHostFile) {
3225 constexpr char dns64_name[] = "ipv4only.arpa.";
3226 constexpr char host_name[] = "localhost";
3227 // The address is synthesized by prefix64:localhost.
3228 constexpr char host_addr[] = "64:ff9b::7f00:1";
nuccachena26cc2a2018-07-17 18:07:23 +08003229 constexpr char listen_addr[] = "::1";
Xiao Ma09b71022018-12-11 17:56:32 +09003230
3231 test::DNSResponder dns(listen_addr);
3232 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"}});
nuccachena26cc2a2018-07-17 18:07:23 +08003233 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003234 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003235
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003236 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003237 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003238 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003239
3240 // Using synthesized "localhost" address to be a trick for resolving host name
3241 // from host file /etc/hosts and "localhost" is the only name in /etc/hosts. Note that this is
3242 // not realistic: the code never synthesizes AAAA records for addresses in 127.0.0.0/8.
3243 struct in6_addr v6addr;
3244 inet_pton(AF_INET6, host_addr, &v6addr);
3245 struct hostent* result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
3246 ASSERT_TRUE(result != nullptr);
3247 // Expect no DNS queries; localhost is resolved via /etc/hosts.
3248 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
3249
Luke Huangf8215372019-11-22 11:53:41 +08003250 ASSERT_EQ(sizeof(in6_addr), (unsigned)result->h_length);
nuccachena26cc2a2018-07-17 18:07:23 +08003251 ASSERT_EQ(AF_INET6, result->h_addrtype);
3252 std::string result_str = ToString(result);
3253 EXPECT_EQ(result_str, host_addr);
3254 result_str = result->h_name ? result->h_name : "null";
3255 EXPECT_EQ(result_str, host_name);
3256}
3257
Hungming Chen9e6185a2019-06-04 16:09:19 +08003258TEST_F(ResolverTest, GetHostByAddr_cnamesClasslessReverseDelegation) {
3259 // IPv4 addresses in the subnet with notation '/' or '-'.
3260 constexpr char addr_slash[] = "192.0.2.1";
3261 constexpr char addr_hyphen[] = "192.0.3.1";
3262
3263 // Used to verify DNS reverse query for classless reverse lookup zone. See detail in RFC 2317
3264 // section 4.
3265 const static std::vector<DnsRecord> records = {
3266 // The records for reverse querying "192.0.2.1" in the subnet with notation '/'.
3267 {"1.2.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0/25.2.0.192.in-addr.arpa."},
3268 {"1.0/25.2.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3269
3270 // The records for reverse querying "192.0.3.1" in the subnet with notation '-'.
3271 {"1.3.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0-127.3.0.192.in-addr.arpa."},
3272 {"1.0-127.3.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3273 };
3274
3275 test::DNSResponder dns;
3276 StartDns(dns, records);
3277 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3278
3279 for (const auto& address : {addr_slash, addr_hyphen}) {
3280 SCOPED_TRACE(address);
3281
3282 in_addr v4addr;
3283 ASSERT_TRUE(inet_pton(AF_INET, address, &v4addr));
3284 hostent* result = gethostbyaddr(&v4addr, sizeof(v4addr), AF_INET);
3285 ASSERT_TRUE(result != nullptr);
3286 EXPECT_STREQ("hello.example.com", result->h_name);
3287 }
3288}
3289
nuccachena26cc2a2018-07-17 18:07:23 +08003290TEST_F(ResolverTest, GetNameInfo_ReverseDnsQueryWithHavingNat64Prefix) {
3291 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003292 constexpr char dns64_name[] = "ipv4only.arpa.";
3293 constexpr char ptr_name[] = "v4v6.example.com.";
3294 // PTR record for IPv4 address 1.2.3.4
3295 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
3296 // PTR record for IPv6 address 2001:db8::102:304
3297 constexpr char ptr_addr_v6[] =
3298 "4.0.3.0.2.0.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.";
Xiao Ma09b71022018-12-11 17:56:32 +09003299 const std::vector<DnsRecord> records = {
3300 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3301 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
3302 {ptr_addr_v6, ns_type::ns_t_ptr, ptr_name},
3303 };
nuccachena26cc2a2018-07-17 18:07:23 +08003304
Xiao Ma09b71022018-12-11 17:56:32 +09003305 test::DNSResponder dns(listen_addr);
3306 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003307 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003308 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003309
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003310 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003311 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003312 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003313
Luke Huangf8215372019-11-22 11:53:41 +08003314 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08003315 static const struct TestConfig {
3316 int flag;
3317 int family;
3318 std::string addr;
3319 std::string host;
3320
3321 std::string asParameters() const {
3322 return StringPrintf("flag=%d, family=%d, addr=%s, host=%s", flag, family, addr.c_str(),
3323 host.c_str());
3324 }
3325 } testConfigs[]{
3326 {NI_NAMEREQD, AF_INET, "1.2.3.4", "v4v6.example.com"},
3327 {NI_NUMERICHOST, AF_INET, "1.2.3.4", "1.2.3.4"},
3328 {0, AF_INET, "1.2.3.4", "v4v6.example.com"},
3329 {0, AF_INET, "5.6.7.8", "5.6.7.8"}, // unmapped
3330 {NI_NAMEREQD, AF_INET6, "2001:db8::102:304", "v4v6.example.com"},
3331 {NI_NUMERICHOST, AF_INET6, "2001:db8::102:304", "2001:db8::102:304"},
3332 {0, AF_INET6, "2001:db8::102:304", "v4v6.example.com"},
3333 {0, AF_INET6, "2001:db8::506:708", "2001:db8::506:708"}, // unmapped
3334 };
Luke Huangf8215372019-11-22 11:53:41 +08003335 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08003336
3337 // Reverse IPv4/IPv6 DNS query. Prefix should have no effect on it.
3338 for (const auto& config : testConfigs) {
3339 SCOPED_TRACE(config.asParameters());
3340
3341 int rv;
3342 char host[NI_MAXHOST];
3343 struct sockaddr_in sin;
3344 struct sockaddr_in6 sin6;
3345 if (config.family == AF_INET) {
3346 memset(&sin, 0, sizeof(sin));
3347 sin.sin_family = AF_INET;
3348 inet_pton(AF_INET, config.addr.c_str(), &sin.sin_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003349 rv = getnameinfo((const struct sockaddr*)&sin, sizeof(sin), host, sizeof(host), nullptr,
3350 0, config.flag);
nuccachena26cc2a2018-07-17 18:07:23 +08003351 if (config.flag == NI_NAMEREQD) EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v4));
3352 } else if (config.family == AF_INET6) {
3353 memset(&sin6, 0, sizeof(sin6));
3354 sin6.sin6_family = AF_INET6;
3355 inet_pton(AF_INET6, config.addr.c_str(), &sin6.sin6_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003356 rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host),
nuccachena26cc2a2018-07-17 18:07:23 +08003357 nullptr, 0, config.flag);
3358 if (config.flag == NI_NAMEREQD) EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6));
3359 }
3360 ASSERT_EQ(0, rv);
3361 std::string result_str = host;
3362 EXPECT_EQ(result_str, config.host);
3363 dns.clearQueries();
3364 }
3365}
3366
3367TEST_F(ResolverTest, GetNameInfo_ReverseDns64Query) {
3368 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003369 constexpr char dns64_name[] = "ipv4only.arpa.";
3370 constexpr char ptr_name[] = "v4only.example.com.";
3371 // PTR record for IPv4 address 1.2.3.4
3372 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
3373 // PTR record for IPv6 address 64:ff9b::1.2.3.4
3374 constexpr char ptr_addr_v6_nomapping[] =
3375 "4.0.3.0.2.0.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.b.9.f.f.4.6.0.0.ip6.arpa.";
3376 constexpr char ptr_name_v6_synthesis[] = "v6synthesis.example.com.";
3377 // PTR record for IPv6 address 64:ff9b::5.6.7.8
3378 constexpr char ptr_addr_v6_synthesis[] =
3379 "8.0.7.0.6.0.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.b.9.f.f.4.6.0.0.ip6.arpa.";
Xiao Ma09b71022018-12-11 17:56:32 +09003380 const std::vector<DnsRecord> records = {
3381 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3382 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
3383 {ptr_addr_v6_synthesis, ns_type::ns_t_ptr, ptr_name_v6_synthesis},
3384 };
nuccachena26cc2a2018-07-17 18:07:23 +08003385
Xiao Ma09b71022018-12-11 17:56:32 +09003386 test::DNSResponder dns(listen_addr);
3387 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003388 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003389 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003390
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003391 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003392 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003393 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003394
Luke Huangf8215372019-11-22 11:53:41 +08003395 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08003396 static const struct TestConfig {
3397 bool hasSynthesizedPtrRecord;
3398 int flag;
3399 std::string addr;
3400 std::string host;
3401
3402 std::string asParameters() const {
3403 return StringPrintf("hasSynthesizedPtrRecord=%d, flag=%d, addr=%s, host=%s",
3404 hasSynthesizedPtrRecord, flag, addr.c_str(), host.c_str());
3405 }
3406 } testConfigs[]{
3407 {false, NI_NAMEREQD, "64:ff9b::102:304", "v4only.example.com"},
3408 {false, NI_NUMERICHOST, "64:ff9b::102:304", "64:ff9b::102:304"},
3409 {false, 0, "64:ff9b::102:304", "v4only.example.com"},
3410 {true, NI_NAMEREQD, "64:ff9b::506:708", "v6synthesis.example.com"},
3411 {true, NI_NUMERICHOST, "64:ff9b::506:708", "64:ff9b::506:708"},
3412 {true, 0, "64:ff9b::506:708", "v6synthesis.example.com"}
3413 };
Luke Huangf8215372019-11-22 11:53:41 +08003414 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08003415
3416 // hasSynthesizedPtrRecord = false
3417 // Synthesized PTR record doesn't exist on DNS server
3418 // Reverse IPv6 DNS64 query while DNS server doesn't have an answer for synthesized address.
3419 // After querying synthesized address failed, expect that prefix is removed from IPv6
3420 // synthesized address and do reverse IPv4 query instead.
3421 //
3422 // hasSynthesizedPtrRecord = true
3423 // Synthesized PTR record exists on DNS server
3424 // Reverse IPv6 DNS64 query while DNS server has an answer for synthesized address.
3425 // Expect to just pass through synthesized address for DNS queries.
3426 for (const auto& config : testConfigs) {
3427 SCOPED_TRACE(config.asParameters());
3428
3429 char host[NI_MAXHOST];
3430 struct sockaddr_in6 sin6;
3431 memset(&sin6, 0, sizeof(sin6));
3432 sin6.sin6_family = AF_INET6;
3433 inet_pton(AF_INET6, config.addr.c_str(), &sin6.sin6_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003434 int rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host),
nuccachena26cc2a2018-07-17 18:07:23 +08003435 nullptr, 0, config.flag);
3436 ASSERT_EQ(0, rv);
3437 if (config.flag == NI_NAMEREQD) {
3438 if (config.hasSynthesizedPtrRecord) {
3439 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_synthesis));
3440 } else {
3441 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_nomapping)); // PTR record not exist.
3442 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v4)); // PTR record exist.
3443 }
3444 }
3445 std::string result_str = host;
3446 EXPECT_EQ(result_str, config.host);
3447 dns.clearQueries();
3448 }
3449}
3450
3451TEST_F(ResolverTest, GetNameInfo_ReverseDns64QueryFromHostFile) {
3452 constexpr char dns64_name[] = "ipv4only.arpa.";
3453 constexpr char host_name[] = "localhost";
3454 // The address is synthesized by prefix64:localhost.
3455 constexpr char host_addr[] = "64:ff9b::7f00:1";
nuccachena26cc2a2018-07-17 18:07:23 +08003456 constexpr char listen_addr[] = "::1";
Xiao Ma09b71022018-12-11 17:56:32 +09003457
3458 test::DNSResponder dns(listen_addr);
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003459
Xiao Ma09b71022018-12-11 17:56:32 +09003460 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"}});
nuccachena26cc2a2018-07-17 18:07:23 +08003461 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003462 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003463
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003464 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003465 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003466 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003467
3468 // Using synthesized "localhost" address to be a trick for resolving host name
3469 // from host file /etc/hosts and "localhost" is the only name in /etc/hosts. Note that this is
3470 // not realistic: the code never synthesizes AAAA records for addresses in 127.0.0.0/8.
3471 char host[NI_MAXHOST];
Xiao Ma09b71022018-12-11 17:56:32 +09003472 struct sockaddr_in6 sin6 = {.sin6_family = AF_INET6};
nuccachena26cc2a2018-07-17 18:07:23 +08003473 inet_pton(AF_INET6, host_addr, &sin6.sin6_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003474 int rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host), nullptr,
nuccachena26cc2a2018-07-17 18:07:23 +08003475 0, NI_NAMEREQD);
3476 ASSERT_EQ(0, rv);
3477 // Expect no DNS queries; localhost is resolved via /etc/hosts.
3478 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
3479
3480 std::string result_str = host;
3481 EXPECT_EQ(result_str, host_name);
3482}
3483
Hungming Chen9e6185a2019-06-04 16:09:19 +08003484TEST_F(ResolverTest, GetNameInfo_cnamesClasslessReverseDelegation) {
3485 // IPv4 addresses in the subnet with notation '/' or '-'.
3486 constexpr char addr_slash[] = "192.0.2.1";
3487 constexpr char addr_hyphen[] = "192.0.3.1";
3488
3489 // Used to verify DNS reverse query for classless reverse lookup zone. See detail in RFC 2317
3490 // section 4.
3491 const static std::vector<DnsRecord> records = {
3492 // The records for reverse querying "192.0.2.1" in the subnet with notation '/'.
3493 {"1.2.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0/25.2.0.192.in-addr.arpa."},
3494 {"1.0/25.2.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3495
3496 // The records for reverse querying "192.0.3.1" in the subnet with notation '-'.
3497 {"1.3.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0-127.3.0.192.in-addr.arpa."},
3498 {"1.0-127.3.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3499 };
3500
3501 test::DNSResponder dns;
3502 StartDns(dns, records);
3503 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3504
3505 for (const auto& address : {addr_slash, addr_hyphen}) {
3506 SCOPED_TRACE(address);
3507
3508 char host[NI_MAXHOST];
3509 sockaddr_in sin = {.sin_family = AF_INET};
3510 ASSERT_TRUE(inet_pton(AF_INET, address, &sin.sin_addr));
3511 int rv = getnameinfo((const sockaddr*)&sin, sizeof(sin), host, sizeof(host), nullptr, 0,
3512 NI_NAMEREQD);
3513 ASSERT_EQ(0, rv);
3514 EXPECT_STREQ("hello.example.com", host);
3515 }
3516}
3517
nuccachena26cc2a2018-07-17 18:07:23 +08003518TEST_F(ResolverTest, GetHostByName2_Dns64Synthesize) {
Xiao Ma09b71022018-12-11 17:56:32 +09003519 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003520 constexpr char dns64_name[] = "ipv4only.arpa.";
3521 constexpr char host_name[] = "ipv4only.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09003522 const std::vector<DnsRecord> records = {
3523 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3524 {host_name, ns_type::ns_t_a, "1.2.3.4"},
3525 };
nuccachena26cc2a2018-07-17 18:07:23 +08003526
Xiao Ma09b71022018-12-11 17:56:32 +09003527 test::DNSResponder dns(listen_addr);
3528 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003529 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003530 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003531
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003532 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003533 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003534 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003535
3536 // Query an IPv4-only hostname. Expect that gets a synthesized address.
3537 struct hostent* result = gethostbyname2("ipv4only", AF_INET6);
3538 ASSERT_TRUE(result != nullptr);
3539 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3540 std::string result_str = ToString(result);
3541 EXPECT_EQ(result_str, "64:ff9b::102:304");
3542}
nuccachena26cc2a2018-07-17 18:07:23 +08003543
3544TEST_F(ResolverTest, GetHostByName2_DnsQueryWithHavingNat64Prefix) {
3545 constexpr char dns64_name[] = "ipv4only.arpa.";
3546 constexpr char host_name[] = "v4v6.example.com.";
nuccachena26cc2a2018-07-17 18:07:23 +08003547 constexpr char listen_addr[] = "::1";
Xiao Ma09b71022018-12-11 17:56:32 +09003548 const std::vector<DnsRecord> records = {
3549 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3550 {host_name, ns_type::ns_t_a, "1.2.3.4"},
3551 {host_name, ns_type::ns_t_aaaa, "2001:db8::1.2.3.4"},
3552 };
3553
3554 test::DNSResponder dns(listen_addr);
3555 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003556 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003557 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003558
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003559 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003560 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003561 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003562
3563 // IPv4 DNS query. Prefix should have no effect on it.
3564 struct hostent* result = gethostbyname2("v4v6", AF_INET);
3565 ASSERT_TRUE(result != nullptr);
3566 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3567 std::string result_str = ToString(result);
3568 EXPECT_EQ(result_str, "1.2.3.4");
3569 dns.clearQueries();
3570
3571 // IPv6 DNS query. Prefix should have no effect on it.
3572 result = gethostbyname2("v4v6", AF_INET6);
3573 ASSERT_TRUE(result != nullptr);
3574 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3575 result_str = ToString(result);
3576 EXPECT_EQ(result_str, "2001:db8::102:304");
3577}
3578
3579TEST_F(ResolverTest, GetHostByName2_Dns64QuerySpecialUseIPv4Addresses) {
3580 constexpr char THIS_NETWORK[] = "this_network";
3581 constexpr char LOOPBACK[] = "loopback";
3582 constexpr char LINK_LOCAL[] = "link_local";
3583 constexpr char MULTICAST[] = "multicast";
3584 constexpr char LIMITED_BROADCAST[] = "limited_broadcast";
3585
3586 constexpr char ADDR_THIS_NETWORK[] = "0.0.0.1";
3587 constexpr char ADDR_LOOPBACK[] = "127.0.0.1";
3588 constexpr char ADDR_LINK_LOCAL[] = "169.254.0.1";
3589 constexpr char ADDR_MULTICAST[] = "224.0.0.1";
3590 constexpr char ADDR_LIMITED_BROADCAST[] = "255.255.255.255";
3591
3592 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003593 constexpr char dns64_name[] = "ipv4only.arpa.";
3594
Xiao Ma09b71022018-12-11 17:56:32 +09003595 test::DNSResponder dns(listen_addr);
3596 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::"}});
nuccachena26cc2a2018-07-17 18:07:23 +08003597 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003598 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003599
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003600 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003601 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003602 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003603
Luke Huangf8215372019-11-22 11:53:41 +08003604 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08003605 static const struct TestConfig {
3606 std::string name;
3607 std::string addr;
3608
3609 std::string asHostName() const {
Luke Huangf8215372019-11-22 11:53:41 +08003610 return StringPrintf("%s.example.com.", name.c_str());
nuccachena26cc2a2018-07-17 18:07:23 +08003611 }
3612 } testConfigs[]{
3613 {THIS_NETWORK, ADDR_THIS_NETWORK},
3614 {LOOPBACK, ADDR_LOOPBACK},
3615 {LINK_LOCAL, ADDR_LINK_LOCAL},
3616 {MULTICAST, ADDR_MULTICAST},
3617 {LIMITED_BROADCAST, ADDR_LIMITED_BROADCAST}
3618 };
Luke Huangf8215372019-11-22 11:53:41 +08003619 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08003620
3621 for (const auto& config : testConfigs) {
3622 const std::string testHostName = config.asHostName();
3623 SCOPED_TRACE(testHostName);
3624
3625 const char* host_name = testHostName.c_str();
3626 dns.addMapping(host_name, ns_type::ns_t_a, config.addr.c_str());
3627
3628 struct hostent* result = gethostbyname2(config.name.c_str(), AF_INET6);
3629 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3630
3631 // In AF_INET6 case, don't synthesize special use IPv4 address.
3632 // Expect to have no answer
3633 EXPECT_EQ(nullptr, result);
3634
3635 dns.clearQueries();
3636 }
Bernie Innocenti2fef2b82018-12-20 15:56:40 +09003637}
Mike Yuf14e1a92019-05-10 13:54:58 +08003638
3639TEST_F(ResolverTest, PrefixDiscoveryBypassTls) {
3640 constexpr char listen_addr[] = "::1";
3641 constexpr char cleartext_port[] = "53";
3642 constexpr char tls_port[] = "853";
3643 constexpr char dns64_name[] = "ipv4only.arpa.";
3644 const std::vector<std::string> servers = {listen_addr};
3645
3646 test::DNSResponder dns(listen_addr);
3647 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"}});
3648 test::DnsTlsFrontend tls(listen_addr, tls_port, listen_addr, cleartext_port);
3649 ASSERT_TRUE(tls.startServer());
3650
3651 // Setup OPPORTUNISTIC mode and wait for the validation complete.
waynema0e73c2e2019-07-31 15:04:08 +08003652 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08003653 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003654 EXPECT_TRUE(tls.waitForQueries(1));
Mike Yuf14e1a92019-05-10 13:54:58 +08003655 tls.clearQueries();
3656
3657 // Start NAT64 prefix discovery and wait for it complete.
3658 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003659 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
Mike Yuf14e1a92019-05-10 13:54:58 +08003660
3661 // Verify it bypassed TLS even though there's a TLS server available.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003662 EXPECT_EQ(0, tls.queries()) << dns.dumpQueries();
3663 EXPECT_EQ(1U, GetNumQueries(dns, dns64_name)) << dns.dumpQueries();
Mike Yuf14e1a92019-05-10 13:54:58 +08003664
3665 // Restart the testing network to reset the cache.
3666 mDnsClient.TearDown();
3667 mDnsClient.SetUp();
3668 dns.clearQueries();
3669
3670 // Setup STRICT mode and wait for the validation complete.
waynema0e73c2e2019-07-31 15:04:08 +08003671 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
3672 kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08003673 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003674 EXPECT_TRUE(tls.waitForQueries(1));
Mike Yuf14e1a92019-05-10 13:54:58 +08003675 tls.clearQueries();
3676
3677 // Start NAT64 prefix discovery and wait for it to complete.
3678 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003679 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
Mike Yuf14e1a92019-05-10 13:54:58 +08003680
3681 // Verify it bypassed TLS despite STRICT mode.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003682 EXPECT_EQ(0, tls.queries()) << dns.dumpQueries();
3683 EXPECT_EQ(1U, GetNumQueries(dns, dns64_name)) << dns.dumpQueries();
Mike Yuf14e1a92019-05-10 13:54:58 +08003684}
Luke Huang9807e6b2019-05-20 16:17:12 +08003685
3686namespace {
3687
Luke Huang0d592bc2019-05-25 18:24:03 +08003688class ScopedSetNetworkForProcess {
3689 public:
3690 explicit ScopedSetNetworkForProcess(unsigned netId) {
3691 mStoredNetId = getNetworkForProcess();
3692 if (netId == mStoredNetId) return;
3693 EXPECT_EQ(0, setNetworkForProcess(netId));
3694 }
3695 ~ScopedSetNetworkForProcess() { EXPECT_EQ(0, setNetworkForProcess(mStoredNetId)); }
3696
3697 private:
3698 unsigned mStoredNetId;
3699};
3700
3701class ScopedSetNetworkForResolv {
3702 public:
3703 explicit ScopedSetNetworkForResolv(unsigned netId) { EXPECT_EQ(0, setNetworkForResolv(netId)); }
3704 ~ScopedSetNetworkForResolv() { EXPECT_EQ(0, setNetworkForResolv(NETID_UNSET)); }
3705};
3706
Luke Huang9807e6b2019-05-20 16:17:12 +08003707void sendCommand(int fd, const std::string& cmd) {
3708 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size() + 1));
3709 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size() + 1));
3710}
3711
3712int32_t readBE32(int fd) {
3713 int32_t tmp;
3714 int n = TEMP_FAILURE_RETRY(read(fd, &tmp, sizeof(tmp)));
3715 EXPECT_TRUE(n > 0);
3716 return ntohl(tmp);
3717}
3718
Luke Huang0d592bc2019-05-25 18:24:03 +08003719int readResponseCode(int fd) {
Luke Huang9807e6b2019-05-20 16:17:12 +08003720 char buf[4];
3721 int n = TEMP_FAILURE_RETRY(read(fd, &buf, sizeof(buf)));
3722 EXPECT_TRUE(n > 0);
3723 // The format of response code is that 4 bytes for the code & null.
3724 buf[3] = '\0';
3725 int result;
3726 EXPECT_TRUE(ParseInt(buf, &result));
3727 return result;
3728}
3729
Luke Huang0d592bc2019-05-25 18:24:03 +08003730bool checkAndClearUseLocalNameserversFlag(unsigned* netid) {
3731 if (netid == nullptr || ((*netid) & NETID_USE_LOCAL_NAMESERVERS) == 0) {
3732 return false;
3733 }
3734 *netid = (*netid) & ~NETID_USE_LOCAL_NAMESERVERS;
3735 return true;
3736}
3737
Luke Huangf8215372019-11-22 11:53:41 +08003738aidl::android::net::UidRangeParcel makeUidRangeParcel(int start, int stop) {
3739 aidl::android::net::UidRangeParcel res;
Luke Huang0d592bc2019-05-25 18:24:03 +08003740 res.start = start;
3741 res.stop = stop;
3742
3743 return res;
3744}
3745
3746void expectNetIdWithLocalNameserversFlag(unsigned netId) {
3747 unsigned dnsNetId = 0;
3748 EXPECT_EQ(0, getNetworkForDns(&dnsNetId));
3749 EXPECT_TRUE(checkAndClearUseLocalNameserversFlag(&dnsNetId));
3750 EXPECT_EQ(netId, static_cast<unsigned>(dnsNetId));
3751}
3752
3753void expectDnsNetIdEquals(unsigned netId) {
3754 unsigned dnsNetId = 0;
3755 EXPECT_EQ(0, getNetworkForDns(&dnsNetId));
3756 EXPECT_EQ(netId, static_cast<unsigned>(dnsNetId));
3757}
3758
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003759void expectDnsNetIdIsDefaultNetwork(INetd* netdService) {
Luke Huang0d592bc2019-05-25 18:24:03 +08003760 int currentNetid;
3761 EXPECT_TRUE(netdService->networkGetDefault(&currentNetid).isOk());
3762 expectDnsNetIdEquals(currentNetid);
3763}
3764
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003765void expectDnsNetIdWithVpn(INetd* netdService, unsigned vpnNetId, unsigned expectedNetId) {
Luke Huang0d592bc2019-05-25 18:24:03 +08003766 EXPECT_TRUE(netdService->networkCreateVpn(vpnNetId, false /* secure */).isOk());
3767 uid_t uid = getuid();
3768 // Add uid to VPN
3769 EXPECT_TRUE(netdService->networkAddUidRanges(vpnNetId, {makeUidRangeParcel(uid, uid)}).isOk());
3770 expectDnsNetIdEquals(expectedNetId);
3771 EXPECT_TRUE(netdService->networkDestroy(vpnNetId).isOk());
3772}
3773
Luke Huang9807e6b2019-05-20 16:17:12 +08003774} // namespace
3775
3776TEST_F(ResolverTest, getDnsNetId) {
3777 // We've called setNetworkForProcess in SetupOemNetwork, so reset to default first.
3778 setNetworkForProcess(NETID_UNSET);
Luke Huang0d592bc2019-05-25 18:24:03 +08003779
3780 expectDnsNetIdIsDefaultNetwork(mDnsClient.netdService());
3781 expectDnsNetIdWithVpn(mDnsClient.netdService(), TEST_VPN_NETID, TEST_VPN_NETID);
Luke Huang9807e6b2019-05-20 16:17:12 +08003782
3783 // Test with setNetworkForProcess
Luke Huang0d592bc2019-05-25 18:24:03 +08003784 {
3785 ScopedSetNetworkForProcess scopedSetNetworkForProcess(TEST_NETID);
3786 expectDnsNetIdEquals(TEST_NETID);
3787 }
3788
3789 // Test with setNetworkForProcess with NETID_USE_LOCAL_NAMESERVERS
3790 {
3791 ScopedSetNetworkForProcess scopedSetNetworkForProcess(TEST_NETID |
3792 NETID_USE_LOCAL_NAMESERVERS);
3793 expectNetIdWithLocalNameserversFlag(TEST_NETID);
3794 }
Luke Huang9807e6b2019-05-20 16:17:12 +08003795
3796 // Test with setNetworkForResolv
Luke Huang0d592bc2019-05-25 18:24:03 +08003797 {
3798 ScopedSetNetworkForResolv scopedSetNetworkForResolv(TEST_NETID);
3799 expectDnsNetIdEquals(TEST_NETID);
3800 }
3801
3802 // Test with setNetworkForResolv with NETID_USE_LOCAL_NAMESERVERS
3803 {
3804 ScopedSetNetworkForResolv scopedSetNetworkForResolv(TEST_NETID |
3805 NETID_USE_LOCAL_NAMESERVERS);
3806 expectNetIdWithLocalNameserversFlag(TEST_NETID);
3807 }
3808
3809 // Test with setNetworkForResolv under bypassable vpn
3810 {
3811 ScopedSetNetworkForResolv scopedSetNetworkForResolv(TEST_NETID);
3812 expectDnsNetIdWithVpn(mDnsClient.netdService(), TEST_VPN_NETID, TEST_NETID);
3813 }
Luke Huang9807e6b2019-05-20 16:17:12 +08003814
3815 // Create socket connected to DnsProxyListener
3816 int fd = dns_open_proxy();
3817 EXPECT_TRUE(fd > 0);
3818 unique_fd ufd(fd);
3819
3820 // Test command with wrong netId
3821 sendCommand(fd, "getdnsnetid abc");
Luke Huang0d592bc2019-05-25 18:24:03 +08003822 EXPECT_EQ(ResponseCode::DnsProxyQueryResult, readResponseCode(fd));
Luke Huang9807e6b2019-05-20 16:17:12 +08003823 EXPECT_EQ(-EINVAL, readBE32(fd));
3824
3825 // Test unsupported command
3826 sendCommand(fd, "getdnsnetidNotSupported");
3827 // Keep in sync with FrameworkListener.cpp (500, "Command not recognized")
Luke Huang0d592bc2019-05-25 18:24:03 +08003828 EXPECT_EQ(500, readResponseCode(fd));
Luke Huang9807e6b2019-05-20 16:17:12 +08003829}
Sehee Park2c118782019-05-07 13:02:45 +09003830
3831TEST_F(ResolverTest, BlockDnsQueryWithUidRule) {
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003832 // This test relies on blocking traffic on loopback, which xt_qtaguid does not do.
3833 // See aosp/358413 and b/34444781 for why.
3834 SKIP_IF_BPF_NOT_SUPPORTED;
3835
Sehee Park2c118782019-05-07 13:02:45 +09003836 constexpr char listen_addr1[] = "127.0.0.4";
3837 constexpr char listen_addr2[] = "::1";
3838 constexpr char host_name[] = "howdy.example.com.";
3839 const std::vector<DnsRecord> records = {
3840 {host_name, ns_type::ns_t_a, "1.2.3.4"},
3841 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
3842 };
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003843 INetd* netdService = mDnsClient.netdService();
Sehee Park2c118782019-05-07 13:02:45 +09003844
3845 test::DNSResponder dns1(listen_addr1);
3846 test::DNSResponder dns2(listen_addr2);
3847 StartDns(dns1, records);
3848 StartDns(dns2, records);
3849
3850 std::vector<std::string> servers = {listen_addr1, listen_addr2};
3851 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
3852 dns1.clearQueries();
3853 dns2.clearQueries();
3854
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003855 // Add drop rule for TEST_UID. Also enable the standby chain because it might not be enabled.
3856 // Unfortunately we cannot use FIREWALL_CHAIN_NONE, or custom iptables rules, for this purpose
3857 // because netd calls fchown() on the DNS query sockets, and "iptables -m owner" matches the
3858 // UID of the socket creator, not the UID set by fchown().
3859 //
3860 // TODO: migrate FIREWALL_CHAIN_NONE to eBPF as well.
3861 EXPECT_TRUE(netdService->firewallEnableChildChain(INetd::FIREWALL_CHAIN_STANDBY, true).isOk());
3862 EXPECT_TRUE(netdService
Sehee Park2c118782019-05-07 13:02:45 +09003863 ->firewallSetUidRule(INetd::FIREWALL_CHAIN_STANDBY, TEST_UID,
3864 INetd::FIREWALL_RULE_DENY)
3865 .isOk());
3866
3867 // Save uid
3868 int suid = getuid();
3869
3870 // Switch to TEST_UID
3871 EXPECT_TRUE(seteuid(TEST_UID) == 0);
3872
3873 // Dns Query
3874 int fd1 = resNetworkQuery(TEST_NETID, host_name, ns_c_in, ns_t_a, 0);
3875 int fd2 = resNetworkQuery(TEST_NETID, host_name, ns_c_in, ns_t_aaaa, 0);
3876 EXPECT_TRUE(fd1 != -1);
3877 EXPECT_TRUE(fd2 != -1);
3878
3879 uint8_t buf[MAXPACKET] = {};
3880 int rcode;
3881 int res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
3882 EXPECT_EQ(-ECONNREFUSED, res);
3883
3884 memset(buf, 0, MAXPACKET);
3885 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
3886 EXPECT_EQ(-ECONNREFUSED, res);
3887
3888 // Restore uid
3889 EXPECT_TRUE(seteuid(suid) == 0);
3890
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003891 // Remove drop rule for TEST_UID, and disable the standby chain.
3892 EXPECT_TRUE(netdService
Sehee Park2c118782019-05-07 13:02:45 +09003893 ->firewallSetUidRule(INetd::FIREWALL_CHAIN_STANDBY, TEST_UID,
3894 INetd::FIREWALL_RULE_ALLOW)
3895 .isOk());
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003896 EXPECT_TRUE(netdService->firewallEnableChildChain(INetd::FIREWALL_CHAIN_STANDBY, false).isOk());
Sehee Park2c118782019-05-07 13:02:45 +09003897}
Mike Yua772c202019-09-23 17:47:21 +08003898
Mike Yu40e67072019-10-09 21:14:09 +08003899namespace {
3900
3901const std::string kDotConnectTimeoutMsFlag(
3902 "persist.device_config.netd_native.dot_connect_timeout_ms");
3903
3904class ScopedSystemProperties {
3905 public:
3906 explicit ScopedSystemProperties(const std::string& key, const std::string& value)
3907 : mStoredKey(key) {
3908 mStoredValue = android::base::GetProperty(key, "");
3909 android::base::SetProperty(key, value);
3910 }
3911 ~ScopedSystemProperties() { android::base::SetProperty(mStoredKey, mStoredValue); }
3912
3913 private:
3914 std::string mStoredKey;
3915 std::string mStoredValue;
3916};
3917
3918} // namespace
3919
Mike Yua772c202019-09-23 17:47:21 +08003920TEST_F(ResolverTest, ConnectTlsServerTimeout) {
Mike Yu40e67072019-10-09 21:14:09 +08003921 constexpr int expectedTimeout = 1000;
3922 constexpr char hostname1[] = "query1.example.com.";
3923 constexpr char hostname2[] = "query2.example.com.";
Mike Yua772c202019-09-23 17:47:21 +08003924 const std::vector<DnsRecord> records = {
Mike Yu40e67072019-10-09 21:14:09 +08003925 {hostname1, ns_type::ns_t_a, "1.2.3.4"},
3926 {hostname2, ns_type::ns_t_a, "1.2.3.5"},
Mike Yua772c202019-09-23 17:47:21 +08003927 };
3928
3929 test::DNSResponder dns;
3930 StartDns(dns, records);
Mike Yu40e67072019-10-09 21:14:09 +08003931 test::DnsTlsFrontend tls;
Mike Yua772c202019-09-23 17:47:21 +08003932 ASSERT_TRUE(tls.startServer());
3933
Mike Yu40e67072019-10-09 21:14:09 +08003934 // The resolver will adjust the timeout value to 1000ms since the value is too small.
3935 ScopedSystemProperties scopedSystemProperties(kDotConnectTimeoutMsFlag, "100");
Mike Yua772c202019-09-23 17:47:21 +08003936
Mike Yu40e67072019-10-09 21:14:09 +08003937 // Set up resolver to opportunistic mode with the default configuration.
Mike Yu8ac63402019-12-02 15:28:38 +08003938 const ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
Mike Yu40e67072019-10-09 21:14:09 +08003939 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
Mike Yua772c202019-09-23 17:47:21 +08003940 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003941 EXPECT_TRUE(tls.waitForQueries(1));
Mike Yua772c202019-09-23 17:47:21 +08003942 tls.clearQueries();
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003943 dns.clearQueries();
Mike Yua772c202019-09-23 17:47:21 +08003944
3945 // The server becomes unresponsive to the handshake request.
3946 tls.setHangOnHandshakeForTesting(true);
3947
3948 // Expect the things happening in getaddrinfo():
3949 // 1. Connect to the private DNS server.
3950 // 2. SSL handshake times out.
3951 // 3. Fallback to UDP transport, and then get the answer.
Mike Yu40e67072019-10-09 21:14:09 +08003952 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
3953 auto [result, timeTakenMs] = safe_getaddrinfo_time_taken(hostname1, nullptr, hints);
Mike Yua772c202019-09-23 17:47:21 +08003954
Mike Yu40e67072019-10-09 21:14:09 +08003955 EXPECT_NE(nullptr, result);
Mike Yua772c202019-09-23 17:47:21 +08003956 EXPECT_EQ(0, tls.queries());
Mike Yu40e67072019-10-09 21:14:09 +08003957 EXPECT_EQ(1U, GetNumQueries(dns, hostname1));
3958 EXPECT_EQ(records.at(0).addr, ToString(result));
Mike Yua772c202019-09-23 17:47:21 +08003959
Mike Yu40e67072019-10-09 21:14:09 +08003960 // A loose upper bound is set by adding 2000ms buffer time. Theoretically, getaddrinfo()
3961 // should just take a bit more than expetTimeout milliseconds.
3962 EXPECT_GE(timeTakenMs, expectedTimeout);
3963 EXPECT_LE(timeTakenMs, expectedTimeout + 2000);
3964
3965 // Set the server to be responsive. Verify that the resolver will attempt to reconnect
3966 // to the server and then get the result within the timeout.
3967 tls.setHangOnHandshakeForTesting(false);
3968 std::tie(result, timeTakenMs) = safe_getaddrinfo_time_taken(hostname2, nullptr, hints);
3969
3970 EXPECT_NE(nullptr, result);
Luke Huang3caa42b2020-04-23 14:18:04 +00003971 EXPECT_TRUE(tls.waitForQueries(1));
Mike Yu40e67072019-10-09 21:14:09 +08003972 EXPECT_EQ(1U, GetNumQueries(dns, hostname2));
3973 EXPECT_EQ(records.at(1).addr, ToString(result));
3974
3975 EXPECT_LE(timeTakenMs, expectedTimeout);
Mike Yua772c202019-09-23 17:47:21 +08003976}
Hungming Chenbb90ab32019-10-28 18:20:31 +08003977
Ken Chen766feae2019-10-30 15:13:44 +08003978TEST_F(ResolverTest, FlushNetworkCache) {
Luke Huang0b5a76c2019-11-23 03:00:00 +08003979 SKIP_IF_REMOTE_VERSION_LESS_THAN(mDnsClient.resolvService(), 4);
Ken Chen766feae2019-10-30 15:13:44 +08003980 test::DNSResponder dns;
3981 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
3982 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3983
3984 const hostent* result = gethostbyname("hello");
3985 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
3986
3987 // get result from cache
3988 result = gethostbyname("hello");
3989 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
3990
3991 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
3992
3993 result = gethostbyname("hello");
3994 EXPECT_EQ(2U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
3995}
3996
3997TEST_F(ResolverTest, FlushNetworkCache_random) {
Luke Huang0b5a76c2019-11-23 03:00:00 +08003998 SKIP_IF_REMOTE_VERSION_LESS_THAN(mDnsClient.resolvService(), 4);
Ken Chen766feae2019-10-30 15:13:44 +08003999 constexpr int num_flush = 10;
4000 constexpr int num_queries = 20;
4001 test::DNSResponder dns;
4002 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
4003 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4004 const addrinfo hints = {.ai_family = AF_INET};
4005
4006 std::thread t([this]() {
4007 for (int i = 0; i < num_flush; ++i) {
4008 unsigned delay = arc4random_uniform(10 * 1000); // 10ms
4009 usleep(delay);
4010 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
4011 }
4012 });
4013
4014 for (int i = 0; i < num_queries; ++i) {
4015 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
4016 EXPECT_TRUE(result != nullptr);
4017 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4018 }
4019 t.join();
4020}
4021
4022// flush cache while one query is wait-for-response, another is pending.
4023TEST_F(ResolverTest, FlushNetworkCache_concurrent) {
Luke Huang0b5a76c2019-11-23 03:00:00 +08004024 SKIP_IF_REMOTE_VERSION_LESS_THAN(mDnsClient.resolvService(), 4);
Ken Chen766feae2019-10-30 15:13:44 +08004025 const char* listen_addr1 = "127.0.0.9";
4026 const char* listen_addr2 = "127.0.0.10";
4027 test::DNSResponder dns1(listen_addr1);
4028 test::DNSResponder dns2(listen_addr2);
4029 StartDns(dns1, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
4030 StartDns(dns2, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
4031 addrinfo hints = {.ai_family = AF_INET};
4032
4033 // step 1: set server#1 into deferred responding mode
4034 dns1.setDeferredResp(true);
4035 std::thread t1([&listen_addr1, &hints, this]() {
4036 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr1}));
4037 // step 3: query
4038 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
4039 // step 9: check result
4040 EXPECT_TRUE(result != nullptr);
4041 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4042 });
4043
4044 // step 2: wait for the query to reach the server
4045 while (GetNumQueries(dns1, kHelloExampleCom) == 0) {
4046 usleep(1000); // 1ms
4047 }
4048
4049 std::thread t2([&listen_addr2, &hints, &dns2, this]() {
4050 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr2}));
4051 // step 5: query (should be blocked in resolver)
4052 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
4053 // step 7: check result
4054 EXPECT_TRUE(result != nullptr);
4055 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4056 EXPECT_EQ(1U, GetNumQueriesForType(dns2, ns_type::ns_t_a, kHelloExampleCom));
4057 });
4058
4059 // step 4: wait a bit for the 2nd query to enter pending state
4060 usleep(100 * 1000); // 100ms
4061 // step 6: flush cache (will unblock pending queries)
4062 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
4063 t2.join();
4064
4065 // step 8: resume server#1
4066 dns1.setDeferredResp(false);
4067 t1.join();
4068
4069 // step 10: verify if result is correctly cached
4070 dns2.clearQueries();
4071 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
4072 EXPECT_EQ(0U, GetNumQueries(dns2, kHelloExampleCom));
4073 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4074}
4075
waynema29253052019-08-20 11:26:08 +08004076// TODO: Perhaps to have a boundary conditions test for TCP and UDP.
4077TEST_F(ResolverTest, TcpQueryWithOversizePayload) {
4078 test::DNSResponder dns;
4079 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
4080 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4081
4082 int fd = dns_open_proxy();
4083 ASSERT_TRUE(fd > 0);
4084
4085 // Sending DNS query over TCP once the packet sizes exceed 512 bytes.
4086 // The raw data is combined with Question section and Additional section
4087 // Question section : query "hello.example.com", type A, class IN
4088 // Additional section : type OPT (41), Option PADDING, Option Length 546
4089 // Padding option which allows DNS clients and servers to artificially
4090 // increase the size of a DNS message by a variable number of bytes.
4091 // See also RFC7830, section 3
4092 const std::string query =
4093 "+c0BAAABAAAAAAABBWhlbGxvB2V4YW1wbGUDY29tAAABAAEAACkgAAAAgAACJgAMAiIAAAAAAAAAAAAAAAAAA"
4094 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4095 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4096 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4097 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4098 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4099 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4100 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4101 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
4102 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
4103 const std::string cmd =
4104 "resnsend " + std::to_string(TEST_NETID) + " 0 " /* ResNsendFlags */ + query + '\0';
4105 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size()));
4106 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size()));
4107 expectAnswersValid(fd, AF_INET, kHelloExampleComAddrV4);
4108 EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom));
4109 EXPECT_EQ(0U, GetNumQueriesForProtocol(dns, IPPROTO_UDP, kHelloExampleCom));
4110}
4111
Ken Chen99344882020-01-01 14:59:38 +08004112TEST_F(ResolverTest, TruncatedRspMode) {
4113 constexpr char listen_addr[] = "127.0.0.4";
4114 constexpr char listen_addr2[] = "127.0.0.5";
4115 constexpr char listen_srv[] = "53";
4116
4117 test::DNSResponder dns(listen_addr, listen_srv, static_cast<ns_rcode>(-1));
4118 test::DNSResponder dns2(listen_addr2, listen_srv, static_cast<ns_rcode>(-1));
4119 // dns supports UDP only, dns2 support UDP and TCP
4120 dns.setResponseProbability(0.0, IPPROTO_TCP);
4121 StartDns(dns, kLargeCnameChainRecords);
4122 StartDns(dns2, kLargeCnameChainRecords);
4123
4124 const struct TestConfig {
4125 const std::optional<int32_t> tcMode;
4126 const bool ret;
4127 const unsigned numQueries;
4128 std::string asParameters() const {
4129 return StringPrintf("tcMode: %d, ret: %s, numQueries: %u", tcMode.value_or(-1),
4130 ret ? "true" : "false", numQueries);
4131 }
4132 } testConfigs[]{
4133 // clang-format off
4134 {std::nullopt, true, 0}, /* mode unset */
4135 {aidl::android::net::IDnsResolver::TC_MODE_DEFAULT, true, 0}, /* default mode */
4136 {aidl::android::net::IDnsResolver::TC_MODE_UDP_TCP, true, 1}, /* alternative mode */
4137 {-666, false, 1}, /* invalid input */
4138 // clang-format on
4139 };
4140
4141 for (const auto& config : testConfigs) {
4142 SCOPED_TRACE(config.asParameters());
4143
4144 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
4145 parcel.servers = {listen_addr, listen_addr2};
4146 if (config.tcMode) {
Ken Chen05420812020-04-07 18:58:38 +00004147 parcel.resolverOptions.tcMode = config.tcMode.value();
Ken Chen99344882020-01-01 14:59:38 +08004148 }
4149 ASSERT_EQ(mDnsClient.resolvService()->setResolverConfiguration(parcel).isOk(), config.ret);
4150
4151 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
4152 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
4153 ASSERT_TRUE(result != nullptr);
4154 EXPECT_EQ(ToString(result), kHelloExampleComAddrV4);
4155 // TC_MODE_DEFAULT: resolver retries on TCP-only on each name server.
4156 // TC_MODE_UDP_TCP: resolver retries on TCP on the same server, falls back to UDP from next.
4157 ASSERT_EQ(GetNumQueriesForProtocol(dns, IPPROTO_UDP, kHelloExampleCom), 1U);
4158 ASSERT_EQ(GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom), 1U);
4159 ASSERT_EQ(GetNumQueriesForProtocol(dns2, IPPROTO_UDP, kHelloExampleCom), config.numQueries);
4160 ASSERT_EQ(GetNumQueriesForProtocol(dns2, IPPROTO_TCP, kHelloExampleCom), 1U);
4161
4162 dns.clearQueries();
4163 dns2.clearQueries();
4164 ASSERT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
4165 }
4166}
4167
Mike Yuc0000252020-03-19 07:14:23 +00004168TEST_F(ResolverTest, RepeatedSetup_ResolverStatusRemains) {
4169 constexpr char unusable_listen_addr[] = "127.0.0.3";
4170 constexpr char listen_addr[] = "127.0.0.4";
4171 constexpr char hostname[] = "a.hello.query.";
4172 const auto repeatedSetResolversFromParcel = [&](const ResolverParamsParcel& parcel) {
4173 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4174 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4175 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4176 };
4177
4178 test::DNSResponder dns(listen_addr);
4179 StartDns(dns, {{hostname, ns_type::ns_t_a, "1.2.3.3"}});
4180 test::DnsTlsFrontend tls1(listen_addr, "853", listen_addr, "53");
4181 ASSERT_TRUE(tls1.startServer());
4182
4183 // Private DNS off mode.
4184 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
4185 parcel.servers = {unusable_listen_addr, listen_addr};
4186 parcel.tlsServers.clear();
4187 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4188
4189 // Send a query.
4190 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
4191 EXPECT_NE(safe_getaddrinfo(hostname, nullptr, &hints), nullptr);
4192
4193 // Check the stats as expected.
4194 const std::vector<NameserverStats> expectedCleartextDnsStats = {
4195 NameserverStats(unusable_listen_addr).setInternalErrors(1),
4196 NameserverStats(listen_addr).setSuccesses(1),
4197 };
4198 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
4199 EXPECT_EQ(GetNumQueries(dns, hostname), 1U);
4200
4201 // The stats is supposed to remain as long as the list of cleartext DNS servers is unchanged.
4202 static const struct TestConfig {
4203 std::vector<std::string> servers;
4204 std::vector<std::string> tlsServers;
4205 std::string tlsName;
4206 } testConfigs[] = {
4207 // Private DNS opportunistic mode.
4208 {{listen_addr, unusable_listen_addr}, {listen_addr, unusable_listen_addr}, ""},
4209 {{unusable_listen_addr, listen_addr}, {unusable_listen_addr, listen_addr}, ""},
4210
4211 // Private DNS strict mode.
4212 {{listen_addr, unusable_listen_addr}, {"127.0.0.100"}, kDefaultPrivateDnsHostName},
4213 {{unusable_listen_addr, listen_addr}, {"127.0.0.100"}, kDefaultPrivateDnsHostName},
4214
4215 // Private DNS off mode.
4216 {{unusable_listen_addr, listen_addr}, {}, ""},
4217 {{listen_addr, unusable_listen_addr}, {}, ""},
4218 };
4219
4220 for (const auto& config : testConfigs) {
4221 SCOPED_TRACE(fmt::format("testConfig: [{}] [{}] [{}]", fmt::join(config.servers, ","),
4222 fmt::join(config.tlsServers, ","), config.tlsName));
4223 parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
4224 parcel.servers = config.servers;
4225 parcel.tlsServers = config.tlsServers;
4226 parcel.tlsName = config.tlsName;
4227 repeatedSetResolversFromParcel(parcel);
4228 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
4229
4230 // The stats remains when the list of search domains changes.
4231 parcel.domains.push_back("tmp.domains");
4232 repeatedSetResolversFromParcel(parcel);
4233 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
4234
4235 // The stats remains when the parameters change (except maxSamples).
4236 parcel.sampleValiditySeconds++;
4237 parcel.successThreshold++;
4238 parcel.minSamples++;
4239 parcel.baseTimeoutMsec++;
4240 parcel.retryCount++;
4241 repeatedSetResolversFromParcel(parcel);
4242 EXPECT_TRUE(expectStatsFromGetResolverInfo(expectedCleartextDnsStats));
4243 }
4244
4245 // The cache remains.
4246 EXPECT_NE(safe_getaddrinfo(hostname, nullptr, &hints), nullptr);
4247 EXPECT_EQ(GetNumQueries(dns, hostname), 1U);
4248}
4249
4250TEST_F(ResolverTest, RepeatedSetup_NoRedundantPrivateDnsValidation) {
4251 const std::string addr1 = getUniqueIPv4Address(); // For a workable DNS server.
4252 const std::string addr2 = getUniqueIPv4Address(); // For an unresponsive DNS server.
4253 const std::string unusable_addr = getUniqueIPv4Address();
Mike Yu1ec523a2020-03-20 12:22:24 +00004254 const auto waitForPrivateDnsStateUpdated = []() {
4255 // A buffer time for the PrivateDnsConfiguration instance to update its map,
4256 // mPrivateDnsValidateThreads, which is used for tracking validation threads.
4257 // Since there is a time gap between when PrivateDnsConfiguration reports
4258 // onPrivateDnsValidationEvent and when PrivateDnsConfiguration updates the map, this is a
4259 // workaround to avoid the test starts a subsequent resolver setup during the time gap.
4260 // TODO: Report onPrivateDnsValidationEvent after all the relevant updates are complete.
4261 // Reference to b/152009023.
4262 std::this_thread::sleep_for(20ms);
4263 };
Mike Yuc0000252020-03-19 07:14:23 +00004264
4265 test::DNSResponder dns1(addr1);
4266 test::DNSResponder dns2(addr2);
4267 StartDns(dns1, {});
4268 StartDns(dns2, {});
4269 test::DnsTlsFrontend workableTls(addr1, "853", addr1, "53");
4270 test::DnsTlsFrontend unresponsiveTls(addr2, "853", addr2, "53");
4271 unresponsiveTls.setHangOnHandshakeForTesting(true);
4272 ASSERT_TRUE(workableTls.startServer());
4273 ASSERT_TRUE(unresponsiveTls.startServer());
4274
4275 // First setup.
4276 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
4277 parcel.servers = {addr1, addr2, unusable_addr};
4278 parcel.tlsServers = {addr1, addr2, unusable_addr};
4279 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4280
4281 // Check the validation results.
4282 EXPECT_TRUE(WaitForPrivateDnsValidation(workableTls.listen_address(), true));
4283 EXPECT_TRUE(WaitForPrivateDnsValidation(unusable_addr, false));
4284 EXPECT_EQ(unresponsiveTls.acceptConnectionsCount(), 1); // The validation is still in progress.
4285
4286 static const struct TestConfig {
4287 std::vector<std::string> tlsServers;
4288 std::string tlsName;
4289 } testConfigs[] = {
4290 {{addr1, addr2, unusable_addr}, ""},
4291 {{unusable_addr, addr1, addr2}, ""},
4292 {{unusable_addr, addr1, addr2}, kDefaultPrivateDnsHostName},
4293 {{addr1, addr2, unusable_addr}, kDefaultPrivateDnsHostName},
4294 };
4295
4296 std::string TlsNameLastTime;
4297 for (const auto& config : testConfigs) {
4298 SCOPED_TRACE(fmt::format("testConfig: [{}] [{}]", fmt::join(config.tlsServers, ","),
4299 config.tlsName));
4300 parcel.servers = config.tlsServers;
4301 parcel.tlsServers = config.tlsServers;
4302 parcel.tlsName = config.tlsName;
4303 parcel.caCertificate = config.tlsName.empty() ? "" : kCaCert;
4304
4305 const bool dnsModeChanged = (TlsNameLastTime != config.tlsName);
Mike Yu1ec523a2020-03-20 12:22:24 +00004306
4307 waitForPrivateDnsStateUpdated();
Mike Yuc0000252020-03-19 07:14:23 +00004308 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4309
4310 for (const auto& serverAddr : parcel.tlsServers) {
4311 SCOPED_TRACE(serverAddr);
4312 if (serverAddr == workableTls.listen_address()) {
4313 if (dnsModeChanged) {
4314 // In despite of the identical IP address, the server is regarded as a different
4315 // server when DnsTlsServer.name is different. The resolver treats it as a
4316 // different object and begins the validation process.
4317 EXPECT_TRUE(WaitForPrivateDnsValidation(serverAddr, true));
4318 }
4319 } else if (serverAddr == unresponsiveTls.listen_address()) {
4320 // No revalidation needed for the server which have been marked as in_progesss.
4321 } else {
4322 // Must be unusable_addr.
4323 // In opportunistic mode, when a validation for a private DNS server fails, the
4324 // resolver just marks the server as failed and doesn't re-evaluate it, but the
4325 // server can be re-evaluated when setResolverConfiguration() is called.
4326 // However, in strict mode, the resolver automatically re-evaluates the server and
4327 // marks the server as in_progress until the validation succeeds, so repeated setup
4328 // makes no effect.
4329 if (dnsModeChanged || config.tlsName.empty() /* not in strict mode */) {
4330 EXPECT_TRUE(WaitForPrivateDnsValidation(serverAddr, false));
4331 }
4332 }
4333 }
4334
4335 // Repeated setups make no effect in strict mode.
Mike Yu1ec523a2020-03-20 12:22:24 +00004336 waitForPrivateDnsStateUpdated();
Mike Yuc0000252020-03-19 07:14:23 +00004337 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4338 if (config.tlsName.empty()) {
4339 EXPECT_TRUE(WaitForPrivateDnsValidation(unusable_addr, false));
4340 }
Mike Yu1ec523a2020-03-20 12:22:24 +00004341 waitForPrivateDnsStateUpdated();
Mike Yuc0000252020-03-19 07:14:23 +00004342 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4343 if (config.tlsName.empty()) {
4344 EXPECT_TRUE(WaitForPrivateDnsValidation(unusable_addr, false));
4345 }
4346
4347 EXPECT_EQ(unresponsiveTls.acceptConnectionsCount(), 1);
4348
4349 TlsNameLastTime = config.tlsName;
4350 }
4351
4352 // Check that all the validation results are caught.
4353 // Note: it doesn't mean no validation being in progress.
4354 EXPECT_FALSE(hasUncaughtPrivateDnsValidation(addr1));
4355 EXPECT_FALSE(hasUncaughtPrivateDnsValidation(addr2));
4356 EXPECT_FALSE(hasUncaughtPrivateDnsValidation(unusable_addr));
4357}
4358
4359TEST_F(ResolverTest, RepeatedSetup_KeepChangingPrivateDnsServers) {
4360 enum TlsServerState { WORKING, UNSUPPORTED, UNRESPONSIVE };
4361 const std::string addr1 = getUniqueIPv4Address();
4362 const std::string addr2 = getUniqueIPv4Address();
Mike Yubad95cf2020-03-26 03:19:38 +00004363 const auto waitForPrivateDnsStateUpdated = []() {
4364 // A buffer time for PrivateDnsConfiguration to update its state. It prevents this test
4365 // being flaky. See b/152009023 for the reason.
4366 std::this_thread::sleep_for(20ms);
4367 };
Mike Yuc0000252020-03-19 07:14:23 +00004368
4369 test::DNSResponder dns1(addr1);
4370 test::DNSResponder dns2(addr2);
4371 StartDns(dns1, {});
4372 StartDns(dns2, {});
4373 test::DnsTlsFrontend tls1(addr1, "853", addr1, "53");
4374 test::DnsTlsFrontend tls2(addr2, "853", addr2, "53");
4375 ASSERT_TRUE(tls1.startServer());
4376 ASSERT_TRUE(tls2.startServer());
4377
4378 static const struct TestConfig {
4379 std::string tlsServer;
4380 std::string tlsName;
4381 bool expectNothingHappenWhenServerUnsupported;
4382 bool expectNothingHappenWhenServerUnresponsive;
4383 std::string asTestName() const {
4384 return fmt::format("{}, {}, {}, {}", tlsServer, tlsName,
4385 expectNothingHappenWhenServerUnsupported,
4386 expectNothingHappenWhenServerUnresponsive);
4387 }
4388 } testConfigs[] = {
4389 {{addr1}, "", false, false},
4390 {{addr2}, "", false, false},
4391 {{addr1}, "", false, true},
4392 {{addr2}, "", false, true},
4393 {{addr1}, kDefaultPrivateDnsHostName, false, true},
4394 {{addr2}, kDefaultPrivateDnsHostName, false, true},
4395 {{addr1}, kDefaultPrivateDnsHostName, true, true},
4396 {{addr2}, kDefaultPrivateDnsHostName, true, true},
4397
4398 // There's no new validation to start because there are already two validation threads
4399 // running (one is for addr1, the other is for addr2). This is because the comparator
4400 // doesn't compare DnsTlsServer.name. Keep the design as-is until it's known to be
4401 // harmful.
4402 {{addr1}, "", true, true},
4403 {{addr2}, "", true, true},
4404 {{addr1}, "", true, true},
4405 {{addr2}, "", true, true},
4406 };
4407
4408 for (const auto& serverState : {WORKING, UNSUPPORTED, UNRESPONSIVE}) {
4409 int testIndex = 0;
4410 for (const auto& config : testConfigs) {
4411 SCOPED_TRACE(fmt::format("serverState:{} testIndex:{} testConfig:[{}]", serverState,
4412 testIndex++, config.asTestName()));
4413 auto& tls = (config.tlsServer == addr1) ? tls1 : tls2;
4414
4415 if (serverState == UNSUPPORTED && tls.running()) ASSERT_TRUE(tls.stopServer());
4416 if (serverState != UNSUPPORTED && !tls.running()) ASSERT_TRUE(tls.startServer());
4417
4418 tls.setHangOnHandshakeForTesting(serverState == UNRESPONSIVE);
4419 const int connectCountsBefore = tls.acceptConnectionsCount();
4420
Mike Yubad95cf2020-03-26 03:19:38 +00004421 waitForPrivateDnsStateUpdated();
Mike Yuc0000252020-03-19 07:14:23 +00004422 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
4423 parcel.servers = {config.tlsServer};
4424 parcel.tlsServers = {config.tlsServer};
4425 parcel.tlsName = config.tlsName;
4426 parcel.caCertificate = config.tlsName.empty() ? "" : kCaCert;
4427 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
4428
4429 if (serverState == WORKING) {
4430 EXPECT_TRUE(WaitForPrivateDnsValidation(config.tlsServer, true));
4431 } else if (serverState == UNSUPPORTED) {
4432 if (config.expectNothingHappenWhenServerUnsupported) {
4433 // It's possible that the resolver hasn't yet started to
4434 // connect. Wait a while.
4435 // TODO: See if we can get rid of the hard waiting time, such as comparing
4436 // the CountDiff across two tests.
4437 std::this_thread::sleep_for(100ms);
4438 EXPECT_EQ(tls.acceptConnectionsCount(), connectCountsBefore);
4439 } else {
4440 EXPECT_TRUE(WaitForPrivateDnsValidation(config.tlsServer, false));
4441 }
4442 } else {
4443 // Must be UNRESPONSIVE.
4444 // DnsTlsFrontend is the only signal for checking whether or not the resolver starts
4445 // another validation when the server is unresponsive.
4446 const int expectCountDiff =
4447 config.expectNothingHappenWhenServerUnresponsive ? 0 : 1;
4448 if (expectCountDiff == 0) {
4449 // It's possible that the resolver hasn't yet started to
4450 // connect. Wait a while.
4451 std::this_thread::sleep_for(100ms);
4452 }
4453 const auto condition = [&]() {
4454 return tls.acceptConnectionsCount() == connectCountsBefore + expectCountDiff;
4455 };
4456 EXPECT_TRUE(PollForCondition(condition));
4457 }
4458 }
4459
4460 // Set to off mode to reset the PrivateDnsConfiguration state.
4461 ResolverParamsParcel setupOffmode = DnsResponderClient::GetDefaultResolverParamsParcel();
4462 setupOffmode.tlsServers.clear();
4463 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(setupOffmode));
4464 }
4465
4466 // Check that all the validation results are caught.
4467 // Note: it doesn't mean no validation being in progress.
4468 EXPECT_FALSE(hasUncaughtPrivateDnsValidation(addr1));
4469 EXPECT_FALSE(hasUncaughtPrivateDnsValidation(addr2));
4470}
4471
Hungming Chenbb90ab32019-10-28 18:20:31 +08004472// Parameterized tests.
4473// TODO: Merge the existing tests as parameterized test if possible.
4474// TODO: Perhaps move parameterized tests to an independent file.
4475enum class CallType { GETADDRINFO, GETHOSTBYNAME };
4476class ResolverParameterizedTest : public ResolverTest,
Hungming Chen63779052019-10-30 15:06:13 +08004477 public testing::WithParamInterface<CallType> {
4478 protected:
Hungming Chen22617fd2019-12-06 12:15:45 +08004479 void VerifyQueryHelloExampleComV4(const test::DNSResponder& dns, const CallType calltype,
4480 const bool verifyNumQueries = true) {
Hungming Chen63779052019-10-30 15:06:13 +08004481 if (calltype == CallType::GETADDRINFO) {
4482 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
4483 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
4484 ASSERT_TRUE(result != nullptr);
4485 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4486 } else if (calltype == CallType::GETHOSTBYNAME) {
4487 const hostent* result = gethostbyname("hello");
4488 ASSERT_TRUE(result != nullptr);
4489 ASSERT_EQ(4, result->h_length);
4490 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
4491 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4492 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
4493 } else {
4494 FAIL() << "Unsupported call type: " << static_cast<uint32_t>(calltype);
4495 }
Hungming Chen22617fd2019-12-06 12:15:45 +08004496 if (verifyNumQueries) EXPECT_EQ(1U, GetNumQueries(dns, kHelloExampleCom));
Hungming Chen63779052019-10-30 15:06:13 +08004497 }
4498};
Hungming Chenbb90ab32019-10-28 18:20:31 +08004499
Hungming Chen63779052019-10-30 15:06:13 +08004500INSTANTIATE_TEST_SUITE_P(QueryCallTest, ResolverParameterizedTest,
Hungming Chenbb90ab32019-10-28 18:20:31 +08004501 testing::Values(CallType::GETADDRINFO, CallType::GETHOSTBYNAME),
4502 [](const testing::TestParamInfo<CallType>& info) {
Hungming Chenbb90ab32019-10-28 18:20:31 +08004503 switch (info.param) {
4504 case CallType::GETADDRINFO:
Hungming Chen63779052019-10-30 15:06:13 +08004505 return "GetAddrInfo";
Hungming Chenbb90ab32019-10-28 18:20:31 +08004506 case CallType::GETHOSTBYNAME:
Hungming Chen63779052019-10-30 15:06:13 +08004507 return "GetHostByName";
Hungming Chenbb90ab32019-10-28 18:20:31 +08004508 default:
Hungming Chen63779052019-10-30 15:06:13 +08004509 return "InvalidParameter"; // Should not happen.
Hungming Chenbb90ab32019-10-28 18:20:31 +08004510 }
Hungming Chenbb90ab32019-10-28 18:20:31 +08004511 });
4512
4513TEST_P(ResolverParameterizedTest, AuthoritySectionAndAdditionalSection) {
4514 // DNS response may have more information in authority section and additional section.
4515 // Currently, getanswer() of packages/modules/DnsResolver/getaddrinfo.cpp doesn't parse the
4516 // content of authority section and additional section. Test these sections if they crash
4517 // the resolver, just in case. See also RFC 1035 section 4.1.
4518 const auto& calltype = GetParam();
4519 test::DNSHeader header(kDefaultDnsHeader);
4520
4521 // Create a DNS response which has a authoritative nameserver record in authority
4522 // section and its relevant address record in additional section.
4523 //
4524 // Question
4525 // hello.example.com. IN A
4526 // Answer
4527 // hello.example.com. IN A 1.2.3.4
4528 // Authority:
4529 // hello.example.com. IN NS ns1.example.com.
4530 // Additional:
4531 // ns1.example.com. IN A 5.6.7.8
4532 //
4533 // A response may have only question, answer, and authority section. Current testing response
4534 // should be able to cover this condition.
4535
4536 // Question section.
4537 test::DNSQuestion question{
4538 .qname = {.name = kHelloExampleCom},
4539 .qtype = ns_type::ns_t_a,
4540 .qclass = ns_c_in,
4541 };
4542 header.questions.push_back(std::move(question));
4543
4544 // Answer section.
4545 test::DNSRecord recordAnswer{
4546 .name = {.name = kHelloExampleCom},
4547 .rtype = ns_type::ns_t_a,
4548 .rclass = ns_c_in,
4549 .ttl = 0, // no cache
4550 };
Hungming Chen63779052019-10-30 15:06:13 +08004551 EXPECT_TRUE(test::DNSResponder::fillRdata(kHelloExampleComAddrV4, recordAnswer));
Hungming Chenbb90ab32019-10-28 18:20:31 +08004552 header.answers.push_back(std::move(recordAnswer));
4553
4554 // Authority section.
4555 test::DNSRecord recordAuthority{
4556 .name = {.name = kHelloExampleCom},
4557 .rtype = ns_type::ns_t_ns,
4558 .rclass = ns_c_in,
4559 .ttl = 0, // no cache
4560 };
4561 EXPECT_TRUE(test::DNSResponder::fillRdata("ns1.example.com.", recordAuthority));
4562 header.authorities.push_back(std::move(recordAuthority));
4563
4564 // Additional section.
4565 test::DNSRecord recordAdditional{
4566 .name = {.name = "ns1.example.com."},
4567 .rtype = ns_type::ns_t_a,
4568 .rclass = ns_c_in,
4569 .ttl = 0, // no cache
4570 };
4571 EXPECT_TRUE(test::DNSResponder::fillRdata("5.6.7.8", recordAdditional));
4572 header.additionals.push_back(std::move(recordAdditional));
4573
4574 // Start DNS server.
4575 test::DNSResponder dns(test::DNSResponder::MappingType::DNS_HEADER);
4576 dns.addMappingDnsHeader(kHelloExampleCom, ns_type::ns_t_a, header);
4577 ASSERT_TRUE(dns.startServer());
4578 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4579 dns.clearQueries();
4580
4581 // Expect that get the address and the resolver doesn't crash.
Hungming Chen63779052019-10-30 15:06:13 +08004582 VerifyQueryHelloExampleComV4(dns, calltype);
4583}
4584
4585TEST_P(ResolverParameterizedTest, MessageCompression) {
4586 const auto& calltype = GetParam();
4587
4588 // The response with compressed domain name by a pointer. See RFC 1035 section 4.1.4.
4589 //
4590 // Ignoring the other fields of the message, the domain name of question section and answer
4591 // section are presented as:
4592 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4593 // 12 | 5 | h |
4594 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4595 // 14 | e | l |
4596 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4597 // 16 | l | o |
4598 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4599 // 18 | 7 | e |
4600 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4601 // 20 | x | a |
4602 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4603 // 22 | m | p |
4604 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4605 // 24 | l | e |
4606 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4607 // 26 | 3 | c |
4608 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4609 // 28 | o | m |
4610 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4611 // 30 | 0 | ... |
4612 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4613 //
4614 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4615 // 35 | 1 1| 12 |
4616 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4617 const std::vector<uint8_t> kResponseAPointer = {
4618 /* Header */
4619 0x00, 0x00, /* Transaction ID: 0x0000 */
4620 0x81, 0x80, /* Flags: qr rd ra */
4621 0x00, 0x01, /* Questions: 1 */
4622 0x00, 0x01, /* Answer RRs: 1 */
4623 0x00, 0x00, /* Authority RRs: 0 */
4624 0x00, 0x00, /* Additional RRs: 0 */
4625 /* Queries */
4626 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
4627 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name: hello.example.com */
4628 0x00, 0x01, /* Type: A */
4629 0x00, 0x01, /* Class: IN */
4630 /* Answers */
4631 0xc0, 0x0c, /* Name: hello.example.com (a pointer) */
4632 0x00, 0x01, /* Type: A */
4633 0x00, 0x01, /* Class: IN */
4634 0x00, 0x00, 0x00, 0x00, /* Time to live: 0 */
4635 0x00, 0x04, /* Data length: 4 */
4636 0x01, 0x02, 0x03, 0x04 /* Address: 1.2.3.4 */
4637 };
4638
4639 // The response with compressed domain name by a sequence of labels ending with a pointer. See
4640 // RFC 1035 section 4.1.4.
4641 //
4642 // Ignoring the other fields of the message, the domain name of question section and answer
4643 // section are presented as:
4644 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4645 // 12 | 5 | h |
4646 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4647 // 14 | e | l |
4648 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4649 // 16 | l | o |
4650 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4651 // 18 | 7 | e |
4652 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4653 // 20 | x | a |
4654 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4655 // 22 | m | p |
4656 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4657 // 24 | l | e |
4658 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4659 // 26 | 3 | c |
4660 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4661 // 28 | o | m |
4662 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4663 // 30 | 0 | ... |
4664 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4665 //
4666 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4667 // 35 | 5 | h |
4668 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4669 // 37 | e | l |
4670 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4671 // 39 | l | o |
4672 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4673 // 41 | 1 1| 18 |
4674 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4675 const std::vector<uint8_t> kResponseLabelEndingWithAPointer = {
4676 /* Header */
4677 0x00, 0x00, /* Transaction ID: 0x0000 */
4678 0x81, 0x80, /* Flags: qr rd ra */
4679 0x00, 0x01, /* Questions: 1 */
4680 0x00, 0x01, /* Answer RRs: 1 */
4681 0x00, 0x00, /* Authority RRs: 0 */
4682 0x00, 0x00, /* Additional RRs: 0 */
4683 /* Queries */
4684 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
4685 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name: hello.example.com */
4686 0x00, 0x01, /* Type: A */
4687 0x00, 0x01, /* Class: IN */
4688 /* Answers */
4689 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xc0,
4690 0x12, /* Name: hello.example.com (a label ending with a pointer) */
4691 0x00, 0x01, /* Type: A */
4692 0x00, 0x01, /* Class: IN */
4693 0x00, 0x00, 0x00, 0x00, /* Time to live: 0 */
4694 0x00, 0x04, /* Data length: 4 */
4695 0x01, 0x02, 0x03, 0x04 /* Address: 1.2.3.4 */
4696 };
4697
4698 for (const auto& response : {kResponseAPointer, kResponseLabelEndingWithAPointer}) {
4699 SCOPED_TRACE(StringPrintf("Hex dump: %s", toHex(makeSlice(response)).c_str()));
4700
4701 test::DNSResponder dns(test::DNSResponder::MappingType::BINARY_PACKET);
4702 dns.addMappingBinaryPacket(kHelloExampleComQueryV4, response);
4703 StartDns(dns, {});
4704 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4705
4706 // Expect no cache because the TTL of testing responses are 0.
4707 VerifyQueryHelloExampleComV4(dns, calltype);
Hungming Chenbb90ab32019-10-28 18:20:31 +08004708 }
Mike Yu40e67072019-10-09 21:14:09 +08004709}
Hungming Chen22617fd2019-12-06 12:15:45 +08004710
4711TEST_P(ResolverParameterizedTest, TruncatedResponse) {
4712 const auto& calltype = GetParam();
4713
Hungming Chen22617fd2019-12-06 12:15:45 +08004714 test::DNSResponder dns;
Ken Chen99344882020-01-01 14:59:38 +08004715 StartDns(dns, kLargeCnameChainRecords);
Hungming Chen22617fd2019-12-06 12:15:45 +08004716 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4717
4718 // Expect UDP response is truncated. The resolver retries over TCP. See RFC 1035 section 4.2.1.
4719 VerifyQueryHelloExampleComV4(dns, calltype, false);
4720 EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_UDP, kHelloExampleCom));
4721 EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom));
4722}
Luke Huang3caa42b2020-04-23 14:18:04 +00004723
4724TEST_F(ResolverTest, KeepListeningUDP) {
4725 constexpr char listen_addr1[] = "127.0.0.4";
4726 constexpr char listen_addr2[] = "127.0.0.5";
4727 constexpr char host_name[] = "howdy.example.com.";
4728 const std::vector<DnsRecord> records = {
4729 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
4730 };
4731 const std::vector<int> params = {300, 25, 8, 8, 1000 /* BASE_TIMEOUT_MSEC */,
4732 1 /* retry count */};
4733 const int delayTimeMs = 1500;
4734
4735 test::DNSResponder neverRespondDns(listen_addr2, "53", static_cast<ns_rcode>(-1));
4736 neverRespondDns.setResponseProbability(0.0);
4737 StartDns(neverRespondDns, records);
Luke Huang68fa5002020-04-23 15:48:47 +00004738 ScopedSystemProperties scopedSystemProperties(
4739 "persist.device_config.netd_native.keep_listening_udp", "1");
4740 // Re-setup test network to make experiment flag take effect.
4741 resetNetwork();
Luke Huang3caa42b2020-04-23 14:18:04 +00004742
4743 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr1, listen_addr2},
4744 kDefaultSearchDomains, params));
4745 // There are 2 DNS servers for this test.
4746 // |delayedDns| will be blocked for |delayTimeMs|, then start to respond to requests.
4747 // |neverRespondDns| will never respond.
4748 // In the first try, resolver will send query to |delayedDns| but get timeout error
4749 // because |delayTimeMs| > DNS timeout.
4750 // Then it's the second try, resolver will send query to |neverRespondDns| and
4751 // listen on both servers. Resolver will receive the answer coming from |delayedDns|.
Luke Huang3caa42b2020-04-23 14:18:04 +00004752
Luke Huang3caa42b2020-04-23 14:18:04 +00004753 test::DNSResponder delayedDns(listen_addr1);
4754 delayedDns.setResponseDelayMs(delayTimeMs);
4755 StartDns(delayedDns, records);
4756
4757 // Specify hints to ensure resolver doing query only 1 round.
4758 const addrinfo hints = {.ai_family = AF_INET6, .ai_socktype = SOCK_DGRAM};
4759 ScopedAddrinfo result = safe_getaddrinfo(host_name, nullptr, &hints);
4760 EXPECT_TRUE(result != nullptr);
4761
4762 std::string result_str = ToString(result);
4763 EXPECT_TRUE(result_str == "::1.2.3.4") << ", result_str='" << result_str << "'";
4764}
4765
4766TEST_F(ResolverTest, GetAddrInfoParallelLookupTimeout) {
4767 constexpr char listen_addr[] = "127.0.0.4";
4768 constexpr char host_name[] = "howdy.example.com.";
4769 constexpr int TIMING_TOLERANCE_MS = 200;
4770 constexpr int DNS_TIMEOUT_MS = 1000;
4771 const std::vector<DnsRecord> records = {
4772 {host_name, ns_type::ns_t_a, "1.2.3.4"},
4773 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
4774 };
4775 const std::vector<int> params = {300, 25, 8, 8, DNS_TIMEOUT_MS /* BASE_TIMEOUT_MSEC */,
4776 1 /* retry count */};
4777 test::DNSResponder neverRespondDns(listen_addr, "53", static_cast<ns_rcode>(-1));
4778 neverRespondDns.setResponseProbability(0.0);
4779 StartDns(neverRespondDns, records);
Luke Huang68fa5002020-04-23 15:48:47 +00004780 ScopedSystemProperties scopedSystemProperties(
4781 "persist.device_config.netd_native.parallel_lookup", "1");
4782 // Re-setup test network to make experiment flag take effect.
4783 resetNetwork();
Luke Huang3caa42b2020-04-23 14:18:04 +00004784
4785 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr}, kDefaultSearchDomains, params));
4786 neverRespondDns.clearQueries();
4787
Luke Huang3caa42b2020-04-23 14:18:04 +00004788 // Use a never respond DNS server to verify if the A/AAAA queries are sent in parallel.
4789 // The resolver parameters are set to timeout 1s and retry 1 times.
4790 // So we expect the safe_getaddrinfo_time_taken() might take ~1s to
4791 // return when parallel lookup is enabled. And the DNS server should receive 2 queries.
4792 const addrinfo hints = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_DGRAM};
4793 auto [result, timeTakenMs] = safe_getaddrinfo_time_taken(host_name, nullptr, hints);
4794
4795 EXPECT_TRUE(result == nullptr);
4796 EXPECT_NEAR(DNS_TIMEOUT_MS, timeTakenMs, TIMING_TOLERANCE_MS)
4797 << "took time should approximate equal timeout";
4798 EXPECT_EQ(2U, GetNumQueries(neverRespondDns, host_name));
4799}