blob: b78395c87dc8813b2c8fae55bef12ea8330a6d29 [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
Luke Huang70070852019-11-25 18:25:50 +080084using aidl::android::net::IDnsResolver;
Luke Huangf8215372019-11-22 11:53:41 +080085using aidl::android::net::INetd;
Mike Yu8ac63402019-12-02 15:28:38 +080086using aidl::android::net::ResolverParamsParcel;
Luke Huang9807e6b2019-05-20 16:17:12 +080087using android::base::ParseInt;
Ken Chenb9fa2062018-11-13 21:51:13 +080088using android::base::StringPrintf;
Luke Huang9807e6b2019-05-20 16:17:12 +080089using android::base::unique_fd;
Ken Chenb9fa2062018-11-13 21:51:13 +080090using android::net::ResolverStats;
Hungming Chene8f970c2019-04-10 17:34:06 +080091using android::net::metrics::DnsMetricsListener;
Ken Chenb9fa2062018-11-13 21:51:13 +080092using android::netdutils::enableSockopt;
Hungming Chen63779052019-10-30 15:06:13 +080093using android::netdutils::makeSlice;
Luke Huang9807e6b2019-05-20 16:17:12 +080094using android::netdutils::ResponseCode;
Luke Huang9d2d25b2019-06-14 00:34:05 +080095using android::netdutils::ScopedAddrinfo;
Mike Yu40e67072019-10-09 21:14:09 +080096using android::netdutils::Stopwatch;
Hungming Chen63779052019-10-30 15:06:13 +080097using android::netdutils::toHex;
Ken Chenb9fa2062018-11-13 21:51:13 +080098
99// TODO: move into libnetdutils?
100namespace {
Luke Huangfde82482019-06-04 01:04:53 +0800101
Ken Chenb9fa2062018-11-13 21:51:13 +0800102ScopedAddrinfo safe_getaddrinfo(const char* node, const char* service,
103 const struct addrinfo* hints) {
104 addrinfo* result = nullptr;
105 if (getaddrinfo(node, service, hints, &result) != 0) {
106 result = nullptr; // Should already be the case, but...
107 }
108 return ScopedAddrinfo(result);
109}
Luke Huangfde82482019-06-04 01:04:53 +0800110
Mike Yu40e67072019-10-09 21:14:09 +0800111std::pair<ScopedAddrinfo, int> safe_getaddrinfo_time_taken(const char* node, const char* service,
112 const addrinfo& hints) {
113 Stopwatch s;
114 ScopedAddrinfo result = safe_getaddrinfo(node, service, &hints);
115 return {std::move(result), s.timeTakenUs() / 1000};
116}
117
Ken Chenb9fa2062018-11-13 21:51:13 +0800118} // namespace
119
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900120class ResolverTest : public ::testing::Test {
Hungming Chene8f970c2019-04-10 17:34:06 +0800121 public:
Hungming Chen5bf09772019-04-25 11:16:13 +0800122 static void SetUpTestCase() {
123 // Get binder service.
124 // Note that |mDnsClient| is not used for getting binder service in this static function.
125 // The reason is that wants to keep |mDnsClient| as a non-static data member. |mDnsClient|
126 // which sets up device network configuration could be independent from every test.
Luke Huangf8215372019-11-22 11:53:41 +0800127 // TODO: Perhaps add a static function in resolv_test_binder_utils.{cpp,h} to get binder
128 // service.
129
130 AIBinder* binder = AServiceManager_getService("dnsresolver");
131 ndk::SpAIBinder resolvBinder = ndk::SpAIBinder(binder);
132 auto resolvService = aidl::android::net::IDnsResolver::fromBinder(resolvBinder);
Hungming Chen5bf09772019-04-25 11:16:13 +0800133 ASSERT_NE(nullptr, resolvService.get());
134
135 // Subscribe the death recipient to the service IDnsResolver for detecting Netd death.
Luke Huang70070852019-11-25 18:25:50 +0800136 // GTEST assertion macros are not invoked for generating a test failure in the death
137 // recipient because the macros can't indicate failed test if Netd died between tests.
138 // Moreover, continuing testing may have no meaningful after Netd death. Therefore, the
139 // death recipient aborts process by GTEST_LOG_(FATAL) once Netd died.
Luke Huangf8215372019-11-22 11:53:41 +0800140 sResolvDeathRecipient = AIBinder_DeathRecipient_new([](void*) {
141 constexpr char errorMessage[] = "Netd died";
142 LOG(ERROR) << errorMessage;
143 GTEST_LOG_(FATAL) << errorMessage;
144 });
145 ASSERT_EQ(STATUS_OK, AIBinder_linkToDeath(binder, sResolvDeathRecipient, nullptr));
Hungming Chen5bf09772019-04-25 11:16:13 +0800146
147 // Subscribe the DNS listener for verifying DNS metrics event contents.
Luke Huangf8215372019-11-22 11:53:41 +0800148 sDnsMetricsListener = ndk::SharedRefBase::make<DnsMetricsListener>(
149 TEST_NETID /*monitor specific network*/);
Hungming Chen5bf09772019-04-25 11:16:13 +0800150 ASSERT_TRUE(resolvService->registerEventListener(sDnsMetricsListener).isOk());
151
152 // Start the binder thread pool for listening DNS metrics events and receiving death
153 // recipient.
Luke Huangf8215372019-11-22 11:53:41 +0800154 ABinderProcess_startThreadPool();
Hungming Chene8f970c2019-04-10 17:34:06 +0800155 }
Luke Huangf8215372019-11-22 11:53:41 +0800156 static void TearDownTestCase() { AIBinder_DeathRecipient_delete(sResolvDeathRecipient); }
Hungming Chene8f970c2019-04-10 17:34:06 +0800157
Ken Chenb9fa2062018-11-13 21:51:13 +0800158 protected:
Hungming Chen5bf09772019-04-25 11:16:13 +0800159 void SetUp() { mDnsClient.SetUp(); }
Mike Yu960243d2020-01-17 19:02:15 +0800160 void TearDown() {
161 // Ensure the dump works at the end of each test.
162 DumpResolverService();
163
164 mDnsClient.TearDown();
165 }
nuccachena26cc2a2018-07-17 18:07:23 +0800166
Xiao Ma09b71022018-12-11 17:56:32 +0900167 void StartDns(test::DNSResponder& dns, const std::vector<DnsRecord>& records) {
168 for (const auto& r : records) {
169 dns.addMapping(r.host_name, r.type, r.addr);
170 }
171
172 ASSERT_TRUE(dns.startServer());
173 dns.clearQueries();
174 }
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900175
Mike Yu960243d2020-01-17 19:02:15 +0800176 void DumpResolverService() {
177 unique_fd fd(open("/dev/null", O_WRONLY));
178 EXPECT_EQ(mDnsClient.resolvService()->dump(fd, nullptr, 0), 0);
179
180 const char* querylogCmd[] = {"querylog"}; // Keep it sync with DnsQueryLog::DUMP_KEYWORD.
181 EXPECT_EQ(mDnsClient.resolvService()->dump(fd, querylogCmd, std::size(querylogCmd)), 0);
182 }
183
Hungming Chene8f970c2019-04-10 17:34:06 +0800184 bool WaitForNat64Prefix(ExpectNat64PrefixStatus status,
185 std::chrono::milliseconds timeout = std::chrono::milliseconds(1000)) {
Hungming Chen5bf09772019-04-25 11:16:13 +0800186 return sDnsMetricsListener->waitForNat64Prefix(status, timeout);
Hungming Chene8f970c2019-04-10 17:34:06 +0800187 }
188
Mike Yu724f77d2019-08-16 11:14:50 +0800189 bool WaitForPrivateDnsValidation(std::string serverAddr, bool validated) {
190 return sDnsMetricsListener->waitForPrivateDnsValidation(serverAddr, validated);
191 }
192
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900193 DnsResponderClient mDnsClient;
Xiao Ma09b71022018-12-11 17:56:32 +0900194
Hungming Chen5bf09772019-04-25 11:16:13 +0800195 // Use a shared static DNS listener for all tests to avoid registering lots of listeners
196 // which may be released late until process terminated. Currently, registered DNS listener
197 // is removed by binder death notification which is fired when the process hosting an
198 // IBinder has gone away. If every test in ResolverTest registers its DNS listener, Netd
199 // may temporarily hold lots of dead listeners until the unit test process terminates.
200 // TODO: Perhaps add an unregistering listener binder call or fork a listener process which
201 // could be terminated earlier.
Luke Huangf8215372019-11-22 11:53:41 +0800202 static std::shared_ptr<DnsMetricsListener>
203 sDnsMetricsListener; // Initialized in SetUpTestCase.
Hungming Chen5bf09772019-04-25 11:16:13 +0800204
205 // Use a shared static death recipient to monitor the service death. The static death
206 // recipient could monitor the death not only during the test but also between tests.
Luke Huangf8215372019-11-22 11:53:41 +0800207 static AIBinder_DeathRecipient* sResolvDeathRecipient; // Initialized in SetUpTestCase.
Ken Chenb9fa2062018-11-13 21:51:13 +0800208};
209
Hungming Chen5bf09772019-04-25 11:16:13 +0800210// Initialize static member of class.
Luke Huangf8215372019-11-22 11:53:41 +0800211std::shared_ptr<DnsMetricsListener> ResolverTest::sDnsMetricsListener;
212AIBinder_DeathRecipient* ResolverTest::sResolvDeathRecipient;
Hungming Chen5bf09772019-04-25 11:16:13 +0800213
Ken Chenb9fa2062018-11-13 21:51:13 +0800214TEST_F(ResolverTest, GetHostByName) {
Xiao Ma09b71022018-12-11 17:56:32 +0900215 constexpr char nonexistent_host_name[] = "nonexistent.example.com.";
216
217 test::DNSResponder dns;
218 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, "1.2.3.3"}});
219 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800220
221 const hostent* result;
Ken Chenb9fa2062018-11-13 21:51:13 +0800222 result = gethostbyname("nonexistent");
223 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, nonexistent_host_name));
224 ASSERT_TRUE(result == nullptr);
225 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
226
227 dns.clearQueries();
228 result = gethostbyname("hello");
Xiao Ma09b71022018-12-11 17:56:32 +0900229 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
Ken Chenb9fa2062018-11-13 21:51:13 +0800230 ASSERT_FALSE(result == nullptr);
231 ASSERT_EQ(4, result->h_length);
232 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
233 EXPECT_EQ("1.2.3.3", ToString(result));
234 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800235}
236
lifr4e4a2e02019-01-29 16:53:51 +0800237TEST_F(ResolverTest, GetHostByName_cnames) {
238 constexpr char host_name[] = "host.example.com.";
239 size_t cnamecount = 0;
240 test::DNSResponder dns;
241
242 const std::vector<DnsRecord> records = {
243 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
244 {"a.example.com.", ns_type::ns_t_cname, "b.example.com."},
245 {"b.example.com.", ns_type::ns_t_cname, "c.example.com."},
246 {"c.example.com.", ns_type::ns_t_cname, "d.example.com."},
247 {"d.example.com.", ns_type::ns_t_cname, "e.example.com."},
248 {"e.example.com.", ns_type::ns_t_cname, host_name},
249 {host_name, ns_type::ns_t_a, "1.2.3.3"},
250 {host_name, ns_type::ns_t_aaaa, "2001:db8::42"},
251 };
252 StartDns(dns, records);
253 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
254
255 // using gethostbyname2() to resolve ipv4 hello.example.com. to 1.2.3.3
256 // Ensure the v4 address and cnames are correct
257 const hostent* result;
258 result = gethostbyname2("hello", AF_INET);
259 ASSERT_FALSE(result == nullptr);
260
261 for (int i = 0; result != nullptr && result->h_aliases[i] != nullptr; i++) {
262 std::string domain_name = records[i].host_name.substr(0, records[i].host_name.size() - 1);
263 EXPECT_EQ(result->h_aliases[i], domain_name);
264 cnamecount++;
265 }
266 // The size of "Non-cname type" record in DNS records is 2
267 ASSERT_EQ(cnamecount, records.size() - 2);
268 ASSERT_EQ(4, result->h_length);
269 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
270 EXPECT_EQ("1.2.3.3", ToString(result));
271 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
272 EXPECT_EQ(1U, dns.queries().size()) << dns.dumpQueries();
273
274 // using gethostbyname2() to resolve ipv6 hello.example.com. to 2001:db8::42
275 // Ensure the v6 address and cnames are correct
276 cnamecount = 0;
277 dns.clearQueries();
278 result = gethostbyname2("hello", AF_INET6);
279 for (unsigned i = 0; result != nullptr && result->h_aliases[i] != nullptr; i++) {
280 std::string domain_name = records[i].host_name.substr(0, records[i].host_name.size() - 1);
281 EXPECT_EQ(result->h_aliases[i], domain_name);
282 cnamecount++;
283 }
284 // The size of "Non-cname type" DNS record in records is 2
285 ASSERT_EQ(cnamecount, records.size() - 2);
286 ASSERT_FALSE(result == nullptr);
287 ASSERT_EQ(16, result->h_length);
288 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
289 EXPECT_EQ("2001:db8::42", ToString(result));
290 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
291}
292
293TEST_F(ResolverTest, GetHostByName_cnamesInfiniteLoop) {
294 test::DNSResponder dns;
295 const std::vector<DnsRecord> records = {
296 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
297 {"a.example.com.", ns_type::ns_t_cname, kHelloExampleCom},
298 };
299 StartDns(dns, records);
300 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
301
302 const hostent* result;
303 result = gethostbyname2("hello", AF_INET);
304 ASSERT_TRUE(result == nullptr);
305
306 dns.clearQueries();
307 result = gethostbyname2("hello", AF_INET6);
308 ASSERT_TRUE(result == nullptr);
309}
310
Ken Chenb9fa2062018-11-13 21:51:13 +0800311TEST_F(ResolverTest, GetHostByName_localhost) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800312 constexpr char name_camelcase[] = "LocalHost";
Ken Chenb9fa2062018-11-13 21:51:13 +0800313 constexpr char name_ip6_dot[] = "ip6-localhost.";
314 constexpr char name_ip6_fqdn[] = "ip6-localhost.example.com.";
315
316 // Add a dummy nameserver which shouldn't receive any queries
Xiao Ma09b71022018-12-11 17:56:32 +0900317 test::DNSResponder dns;
318 StartDns(dns, {});
319 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800320
321 // Expect no DNS queries; localhost is resolved via /etc/hosts
Xiao Ma09b71022018-12-11 17:56:32 +0900322 const hostent* result = gethostbyname(kLocalHost);
Ken Chenb9fa2062018-11-13 21:51:13 +0800323 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
324 ASSERT_FALSE(result == nullptr);
325 ASSERT_EQ(4, result->h_length);
326 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900327 EXPECT_EQ(kLocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800328 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
329
330 // Ensure the hosts file resolver ignores case of hostnames
331 result = gethostbyname(name_camelcase);
332 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
333 ASSERT_FALSE(result == nullptr);
334 ASSERT_EQ(4, result->h_length);
335 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900336 EXPECT_EQ(kLocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800337 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
338
339 // The hosts file also contains ip6-localhost, but gethostbyname() won't
chenbruce018fdb22019-06-12 18:08:04 +0800340 // return it. This would be easy to
Ken Chenb9fa2062018-11-13 21:51:13 +0800341 // change, but there's no point in changing the legacy behavior; new code
342 // should be calling getaddrinfo() anyway.
343 // So we check the legacy behavior, which results in amusing A-record
344 // lookups for ip6-localhost, with and without search domains appended.
345 dns.clearQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900346 result = gethostbyname(kIp6LocalHost);
Sehee Parkbbca0202018-11-16 10:53:16 +0900347 EXPECT_EQ(2U, dns.queries().size()) << dns.dumpQueries();
348 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, name_ip6_dot)) << dns.dumpQueries();
349 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, name_ip6_fqdn)) << dns.dumpQueries();
Ken Chenb9fa2062018-11-13 21:51:13 +0800350 ASSERT_TRUE(result == nullptr);
351
352 // Finally, use gethostbyname2() to resolve ip6-localhost to ::1 from
353 // the hosts file.
354 dns.clearQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900355 result = gethostbyname2(kIp6LocalHost, AF_INET6);
Ken Chenb9fa2062018-11-13 21:51:13 +0800356 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
357 ASSERT_FALSE(result == nullptr);
358 ASSERT_EQ(16, result->h_length);
359 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900360 EXPECT_EQ(kIp6LocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800361 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800362}
363
364TEST_F(ResolverTest, GetHostByName_numeric) {
365 // Add a dummy nameserver which shouldn't receive any queries
Xiao Ma09b71022018-12-11 17:56:32 +0900366 test::DNSResponder dns;
367 StartDns(dns, {});
368 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800369
370 // Numeric v4 address: expect no DNS queries
371 constexpr char numeric_v4[] = "192.168.0.1";
Ken Chenb9fa2062018-11-13 21:51:13 +0800372 const hostent* result = gethostbyname(numeric_v4);
Sehee Parkbbca0202018-11-16 10:53:16 +0900373 EXPECT_EQ(0U, dns.queries().size());
Ken Chenb9fa2062018-11-13 21:51:13 +0800374 ASSERT_FALSE(result == nullptr);
375 ASSERT_EQ(4, result->h_length); // v4
376 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
377 EXPECT_EQ(numeric_v4, ToString(result));
378 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
379
380 // gethostbyname() recognizes a v6 address, and fails with no DNS queries
381 constexpr char numeric_v6[] = "2001:db8::42";
382 dns.clearQueries();
383 result = gethostbyname(numeric_v6);
Sehee Parkbbca0202018-11-16 10:53:16 +0900384 EXPECT_EQ(0U, dns.queries().size());
Ken Chenb9fa2062018-11-13 21:51:13 +0800385 EXPECT_TRUE(result == nullptr);
386
387 // Numeric v6 address with gethostbyname2(): succeeds with no DNS queries
388 dns.clearQueries();
389 result = gethostbyname2(numeric_v6, AF_INET6);
Sehee Parkbbca0202018-11-16 10:53:16 +0900390 EXPECT_EQ(0U, dns.queries().size());
Ken Chenb9fa2062018-11-13 21:51:13 +0800391 ASSERT_FALSE(result == nullptr);
392 ASSERT_EQ(16, result->h_length); // v6
393 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
394 EXPECT_EQ(numeric_v6, ToString(result));
395 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
396
397 // Numeric v6 address with scope work with getaddrinfo(),
398 // but gethostbyname2() does not understand them; it issues two dns
399 // queries, then fails. This hardly ever happens, there's no point
400 // in fixing this. This test simply verifies the current (bogus)
401 // behavior to avoid further regressions (like crashes, or leaks).
402 constexpr char numeric_v6_scope[] = "fe80::1%lo";
403 dns.clearQueries();
404 result = gethostbyname2(numeric_v6_scope, AF_INET6);
Sehee Parkbbca0202018-11-16 10:53:16 +0900405 EXPECT_EQ(2U, dns.queries().size()); // OUCH!
Ken Chenb9fa2062018-11-13 21:51:13 +0800406 ASSERT_TRUE(result == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800407}
408
409TEST_F(ResolverTest, BinderSerialization) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800410 std::vector<int> params_offsets = {
Luke Huang5bd827c2019-03-14 16:10:04 +0800411 IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY,
412 IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD,
413 IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES,
414 IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES,
415 IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC,
416 IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT,
Ken Chenb9fa2062018-11-13 21:51:13 +0800417 };
Bernie Innocentib102dd22018-12-04 14:57:48 +0900418 const int size = static_cast<int>(params_offsets.size());
Luke Huang5bd827c2019-03-14 16:10:04 +0800419 EXPECT_EQ(size, IDnsResolver::RESOLVER_PARAMS_COUNT);
Ken Chenb9fa2062018-11-13 21:51:13 +0800420 std::sort(params_offsets.begin(), params_offsets.end());
Bernie Innocentib102dd22018-12-04 14:57:48 +0900421 for (int i = 0; i < size; ++i) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800422 EXPECT_EQ(params_offsets[i], i);
423 }
424}
425
426TEST_F(ResolverTest, GetHostByName_Binder) {
Luke Huangf8215372019-11-22 11:53:41 +0800427 std::vector<std::string> domains = {"example.com"};
Ken Chenb9fa2062018-11-13 21:51:13 +0800428 std::vector<std::unique_ptr<test::DNSResponder>> dns;
429 std::vector<std::string> servers;
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900430 std::vector<DnsResponderClient::Mapping> mappings;
431 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupMappings(1, domains, &mappings));
432 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupDNSServers(4, mappings, &dns, &servers));
Ken Chenb9fa2062018-11-13 21:51:13 +0800433 ASSERT_EQ(1U, mappings.size());
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900434 const DnsResponderClient::Mapping& mapping = mappings[0];
Ken Chenb9fa2062018-11-13 21:51:13 +0800435
Xiao Ma09b71022018-12-11 17:56:32 +0900436 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains, kDefaultParams));
Ken Chenb9fa2062018-11-13 21:51:13 +0800437
438 const hostent* result = gethostbyname(mapping.host.c_str());
Bernie Innocentib102dd22018-12-04 14:57:48 +0900439 const size_t total_queries =
Luke Huangfde82482019-06-04 01:04:53 +0800440 std::accumulate(dns.begin(), dns.end(), 0, [&mapping](size_t total, auto& d) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800441 return total + GetNumQueriesForType(*d, ns_type::ns_t_a, mapping.entry.c_str());
442 });
443
444 EXPECT_LE(1U, total_queries);
445 ASSERT_FALSE(result == nullptr);
446 ASSERT_EQ(4, result->h_length);
447 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
448 EXPECT_EQ(mapping.ip4, ToString(result));
449 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
450
451 std::vector<std::string> res_servers;
452 std::vector<std::string> res_domains;
Mike Yu0a1c53d2018-11-26 13:26:21 +0900453 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +0900454 res_params res_params;
Ken Chenb9fa2062018-11-13 21:51:13 +0800455 std::vector<ResolverStats> res_stats;
Ken Chen92bed612018-12-22 21:46:55 +0800456 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +0800457 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
458 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
459 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chenb9fa2062018-11-13 21:51:13 +0800460 EXPECT_EQ(servers.size(), res_servers.size());
461 EXPECT_EQ(domains.size(), res_domains.size());
Mike Yu0a1c53d2018-11-26 13:26:21 +0900462 EXPECT_EQ(0U, res_tls_servers.size());
Luke Huang5bd827c2019-03-14 16:10:04 +0800463 ASSERT_EQ(static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT), kDefaultParams.size());
464 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY],
465 res_params.sample_validity);
466 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +0900467 res_params.success_threshold);
Luke Huang5bd827c2019-03-14 16:10:04 +0800468 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
469 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
470 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
Ken Chenb9fa2062018-11-13 21:51:13 +0800471 res_params.base_timeout_msec);
472 EXPECT_EQ(servers.size(), res_stats.size());
473
Bernie Innocenti0c067e42019-04-01 15:33:16 +0900474 EXPECT_THAT(res_servers, testing::UnorderedElementsAreArray(servers));
475 EXPECT_THAT(res_domains, testing::UnorderedElementsAreArray(domains));
Ken Chenb9fa2062018-11-13 21:51:13 +0800476}
477
478TEST_F(ResolverTest, GetAddrInfo) {
Xiao Ma09b71022018-12-11 17:56:32 +0900479 constexpr char listen_addr[] = "127.0.0.4";
480 constexpr char listen_addr2[] = "127.0.0.5";
481 constexpr char host_name[] = "howdy.example.com.";
Ken Chenb9fa2062018-11-13 21:51:13 +0800482
Xiao Ma09b71022018-12-11 17:56:32 +0900483 const std::vector<DnsRecord> records = {
484 {host_name, ns_type::ns_t_a, "1.2.3.4"},
485 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
486 };
487 test::DNSResponder dns(listen_addr);
488 test::DNSResponder dns2(listen_addr2);
489 StartDns(dns, records);
490 StartDns(dns2, records);
Ken Chenb9fa2062018-11-13 21:51:13 +0800491
Xiao Ma09b71022018-12-11 17:56:32 +0900492 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr}));
Ken Chenb9fa2062018-11-13 21:51:13 +0800493 dns.clearQueries();
494 dns2.clearQueries();
495
496 ScopedAddrinfo result = safe_getaddrinfo("howdy", nullptr, nullptr);
497 EXPECT_TRUE(result != nullptr);
498 size_t found = GetNumQueries(dns, host_name);
499 EXPECT_LE(1U, found);
500 // Could be A or AAAA
501 std::string result_str = ToString(result);
502 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
Luke Huangf8215372019-11-22 11:53:41 +0800503 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +0800504
505 // Verify that the name is cached.
506 size_t old_found = found;
507 result = safe_getaddrinfo("howdy", nullptr, nullptr);
508 EXPECT_TRUE(result != nullptr);
509 found = GetNumQueries(dns, host_name);
510 EXPECT_LE(1U, found);
511 EXPECT_EQ(old_found, found);
512 result_str = ToString(result);
Luke Huangf8215372019-11-22 11:53:41 +0800513 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4") << result_str;
Ken Chenb9fa2062018-11-13 21:51:13 +0800514
515 // Change the DNS resolver, ensure that queries are still cached.
Xiao Ma09b71022018-12-11 17:56:32 +0900516 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr2}));
Ken Chenb9fa2062018-11-13 21:51:13 +0800517 dns.clearQueries();
518 dns2.clearQueries();
519
520 result = safe_getaddrinfo("howdy", nullptr, nullptr);
521 EXPECT_TRUE(result != nullptr);
522 found = GetNumQueries(dns, host_name);
523 size_t found2 = GetNumQueries(dns2, host_name);
524 EXPECT_EQ(0U, found);
525 EXPECT_LE(0U, found2);
526
527 // Could be A or AAAA
528 result_str = ToString(result);
529 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
Luke Huangf8215372019-11-22 11:53:41 +0800530 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +0800531}
532
533TEST_F(ResolverTest, GetAddrInfoV4) {
Xiao Ma09b71022018-12-11 17:56:32 +0900534 test::DNSResponder dns;
535 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, "1.2.3.5"}});
536 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800537
Xiao Ma09b71022018-12-11 17:56:32 +0900538 const addrinfo hints = {.ai_family = AF_INET};
539 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
Ken Chenb9fa2062018-11-13 21:51:13 +0800540 EXPECT_TRUE(result != nullptr);
Xiao Ma09b71022018-12-11 17:56:32 +0900541 EXPECT_EQ(1U, GetNumQueries(dns, kHelloExampleCom));
Ken Chenb9fa2062018-11-13 21:51:13 +0800542 EXPECT_EQ("1.2.3.5", ToString(result));
543}
544
545TEST_F(ResolverTest, GetAddrInfo_localhost) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800546 // Add a dummy nameserver which shouldn't receive any queries
Xiao Ma09b71022018-12-11 17:56:32 +0900547 test::DNSResponder dns;
548 StartDns(dns, {});
549 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800550
Xiao Ma09b71022018-12-11 17:56:32 +0900551 ScopedAddrinfo result = safe_getaddrinfo(kLocalHost, nullptr, nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800552 EXPECT_TRUE(result != nullptr);
553 // Expect no DNS queries; localhost is resolved via /etc/hosts
554 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900555 EXPECT_EQ(kLocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800556
Xiao Ma09b71022018-12-11 17:56:32 +0900557 result = safe_getaddrinfo(kIp6LocalHost, nullptr, nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800558 EXPECT_TRUE(result != nullptr);
559 // Expect no DNS queries; ip6-localhost is resolved via /etc/hosts
560 EXPECT_TRUE(dns.queries().empty()) << dns.dumpQueries();
Xiao Ma09b71022018-12-11 17:56:32 +0900561 EXPECT_EQ(kIp6LocalHostAddr, ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +0800562}
563
Luke Huangd8ac4752019-06-18 17:05:47 +0800564TEST_F(ResolverTest, GetAddrInfo_InvalidSocketType) {
565 test::DNSResponder dns;
566 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, "1.2.3.5"}});
567 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
568
569 // TODO: Test other invalid socket types.
570 const addrinfo hints = {
571 .ai_family = AF_UNSPEC,
Luke Huangd8ac4752019-06-18 17:05:47 +0800572 .ai_socktype = SOCK_PACKET,
573 };
574 addrinfo* result = nullptr;
575 // This is a valid hint, but the query won't be sent because the socket type is
576 // not supported.
577 EXPECT_EQ(EAI_NODATA, getaddrinfo("hello", nullptr, &hints, &result));
578 ScopedAddrinfo result_cleanup(result);
579 EXPECT_EQ(nullptr, result);
580}
581
Ken Chen92bed612018-12-22 21:46:55 +0800582// Verify if the resolver correctly handle multiple queries simultaneously
583// step 1: set dns server#1 into deferred responding mode.
584// step 2: thread#1 query "hello.example.com." --> resolver send query to server#1.
585// step 3: thread#2 query "hello.example.com." --> resolver hold the request and wait for
586// response of previous pending query sent by thread#1.
587// step 4: thread#3 query "konbanha.example.com." --> resolver send query to server#3. Server
588// respond to resolver immediately.
589// step 5: check if server#1 get 1 query by thread#1, server#2 get 0 query, server#3 get 1 query.
590// step 6: resume dns server#1 to respond dns query in step#2.
591// step 7: thread#1 and #2 should get returned from DNS query after step#6. Also, check the
592// number of queries in server#2 is 0 to ensure thread#2 does not wake up unexpectedly
593// before signaled by thread#1.
594TEST_F(ResolverTest, GetAddrInfoV4_deferred_resp) {
595 const char* listen_addr1 = "127.0.0.9";
596 const char* listen_addr2 = "127.0.0.10";
597 const char* listen_addr3 = "127.0.0.11";
598 const char* listen_srv = "53";
599 const char* host_name_deferred = "hello.example.com.";
600 const char* host_name_normal = "konbanha.example.com.";
Mike Yufc125e42019-05-15 20:41:28 +0800601 test::DNSResponder dns1(listen_addr1, listen_srv, ns_rcode::ns_r_servfail);
602 test::DNSResponder dns2(listen_addr2, listen_srv, ns_rcode::ns_r_servfail);
603 test::DNSResponder dns3(listen_addr3, listen_srv, ns_rcode::ns_r_servfail);
Ken Chen92bed612018-12-22 21:46:55 +0800604 dns1.addMapping(host_name_deferred, ns_type::ns_t_a, "1.2.3.4");
605 dns2.addMapping(host_name_deferred, ns_type::ns_t_a, "1.2.3.4");
606 dns3.addMapping(host_name_normal, ns_type::ns_t_a, "1.2.3.5");
607 ASSERT_TRUE(dns1.startServer());
608 ASSERT_TRUE(dns2.startServer());
609 ASSERT_TRUE(dns3.startServer());
610 const std::vector<std::string> servers_for_t1 = {listen_addr1};
611 const std::vector<std::string> servers_for_t2 = {listen_addr2};
612 const std::vector<std::string> servers_for_t3 = {listen_addr3};
613 addrinfo hints = {.ai_family = AF_INET};
614 const std::vector<int> params = {300, 25, 8, 8, 5000};
615 bool t3_task_done = false;
616
617 dns1.setDeferredResp(true);
618 std::thread t1([&, this]() {
619 ASSERT_TRUE(
620 mDnsClient.SetResolversForNetwork(servers_for_t1, kDefaultSearchDomains, params));
621 ScopedAddrinfo result = safe_getaddrinfo(host_name_deferred, nullptr, &hints);
622 // t3's dns query should got returned first
623 EXPECT_TRUE(t3_task_done);
624 EXPECT_EQ(1U, GetNumQueries(dns1, host_name_deferred));
625 EXPECT_TRUE(result != nullptr);
626 EXPECT_EQ("1.2.3.4", ToString(result));
627 });
628
629 // ensuring t1 and t2 handler functions are processed in order
630 usleep(100 * 1000);
631 std::thread t2([&, this]() {
632 ASSERT_TRUE(
633 mDnsClient.SetResolversForNetwork(servers_for_t2, kDefaultSearchDomains, params));
634 ScopedAddrinfo result = safe_getaddrinfo(host_name_deferred, nullptr, &hints);
635 EXPECT_TRUE(t3_task_done);
636 EXPECT_EQ(0U, GetNumQueries(dns2, host_name_deferred));
637 EXPECT_TRUE(result != nullptr);
638 EXPECT_EQ("1.2.3.4", ToString(result));
639
640 std::vector<std::string> res_servers;
641 std::vector<std::string> res_domains;
642 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +0900643 res_params res_params;
Ken Chen92bed612018-12-22 21:46:55 +0800644 std::vector<ResolverStats> res_stats;
645 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +0800646 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
647 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
648 &res_tls_servers, &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chen92bed612018-12-22 21:46:55 +0800649 EXPECT_EQ(0, wait_for_pending_req_timeout_count);
650 });
651
652 // ensuring t2 and t3 handler functions are processed in order
653 usleep(100 * 1000);
654 std::thread t3([&, this]() {
655 ASSERT_TRUE(
656 mDnsClient.SetResolversForNetwork(servers_for_t3, kDefaultSearchDomains, params));
657 ScopedAddrinfo result = safe_getaddrinfo(host_name_normal, nullptr, &hints);
658 EXPECT_EQ(1U, GetNumQueries(dns1, host_name_deferred));
659 EXPECT_EQ(0U, GetNumQueries(dns2, host_name_deferred));
660 EXPECT_EQ(1U, GetNumQueries(dns3, host_name_normal));
661 EXPECT_TRUE(result != nullptr);
662 EXPECT_EQ("1.2.3.5", ToString(result));
663
664 t3_task_done = true;
665 dns1.setDeferredResp(false);
666 });
667 t3.join();
668 t1.join();
669 t2.join();
670}
671
lifr4e4a2e02019-01-29 16:53:51 +0800672TEST_F(ResolverTest, GetAddrInfo_cnames) {
673 constexpr char host_name[] = "host.example.com.";
674 test::DNSResponder dns;
675 const std::vector<DnsRecord> records = {
676 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
677 {"a.example.com.", ns_type::ns_t_cname, "b.example.com."},
678 {"b.example.com.", ns_type::ns_t_cname, "c.example.com."},
679 {"c.example.com.", ns_type::ns_t_cname, "d.example.com."},
680 {"d.example.com.", ns_type::ns_t_cname, "e.example.com."},
681 {"e.example.com.", ns_type::ns_t_cname, host_name},
682 {host_name, ns_type::ns_t_a, "1.2.3.3"},
683 {host_name, ns_type::ns_t_aaaa, "2001:db8::42"},
684 };
685 StartDns(dns, records);
686 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
687
688 addrinfo hints = {.ai_family = AF_INET};
689 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
690 EXPECT_TRUE(result != nullptr);
691 EXPECT_EQ("1.2.3.3", ToString(result));
692
693 dns.clearQueries();
694 hints = {.ai_family = AF_INET6};
695 result = safe_getaddrinfo("hello", nullptr, &hints);
696 EXPECT_TRUE(result != nullptr);
697 EXPECT_EQ("2001:db8::42", ToString(result));
698}
699
700TEST_F(ResolverTest, GetAddrInfo_cnamesNoIpAddress) {
701 test::DNSResponder dns;
702 const std::vector<DnsRecord> records = {
703 {kHelloExampleCom, ns_type::ns_t_cname, "a.example.com."},
704 };
705 StartDns(dns, records);
706 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
707
708 addrinfo hints = {.ai_family = AF_INET};
709 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
710 EXPECT_TRUE(result == nullptr);
711
712 dns.clearQueries();
713 hints = {.ai_family = AF_INET6};
714 result = safe_getaddrinfo("hello", nullptr, &hints);
715 EXPECT_TRUE(result == nullptr);
716}
717
718TEST_F(ResolverTest, GetAddrInfo_cnamesIllegalRdata) {
719 test::DNSResponder dns;
720 const std::vector<DnsRecord> records = {
721 {kHelloExampleCom, ns_type::ns_t_cname, ".!#?"},
722 };
723 StartDns(dns, records);
724 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
725
726 addrinfo hints = {.ai_family = AF_INET};
727 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
728 EXPECT_TRUE(result == nullptr);
729
730 dns.clearQueries();
731 hints = {.ai_family = AF_INET6};
732 result = safe_getaddrinfo("hello", nullptr, &hints);
733 EXPECT_TRUE(result == nullptr);
734}
735
Ken Chenb9fa2062018-11-13 21:51:13 +0800736TEST_F(ResolverTest, MultidomainResolution) {
Xiao Ma09b71022018-12-11 17:56:32 +0900737 constexpr char host_name[] = "nihao.example2.com.";
Luke Huangf8215372019-11-22 11:53:41 +0800738 std::vector<std::string> searchDomains = {"example1.com", "example2.com", "example3.com"};
Ken Chenb9fa2062018-11-13 21:51:13 +0800739
Xiao Ma09b71022018-12-11 17:56:32 +0900740 test::DNSResponder dns("127.0.0.6");
741 StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.3"}});
742 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({"127.0.0.6"}, searchDomains));
743
Ken Chenb9fa2062018-11-13 21:51:13 +0800744 const hostent* result = gethostbyname("nihao");
Xiao Ma09b71022018-12-11 17:56:32 +0900745
Ken Chenb9fa2062018-11-13 21:51:13 +0800746 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
747 ASSERT_FALSE(result == nullptr);
748 ASSERT_EQ(4, result->h_length);
749 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
750 EXPECT_EQ("1.2.3.3", ToString(result));
751 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
Ken Chenb9fa2062018-11-13 21:51:13 +0800752}
753
754TEST_F(ResolverTest, GetAddrInfoV6_numeric) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800755 constexpr char host_name[] = "ohayou.example.com.";
756 constexpr char numeric_addr[] = "fe80::1%lo";
757
Xiao Ma09b71022018-12-11 17:56:32 +0900758 test::DNSResponder dns;
Ken Chenb9fa2062018-11-13 21:51:13 +0800759 dns.setResponseProbability(0.0);
Xiao Ma09b71022018-12-11 17:56:32 +0900760 StartDns(dns, {{host_name, ns_type::ns_t_aaaa, "2001:db8::5"}});
761 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +0800762
763 addrinfo hints = {.ai_family = AF_INET6};
764 ScopedAddrinfo result = safe_getaddrinfo(numeric_addr, nullptr, &hints);
765 EXPECT_TRUE(result != nullptr);
766 EXPECT_EQ(numeric_addr, ToString(result));
767 EXPECT_TRUE(dns.queries().empty()); // Ensure no DNS queries were sent out
768
769 // Now try a non-numeric hostname query with the AI_NUMERICHOST flag set.
770 // We should fail without sending out a DNS query.
771 hints.ai_flags |= AI_NUMERICHOST;
772 result = safe_getaddrinfo(host_name, nullptr, &hints);
773 EXPECT_TRUE(result == nullptr);
774 EXPECT_TRUE(dns.queries().empty()); // Ensure no DNS queries were sent out
775}
776
777TEST_F(ResolverTest, GetAddrInfoV6_failing) {
Xiao Ma09b71022018-12-11 17:56:32 +0900778 constexpr char listen_addr0[] = "127.0.0.7";
779 constexpr char listen_addr1[] = "127.0.0.8";
Ken Chenb9fa2062018-11-13 21:51:13 +0800780 const char* host_name = "ohayou.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +0900781
782 test::DNSResponder dns0(listen_addr0);
783 test::DNSResponder dns1(listen_addr1);
Ken Chenb9fa2062018-11-13 21:51:13 +0800784 dns0.setResponseProbability(0.0);
Xiao Ma09b71022018-12-11 17:56:32 +0900785 StartDns(dns0, {{host_name, ns_type::ns_t_aaaa, "2001:db8::5"}});
786 StartDns(dns1, {{host_name, ns_type::ns_t_aaaa, "2001:db8::6"}});
787
Luke Huangf8215372019-11-22 11:53:41 +0800788 std::vector<std::string> servers = {listen_addr0, listen_addr1};
Ken Chenb9fa2062018-11-13 21:51:13 +0800789 // <sample validity in s> <success threshold in percent> <min samples> <max samples>
790 int sample_count = 8;
Luke Huangf8215372019-11-22 11:53:41 +0800791 const std::vector<int> params = {300, 25, sample_count, sample_count};
Xiao Ma09b71022018-12-11 17:56:32 +0900792 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, kDefaultSearchDomains, params));
Ken Chenb9fa2062018-11-13 21:51:13 +0800793
794 // Repeatedly perform resolutions for non-existing domains until MAXNSSAMPLES resolutions have
795 // reached the dns0, which is set to fail. No more requests should then arrive at that server
796 // for the next sample_lifetime seconds.
797 // TODO: This approach is implementation-dependent, change once metrics reporting is available.
Xiao Ma09b71022018-12-11 17:56:32 +0900798 const addrinfo hints = {.ai_family = AF_INET6};
Bernie Innocentib102dd22018-12-04 14:57:48 +0900799 for (int i = 0; i < sample_count; ++i) {
Ken Chenb9fa2062018-11-13 21:51:13 +0800800 std::string domain = StringPrintf("nonexistent%d", i);
801 ScopedAddrinfo result = safe_getaddrinfo(domain.c_str(), nullptr, &hints);
802 }
803 // Due to 100% errors for all possible samples, the server should be ignored from now on and
804 // only the second one used for all following queries, until NSSAMPLE_VALIDITY is reached.
805 dns0.clearQueries();
806 dns1.clearQueries();
807 ScopedAddrinfo result = safe_getaddrinfo("ohayou", nullptr, &hints);
808 EXPECT_TRUE(result != nullptr);
809 EXPECT_EQ(0U, GetNumQueries(dns0, host_name));
810 EXPECT_EQ(1U, GetNumQueries(dns1, host_name));
811}
812
813TEST_F(ResolverTest, GetAddrInfoV6_nonresponsive) {
Xiao Ma09b71022018-12-11 17:56:32 +0900814 constexpr char listen_addr0[] = "127.0.0.7";
815 constexpr char listen_addr1[] = "127.0.0.8";
816 constexpr char listen_srv[] = "53";
817 constexpr char host_name1[] = "ohayou.example.com.";
818 constexpr char host_name2[] = "ciao.example.com.";
Luke Huang483cf332019-06-03 17:24:51 +0800819 const std::vector<std::string> defaultSearchDomain = {"example.com"};
820 // The minimal timeout is 1000ms, so we can't decrease timeout
821 // So reduce retry count.
822 const std::vector<int> reduceRetryParams = {
823 300, // sample validity in seconds
824 25, // success threshod in percent
825 8, 8, // {MIN,MAX}_SAMPLES
826 1000, // BASE_TIMEOUT_MSEC
827 1, // retry count
828 };
Xiao Ma09b71022018-12-11 17:56:32 +0900829 const std::vector<DnsRecord> records0 = {
830 {host_name1, ns_type::ns_t_aaaa, "2001:db8::5"},
831 {host_name2, ns_type::ns_t_aaaa, "2001:db8::5"},
832 };
833 const std::vector<DnsRecord> records1 = {
834 {host_name1, ns_type::ns_t_aaaa, "2001:db8::6"},
835 {host_name2, ns_type::ns_t_aaaa, "2001:db8::6"},
836 };
Ken Chenb9fa2062018-11-13 21:51:13 +0800837
838 // dns0 does not respond with 100% probability, while
839 // dns1 responds normally, at least initially.
Mike Yufc125e42019-05-15 20:41:28 +0800840 test::DNSResponder dns0(listen_addr0, listen_srv, static_cast<ns_rcode>(-1));
841 test::DNSResponder dns1(listen_addr1, listen_srv, static_cast<ns_rcode>(-1));
Ken Chenb9fa2062018-11-13 21:51:13 +0800842 dns0.setResponseProbability(0.0);
Xiao Ma09b71022018-12-11 17:56:32 +0900843 StartDns(dns0, records0);
844 StartDns(dns1, records1);
Luke Huang483cf332019-06-03 17:24:51 +0800845 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr0, listen_addr1}, defaultSearchDomain,
846 reduceRetryParams));
Ken Chenb9fa2062018-11-13 21:51:13 +0800847
Luke Huang483cf332019-06-03 17:24:51 +0800848 // Specify ai_socktype to make getaddrinfo will only query 1 time
849 const addrinfo hints = {.ai_family = AF_INET6, .ai_socktype = SOCK_STREAM};
Ken Chenb9fa2062018-11-13 21:51:13 +0800850
851 // dns0 will ignore the request, and we'll fallback to dns1 after the first
852 // retry.
853 ScopedAddrinfo result = safe_getaddrinfo(host_name1, nullptr, &hints);
854 EXPECT_TRUE(result != nullptr);
855 EXPECT_EQ(1U, GetNumQueries(dns0, host_name1));
856 EXPECT_EQ(1U, GetNumQueries(dns1, host_name1));
857
858 // Now make dns1 also ignore 100% requests... The resolve should alternate
Luke Huang483cf332019-06-03 17:24:51 +0800859 // queries between the nameservers and fail
Ken Chenb9fa2062018-11-13 21:51:13 +0800860 dns1.setResponseProbability(0.0);
861 addrinfo* result2 = nullptr;
862 EXPECT_EQ(EAI_NODATA, getaddrinfo(host_name2, nullptr, &hints, &result2));
863 EXPECT_EQ(nullptr, result2);
Luke Huang483cf332019-06-03 17:24:51 +0800864 EXPECT_EQ(1U, GetNumQueries(dns0, host_name2));
865 EXPECT_EQ(1U, GetNumQueries(dns1, host_name2));
Ken Chenb9fa2062018-11-13 21:51:13 +0800866}
867
868TEST_F(ResolverTest, GetAddrInfoV6_concurrent) {
Xiao Ma09b71022018-12-11 17:56:32 +0900869 constexpr char listen_addr0[] = "127.0.0.9";
870 constexpr char listen_addr1[] = "127.0.0.10";
871 constexpr char listen_addr2[] = "127.0.0.11";
872 constexpr char host_name[] = "konbanha.example.com.";
873
874 test::DNSResponder dns0(listen_addr0);
875 test::DNSResponder dns1(listen_addr1);
876 test::DNSResponder dns2(listen_addr2);
877 StartDns(dns0, {{host_name, ns_type::ns_t_aaaa, "2001:db8::5"}});
878 StartDns(dns1, {{host_name, ns_type::ns_t_aaaa, "2001:db8::6"}});
879 StartDns(dns2, {{host_name, ns_type::ns_t_aaaa, "2001:db8::7"}});
880
Luke Huangf8215372019-11-22 11:53:41 +0800881 const std::vector<std::string> servers = {listen_addr0, listen_addr1, listen_addr2};
Ken Chenb9fa2062018-11-13 21:51:13 +0800882 std::vector<std::thread> threads(10);
883 for (std::thread& thread : threads) {
Luke Huangf8215372019-11-22 11:53:41 +0800884 thread = std::thread([this, &servers]() {
885 unsigned delay = arc4random_uniform(1 * 1000 * 1000); // <= 1s
Ken Chenb9fa2062018-11-13 21:51:13 +0800886 usleep(delay);
887 std::vector<std::string> serverSubset;
888 for (const auto& server : servers) {
889 if (arc4random_uniform(2)) {
890 serverSubset.push_back(server);
891 }
892 }
893 if (serverSubset.empty()) serverSubset = servers;
Xiao Ma09b71022018-12-11 17:56:32 +0900894 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(serverSubset));
895 const addrinfo hints = {.ai_family = AF_INET6};
Ken Chenb9fa2062018-11-13 21:51:13 +0800896 addrinfo* result = nullptr;
897 int rv = getaddrinfo("konbanha", nullptr, &hints, &result);
898 EXPECT_EQ(0, rv) << "error [" << rv << "] " << gai_strerror(rv);
899 if (result) {
900 freeaddrinfo(result);
901 result = nullptr;
902 }
903 });
904 }
905 for (std::thread& thread : threads) {
906 thread.join();
907 }
Ken Chen92bed612018-12-22 21:46:55 +0800908
909 std::vector<std::string> res_servers;
910 std::vector<std::string> res_domains;
911 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +0900912 res_params res_params;
Ken Chen92bed612018-12-22 21:46:55 +0800913 std::vector<ResolverStats> res_stats;
914 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +0800915 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
916 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
917 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chen92bed612018-12-22 21:46:55 +0800918 EXPECT_EQ(0, wait_for_pending_req_timeout_count);
Ken Chenb9fa2062018-11-13 21:51:13 +0800919}
920
Mike Yu8ac63402019-12-02 15:28:38 +0800921TEST_F(ResolverTest, SkipBadServersDueToInternalError) {
922 constexpr char listen_addr1[] = "fe80::1";
923 constexpr char listen_addr2[] = "255.255.255.255";
924 constexpr char listen_addr3[] = "127.0.0.3";
925
926 test::DNSResponder dns(listen_addr3);
927 ASSERT_TRUE(dns.startServer());
928
929 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
930 parcel.servers = {listen_addr1, listen_addr2, listen_addr3};
931
932 // Bad servers can be distinguished after two attempts.
933 parcel.minSamples = 2;
934 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
935
936 // Start querying five times.
937 for (int i = 0; i < 5; i++) {
938 std::string hostName = StringPrintf("hello%d.com.", i);
939 dns.addMapping(hostName, ns_type::ns_t_a, "1.2.3.4");
940 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
941 EXPECT_TRUE(safe_getaddrinfo(hostName.c_str(), nullptr, &hints) != nullptr);
942 }
943
944 std::vector<std::string> res_servers;
945 std::vector<std::string> res_domains;
946 std::vector<std::string> res_tls_servers;
947 res_params res_params;
948 std::vector<ResolverStats> res_stats;
949 int wait_for_pending_req_timeout_count;
950 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
951 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
952 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
953
954 // Verify the result by means of the statistics.
955 EXPECT_EQ(res_stats[0].successes, 0);
956 EXPECT_EQ(res_stats[1].successes, 0);
957 EXPECT_EQ(res_stats[2].successes, 5);
958 EXPECT_EQ(res_stats[0].internal_errors, 2);
959 EXPECT_EQ(res_stats[1].internal_errors, 2);
960 EXPECT_EQ(res_stats[2].internal_errors, 0);
961}
962
963TEST_F(ResolverTest, SkipBadServersDueToTimeout) {
964 constexpr char listen_addr1[] = "127.0.0.3";
965 constexpr char listen_addr2[] = "127.0.0.4";
966
967 // Set dns1 non-responsive and dns2 workable.
968 test::DNSResponder dns1(listen_addr1, test::kDefaultListenService, static_cast<ns_rcode>(-1));
969 test::DNSResponder dns2(listen_addr2);
970 dns1.setResponseProbability(0.0);
971 ASSERT_TRUE(dns1.startServer());
972 ASSERT_TRUE(dns2.startServer());
973
974 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
975 parcel.servers = {listen_addr1, listen_addr2};
976
977 // Bad servers can be distinguished after two attempts.
978 parcel.minSamples = 2;
979 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
980
981 // Start querying five times.
982 for (int i = 0; i < 5; i++) {
983 std::string hostName = StringPrintf("hello%d.com.", i);
984 dns1.addMapping(hostName, ns_type::ns_t_a, "1.2.3.4");
985 dns2.addMapping(hostName, ns_type::ns_t_a, "1.2.3.5");
986 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
987 EXPECT_TRUE(safe_getaddrinfo(hostName.c_str(), nullptr, &hints) != nullptr);
988 }
989
990 std::vector<std::string> res_servers;
991 std::vector<std::string> res_domains;
992 std::vector<std::string> res_tls_servers;
993 res_params res_params;
994 std::vector<ResolverStats> res_stats;
995 int wait_for_pending_req_timeout_count;
996 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
997 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
998 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
999
1000 // Verify the result by means of the statistics as well as the query counts.
1001 EXPECT_EQ(res_stats[0].successes, 0);
1002 EXPECT_EQ(res_stats[1].successes, 5);
1003 EXPECT_EQ(res_stats[0].timeouts, 2);
1004 EXPECT_EQ(res_stats[1].timeouts, 0);
1005 EXPECT_EQ(dns1.queries().size(), 2U);
1006 EXPECT_EQ(dns2.queries().size(), 5U);
1007}
1008
chenbrucefd837fa2019-10-29 18:35:36 +08001009TEST_F(ResolverTest, GetAddrInfoFromCustTable_InvalidInput) {
1010 constexpr char hostnameNoip[] = "noip.example.com.";
1011 constexpr char hostnameInvalidip[] = "invalidip.example.com.";
1012 const std::vector<aidl::android::net::ResolverHostsParcel> invalidCustHosts = {
1013 {"", hostnameNoip},
1014 {"wrong IP", hostnameInvalidip},
1015 };
1016 test::DNSResponder dns;
1017 StartDns(dns, {});
1018 auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
Ken Chen99344882020-01-01 14:59:38 +08001019 resolverParams.experimentalOptions.hosts = invalidCustHosts;
chenbrucefd837fa2019-10-29 18:35:36 +08001020 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1021 for (const auto& hostname : {hostnameNoip, hostnameInvalidip}) {
1022 // The query won't get data from customized table because of invalid customized table
1023 // and DNSResponder also has no records. hostnameNoip has never registered and
1024 // hostnameInvalidip has registered but wrong IP.
1025 const addrinfo hints = {.ai_family = AF_UNSPEC};
1026 ScopedAddrinfo result = safe_getaddrinfo(hostname, nullptr, &hints);
1027 ASSERT_TRUE(result == nullptr);
1028 EXPECT_EQ(4U, GetNumQueries(dns, hostname));
1029 }
1030}
1031
1032TEST_F(ResolverTest, GetAddrInfoFromCustTable) {
1033 constexpr char hostnameV4[] = "v4only.example.com.";
1034 constexpr char hostnameV6[] = "v6only.example.com.";
1035 constexpr char hostnameV4V6[] = "v4v6.example.com.";
1036 constexpr char custAddrV4[] = "1.2.3.4";
1037 constexpr char custAddrV6[] = "::1.2.3.4";
1038 constexpr char dnsSvAddrV4[] = "1.2.3.5";
1039 constexpr char dnsSvAddrV6[] = "::1.2.3.5";
1040 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV4 = {
1041 {custAddrV4, hostnameV4},
1042 };
1043 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV6 = {
1044 {custAddrV6, hostnameV6},
1045 };
1046 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV4V6 = {
1047 {custAddrV4, hostnameV4V6},
1048 {custAddrV6, hostnameV4V6},
1049 };
1050 const std::vector<DnsRecord> dnsSvHostV4 = {
1051 {hostnameV4, ns_type::ns_t_a, dnsSvAddrV4},
1052 };
1053 const std::vector<DnsRecord> dnsSvHostV6 = {
1054 {hostnameV6, ns_type::ns_t_aaaa, dnsSvAddrV6},
1055 };
1056 const std::vector<DnsRecord> dnsSvHostV4V6 = {
1057 {hostnameV4V6, ns_type::ns_t_a, dnsSvAddrV4},
1058 {hostnameV4V6, ns_type::ns_t_aaaa, dnsSvAddrV6},
1059 };
1060 struct TestConfig {
1061 const std::string name;
1062 const std::vector<aidl::android::net::ResolverHostsParcel> customizedHosts;
1063 const std::vector<DnsRecord> dnsserverHosts;
1064 const std::vector<std::string> queryResult;
1065 std::string asParameters() const {
1066 return StringPrintf("name: %s, customizedHosts: %s, dnsserverHosts: %s", name.c_str(),
1067 customizedHosts.empty() ? "No" : "Yes",
1068 dnsserverHosts.empty() ? "No" : "Yes");
1069 }
1070 } testConfigs[]{
1071 // clang-format off
1072 {hostnameV4, {}, {}, {}},
1073 {hostnameV4, {}, dnsSvHostV4, {dnsSvAddrV4}},
1074 {hostnameV4, custHostV4, {}, {custAddrV4}},
1075 {hostnameV4, custHostV4, dnsSvHostV4, {custAddrV4}},
1076 {hostnameV6, {}, {}, {}},
1077 {hostnameV6, {}, dnsSvHostV6, {dnsSvAddrV6}},
1078 {hostnameV6, custHostV6, {}, {custAddrV6}},
1079 {hostnameV6, custHostV6, dnsSvHostV6, {custAddrV6}},
1080 {hostnameV4V6, {}, {}, {}},
1081 {hostnameV4V6, {}, dnsSvHostV4V6, {dnsSvAddrV4, dnsSvAddrV6}},
1082 {hostnameV4V6, custHostV4V6, {}, {custAddrV4, custAddrV6}},
1083 {hostnameV4V6, custHostV4V6, dnsSvHostV4V6, {custAddrV4, custAddrV6}},
1084 // clang-format on
1085 };
1086
1087 for (const auto& config : testConfigs) {
1088 SCOPED_TRACE(config.asParameters());
1089
1090 test::DNSResponder dns;
1091 StartDns(dns, config.dnsserverHosts);
1092
1093 auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
Ken Chen99344882020-01-01 14:59:38 +08001094 resolverParams.experimentalOptions.hosts = config.customizedHosts;
chenbrucefd837fa2019-10-29 18:35:36 +08001095 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1096 const addrinfo hints = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM};
1097 ScopedAddrinfo result = safe_getaddrinfo(config.name.c_str(), nullptr, &hints);
1098 if (config.customizedHosts.empty() && config.dnsserverHosts.empty()) {
1099 ASSERT_TRUE(result == nullptr);
1100 EXPECT_EQ(2U, GetNumQueries(dns, config.name.c_str()));
1101 } else {
1102 ASSERT_TRUE(result != nullptr);
1103 EXPECT_THAT(ToStrings(result), testing::UnorderedElementsAreArray(config.queryResult));
1104 EXPECT_EQ(config.customizedHosts.empty() ? 2U : 0U,
1105 GetNumQueries(dns, config.name.c_str()));
1106 }
1107
1108 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
1109 }
1110}
1111
1112TEST_F(ResolverTest, GetAddrInfoFromCustTable_Modify) {
1113 constexpr char hostnameV4V6[] = "v4v6.example.com.";
1114 constexpr char custAddrV4[] = "1.2.3.4";
1115 constexpr char custAddrV6[] = "::1.2.3.4";
1116 constexpr char dnsSvAddrV4[] = "1.2.3.5";
1117 constexpr char dnsSvAddrV6[] = "::1.2.3.5";
1118 const std::vector<DnsRecord> dnsSvHostV4V6 = {
1119 {hostnameV4V6, ns_type::ns_t_a, dnsSvAddrV4},
1120 {hostnameV4V6, ns_type::ns_t_aaaa, dnsSvAddrV6},
1121 };
1122 const std::vector<aidl::android::net::ResolverHostsParcel> custHostV4V6 = {
1123 {custAddrV4, hostnameV4V6},
1124 {custAddrV6, hostnameV4V6},
1125 };
1126 test::DNSResponder dns;
1127 StartDns(dns, dnsSvHostV4V6);
1128 auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
1129
Ken Chen99344882020-01-01 14:59:38 +08001130 resolverParams.experimentalOptions.hosts = custHostV4V6;
chenbrucefd837fa2019-10-29 18:35:36 +08001131 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1132 const addrinfo hints = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM};
1133 ScopedAddrinfo result = safe_getaddrinfo(hostnameV4V6, nullptr, &hints);
1134 ASSERT_TRUE(result != nullptr);
1135 EXPECT_THAT(ToStrings(result), testing::UnorderedElementsAreArray({custAddrV4, custAddrV6}));
1136 EXPECT_EQ(0U, GetNumQueries(dns, hostnameV4V6));
1137
Ken Chen99344882020-01-01 14:59:38 +08001138 resolverParams.experimentalOptions.hosts = {};
chenbrucefd837fa2019-10-29 18:35:36 +08001139 ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
1140 result = safe_getaddrinfo(hostnameV4V6, nullptr, &hints);
1141 ASSERT_TRUE(result != nullptr);
1142 EXPECT_THAT(ToStrings(result), testing::UnorderedElementsAreArray({dnsSvAddrV4, dnsSvAddrV6}));
1143 EXPECT_EQ(2U, GetNumQueries(dns, hostnameV4V6));
1144}
1145
Ken Chenb9fa2062018-11-13 21:51:13 +08001146TEST_F(ResolverTest, EmptySetup) {
Ken Chenb9fa2062018-11-13 21:51:13 +08001147 std::vector<std::string> servers;
1148 std::vector<std::string> domains;
Xiao Ma09b71022018-12-11 17:56:32 +09001149 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
Ken Chenb9fa2062018-11-13 21:51:13 +08001150 std::vector<std::string> res_servers;
1151 std::vector<std::string> res_domains;
Mike Yu0a1c53d2018-11-26 13:26:21 +09001152 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +09001153 res_params res_params;
Ken Chenb9fa2062018-11-13 21:51:13 +08001154 std::vector<ResolverStats> res_stats;
Ken Chen92bed612018-12-22 21:46:55 +08001155 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001156 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
1157 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
1158 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Ken Chenb9fa2062018-11-13 21:51:13 +08001159 EXPECT_EQ(0U, res_servers.size());
1160 EXPECT_EQ(0U, res_domains.size());
Mike Yu0a1c53d2018-11-26 13:26:21 +09001161 EXPECT_EQ(0U, res_tls_servers.size());
Luke Huang5bd827c2019-03-14 16:10:04 +08001162 ASSERT_EQ(static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT), kDefaultParams.size());
1163 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY],
1164 res_params.sample_validity);
1165 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +09001166 res_params.success_threshold);
Luke Huang5bd827c2019-03-14 16:10:04 +08001167 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
1168 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
1169 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
Ken Chenb9fa2062018-11-13 21:51:13 +08001170 res_params.base_timeout_msec);
Luke Huang5bd827c2019-03-14 16:10:04 +08001171 EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT], res_params.retry_count);
Ken Chenb9fa2062018-11-13 21:51:13 +08001172}
1173
1174TEST_F(ResolverTest, SearchPathChange) {
Xiao Ma09b71022018-12-11 17:56:32 +09001175 constexpr char listen_addr[] = "127.0.0.13";
1176 constexpr char host_name1[] = "test13.domain1.org.";
1177 constexpr char host_name2[] = "test13.domain2.org.";
Luke Huangf8215372019-11-22 11:53:41 +08001178 std::vector<std::string> servers = {listen_addr};
1179 std::vector<std::string> domains = {"domain1.org"};
Xiao Ma09b71022018-12-11 17:56:32 +09001180
1181 const std::vector<DnsRecord> records = {
1182 {host_name1, ns_type::ns_t_aaaa, "2001:db8::13"},
1183 {host_name2, ns_type::ns_t_aaaa, "2001:db8::1:13"},
1184 };
1185 test::DNSResponder dns(listen_addr);
1186 StartDns(dns, records);
1187 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
Ken Chenb9fa2062018-11-13 21:51:13 +08001188
1189 const addrinfo hints = {.ai_family = AF_INET6};
1190 ScopedAddrinfo result = safe_getaddrinfo("test13", nullptr, &hints);
1191 EXPECT_TRUE(result != nullptr);
1192 EXPECT_EQ(1U, dns.queries().size());
1193 EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
1194 EXPECT_EQ("2001:db8::13", ToString(result));
1195
1196 // Test that changing the domain search path on its own works.
Luke Huangf8215372019-11-22 11:53:41 +08001197 domains = {"domain2.org"};
Xiao Ma09b71022018-12-11 17:56:32 +09001198 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
Ken Chenb9fa2062018-11-13 21:51:13 +08001199 dns.clearQueries();
1200
1201 result = safe_getaddrinfo("test13", nullptr, &hints);
1202 EXPECT_TRUE(result != nullptr);
1203 EXPECT_EQ(1U, dns.queries().size());
1204 EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
1205 EXPECT_EQ("2001:db8::1:13", ToString(result));
1206}
1207
Luke Huang2dac4382019-06-24 13:28:44 +08001208namespace {
1209
Luke Huangf8215372019-11-22 11:53:41 +08001210std::vector<std::string> getResolverDomains(aidl::android::net::IDnsResolver* dnsResolverService,
Luke Huang2dac4382019-06-24 13:28:44 +08001211 unsigned netId) {
1212 std::vector<std::string> res_servers;
1213 std::vector<std::string> res_domains;
1214 std::vector<std::string> res_tls_servers;
1215 res_params res_params;
1216 std::vector<ResolverStats> res_stats;
1217 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001218 DnsResponderClient::GetResolverInfo(dnsResolverService, netId, &res_servers, &res_domains,
1219 &res_tls_servers, &res_params, &res_stats,
1220 &wait_for_pending_req_timeout_count);
Luke Huang2dac4382019-06-24 13:28:44 +08001221 return res_domains;
1222}
1223
1224} // namespace
1225
1226TEST_F(ResolverTest, SearchPathPrune) {
1227 constexpr size_t DUPLICATED_DOMAIN_NUM = 3;
1228 constexpr char listen_addr[] = "127.0.0.13";
1229 constexpr char domian_name1[] = "domain13.org.";
1230 constexpr char domian_name2[] = "domain14.org.";
1231 constexpr char host_name1[] = "test13.domain13.org.";
1232 constexpr char host_name2[] = "test14.domain14.org.";
1233 std::vector<std::string> servers = {listen_addr};
1234
1235 std::vector<std::string> testDomains1;
1236 std::vector<std::string> testDomains2;
1237 // Domain length should be <= 255
1238 // Max number of domains in search path is 6
1239 for (size_t i = 0; i < MAXDNSRCH + 1; i++) {
1240 // Fill up with invalid domain
1241 testDomains1.push_back(std::string(300, i + '0'));
1242 // Fill up with valid but duplicated domain
1243 testDomains2.push_back(StringPrintf("domain%zu.org", i % DUPLICATED_DOMAIN_NUM));
1244 }
1245
1246 // Add valid domain used for query.
1247 testDomains1.push_back(domian_name1);
1248
1249 // Add valid domain twice used for query.
1250 testDomains2.push_back(domian_name2);
1251 testDomains2.push_back(domian_name2);
1252
1253 const std::vector<DnsRecord> records = {
1254 {host_name1, ns_type::ns_t_aaaa, "2001:db8::13"},
1255 {host_name2, ns_type::ns_t_aaaa, "2001:db8::1:13"},
1256 };
1257 test::DNSResponder dns(listen_addr);
1258 StartDns(dns, records);
1259 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, testDomains1));
1260
1261 const addrinfo hints = {.ai_family = AF_INET6};
1262 ScopedAddrinfo result = safe_getaddrinfo("test13", nullptr, &hints);
1263
1264 EXPECT_TRUE(result != nullptr);
1265
1266 EXPECT_EQ(1U, dns.queries().size());
1267 EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
1268 EXPECT_EQ("2001:db8::13", ToString(result));
1269
1270 const auto& res_domains1 = getResolverDomains(mDnsClient.resolvService(), TEST_NETID);
1271 // Expect 1 valid domain, invalid domains are removed.
1272 ASSERT_EQ(1U, res_domains1.size());
1273 EXPECT_EQ(domian_name1, res_domains1[0]);
1274
1275 dns.clearQueries();
1276
1277 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, testDomains2));
1278
1279 result = safe_getaddrinfo("test14", nullptr, &hints);
1280 EXPECT_TRUE(result != nullptr);
1281
1282 // (3 domains * 2 retries) + 1 success query = 7
1283 EXPECT_EQ(7U, dns.queries().size());
1284 EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
1285 EXPECT_EQ("2001:db8::1:13", ToString(result));
1286
1287 const auto& res_domains2 = getResolverDomains(mDnsClient.resolvService(), TEST_NETID);
1288 // Expect 4 valid domain, duplicate domains are removed.
1289 EXPECT_EQ(DUPLICATED_DOMAIN_NUM + 1U, res_domains2.size());
1290 EXPECT_THAT(
1291 std::vector<std::string>({"domain0.org", "domain1.org", "domain2.org", domian_name2}),
1292 testing::ElementsAreArray(res_domains2));
1293}
1294
Mike Yu0a1c53d2018-11-26 13:26:21 +09001295// If we move this function to dns_responder_client, it will complicate the dependency need of
1296// dns_tls_frontend.h.
1297static void setupTlsServers(const std::vector<std::string>& servers,
waynema0e73c2e2019-07-31 15:04:08 +08001298 std::vector<std::unique_ptr<test::DnsTlsFrontend>>* tls) {
Xiao Ma09b71022018-12-11 17:56:32 +09001299 constexpr char listen_udp[] = "53";
1300 constexpr char listen_tls[] = "853";
Mike Yu0a1c53d2018-11-26 13:26:21 +09001301
1302 for (const auto& server : servers) {
1303 auto t = std::make_unique<test::DnsTlsFrontend>(server, listen_tls, server, listen_udp);
1304 t = std::make_unique<test::DnsTlsFrontend>(server, listen_tls, server, listen_udp);
1305 t->startServer();
Mike Yu0a1c53d2018-11-26 13:26:21 +09001306 tls->push_back(std::move(t));
1307 }
1308}
1309
Mike Yu0a1c53d2018-11-26 13:26:21 +09001310TEST_F(ResolverTest, MaxServerPrune_Binder) {
Mike Yu0a1c53d2018-11-26 13:26:21 +09001311 std::vector<std::string> domains;
1312 std::vector<std::unique_ptr<test::DNSResponder>> dns;
1313 std::vector<std::unique_ptr<test::DnsTlsFrontend>> tls;
1314 std::vector<std::string> servers;
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +09001315 std::vector<DnsResponderClient::Mapping> mappings;
Mike Yu0a1c53d2018-11-26 13:26:21 +09001316
1317 for (unsigned i = 0; i < MAXDNSRCH + 1; i++) {
1318 domains.push_back(StringPrintf("example%u.com", i));
1319 }
Bernie Innocentia5c7b7b2019-01-17 21:28:24 +09001320 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupMappings(1, domains, &mappings));
1321 ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupDNSServers(MAXNS + 1, mappings, &dns, &servers));
waynema0e73c2e2019-07-31 15:04:08 +08001322 ASSERT_NO_FATAL_FAILURE(setupTlsServers(servers, &tls));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001323
waynema0e73c2e2019-07-31 15:04:08 +08001324 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, domains, kDefaultParams,
1325 kDefaultPrivateDnsHostName));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001326
Mike Yu383855b2019-01-15 17:53:27 +08001327 // If the private DNS validation hasn't completed yet before backend DNS servers stop,
1328 // TLS servers will get stuck in handleOneRequest(), which causes this test stuck in
1329 // ~DnsTlsFrontend() because the TLS server loop threads can't be terminated.
1330 // So, wait for private DNS validation done before stopping backend DNS servers.
1331 for (int i = 0; i < MAXNS; i++) {
chenbruceaff85842019-05-31 15:46:42 +08001332 LOG(INFO) << "Waiting for private DNS validation on " << tls[i]->listen_address() << ".";
Mike Yu724f77d2019-08-16 11:14:50 +08001333 EXPECT_TRUE(WaitForPrivateDnsValidation(tls[i]->listen_address(), true));
chenbruceaff85842019-05-31 15:46:42 +08001334 LOG(INFO) << "private DNS validation on " << tls[i]->listen_address() << " done.";
Mike Yu383855b2019-01-15 17:53:27 +08001335 }
1336
Mike Yu0a1c53d2018-11-26 13:26:21 +09001337 std::vector<std::string> res_servers;
1338 std::vector<std::string> res_domains;
1339 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +09001340 res_params res_params;
Mike Yu0a1c53d2018-11-26 13:26:21 +09001341 std::vector<ResolverStats> res_stats;
Ken Chen92bed612018-12-22 21:46:55 +08001342 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001343 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
1344 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
1345 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001346
1347 // Check the size of the stats and its contents.
1348 EXPECT_EQ(static_cast<size_t>(MAXNS), res_servers.size());
1349 EXPECT_EQ(static_cast<size_t>(MAXNS), res_tls_servers.size());
1350 EXPECT_EQ(static_cast<size_t>(MAXDNSRCH), res_domains.size());
1351 EXPECT_TRUE(std::equal(servers.begin(), servers.begin() + MAXNS, res_servers.begin()));
1352 EXPECT_TRUE(std::equal(servers.begin(), servers.begin() + MAXNS, res_tls_servers.begin()));
1353 EXPECT_TRUE(std::equal(domains.begin(), domains.begin() + MAXDNSRCH, res_domains.begin()));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001354}
1355
1356TEST_F(ResolverTest, ResolverStats) {
Xiao Ma09b71022018-12-11 17:56:32 +09001357 constexpr char listen_addr1[] = "127.0.0.4";
1358 constexpr char listen_addr2[] = "127.0.0.5";
1359 constexpr char listen_addr3[] = "127.0.0.6";
Mike Yu0a1c53d2018-11-26 13:26:21 +09001360
1361 // Set server 1 timeout.
Mike Yufc125e42019-05-15 20:41:28 +08001362 test::DNSResponder dns1(listen_addr1, "53", static_cast<ns_rcode>(-1));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001363 dns1.setResponseProbability(0.0);
1364 ASSERT_TRUE(dns1.startServer());
1365
1366 // Set server 2 responding server failure.
Xiao Ma09b71022018-12-11 17:56:32 +09001367 test::DNSResponder dns2(listen_addr2);
Mike Yu0a1c53d2018-11-26 13:26:21 +09001368 dns2.setResponseProbability(0.0);
1369 ASSERT_TRUE(dns2.startServer());
1370
1371 // Set server 3 workable.
Xiao Ma09b71022018-12-11 17:56:32 +09001372 test::DNSResponder dns3(listen_addr3);
1373 dns3.addMapping(kHelloExampleCom, ns_type::ns_t_a, "1.2.3.4");
Mike Yu0a1c53d2018-11-26 13:26:21 +09001374 ASSERT_TRUE(dns3.startServer());
1375
1376 std::vector<std::string> servers = {listen_addr1, listen_addr2, listen_addr3};
Xiao Ma09b71022018-12-11 17:56:32 +09001377 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001378
1379 dns3.clearQueries();
Xiao Ma09b71022018-12-11 17:56:32 +09001380 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
Mike Yu0a1c53d2018-11-26 13:26:21 +09001381 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
Xiao Ma09b71022018-12-11 17:56:32 +09001382 size_t found = GetNumQueries(dns3, kHelloExampleCom);
Mike Yu0a1c53d2018-11-26 13:26:21 +09001383 EXPECT_LE(1U, found);
1384 std::string result_str = ToString(result);
1385 EXPECT_TRUE(result_str == "1.2.3.4") << ", result_str='" << result_str << "'";
1386
1387 std::vector<std::string> res_servers;
1388 std::vector<std::string> res_domains;
1389 std::vector<std::string> res_tls_servers;
Bernie Innocenti758005f2019-02-19 18:08:36 +09001390 res_params res_params;
Mike Yu0a1c53d2018-11-26 13:26:21 +09001391 std::vector<ResolverStats> res_stats;
Ken Chen92bed612018-12-22 21:46:55 +08001392 int wait_for_pending_req_timeout_count;
Luke Huangf8215372019-11-22 11:53:41 +08001393 ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
1394 mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
1395 &res_params, &res_stats, &wait_for_pending_req_timeout_count));
Mike Yu0a1c53d2018-11-26 13:26:21 +09001396
1397 EXPECT_EQ(1, res_stats[0].timeouts);
1398 EXPECT_EQ(1, res_stats[1].errors);
1399 EXPECT_EQ(1, res_stats[2].successes);
Mike Yu0a1c53d2018-11-26 13:26:21 +09001400}
1401
Ken Chenb9fa2062018-11-13 21:51:13 +08001402// Test what happens if the specified TLS server is nonexistent.
1403TEST_F(ResolverTest, GetHostByName_TlsMissing) {
Xiao Ma09b71022018-12-11 17:56:32 +09001404 constexpr char listen_addr[] = "127.0.0.3";
1405 constexpr char host_name[] = "tlsmissing.example.com.";
1406
1407 test::DNSResponder dns;
1408 StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.3"}});
Luke Huangf8215372019-11-22 11:53:41 +08001409 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001410
1411 // There's nothing listening on this address, so validation will either fail or
1412 /// hang. Either way, queries will continue to flow to the DNSResponder.
waynema0e73c2e2019-07-31 15:04:08 +08001413 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Ken Chenb9fa2062018-11-13 21:51:13 +08001414
1415 const hostent* result;
1416
1417 result = gethostbyname("tlsmissing");
1418 ASSERT_FALSE(result == nullptr);
1419 EXPECT_EQ("1.2.3.3", ToString(result));
1420
1421 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001422 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001423}
1424
1425// Test what happens if the specified TLS server replies with garbage.
1426TEST_F(ResolverTest, GetHostByName_TlsBroken) {
Xiao Ma09b71022018-12-11 17:56:32 +09001427 constexpr char listen_addr[] = "127.0.0.3";
1428 constexpr char host_name1[] = "tlsbroken1.example.com.";
1429 constexpr char host_name2[] = "tlsbroken2.example.com.";
1430 const std::vector<DnsRecord> records = {
1431 {host_name1, ns_type::ns_t_a, "1.2.3.1"},
1432 {host_name2, ns_type::ns_t_a, "1.2.3.2"},
1433 };
1434
1435 test::DNSResponder dns;
1436 StartDns(dns, records);
Luke Huangf8215372019-11-22 11:53:41 +08001437 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001438
1439 // Bind the specified private DNS socket but don't respond to any client sockets yet.
1440 int s = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_TCP);
1441 ASSERT_TRUE(s >= 0);
1442 struct sockaddr_in tlsServer = {
Luke Huangf8215372019-11-22 11:53:41 +08001443 .sin_family = AF_INET,
1444 .sin_port = htons(853),
Ken Chenb9fa2062018-11-13 21:51:13 +08001445 };
1446 ASSERT_TRUE(inet_pton(AF_INET, listen_addr, &tlsServer.sin_addr));
1447 ASSERT_TRUE(enableSockopt(s, SOL_SOCKET, SO_REUSEPORT).ok());
1448 ASSERT_TRUE(enableSockopt(s, SOL_SOCKET, SO_REUSEADDR).ok());
1449 ASSERT_FALSE(bind(s, reinterpret_cast<struct sockaddr*>(&tlsServer), sizeof(tlsServer)));
1450 ASSERT_FALSE(listen(s, 1));
1451
1452 // Trigger TLS validation.
waynema0e73c2e2019-07-31 15:04:08 +08001453 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Ken Chenb9fa2062018-11-13 21:51:13 +08001454
1455 struct sockaddr_storage cliaddr;
1456 socklen_t sin_size = sizeof(cliaddr);
Luke Huangf8215372019-11-22 11:53:41 +08001457 int new_fd = accept4(s, reinterpret_cast<struct sockaddr*>(&cliaddr), &sin_size, SOCK_CLOEXEC);
Ken Chenb9fa2062018-11-13 21:51:13 +08001458 ASSERT_TRUE(new_fd > 0);
1459
1460 // We've received the new file descriptor but not written to it or closed, so the
1461 // validation is still pending. Queries should still flow correctly because the
1462 // server is not used until validation succeeds.
1463 const hostent* result;
1464 result = gethostbyname("tlsbroken1");
1465 ASSERT_FALSE(result == nullptr);
1466 EXPECT_EQ("1.2.3.1", ToString(result));
1467
1468 // Now we cause the validation to fail.
1469 std::string garbage = "definitely not a valid TLS ServerHello";
1470 write(new_fd, garbage.data(), garbage.size());
1471 close(new_fd);
1472
1473 // Validation failure shouldn't interfere with lookups, because lookups won't be sent
1474 // to the TLS server unless validation succeeds.
1475 result = gethostbyname("tlsbroken2");
1476 ASSERT_FALSE(result == nullptr);
1477 EXPECT_EQ("1.2.3.2", ToString(result));
1478
1479 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001480 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001481 close(s);
1482}
1483
1484TEST_F(ResolverTest, GetHostByName_Tls) {
Xiao Ma09b71022018-12-11 17:56:32 +09001485 constexpr char listen_addr[] = "127.0.0.3";
1486 constexpr char listen_udp[] = "53";
1487 constexpr char listen_tls[] = "853";
1488 constexpr char host_name1[] = "tls1.example.com.";
1489 constexpr char host_name2[] = "tls2.example.com.";
1490 constexpr char host_name3[] = "tls3.example.com.";
1491 const std::vector<DnsRecord> records = {
1492 {host_name1, ns_type::ns_t_a, "1.2.3.1"},
1493 {host_name2, ns_type::ns_t_a, "1.2.3.2"},
1494 {host_name3, ns_type::ns_t_a, "1.2.3.3"},
1495 };
1496
1497 test::DNSResponder dns;
1498 StartDns(dns, records);
Luke Huangf8215372019-11-22 11:53:41 +08001499 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001500
1501 test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
1502 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08001503 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08001504 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Ken Chenb9fa2062018-11-13 21:51:13 +08001505
Mike Yu724f77d2019-08-16 11:14:50 +08001506 const hostent* result = gethostbyname("tls1");
Ken Chenb9fa2062018-11-13 21:51:13 +08001507 ASSERT_FALSE(result == nullptr);
1508 EXPECT_EQ("1.2.3.1", ToString(result));
1509
1510 // Wait for query to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001511 EXPECT_TRUE(tls.waitForQueries(2));
Ken Chenb9fa2062018-11-13 21:51:13 +08001512
1513 // Stop the TLS server. Since we're in opportunistic mode, queries will
1514 // fall back to the locally-assigned (clear text) nameservers.
1515 tls.stopServer();
1516
1517 dns.clearQueries();
1518 result = gethostbyname("tls2");
1519 EXPECT_FALSE(result == nullptr);
1520 EXPECT_EQ("1.2.3.2", ToString(result));
1521 const auto queries = dns.queries();
1522 EXPECT_EQ(1U, queries.size());
waynema29253052019-08-20 11:26:08 +08001523 EXPECT_EQ("tls2.example.com.", queries[0].name);
1524 EXPECT_EQ(ns_t_a, queries[0].type);
Ken Chenb9fa2062018-11-13 21:51:13 +08001525
1526 // Reset the resolvers without enabling TLS. Queries should still be routed
1527 // to the UDP endpoint.
Xiao Ma09b71022018-12-11 17:56:32 +09001528 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001529
1530 result = gethostbyname("tls3");
1531 ASSERT_FALSE(result == nullptr);
1532 EXPECT_EQ("1.2.3.3", ToString(result));
Ken Chenb9fa2062018-11-13 21:51:13 +08001533}
1534
Ken Chenb9fa2062018-11-13 21:51:13 +08001535TEST_F(ResolverTest, GetHostByName_TlsFailover) {
Xiao Ma09b71022018-12-11 17:56:32 +09001536 constexpr char listen_addr1[] = "127.0.0.3";
1537 constexpr char listen_addr2[] = "127.0.0.4";
1538 constexpr char listen_udp[] = "53";
1539 constexpr char listen_tls[] = "853";
1540 constexpr char host_name1[] = "tlsfailover1.example.com.";
1541 constexpr char host_name2[] = "tlsfailover2.example.com.";
1542 const std::vector<DnsRecord> records1 = {
1543 {host_name1, ns_type::ns_t_a, "1.2.3.1"},
1544 {host_name2, ns_type::ns_t_a, "1.2.3.2"},
1545 };
1546 const std::vector<DnsRecord> records2 = {
1547 {host_name1, ns_type::ns_t_a, "1.2.3.3"},
1548 {host_name2, ns_type::ns_t_a, "1.2.3.4"},
1549 };
1550
1551 test::DNSResponder dns1(listen_addr1);
1552 test::DNSResponder dns2(listen_addr2);
1553 StartDns(dns1, records1);
1554 StartDns(dns2, records2);
1555
Luke Huangf8215372019-11-22 11:53:41 +08001556 std::vector<std::string> servers = {listen_addr1, listen_addr2};
Ken Chenb9fa2062018-11-13 21:51:13 +08001557
1558 test::DnsTlsFrontend tls1(listen_addr1, listen_tls, listen_addr1, listen_udp);
1559 test::DnsTlsFrontend tls2(listen_addr2, listen_tls, listen_addr2, listen_udp);
1560 ASSERT_TRUE(tls1.startServer());
1561 ASSERT_TRUE(tls2.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08001562 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
1563 kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08001564 EXPECT_TRUE(WaitForPrivateDnsValidation(tls1.listen_address(), true));
1565 EXPECT_TRUE(WaitForPrivateDnsValidation(tls2.listen_address(), true));
Ken Chenb9fa2062018-11-13 21:51:13 +08001566
Mike Yu724f77d2019-08-16 11:14:50 +08001567 const hostent* result = gethostbyname("tlsfailover1");
Ken Chenb9fa2062018-11-13 21:51:13 +08001568 ASSERT_FALSE(result == nullptr);
1569 EXPECT_EQ("1.2.3.1", ToString(result));
1570
1571 // Wait for query to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001572 EXPECT_TRUE(tls1.waitForQueries(2));
Ken Chenb9fa2062018-11-13 21:51:13 +08001573 // No new queries should have reached tls2.
1574 EXPECT_EQ(1, tls2.queries());
1575
1576 // Stop tls1. Subsequent queries should attempt to reach tls1, fail, and retry to tls2.
1577 tls1.stopServer();
1578
1579 result = gethostbyname("tlsfailover2");
1580 EXPECT_EQ("1.2.3.4", ToString(result));
1581
1582 // Wait for query to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001583 EXPECT_TRUE(tls2.waitForQueries(2));
Ken Chenb9fa2062018-11-13 21:51:13 +08001584
1585 // No additional queries should have reached the insecure servers.
1586 EXPECT_EQ(2U, dns1.queries().size());
1587 EXPECT_EQ(2U, dns2.queries().size());
1588
1589 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001590 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Ken Chenb9fa2062018-11-13 21:51:13 +08001591}
1592
1593TEST_F(ResolverTest, GetHostByName_BadTlsName) {
Xiao Ma09b71022018-12-11 17:56:32 +09001594 constexpr char listen_addr[] = "127.0.0.3";
1595 constexpr char listen_udp[] = "53";
1596 constexpr char listen_tls[] = "853";
1597 constexpr char host_name[] = "badtlsname.example.com.";
1598
1599 test::DNSResponder dns;
1600 StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.1"}});
Luke Huangf8215372019-11-22 11:53:41 +08001601 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001602
1603 test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
1604 ASSERT_TRUE(tls.startServer());
Xiao Ma09b71022018-12-11 17:56:32 +09001605 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
waynema0e73c2e2019-07-31 15:04:08 +08001606 kDefaultIncorrectPrivateDnsHostName));
Ken Chenb9fa2062018-11-13 21:51:13 +08001607
waynema0e73c2e2019-07-31 15:04:08 +08001608 // The TLS handshake would fail because the name of TLS server doesn't
1609 // match with TLS server's certificate.
Mike Yu724f77d2019-08-16 11:14:50 +08001610 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), false));
Ken Chenb9fa2062018-11-13 21:51:13 +08001611
1612 // The query should fail hard, because a name was specified.
1613 EXPECT_EQ(nullptr, gethostbyname("badtlsname"));
1614
1615 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001616 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001617}
1618
1619TEST_F(ResolverTest, GetAddrInfo_Tls) {
Xiao Ma09b71022018-12-11 17:56:32 +09001620 constexpr char listen_addr[] = "127.0.0.3";
1621 constexpr char listen_udp[] = "53";
1622 constexpr char listen_tls[] = "853";
1623 constexpr char host_name[] = "addrinfotls.example.com.";
1624 const std::vector<DnsRecord> records = {
1625 {host_name, ns_type::ns_t_a, "1.2.3.4"},
1626 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
1627 };
1628
1629 test::DNSResponder dns;
1630 StartDns(dns, records);
Luke Huangf8215372019-11-22 11:53:41 +08001631 std::vector<std::string> servers = {listen_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001632
1633 test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
1634 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08001635 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
1636 kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08001637 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Ken Chenb9fa2062018-11-13 21:51:13 +08001638
1639 dns.clearQueries();
1640 ScopedAddrinfo result = safe_getaddrinfo("addrinfotls", nullptr, nullptr);
1641 EXPECT_TRUE(result != nullptr);
1642 size_t found = GetNumQueries(dns, host_name);
1643 EXPECT_LE(1U, found);
1644 // Could be A or AAAA
1645 std::string result_str = ToString(result);
1646 EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
Luke Huangf8215372019-11-22 11:53:41 +08001647 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +08001648 // Wait for both A and AAAA queries to get counted.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001649 EXPECT_TRUE(tls.waitForQueries(3));
Ken Chenb9fa2062018-11-13 21:51:13 +08001650
1651 // Clear TLS bit.
Xiao Ma09b71022018-12-11 17:56:32 +09001652 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
Ken Chenb9fa2062018-11-13 21:51:13 +08001653}
1654
1655TEST_F(ResolverTest, TlsBypass) {
1656 const char OFF[] = "off";
1657 const char OPPORTUNISTIC[] = "opportunistic";
1658 const char STRICT[] = "strict";
1659
1660 const char GETHOSTBYNAME[] = "gethostbyname";
1661 const char GETADDRINFO[] = "getaddrinfo";
1662 const char GETADDRINFOFORNET[] = "getaddrinfofornet";
1663
1664 const unsigned BYPASS_NETID = NETID_USE_LOCAL_NAMESERVERS | TEST_NETID;
1665
Ken Chenb9fa2062018-11-13 21:51:13 +08001666 const char ADDR4[] = "192.0.2.1";
1667 const char ADDR6[] = "2001:db8::1";
1668
1669 const char cleartext_addr[] = "127.0.0.53";
1670 const char cleartext_port[] = "53";
1671 const char tls_port[] = "853";
Luke Huangf8215372019-11-22 11:53:41 +08001672 const std::vector<std::string> servers = {cleartext_addr};
Ken Chenb9fa2062018-11-13 21:51:13 +08001673
Xiao Ma09b71022018-12-11 17:56:32 +09001674 test::DNSResponder dns(cleartext_addr);
Ken Chenb9fa2062018-11-13 21:51:13 +08001675 ASSERT_TRUE(dns.startServer());
1676
1677 test::DnsTlsFrontend tls(cleartext_addr, tls_port, cleartext_addr, cleartext_port);
Mike Yudd4ac2d2019-05-31 16:52:11 +08001678 ASSERT_TRUE(tls.startServer());
Ken Chenb9fa2062018-11-13 21:51:13 +08001679
Luke Huangf8215372019-11-22 11:53:41 +08001680 // clang-format off
Ken Chenb9fa2062018-11-13 21:51:13 +08001681 struct TestConfig {
1682 const std::string mode;
1683 const bool withWorkingTLS;
1684 const std::string method;
1685
1686 std::string asHostName() const {
Luke Huangf8215372019-11-22 11:53:41 +08001687 return StringPrintf("%s.%s.%s.", mode.c_str(), withWorkingTLS ? "tlsOn" : "tlsOff",
Ken Chenb9fa2062018-11-13 21:51:13 +08001688 method.c_str());
1689 }
1690 } testConfigs[]{
Ken Chenb9fa2062018-11-13 21:51:13 +08001691 {OFF, true, GETHOSTBYNAME},
1692 {OPPORTUNISTIC, true, GETHOSTBYNAME},
1693 {STRICT, true, GETHOSTBYNAME},
Ken Chenb9fa2062018-11-13 21:51:13 +08001694 {OFF, true, GETADDRINFO},
1695 {OPPORTUNISTIC, true, GETADDRINFO},
1696 {STRICT, true, GETADDRINFO},
Ken Chenb9fa2062018-11-13 21:51:13 +08001697 {OFF, true, GETADDRINFOFORNET},
1698 {OPPORTUNISTIC, true, GETADDRINFOFORNET},
1699 {STRICT, true, GETADDRINFOFORNET},
Mike Yudd4ac2d2019-05-31 16:52:11 +08001700 {OFF, false, GETHOSTBYNAME},
1701 {OPPORTUNISTIC, false, GETHOSTBYNAME},
1702 {STRICT, false, GETHOSTBYNAME},
1703 {OFF, false, GETADDRINFO},
1704 {OPPORTUNISTIC, false, GETADDRINFO},
1705 {STRICT, false, GETADDRINFO},
1706 {OFF, false, GETADDRINFOFORNET},
1707 {OPPORTUNISTIC, false, GETADDRINFOFORNET},
1708 {STRICT, false, GETADDRINFOFORNET},
Ken Chenb9fa2062018-11-13 21:51:13 +08001709 };
Luke Huangf8215372019-11-22 11:53:41 +08001710 // clang-format on
Ken Chenb9fa2062018-11-13 21:51:13 +08001711
1712 for (const auto& config : testConfigs) {
1713 const std::string testHostName = config.asHostName();
1714 SCOPED_TRACE(testHostName);
1715
1716 // Don't tempt test bugs due to caching.
1717 const char* host_name = testHostName.c_str();
1718 dns.addMapping(host_name, ns_type::ns_t_a, ADDR4);
1719 dns.addMapping(host_name, ns_type::ns_t_aaaa, ADDR6);
1720
Mike Yudd4ac2d2019-05-31 16:52:11 +08001721 if (config.withWorkingTLS) {
1722 if (!tls.running()) {
1723 ASSERT_TRUE(tls.startServer());
1724 }
1725 } else {
1726 if (tls.running()) {
1727 ASSERT_TRUE(tls.stopServer());
1728 }
1729 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001730
1731 if (config.mode == OFF) {
Xiao Ma09b71022018-12-11 17:56:32 +09001732 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, kDefaultSearchDomains,
1733 kDefaultParams));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001734 } else /* OPPORTUNISTIC or STRICT */ {
1735 const char* tls_hostname = (config.mode == STRICT) ? kDefaultPrivateDnsHostName : "";
Xiao Ma09b71022018-12-11 17:56:32 +09001736 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001737 kDefaultParams, tls_hostname));
Mike Yu724f77d2019-08-16 11:14:50 +08001738
1739 // Wait for the validation event. If the server is running, the validation should
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001740 // succeed; otherwise, the validation should fail.
Mike Yu724f77d2019-08-16 11:14:50 +08001741 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), config.withWorkingTLS));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09001742 if (config.withWorkingTLS) {
1743 EXPECT_TRUE(tls.waitForQueries(1));
1744 tls.clearQueries();
1745 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001746 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001747
1748 const hostent* h_result = nullptr;
1749 ScopedAddrinfo ai_result;
1750
1751 if (config.method == GETHOSTBYNAME) {
1752 ASSERT_EQ(0, setNetworkForResolv(BYPASS_NETID));
1753 h_result = gethostbyname(host_name);
1754
1755 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
1756 ASSERT_FALSE(h_result == nullptr);
1757 ASSERT_EQ(4, h_result->h_length);
1758 ASSERT_FALSE(h_result->h_addr_list[0] == nullptr);
1759 EXPECT_EQ(ADDR4, ToString(h_result));
1760 EXPECT_TRUE(h_result->h_addr_list[1] == nullptr);
1761 } else if (config.method == GETADDRINFO) {
1762 ASSERT_EQ(0, setNetworkForResolv(BYPASS_NETID));
1763 ai_result = safe_getaddrinfo(host_name, nullptr, nullptr);
1764 EXPECT_TRUE(ai_result != nullptr);
1765
1766 EXPECT_LE(1U, GetNumQueries(dns, host_name));
1767 // Could be A or AAAA
1768 const std::string result_str = ToString(ai_result);
1769 EXPECT_TRUE(result_str == ADDR4 || result_str == ADDR6)
Luke Huangf8215372019-11-22 11:53:41 +08001770 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +08001771 } else if (config.method == GETADDRINFOFORNET) {
1772 addrinfo* raw_ai_result = nullptr;
1773 EXPECT_EQ(0, android_getaddrinfofornet(host_name, /*servname=*/nullptr,
1774 /*hints=*/nullptr, BYPASS_NETID, MARK_UNSET,
1775 &raw_ai_result));
1776 ai_result.reset(raw_ai_result);
1777
1778 EXPECT_LE(1U, GetNumQueries(dns, host_name));
1779 // Could be A or AAAA
1780 const std::string result_str = ToString(ai_result);
1781 EXPECT_TRUE(result_str == ADDR4 || result_str == ADDR6)
Luke Huangf8215372019-11-22 11:53:41 +08001782 << ", result_str='" << result_str << "'";
Ken Chenb9fa2062018-11-13 21:51:13 +08001783 }
1784
Mike Yudd4ac2d2019-05-31 16:52:11 +08001785 EXPECT_EQ(0, tls.queries());
Ken Chenb9fa2062018-11-13 21:51:13 +08001786
1787 // Clear per-process resolv netid.
1788 ASSERT_EQ(0, setNetworkForResolv(NETID_UNSET));
Ken Chenb9fa2062018-11-13 21:51:13 +08001789 dns.clearQueries();
1790 }
Ken Chenb9fa2062018-11-13 21:51:13 +08001791}
1792
1793TEST_F(ResolverTest, StrictMode_NoTlsServers) {
Xiao Ma09b71022018-12-11 17:56:32 +09001794 constexpr char cleartext_addr[] = "127.0.0.53";
Luke Huangf8215372019-11-22 11:53:41 +08001795 const std::vector<std::string> servers = {cleartext_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09001796 constexpr char host_name[] = "strictmode.notlsips.example.com.";
1797 const std::vector<DnsRecord> records = {
1798 {host_name, ns_type::ns_t_a, "1.2.3.4"},
1799 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
1800 };
Ken Chenb9fa2062018-11-13 21:51:13 +08001801
Xiao Ma09b71022018-12-11 17:56:32 +09001802 test::DNSResponder dns(cleartext_addr);
1803 StartDns(dns, records);
Ken Chenb9fa2062018-11-13 21:51:13 +08001804
waynema0e73c2e2019-07-31 15:04:08 +08001805 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
1806 kDefaultIncorrectPrivateDnsHostName));
Ken Chenb9fa2062018-11-13 21:51:13 +08001807
1808 addrinfo* ai_result = nullptr;
1809 EXPECT_NE(0, getaddrinfo(host_name, nullptr, nullptr, &ai_result));
1810 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
1811}
Luke Huang94b10b92018-11-21 20:13:38 +08001812
1813namespace {
1814
Luke Huang70931aa2019-01-31 11:57:41 +08001815int getAsyncResponse(int fd, int* rcode, uint8_t* buf, int bufLen) {
Luke Huang94b10b92018-11-21 20:13:38 +08001816 struct pollfd wait_fd[1];
1817 wait_fd[0].fd = fd;
1818 wait_fd[0].events = POLLIN;
1819 short revents;
1820 int ret;
1821
1822 ret = poll(wait_fd, 1, -1);
1823 revents = wait_fd[0].revents;
1824 if (revents & POLLIN) {
1825 int n = resNetworkResult(fd, rcode, buf, bufLen);
Luke Huangba7bef92018-12-26 16:53:03 +08001826 // Verify that resNetworkResult() closed the fd
1827 char dummy;
1828 EXPECT_EQ(-1, read(fd, &dummy, sizeof dummy));
1829 EXPECT_EQ(EBADF, errno);
Luke Huang94b10b92018-11-21 20:13:38 +08001830 return n;
1831 }
1832 return -1;
1833}
1834
Luke Huang70931aa2019-01-31 11:57:41 +08001835std::string toString(uint8_t* buf, int bufLen, int ipType) {
Luke Huang94b10b92018-11-21 20:13:38 +08001836 ns_msg handle;
1837 int ancount, n = 0;
1838 ns_rr rr;
1839
Luke Huangf8215372019-11-22 11:53:41 +08001840 if (ns_initparse((const uint8_t*)buf, bufLen, &handle) >= 0) {
Luke Huang94b10b92018-11-21 20:13:38 +08001841 ancount = ns_msg_count(handle, ns_s_an);
1842 if (ns_parserr(&handle, ns_s_an, n, &rr) == 0) {
Luke Huang70931aa2019-01-31 11:57:41 +08001843 const uint8_t* rdata = ns_rr_rdata(rr);
Luke Huang94b10b92018-11-21 20:13:38 +08001844 char buffer[INET6_ADDRSTRLEN];
Luke Huangf8215372019-11-22 11:53:41 +08001845 if (inet_ntop(ipType, (const char*)rdata, buffer, sizeof(buffer))) {
Luke Huang94b10b92018-11-21 20:13:38 +08001846 return buffer;
1847 }
1848 }
1849 }
1850 return "";
1851}
1852
1853int dns_open_proxy() {
1854 int s = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
1855 if (s == -1) {
1856 return -1;
1857 }
1858 const int one = 1;
1859 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1860
1861 static const struct sockaddr_un proxy_addr = {
1862 .sun_family = AF_UNIX,
1863 .sun_path = "/dev/socket/dnsproxyd",
1864 };
1865
Luke Huangf8215372019-11-22 11:53:41 +08001866 if (TEMP_FAILURE_RETRY(connect(s, (const struct sockaddr*)&proxy_addr, sizeof(proxy_addr))) !=
Luke Huang94b10b92018-11-21 20:13:38 +08001867 0) {
1868 close(s);
1869 return -1;
1870 }
1871
1872 return s;
1873}
1874
Luke Huangba7bef92018-12-26 16:53:03 +08001875void expectAnswersValid(int fd, int ipType, const std::string& expectedAnswer) {
1876 int rcode = -1;
1877 uint8_t buf[MAXPACKET] = {};
1878
1879 int res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
1880 EXPECT_GT(res, 0);
1881 EXPECT_EQ(expectedAnswer, toString(buf, res, ipType));
1882}
1883
1884void expectAnswersNotValid(int fd, int expectedErrno) {
1885 int rcode = -1;
1886 uint8_t buf[MAXPACKET] = {};
1887
1888 int res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
1889 EXPECT_EQ(expectedErrno, res);
1890}
1891
Luke Huang94b10b92018-11-21 20:13:38 +08001892} // namespace
1893
1894TEST_F(ResolverTest, Async_NormalQueryV4V6) {
Xiao Ma09b71022018-12-11 17:56:32 +09001895 constexpr char listen_addr[] = "127.0.0.4";
1896 constexpr char host_name[] = "howdy.example.com.";
1897 const std::vector<DnsRecord> records = {
1898 {host_name, ns_type::ns_t_a, "1.2.3.4"},
1899 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
1900 };
1901
1902 test::DNSResponder dns(listen_addr);
1903 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08001904 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09001905 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08001906
Luke Huangba7bef92018-12-26 16:53:03 +08001907 int fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
1908 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08001909 EXPECT_TRUE(fd1 != -1);
1910 EXPECT_TRUE(fd2 != -1);
1911
Luke Huang70931aa2019-01-31 11:57:41 +08001912 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08001913 int rcode;
1914 int res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
1915 EXPECT_GT(res, 0);
1916 EXPECT_EQ("::1.2.3.4", toString(buf, res, AF_INET6));
1917
1918 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
1919 EXPECT_GT(res, 0);
1920 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
1921
1922 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
1923
1924 // Re-query verify cache works
Luke Huangba7bef92018-12-26 16:53:03 +08001925 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
1926 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08001927
1928 EXPECT_TRUE(fd1 != -1);
1929 EXPECT_TRUE(fd2 != -1);
1930
1931 res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
1932 EXPECT_GT(res, 0);
1933 EXPECT_EQ("::1.2.3.4", toString(buf, res, AF_INET6));
1934
1935 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
1936 EXPECT_GT(res, 0);
1937 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
1938
1939 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
1940}
1941
1942TEST_F(ResolverTest, Async_BadQuery) {
Xiao Ma09b71022018-12-11 17:56:32 +09001943 constexpr char listen_addr[] = "127.0.0.4";
1944 constexpr char host_name[] = "howdy.example.com.";
1945 const std::vector<DnsRecord> records = {
1946 {host_name, ns_type::ns_t_a, "1.2.3.4"},
1947 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
1948 };
1949
1950 test::DNSResponder dns(listen_addr);
1951 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08001952 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09001953 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08001954
1955 static struct {
1956 int fd;
1957 const char* dname;
1958 const int queryType;
1959 const int expectRcode;
1960 } kTestData[] = {
Luke Huangba7bef92018-12-26 16:53:03 +08001961 {-1, "", ns_t_aaaa, 0},
1962 {-1, "as65ass46", ns_t_aaaa, 0},
1963 {-1, "454564564564", ns_t_aaaa, 0},
1964 {-1, "h645235", ns_t_a, 0},
1965 {-1, "www.google.com", ns_t_a, 0},
Luke Huang94b10b92018-11-21 20:13:38 +08001966 };
1967
1968 for (auto& td : kTestData) {
1969 SCOPED_TRACE(td.dname);
Luke Huangba7bef92018-12-26 16:53:03 +08001970 td.fd = resNetworkQuery(TEST_NETID, td.dname, ns_c_in, td.queryType, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08001971 EXPECT_TRUE(td.fd != -1);
1972 }
1973
1974 // dns_responder return empty resp(packet only contains query part) with no error currently
1975 for (const auto& td : kTestData) {
Luke Huang70931aa2019-01-31 11:57:41 +08001976 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08001977 int rcode;
1978 SCOPED_TRACE(td.dname);
1979 int res = getAsyncResponse(td.fd, &rcode, buf, MAXPACKET);
1980 EXPECT_GT(res, 0);
1981 EXPECT_EQ(rcode, td.expectRcode);
1982 }
1983}
1984
1985TEST_F(ResolverTest, Async_EmptyAnswer) {
Xiao Ma09b71022018-12-11 17:56:32 +09001986 constexpr char listen_addr[] = "127.0.0.4";
1987 constexpr char host_name[] = "howdy.example.com.";
1988 const std::vector<DnsRecord> records = {
1989 {host_name, ns_type::ns_t_a, "1.2.3.4"},
1990 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
1991 };
1992
1993 test::DNSResponder dns(listen_addr);
1994 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08001995 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09001996 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08001997
Luke Huang9c264bb2018-12-18 16:44:41 +08001998 // TODO: Disable retry to make this test explicit.
1999 auto& cv = dns.getCv();
2000 auto& cvMutex = dns.getCvMutex();
2001 int fd1;
2002 // Wait on the condition variable to ensure that the DNS server has handled our first query.
2003 {
2004 std::unique_lock lk(cvMutex);
Luke Huangba7bef92018-12-26 16:53:03 +08002005 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
Luke Huang9c264bb2018-12-18 16:44:41 +08002006 EXPECT_TRUE(fd1 != -1);
2007 EXPECT_EQ(std::cv_status::no_timeout, cv.wait_for(lk, std::chrono::seconds(1)));
2008 }
Luke Huang94b10b92018-11-21 20:13:38 +08002009
Luke Huang94b10b92018-11-21 20:13:38 +08002010 dns.setResponseProbability(0.0);
Luke Huang94b10b92018-11-21 20:13:38 +08002011
Luke Huangba7bef92018-12-26 16:53:03 +08002012 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002013 EXPECT_TRUE(fd2 != -1);
2014
Luke Huangba7bef92018-12-26 16:53:03 +08002015 int fd3 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002016 EXPECT_TRUE(fd3 != -1);
2017
Luke Huang9c264bb2018-12-18 16:44:41 +08002018 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002019 int rcode;
2020
Luke Huang9c264bb2018-12-18 16:44:41 +08002021 // expect no response
2022 int res = getAsyncResponse(fd3, &rcode, buf, MAXPACKET);
2023 EXPECT_EQ(-ETIMEDOUT, res);
Luke Huang94b10b92018-11-21 20:13:38 +08002024
Luke Huang9c264bb2018-12-18 16:44:41 +08002025 // expect no response
Luke Huang94b10b92018-11-21 20:13:38 +08002026 memset(buf, 0, MAXPACKET);
Luke Huang9c264bb2018-12-18 16:44:41 +08002027 res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
2028 EXPECT_EQ(-ETIMEDOUT, res);
Luke Huang94b10b92018-11-21 20:13:38 +08002029
Luke Huang94b10b92018-11-21 20:13:38 +08002030 dns.setResponseProbability(1.0);
Luke Huang94b10b92018-11-21 20:13:38 +08002031
Luke Huangba7bef92018-12-26 16:53:03 +08002032 int fd4 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
Luke Huang94b10b92018-11-21 20:13:38 +08002033 EXPECT_TRUE(fd4 != -1);
2034
2035 memset(buf, 0, MAXPACKET);
2036 res = getAsyncResponse(fd4, &rcode, buf, MAXPACKET);
2037 EXPECT_GT(res, 0);
2038 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2039
2040 memset(buf, 0, MAXPACKET);
2041 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
2042 EXPECT_GT(res, 0);
2043 EXPECT_EQ("::1.2.3.4", toString(buf, res, AF_INET6));
2044}
2045
2046TEST_F(ResolverTest, Async_MalformedQuery) {
Xiao Ma09b71022018-12-11 17:56:32 +09002047 constexpr char listen_addr[] = "127.0.0.4";
2048 constexpr char host_name[] = "howdy.example.com.";
2049 const std::vector<DnsRecord> records = {
2050 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2051 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2052 };
2053
2054 test::DNSResponder dns(listen_addr);
2055 StartDns(dns, records);
Luke Huang94b10b92018-11-21 20:13:38 +08002056 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002057 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huang94b10b92018-11-21 20:13:38 +08002058
2059 int fd = dns_open_proxy();
2060 EXPECT_TRUE(fd > 0);
2061
2062 const std::string badMsg = "16-52512#";
Xiao Ma09b71022018-12-11 17:56:32 +09002063 static const struct {
Luke Huang94b10b92018-11-21 20:13:38 +08002064 const std::string cmd;
2065 const int expectErr;
2066 } kTestData[] = {
Luke Huangba7bef92018-12-26 16:53:03 +08002067 // Too few arguments
Luke Huang94b10b92018-11-21 20:13:38 +08002068 {"resnsend " + badMsg + '\0', -EINVAL},
2069 // Bad netId
Luke Huangba7bef92018-12-26 16:53:03 +08002070 {"resnsend badnetId 0 " + badMsg + '\0', -EINVAL},
Luke Huang94b10b92018-11-21 20:13:38 +08002071 // Bad raw data
Luke Huangba7bef92018-12-26 16:53:03 +08002072 {"resnsend " + std::to_string(TEST_NETID) + " 0 " + badMsg + '\0', -EILSEQ},
Luke Huang94b10b92018-11-21 20:13:38 +08002073 };
2074
2075 for (unsigned int i = 0; i < std::size(kTestData); i++) {
2076 auto& td = kTestData[i];
2077 SCOPED_TRACE(td.cmd);
2078 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, td.cmd.c_str(), td.cmd.size()));
2079 EXPECT_EQ(rc, static_cast<ssize_t>(td.cmd.size()));
2080
2081 int32_t tmp;
2082 rc = TEMP_FAILURE_RETRY(read(fd, &tmp, sizeof(tmp)));
2083 EXPECT_TRUE(rc > 0);
2084 EXPECT_EQ(static_cast<int>(ntohl(tmp)), td.expectErr);
2085 }
2086 // Normal query with answer buffer
2087 // This is raw data of query "howdy.example.com" type 1 class 1
2088 std::string query = "81sBAAABAAAAAAAABWhvd2R5B2V4YW1wbGUDY29tAAABAAE=";
Luke Huangba7bef92018-12-26 16:53:03 +08002089 std::string cmd = "resnsend " + std::to_string(TEST_NETID) + " 0 " + query + '\0';
Luke Huang94b10b92018-11-21 20:13:38 +08002090 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size()));
2091 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size()));
2092
Luke Huang70931aa2019-01-31 11:57:41 +08002093 uint8_t smallBuf[1] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002094 int rcode;
2095 rc = getAsyncResponse(fd, &rcode, smallBuf, 1);
Luke Huangba7bef92018-12-26 16:53:03 +08002096 EXPECT_EQ(-EMSGSIZE, rc);
Luke Huang94b10b92018-11-21 20:13:38 +08002097
2098 // Do the normal test with large buffer again
2099 fd = dns_open_proxy();
2100 EXPECT_TRUE(fd > 0);
2101 rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size()));
2102 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size()));
Luke Huang70931aa2019-01-31 11:57:41 +08002103 uint8_t buf[MAXPACKET] = {};
Luke Huang94b10b92018-11-21 20:13:38 +08002104 rc = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2105 EXPECT_EQ("1.2.3.4", toString(buf, rc, AF_INET));
Mike Yu4f3747b2018-12-02 17:54:29 +09002106}
2107
Luke Huangba7bef92018-12-26 16:53:03 +08002108TEST_F(ResolverTest, Async_CacheFlags) {
Xiao Ma09b71022018-12-11 17:56:32 +09002109 constexpr char listen_addr[] = "127.0.0.4";
2110 constexpr char host_name[] = "howdy.example.com.";
Luke Huang40f5f492019-05-09 19:37:35 +08002111 constexpr char another_host_name[] = "howdy.example2.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002112 const std::vector<DnsRecord> records = {
2113 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2114 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
Luke Huang40f5f492019-05-09 19:37:35 +08002115 {another_host_name, ns_type::ns_t_a, "1.2.3.5"},
2116 {another_host_name, ns_type::ns_t_aaaa, "::1.2.3.5"},
Xiao Ma09b71022018-12-11 17:56:32 +09002117 };
2118
2119 test::DNSResponder dns(listen_addr);
2120 StartDns(dns, records);
Luke Huangba7bef92018-12-26 16:53:03 +08002121 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002122 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Luke Huangba7bef92018-12-26 16:53:03 +08002123
2124 // ANDROID_RESOLV_NO_CACHE_STORE
2125 int fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2126 ANDROID_RESOLV_NO_CACHE_STORE);
2127 EXPECT_TRUE(fd1 != -1);
2128 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2129 ANDROID_RESOLV_NO_CACHE_STORE);
2130 EXPECT_TRUE(fd2 != -1);
2131 int fd3 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2132 ANDROID_RESOLV_NO_CACHE_STORE);
2133 EXPECT_TRUE(fd3 != -1);
2134
2135 expectAnswersValid(fd3, AF_INET, "1.2.3.4");
2136 expectAnswersValid(fd2, AF_INET, "1.2.3.4");
2137 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2138
2139 // No cache exists, expect 3 queries
2140 EXPECT_EQ(3U, GetNumQueries(dns, host_name));
2141
2142 // Re-query and cache
2143 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2144
2145 EXPECT_TRUE(fd1 != -1);
2146
2147 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2148
2149 // Now we have cache, expect 4 queries
2150 EXPECT_EQ(4U, GetNumQueries(dns, host_name));
2151
2152 // ANDROID_RESOLV_NO_CACHE_LOOKUP
2153 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2154 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2155 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2156 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2157
2158 EXPECT_TRUE(fd1 != -1);
2159 EXPECT_TRUE(fd2 != -1);
2160
2161 expectAnswersValid(fd2, AF_INET, "1.2.3.4");
2162 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2163
2164 // Skip cache, expect 6 queries
2165 EXPECT_EQ(6U, GetNumQueries(dns, host_name));
2166
2167 // Re-query verify cache works
2168 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2169 ANDROID_RESOLV_NO_CACHE_STORE);
2170 EXPECT_TRUE(fd1 != -1);
2171 expectAnswersValid(fd1, AF_INET, "1.2.3.4");
2172
2173 // Cache hits, expect still 6 queries
2174 EXPECT_EQ(6U, GetNumQueries(dns, host_name));
Luke Huanga1d74182019-03-19 17:30:36 +08002175
2176 // Start to verify if ANDROID_RESOLV_NO_CACHE_LOOKUP does write response into cache
2177 dns.clearQueries();
2178
2179 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa,
2180 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2181 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa,
2182 ANDROID_RESOLV_NO_CACHE_LOOKUP);
2183
2184 EXPECT_TRUE(fd1 != -1);
2185 EXPECT_TRUE(fd2 != -1);
2186
2187 expectAnswersValid(fd2, AF_INET6, "::1.2.3.4");
2188 expectAnswersValid(fd1, AF_INET6, "::1.2.3.4");
2189
2190 // Skip cache, expect 2 queries
2191 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
2192
2193 // Re-query without flags
2194 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
2195 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
2196
2197 EXPECT_TRUE(fd1 != -1);
2198 EXPECT_TRUE(fd2 != -1);
2199
2200 expectAnswersValid(fd2, AF_INET6, "::1.2.3.4");
2201 expectAnswersValid(fd1, AF_INET6, "::1.2.3.4");
2202
2203 // Cache hits, expect still 2 queries
2204 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
Luke Huang40f5f492019-05-09 19:37:35 +08002205
2206 // Test both ANDROID_RESOLV_NO_CACHE_STORE and ANDROID_RESOLV_NO_CACHE_LOOKUP are set
2207 dns.clearQueries();
2208
2209 // Make sure that the cache of "howdy.example2.com" exists.
2210 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_aaaa, 0);
2211 EXPECT_TRUE(fd1 != -1);
2212 expectAnswersValid(fd1, AF_INET6, "::1.2.3.5");
2213 EXPECT_EQ(1U, GetNumQueries(dns, another_host_name));
2214
2215 // Re-query with testFlags
2216 const int testFlag = ANDROID_RESOLV_NO_CACHE_STORE | ANDROID_RESOLV_NO_CACHE_LOOKUP;
2217 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_aaaa, testFlag);
2218 EXPECT_TRUE(fd1 != -1);
2219 expectAnswersValid(fd1, AF_INET6, "::1.2.3.5");
2220 // Expect cache lookup is skipped.
2221 EXPECT_EQ(2U, GetNumQueries(dns, another_host_name));
2222
2223 // Do another query with testFlags
2224 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_a, testFlag);
2225 EXPECT_TRUE(fd1 != -1);
2226 expectAnswersValid(fd1, AF_INET, "1.2.3.5");
2227 // Expect cache lookup is skipped.
2228 EXPECT_EQ(3U, GetNumQueries(dns, another_host_name));
2229
2230 // Re-query with no flags
2231 fd1 = resNetworkQuery(TEST_NETID, "howdy.example2.com", ns_c_in, ns_t_a, 0);
2232 EXPECT_TRUE(fd1 != -1);
2233 expectAnswersValid(fd1, AF_INET, "1.2.3.5");
2234 // Expect no cache hit because cache storing is also skipped in previous query.
2235 EXPECT_EQ(4U, GetNumQueries(dns, another_host_name));
Luke Huangba7bef92018-12-26 16:53:03 +08002236}
2237
Luke Huang08b13d22020-02-05 14:46:21 +08002238TEST_F(ResolverTest, Async_NoCacheStoreFlagDoesNotRefreshStaleCacheEntry) {
2239 constexpr char listen_addr[] = "127.0.0.4";
2240 constexpr char host_name[] = "howdy.example.com.";
2241 const std::vector<DnsRecord> records = {
2242 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2243 };
2244
2245 test::DNSResponder dns(listen_addr);
2246 StartDns(dns, records);
2247 std::vector<std::string> servers = {listen_addr};
2248 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
2249
2250 const unsigned SHORT_TTL_SEC = 1;
2251 dns.setTtl(SHORT_TTL_SEC);
2252
2253 // Refer to b/148842821 for the purpose of below test steps.
2254 // Basically, this test is used to ensure stale cache case is handled
2255 // correctly with ANDROID_RESOLV_NO_CACHE_STORE.
2256 int fd = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2257 EXPECT_TRUE(fd != -1);
2258 expectAnswersValid(fd, AF_INET, "1.2.3.4");
2259
2260 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2261 dns.clearQueries();
2262
2263 // Wait until cache expired
2264 sleep(SHORT_TTL_SEC + 0.5);
2265
2266 // Now request the same hostname again.
2267 // We should see a new DNS query because the entry in cache has become stale.
2268 // Due to ANDROID_RESOLV_NO_CACHE_STORE, this query must *not* refresh that stale entry.
2269 fd = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2270 ANDROID_RESOLV_NO_CACHE_STORE);
2271 EXPECT_TRUE(fd != -1);
2272 expectAnswersValid(fd, AF_INET, "1.2.3.4");
2273 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2274 dns.clearQueries();
2275
2276 // If the cache is still stale, we expect to see one more DNS query
2277 // (this time the cache will be refreshed, but we're not checking for it).
2278 fd = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2279 EXPECT_TRUE(fd != -1);
2280 expectAnswersValid(fd, AF_INET, "1.2.3.4");
2281 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2282}
2283
Luke Huangba7bef92018-12-26 16:53:03 +08002284TEST_F(ResolverTest, Async_NoRetryFlag) {
Luke Huang70931aa2019-01-31 11:57:41 +08002285 constexpr char listen_addr0[] = "127.0.0.4";
2286 constexpr char listen_addr1[] = "127.0.0.6";
Xiao Ma09b71022018-12-11 17:56:32 +09002287 constexpr char host_name[] = "howdy.example.com.";
2288 const std::vector<DnsRecord> records = {
2289 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2290 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2291 };
2292
Luke Huang70931aa2019-01-31 11:57:41 +08002293 test::DNSResponder dns0(listen_addr0);
2294 test::DNSResponder dns1(listen_addr1);
2295 StartDns(dns0, records);
2296 StartDns(dns1, records);
2297 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr0, listen_addr1}));
Luke Huangba7bef92018-12-26 16:53:03 +08002298
Luke Huang70931aa2019-01-31 11:57:41 +08002299 dns0.clearQueries();
2300 dns1.clearQueries();
2301
2302 dns0.setResponseProbability(0.0);
2303 dns1.setResponseProbability(0.0);
Luke Huangba7bef92018-12-26 16:53:03 +08002304
2305 int fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a,
2306 ANDROID_RESOLV_NO_RETRY);
2307 EXPECT_TRUE(fd1 != -1);
2308
2309 int fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa,
2310 ANDROID_RESOLV_NO_RETRY);
2311 EXPECT_TRUE(fd2 != -1);
2312
2313 // expect no response
2314 expectAnswersNotValid(fd1, -ETIMEDOUT);
2315 expectAnswersNotValid(fd2, -ETIMEDOUT);
2316
Luke Huang70931aa2019-01-31 11:57:41 +08002317 // No retry case, expect total 2 queries. The server is selected randomly.
2318 EXPECT_EQ(2U, GetNumQueries(dns0, host_name) + GetNumQueries(dns1, host_name));
Luke Huangba7bef92018-12-26 16:53:03 +08002319
Luke Huang70931aa2019-01-31 11:57:41 +08002320 dns0.clearQueries();
2321 dns1.clearQueries();
Luke Huangba7bef92018-12-26 16:53:03 +08002322
2323 fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
2324 EXPECT_TRUE(fd1 != -1);
2325
2326 fd2 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_aaaa, 0);
2327 EXPECT_TRUE(fd2 != -1);
2328
2329 // expect no response
2330 expectAnswersNotValid(fd1, -ETIMEDOUT);
2331 expectAnswersNotValid(fd2, -ETIMEDOUT);
2332
2333 // Retry case, expect 4 queries
Luke Huang70931aa2019-01-31 11:57:41 +08002334 EXPECT_EQ(4U, GetNumQueries(dns0, host_name));
2335 EXPECT_EQ(4U, GetNumQueries(dns1, host_name));
2336}
2337
2338TEST_F(ResolverTest, Async_VerifyQueryID) {
2339 constexpr char listen_addr[] = "127.0.0.4";
2340 constexpr char host_name[] = "howdy.example.com.";
2341 const std::vector<DnsRecord> records = {
2342 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2343 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
2344 };
2345
2346 test::DNSResponder dns(listen_addr);
2347 StartDns(dns, records);
2348 std::vector<std::string> servers = {listen_addr};
2349 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
2350
2351 const uint8_t queryBuf1[] = {
2352 /* Header */
2353 0x55, 0x66, /* Transaction ID */
2354 0x01, 0x00, /* Flags */
2355 0x00, 0x01, /* Questions */
2356 0x00, 0x00, /* Answer RRs */
2357 0x00, 0x00, /* Authority RRs */
2358 0x00, 0x00, /* Additional RRs */
2359 /* Queries */
2360 0x05, 0x68, 0x6f, 0x77, 0x64, 0x79, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
2361 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name */
2362 0x00, 0x01, /* Type */
2363 0x00, 0x01 /* Class */
2364 };
2365
2366 int fd = resNetworkSend(TEST_NETID, queryBuf1, sizeof(queryBuf1), 0);
2367 EXPECT_TRUE(fd != -1);
2368
2369 uint8_t buf[MAXPACKET] = {};
2370 int rcode;
2371
2372 int res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2373 EXPECT_GT(res, 0);
2374 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2375
2376 auto hp = reinterpret_cast<HEADER*>(buf);
2377 EXPECT_EQ(21862U, htons(hp->id));
2378
2379 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2380
2381 const uint8_t queryBuf2[] = {
2382 /* Header */
2383 0x00, 0x53, /* Transaction ID */
2384 0x01, 0x00, /* Flags */
2385 0x00, 0x01, /* Questions */
2386 0x00, 0x00, /* Answer RRs */
2387 0x00, 0x00, /* Authority RRs */
2388 0x00, 0x00, /* Additional RRs */
2389 /* Queries */
2390 0x05, 0x68, 0x6f, 0x77, 0x64, 0x79, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
2391 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name */
2392 0x00, 0x01, /* Type */
2393 0x00, 0x01 /* Class */
2394 };
2395
2396 // Re-query verify cache works and query id is correct
2397 fd = resNetworkSend(TEST_NETID, queryBuf2, sizeof(queryBuf2), 0);
2398
2399 EXPECT_TRUE(fd != -1);
2400
2401 res = getAsyncResponse(fd, &rcode, buf, MAXPACKET);
2402 EXPECT_GT(res, 0);
2403 EXPECT_EQ("1.2.3.4", toString(buf, res, AF_INET));
2404
2405 EXPECT_EQ(0x0053U, htons(hp->id));
2406
2407 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
Luke Huangba7bef92018-12-26 16:53:03 +08002408}
2409
Mike Yu4f3747b2018-12-02 17:54:29 +09002410// This test checks that the resolver should not generate the request containing OPT RR when using
Ken Chen0a015532019-01-02 14:59:38 +08002411// cleartext DNS. If we query the DNS server not supporting EDNS0 and it reponds with
2412// FORMERR_ON_EDNS, we will fallback to no EDNS0 and try again. If the server does no response, we
2413// won't retry so that we get no answer.
Mike Yu4f3747b2018-12-02 17:54:29 +09002414TEST_F(ResolverTest, BrokenEdns) {
2415 typedef test::DNSResponder::Edns Edns;
2416 enum ExpectResult { EXPECT_FAILURE, EXPECT_SUCCESS };
2417
2418 const char OFF[] = "off";
2419 const char OPPORTUNISTIC_UDP[] = "opportunistic_udp";
2420 const char OPPORTUNISTIC_TLS[] = "opportunistic_tls";
2421 const char STRICT[] = "strict";
2422 const char GETHOSTBYNAME[] = "gethostbyname";
2423 const char GETADDRINFO[] = "getaddrinfo";
Mike Yu4f3747b2018-12-02 17:54:29 +09002424 const char ADDR4[] = "192.0.2.1";
2425 const char CLEARTEXT_ADDR[] = "127.0.0.53";
2426 const char CLEARTEXT_PORT[] = "53";
2427 const char TLS_PORT[] = "853";
Luke Huangf8215372019-11-22 11:53:41 +08002428 const std::vector<std::string> servers = {CLEARTEXT_ADDR};
Mike Yu4f3747b2018-12-02 17:54:29 +09002429
Mike Yufc125e42019-05-15 20:41:28 +08002430 test::DNSResponder dns(CLEARTEXT_ADDR, CLEARTEXT_PORT, ns_rcode::ns_r_servfail);
Mike Yu4f3747b2018-12-02 17:54:29 +09002431 ASSERT_TRUE(dns.startServer());
2432
2433 test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
2434
Luke Huangf8215372019-11-22 11:53:41 +08002435 // clang-format off
Mike Yu4f3747b2018-12-02 17:54:29 +09002436 static const struct TestConfig {
2437 std::string mode;
2438 std::string method;
2439 Edns edns;
2440 ExpectResult expectResult;
2441
2442 std::string asHostName() const {
2443 const char* ednsString;
2444 switch (edns) {
2445 case Edns::ON:
2446 ednsString = "ednsOn";
2447 break;
Ken Chen0a015532019-01-02 14:59:38 +08002448 case Edns::FORMERR_ON_EDNS:
Mike Yu4f3747b2018-12-02 17:54:29 +09002449 ednsString = "ednsFormerr";
2450 break;
2451 case Edns::DROP:
2452 ednsString = "ednsDrop";
2453 break;
2454 default:
2455 ednsString = "";
2456 break;
2457 }
2458 return StringPrintf("%s.%s.%s.", mode.c_str(), method.c_str(), ednsString);
2459 }
2460 } testConfigs[] = {
2461 // In OPPORTUNISTIC_TLS, we get no answer if the DNS server supports TLS but not EDNS0.
2462 // Could such server exist? if so, we might need to fallback to query cleartext DNS.
2463 // Another thing is that {OPPORTUNISTIC_TLS, Edns::DROP} and {STRICT, Edns::DROP} are
2464 // commented out since TLS timeout is not configurable.
2465 // TODO: Uncomment them after TLS timeout is configurable.
2466 {OFF, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2467 {OPPORTUNISTIC_UDP, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2468 {OPPORTUNISTIC_TLS, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
2469 {STRICT, GETHOSTBYNAME, Edns::ON, EXPECT_SUCCESS},
Ken Chen0a015532019-01-02 14:59:38 +08002470 {OFF, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2471 {OPPORTUNISTIC_UDP, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2472 {OPPORTUNISTIC_TLS, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
2473 {STRICT, GETHOSTBYNAME, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
Mike Yu4f3747b2018-12-02 17:54:29 +09002474 {OFF, GETHOSTBYNAME, Edns::DROP, EXPECT_SUCCESS},
2475 {OPPORTUNISTIC_UDP, GETHOSTBYNAME, Edns::DROP, EXPECT_SUCCESS},
2476 //{OPPORTUNISTIC_TLS, GETHOSTBYNAME, Edns::DROP, EXPECT_FAILURE},
2477 //{STRICT, GETHOSTBYNAME, Edns::DROP, EXPECT_FAILURE},
2478 {OFF, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2479 {OPPORTUNISTIC_UDP, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2480 {OPPORTUNISTIC_TLS, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
2481 {STRICT, GETADDRINFO, Edns::ON, EXPECT_SUCCESS},
Ken Chen0a015532019-01-02 14:59:38 +08002482 {OFF, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2483 {OPPORTUNISTIC_UDP, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_SUCCESS},
2484 {OPPORTUNISTIC_TLS, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
2485 {STRICT, GETADDRINFO, Edns::FORMERR_ON_EDNS, EXPECT_FAILURE},
Mike Yu4f3747b2018-12-02 17:54:29 +09002486 {OFF, GETADDRINFO, Edns::DROP, EXPECT_SUCCESS},
2487 {OPPORTUNISTIC_UDP, GETADDRINFO, Edns::DROP, EXPECT_SUCCESS},
2488 //{OPPORTUNISTIC_TLS, GETADDRINFO, Edns::DROP, EXPECT_FAILURE},
2489 //{STRICT, GETADDRINFO, Edns::DROP, EXPECT_FAILURE},
2490 };
Luke Huangf8215372019-11-22 11:53:41 +08002491 // clang-format on
Mike Yu4f3747b2018-12-02 17:54:29 +09002492
2493 for (const auto& config : testConfigs) {
2494 const std::string testHostName = config.asHostName();
2495 SCOPED_TRACE(testHostName);
2496
2497 const char* host_name = testHostName.c_str();
2498 dns.addMapping(host_name, ns_type::ns_t_a, ADDR4);
2499 dns.setEdns(config.edns);
2500
2501 if (config.mode == OFF) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002502 if (tls.running()) {
2503 ASSERT_TRUE(tls.stopServer());
2504 }
Xiao Ma09b71022018-12-11 17:56:32 +09002505 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
Mike Yu4f3747b2018-12-02 17:54:29 +09002506 } else if (config.mode == OPPORTUNISTIC_UDP) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002507 if (tls.running()) {
2508 ASSERT_TRUE(tls.stopServer());
2509 }
Xiao Ma09b71022018-12-11 17:56:32 +09002510 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
waynema0e73c2e2019-07-31 15:04:08 +08002511 kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002512 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), false));
Mike Yu4f3747b2018-12-02 17:54:29 +09002513 } else if (config.mode == OPPORTUNISTIC_TLS) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002514 if (!tls.running()) {
2515 ASSERT_TRUE(tls.startServer());
2516 }
Xiao Ma09b71022018-12-11 17:56:32 +09002517 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
waynema0e73c2e2019-07-31 15:04:08 +08002518 kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002519 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Mike Yu4f3747b2018-12-02 17:54:29 +09002520 } else if (config.mode == STRICT) {
Mike Yu0f20cdd2019-06-11 11:52:37 +08002521 if (!tls.running()) {
2522 ASSERT_TRUE(tls.startServer());
2523 }
Xiao Ma09b71022018-12-11 17:56:32 +09002524 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains,
waynema0e73c2e2019-07-31 15:04:08 +08002525 kDefaultParams, kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08002526 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Mike Yu4f3747b2018-12-02 17:54:29 +09002527 }
2528
2529 if (config.method == GETHOSTBYNAME) {
2530 const hostent* h_result = gethostbyname(host_name);
2531 if (config.expectResult == EXPECT_SUCCESS) {
2532 EXPECT_LE(1U, GetNumQueries(dns, host_name));
2533 ASSERT_TRUE(h_result != nullptr);
2534 ASSERT_EQ(4, h_result->h_length);
2535 ASSERT_FALSE(h_result->h_addr_list[0] == nullptr);
2536 EXPECT_EQ(ADDR4, ToString(h_result));
2537 EXPECT_TRUE(h_result->h_addr_list[1] == nullptr);
2538 } else {
2539 EXPECT_EQ(0U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
2540 ASSERT_TRUE(h_result == nullptr);
2541 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
2542 }
2543 } else if (config.method == GETADDRINFO) {
2544 ScopedAddrinfo ai_result;
2545 addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
2546 ai_result = safe_getaddrinfo(host_name, nullptr, &hints);
2547 if (config.expectResult == EXPECT_SUCCESS) {
2548 EXPECT_TRUE(ai_result != nullptr);
2549 EXPECT_EQ(1U, GetNumQueries(dns, host_name));
2550 const std::string result_str = ToString(ai_result);
2551 EXPECT_EQ(ADDR4, result_str);
2552 } else {
2553 EXPECT_TRUE(ai_result == nullptr);
2554 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
2555 }
2556 } else {
2557 FAIL() << "Unsupported query method: " << config.method;
2558 }
2559
Mike Yudd4ac2d2019-05-31 16:52:11 +08002560 tls.clearQueries();
Mike Yu4f3747b2018-12-02 17:54:29 +09002561 dns.clearQueries();
2562 }
Mike Yu4f3747b2018-12-02 17:54:29 +09002563}
nuccachena26cc2a2018-07-17 18:07:23 +08002564
Ken Chen0a015532019-01-02 14:59:38 +08002565// DNS-over-TLS validation success, but server does not respond to TLS query after a while.
2566// Resolver should have a reasonable number of retries instead of spinning forever. We don't have
2567// an efficient way to know if resolver is stuck in an infinite loop. However, test case will be
2568// failed due to timeout.
2569TEST_F(ResolverTest, UnstableTls) {
2570 const char CLEARTEXT_ADDR[] = "127.0.0.53";
2571 const char CLEARTEXT_PORT[] = "53";
2572 const char TLS_PORT[] = "853";
2573 const char* host_name1 = "nonexistent1.example.com.";
2574 const char* host_name2 = "nonexistent2.example.com.";
2575 const std::vector<std::string> servers = {CLEARTEXT_ADDR};
2576
Mike Yufc125e42019-05-15 20:41:28 +08002577 test::DNSResponder dns(CLEARTEXT_ADDR, CLEARTEXT_PORT, ns_rcode::ns_r_servfail);
Ken Chen0a015532019-01-02 14:59:38 +08002578 ASSERT_TRUE(dns.startServer());
2579 dns.setEdns(test::DNSResponder::Edns::FORMERR_ON_EDNS);
2580 test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
2581 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08002582 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002583 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
2584
Ken Chen0a015532019-01-02 14:59:38 +08002585 // Shutdown TLS server to get an error. It's similar to no response case but without waiting.
2586 tls.stopServer();
2587
2588 const hostent* h_result = gethostbyname(host_name1);
2589 EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
2590 ASSERT_TRUE(h_result == nullptr);
2591 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
2592
2593 addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
2594 ScopedAddrinfo ai_result = safe_getaddrinfo(host_name2, nullptr, &hints);
2595 EXPECT_TRUE(ai_result == nullptr);
2596 EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
2597}
2598
2599// DNS-over-TLS validation success, but server does not respond to TLS query after a while.
2600// Moreover, server responds RCODE=FORMERR even on non-EDNS query.
2601TEST_F(ResolverTest, BogusDnsServer) {
2602 const char CLEARTEXT_ADDR[] = "127.0.0.53";
2603 const char CLEARTEXT_PORT[] = "53";
2604 const char TLS_PORT[] = "853";
2605 const char* host_name1 = "nonexistent1.example.com.";
2606 const char* host_name2 = "nonexistent2.example.com.";
2607 const std::vector<std::string> servers = {CLEARTEXT_ADDR};
2608
Mike Yufc125e42019-05-15 20:41:28 +08002609 test::DNSResponder dns(CLEARTEXT_ADDR, CLEARTEXT_PORT, ns_rcode::ns_r_servfail);
Ken Chen0a015532019-01-02 14:59:38 +08002610 ASSERT_TRUE(dns.startServer());
2611 test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
2612 ASSERT_TRUE(tls.startServer());
waynema0e73c2e2019-07-31 15:04:08 +08002613 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08002614 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
2615
Ken Chen0a015532019-01-02 14:59:38 +08002616 // Shutdown TLS server to get an error. It's similar to no response case but without waiting.
2617 tls.stopServer();
2618 dns.setEdns(test::DNSResponder::Edns::FORMERR_UNCOND);
2619
2620 const hostent* h_result = gethostbyname(host_name1);
2621 EXPECT_EQ(0U, GetNumQueries(dns, host_name1));
2622 ASSERT_TRUE(h_result == nullptr);
2623 ASSERT_EQ(HOST_NOT_FOUND, h_errno);
2624
2625 addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
2626 ScopedAddrinfo ai_result = safe_getaddrinfo(host_name2, nullptr, &hints);
2627 EXPECT_TRUE(ai_result == nullptr);
2628 EXPECT_EQ(0U, GetNumQueries(dns, host_name2));
2629}
2630
nuccachena26cc2a2018-07-17 18:07:23 +08002631TEST_F(ResolverTest, GetAddrInfo_Dns64Synthesize) {
2632 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002633 constexpr char dns64_name[] = "ipv4only.arpa.";
2634 constexpr char host_name[] = "v4only.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002635 const std::vector<DnsRecord> records = {
2636 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2637 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2638 };
nuccachena26cc2a2018-07-17 18:07:23 +08002639
Xiao Ma09b71022018-12-11 17:56:32 +09002640 test::DNSResponder dns(listen_addr);
Xiao Ma09b71022018-12-11 17:56:32 +09002641 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002642
2643 std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002644 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002645
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002646 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002647 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002648 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002649
2650 // hints are necessary in order to let netd know which type of addresses the caller is
2651 // interested in.
Xiao Ma09b71022018-12-11 17:56:32 +09002652 const addrinfo hints = {.ai_family = AF_UNSPEC};
nuccachena26cc2a2018-07-17 18:07:23 +08002653 ScopedAddrinfo result = safe_getaddrinfo("v4only", nullptr, &hints);
2654 EXPECT_TRUE(result != nullptr);
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002655 // TODO: BUG: there should only be two queries, one AAAA (which returns no records) and one A
2656 // (which returns 1.2.3.4). But there is an extra AAAA.
2657 EXPECT_EQ(3U, GetNumQueries(dns, host_name));
nuccachena26cc2a2018-07-17 18:07:23 +08002658
2659 std::string result_str = ToString(result);
2660 EXPECT_EQ(result_str, "64:ff9b::102:304");
2661
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002662 // Stopping NAT64 prefix discovery disables synthesis.
Luke Huang5bd827c2019-03-14 16:10:04 +08002663 EXPECT_TRUE(mDnsClient.resolvService()->stopPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002664 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_NOT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002665
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002666 dns.clearQueries();
nuccachena26cc2a2018-07-17 18:07:23 +08002667
2668 result = safe_getaddrinfo("v4only", nullptr, &hints);
2669 EXPECT_TRUE(result != nullptr);
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002670 // TODO: BUG: there should only be one query, an AAAA (which returns no records), because the
2671 // A is already cached. But there is an extra AAAA.
2672 EXPECT_EQ(2U, GetNumQueries(dns, host_name));
nuccachena26cc2a2018-07-17 18:07:23 +08002673
2674 result_str = ToString(result);
2675 EXPECT_EQ(result_str, "1.2.3.4");
2676}
2677
nuccachena26cc2a2018-07-17 18:07:23 +08002678TEST_F(ResolverTest, GetAddrInfo_Dns64QuerySpecified) {
2679 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002680 constexpr char dns64_name[] = "ipv4only.arpa.";
2681 constexpr char host_name[] = "v4only.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002682 const std::vector<DnsRecord> records = {
2683 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2684 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2685 };
nuccachena26cc2a2018-07-17 18:07:23 +08002686
Xiao Ma09b71022018-12-11 17:56:32 +09002687 test::DNSResponder dns(listen_addr);
2688 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002689 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002690 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002691
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002692 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002693 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002694 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002695
2696 // Ensure to synthesize AAAA if AF_INET6 is specified, and not to synthesize AAAA
2697 // in AF_INET case.
2698 addrinfo hints;
2699 memset(&hints, 0, sizeof(hints));
2700 hints.ai_family = AF_INET6;
2701 ScopedAddrinfo result = safe_getaddrinfo("v4only", nullptr, &hints);
2702 EXPECT_TRUE(result != nullptr);
2703 std::string result_str = ToString(result);
2704 EXPECT_EQ(result_str, "64:ff9b::102:304");
2705
2706 hints.ai_family = AF_INET;
2707 result = safe_getaddrinfo("v4only", nullptr, &hints);
2708 EXPECT_TRUE(result != nullptr);
2709 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2710 result_str = ToString(result);
2711 EXPECT_EQ(result_str, "1.2.3.4");
2712}
nuccachena26cc2a2018-07-17 18:07:23 +08002713
2714TEST_F(ResolverTest, GetAddrInfo_Dns64QueryUnspecifiedV6) {
2715 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002716 constexpr char dns64_name[] = "ipv4only.arpa.";
2717 constexpr char host_name[] = "v4v6.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002718 const std::vector<DnsRecord> records = {
2719 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2720 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2721 {host_name, ns_type::ns_t_aaaa, "2001:db8::1.2.3.4"},
2722 };
nuccachena26cc2a2018-07-17 18:07:23 +08002723
Xiao Ma09b71022018-12-11 17:56:32 +09002724 test::DNSResponder dns(listen_addr);
2725 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002726 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002727 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002728
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002729 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002730 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002731 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002732
Xiao Ma09b71022018-12-11 17:56:32 +09002733 const addrinfo hints = {.ai_family = AF_UNSPEC};
nuccachena26cc2a2018-07-17 18:07:23 +08002734 ScopedAddrinfo result = safe_getaddrinfo("v4v6", nullptr, &hints);
2735 EXPECT_TRUE(result != nullptr);
2736 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2737
2738 // In AF_UNSPEC case, do not synthesize AAAA if there's at least one AAAA answer.
Xiao Ma09b71022018-12-11 17:56:32 +09002739 const std::vector<std::string> result_strs = ToStrings(result);
nuccachena26cc2a2018-07-17 18:07:23 +08002740 for (const auto& str : result_strs) {
2741 EXPECT_TRUE(str == "1.2.3.4" || str == "2001:db8::102:304")
2742 << ", result_str='" << str << "'";
2743 }
2744}
2745
2746TEST_F(ResolverTest, GetAddrInfo_Dns64QueryUnspecifiedNoV6) {
2747 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002748 constexpr char dns64_name[] = "ipv4only.arpa.";
2749 constexpr char host_name[] = "v4v6.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002750 const std::vector<DnsRecord> records = {
2751 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2752 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2753 };
nuccachena26cc2a2018-07-17 18:07:23 +08002754
Xiao Ma09b71022018-12-11 17:56:32 +09002755 test::DNSResponder dns(listen_addr);
2756 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002757 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002758 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002759
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002760 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002761 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002762 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002763
Xiao Ma09b71022018-12-11 17:56:32 +09002764 const addrinfo hints = {.ai_family = AF_UNSPEC};
nuccachena26cc2a2018-07-17 18:07:23 +08002765 ScopedAddrinfo result = safe_getaddrinfo("v4v6", nullptr, &hints);
2766 EXPECT_TRUE(result != nullptr);
2767 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2768
2769 // In AF_UNSPEC case, synthesize AAAA if there's no AAAA answer.
2770 std::string result_str = ToString(result);
2771 EXPECT_EQ(result_str, "64:ff9b::102:304");
2772}
2773
2774TEST_F(ResolverTest, GetAddrInfo_Dns64QuerySpecialUseIPv4Addresses) {
2775 constexpr char THIS_NETWORK[] = "this_network";
2776 constexpr char LOOPBACK[] = "loopback";
2777 constexpr char LINK_LOCAL[] = "link_local";
2778 constexpr char MULTICAST[] = "multicast";
2779 constexpr char LIMITED_BROADCAST[] = "limited_broadcast";
2780
2781 constexpr char ADDR_THIS_NETWORK[] = "0.0.0.1";
2782 constexpr char ADDR_LOOPBACK[] = "127.0.0.1";
2783 constexpr char ADDR_LINK_LOCAL[] = "169.254.0.1";
2784 constexpr char ADDR_MULTICAST[] = "224.0.0.1";
2785 constexpr char ADDR_LIMITED_BROADCAST[] = "255.255.255.255";
2786
2787 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002788 constexpr char dns64_name[] = "ipv4only.arpa.";
2789
Xiao Ma09b71022018-12-11 17:56:32 +09002790 test::DNSResponder dns(listen_addr);
2791 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::"}});
nuccachena26cc2a2018-07-17 18:07:23 +08002792 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002793 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002794
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002795 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002796 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002797 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002798
Luke Huangf8215372019-11-22 11:53:41 +08002799 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08002800 static const struct TestConfig {
2801 std::string name;
2802 std::string addr;
2803
2804 std::string asHostName() const { return StringPrintf("%s.example.com.", name.c_str()); }
2805 } testConfigs[]{
2806 {THIS_NETWORK, ADDR_THIS_NETWORK},
2807 {LOOPBACK, ADDR_LOOPBACK},
2808 {LINK_LOCAL, ADDR_LINK_LOCAL},
2809 {MULTICAST, ADDR_MULTICAST},
2810 {LIMITED_BROADCAST, ADDR_LIMITED_BROADCAST}
2811 };
Luke Huangf8215372019-11-22 11:53:41 +08002812 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08002813
2814 for (const auto& config : testConfigs) {
2815 const std::string testHostName = config.asHostName();
2816 SCOPED_TRACE(testHostName);
2817
2818 const char* host_name = testHostName.c_str();
2819 dns.addMapping(host_name, ns_type::ns_t_a, config.addr.c_str());
2820
2821 addrinfo hints;
2822 memset(&hints, 0, sizeof(hints));
2823 hints.ai_family = AF_INET6;
2824 ScopedAddrinfo result = safe_getaddrinfo(config.name.c_str(), nullptr, &hints);
2825 // In AF_INET6 case, don't return IPv4 answers
2826 EXPECT_TRUE(result == nullptr);
2827 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2828 dns.clearQueries();
2829
2830 memset(&hints, 0, sizeof(hints));
2831 hints.ai_family = AF_UNSPEC;
2832 result = safe_getaddrinfo(config.name.c_str(), nullptr, &hints);
2833 EXPECT_TRUE(result != nullptr);
2834 // Expect IPv6 query only. IPv4 answer has been cached in previous query.
2835 EXPECT_LE(1U, GetNumQueries(dns, host_name));
2836 // In AF_UNSPEC case, don't synthesize special use IPv4 address.
2837 std::string result_str = ToString(result);
2838 EXPECT_EQ(result_str, config.addr.c_str());
2839 dns.clearQueries();
2840 }
2841}
2842
2843TEST_F(ResolverTest, GetAddrInfo_Dns64QueryWithNullArgumentHints) {
2844 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002845 constexpr char dns64_name[] = "ipv4only.arpa.";
2846 constexpr char host_name[] = "v4only.example.com.";
2847 constexpr char host_name2[] = "v4v6.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09002848 const std::vector<DnsRecord> records = {
2849 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2850 {host_name, ns_type::ns_t_a, "1.2.3.4"},
2851 {host_name2, ns_type::ns_t_a, "1.2.3.4"},
2852 {host_name2, ns_type::ns_t_aaaa, "2001:db8::1.2.3.4"},
2853 };
nuccachena26cc2a2018-07-17 18:07:23 +08002854
Xiao Ma09b71022018-12-11 17:56:32 +09002855 test::DNSResponder dns(listen_addr);
2856 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002857 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002858 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002859
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002860 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002861 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002862 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002863
2864 // Assign argument hints of getaddrinfo() as null is equivalent to set ai_family AF_UNSPEC.
2865 // In AF_UNSPEC case, synthesize AAAA if there has A answer only.
2866 ScopedAddrinfo result = safe_getaddrinfo("v4only", nullptr, nullptr);
2867 EXPECT_TRUE(result != nullptr);
2868 EXPECT_LE(2U, GetNumQueries(dns, host_name));
2869 std::string result_str = ToString(result);
2870 EXPECT_EQ(result_str, "64:ff9b::102:304");
2871 dns.clearQueries();
2872
2873 // In AF_UNSPEC case, do not synthesize AAAA if there's at least one AAAA answer.
2874 result = safe_getaddrinfo("v4v6", nullptr, nullptr);
2875 EXPECT_TRUE(result != nullptr);
2876 EXPECT_LE(2U, GetNumQueries(dns, host_name2));
2877 std::vector<std::string> result_strs = ToStrings(result);
2878 for (const auto& str : result_strs) {
2879 EXPECT_TRUE(str == "1.2.3.4" || str == "2001:db8::102:304")
2880 << ", result_str='" << str << "'";
2881 }
2882}
2883
2884TEST_F(ResolverTest, GetAddrInfo_Dns64QueryNullArgumentNode) {
2885 constexpr char ADDR_ANYADDR_V4[] = "0.0.0.0";
2886 constexpr char ADDR_ANYADDR_V6[] = "::";
2887 constexpr char ADDR_LOCALHOST_V4[] = "127.0.0.1";
2888 constexpr char ADDR_LOCALHOST_V6[] = "::1";
2889
2890 constexpr char PORT_NAME_HTTP[] = "http";
2891 constexpr char PORT_NUMBER_HTTP[] = "80";
2892
2893 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002894 constexpr char dns64_name[] = "ipv4only.arpa.";
2895
Xiao Ma09b71022018-12-11 17:56:32 +09002896 test::DNSResponder dns(listen_addr);
2897 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::"}});
nuccachena26cc2a2018-07-17 18:07:23 +08002898 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002899 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002900
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002901 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002902 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002903 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002904
Luke Huangf8215372019-11-22 11:53:41 +08002905 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08002906 // If node is null, return address is listed by libc/getaddrinfo.c as follows.
2907 // - passive socket -> anyaddr (0.0.0.0 or ::)
2908 // - non-passive socket -> localhost (127.0.0.1 or ::1)
2909 static const struct TestConfig {
2910 int flag;
2911 std::string addr_v4;
2912 std::string addr_v6;
2913
2914 std::string asParameters() const {
2915 return StringPrintf("flag=%d, addr_v4=%s, addr_v6=%s", flag, addr_v4.c_str(),
2916 addr_v6.c_str());
2917 }
2918 } testConfigs[]{
2919 {0 /* non-passive */, ADDR_LOCALHOST_V4, ADDR_LOCALHOST_V6},
2920 {AI_PASSIVE, ADDR_ANYADDR_V4, ADDR_ANYADDR_V6}
2921 };
Luke Huangf8215372019-11-22 11:53:41 +08002922 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08002923
2924 for (const auto& config : testConfigs) {
2925 SCOPED_TRACE(config.asParameters());
2926
Xiao Ma09b71022018-12-11 17:56:32 +09002927 addrinfo hints = {
Nick Desaulnierscd6395a2019-10-11 09:15:24 -07002928 .ai_flags = config.flag,
Xiao Ma09b71022018-12-11 17:56:32 +09002929 .ai_family = AF_UNSPEC, // any address family
2930 .ai_socktype = 0, // any type
2931 .ai_protocol = 0, // any protocol
Xiao Ma09b71022018-12-11 17:56:32 +09002932 };
nuccachena26cc2a2018-07-17 18:07:23 +08002933
2934 // Assign hostname as null and service as port name.
2935 ScopedAddrinfo result = safe_getaddrinfo(nullptr, PORT_NAME_HTTP, &hints);
2936 ASSERT_TRUE(result != nullptr);
2937
2938 // Can't be synthesized because it should not get into Netd.
2939 std::vector<std::string> result_strs = ToStrings(result);
2940 for (const auto& str : result_strs) {
2941 EXPECT_TRUE(str == config.addr_v4 || str == config.addr_v6)
2942 << ", result_str='" << str << "'";
2943 }
2944
2945 // Assign hostname as null and service as numeric port number.
2946 hints.ai_flags = config.flag | AI_NUMERICSERV;
2947 result = safe_getaddrinfo(nullptr, PORT_NUMBER_HTTP, &hints);
2948 ASSERT_TRUE(result != nullptr);
2949
2950 // Can't be synthesized because it should not get into Netd.
2951 result_strs = ToStrings(result);
2952 for (const auto& str : result_strs) {
2953 EXPECT_TRUE(str == config.addr_v4 || str == config.addr_v6)
2954 << ", result_str='" << str << "'";
2955 }
2956 }
2957}
2958
2959TEST_F(ResolverTest, GetHostByAddr_ReverseDnsQueryWithHavingNat64Prefix) {
2960 struct hostent* result = nullptr;
2961 struct in_addr v4addr;
2962 struct in6_addr v6addr;
2963
2964 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08002965 constexpr char dns64_name[] = "ipv4only.arpa.";
2966 constexpr char ptr_name[] = "v4v6.example.com.";
2967 // PTR record for IPv4 address 1.2.3.4
2968 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
2969 // PTR record for IPv6 address 2001:db8::102:304
2970 constexpr char ptr_addr_v6[] =
2971 "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 +09002972 const std::vector<DnsRecord> records = {
2973 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
2974 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
2975 {ptr_addr_v6, ns_type::ns_t_ptr, ptr_name},
2976 };
nuccachena26cc2a2018-07-17 18:07:23 +08002977
Xiao Ma09b71022018-12-11 17:56:32 +09002978 test::DNSResponder dns(listen_addr);
2979 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08002980 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09002981 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08002982
Lorenzo Colittid39345c2019-02-18 10:59:29 +09002983 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08002984 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08002985 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08002986
2987 // Reverse IPv4 DNS query. Prefix should have no effect on it.
2988 inet_pton(AF_INET, "1.2.3.4", &v4addr);
2989 result = gethostbyaddr(&v4addr, sizeof(v4addr), AF_INET);
2990 ASSERT_TRUE(result != nullptr);
2991 std::string result_str = result->h_name ? result->h_name : "null";
2992 EXPECT_EQ(result_str, "v4v6.example.com");
2993
2994 // Reverse IPv6 DNS query. Prefix should have no effect on it.
2995 inet_pton(AF_INET6, "2001:db8::102:304", &v6addr);
2996 result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
2997 ASSERT_TRUE(result != nullptr);
2998 result_str = result->h_name ? result->h_name : "null";
2999 EXPECT_EQ(result_str, "v4v6.example.com");
3000}
3001
3002TEST_F(ResolverTest, GetHostByAddr_ReverseDns64Query) {
3003 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003004 constexpr char dns64_name[] = "ipv4only.arpa.";
3005 constexpr char ptr_name[] = "v4only.example.com.";
3006 // PTR record for IPv4 address 1.2.3.4
3007 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
3008 // PTR record for IPv6 address 64:ff9b::1.2.3.4
3009 constexpr char ptr_addr_v6_nomapping[] =
3010 "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.";
3011 constexpr char ptr_name_v6_synthesis[] = "v6synthesis.example.com.";
3012 // PTR record for IPv6 address 64:ff9b::5.6.7.8
3013 constexpr char ptr_addr_v6_synthesis[] =
3014 "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 +09003015 const std::vector<DnsRecord> records = {
3016 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3017 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
3018 {ptr_addr_v6_synthesis, ns_type::ns_t_ptr, ptr_name_v6_synthesis},
3019 };
nuccachena26cc2a2018-07-17 18:07:23 +08003020
Xiao Ma09b71022018-12-11 17:56:32 +09003021 test::DNSResponder dns(listen_addr);
3022 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003023 // "ptr_addr_v6_nomapping" is not mapped in DNS server
nuccachena26cc2a2018-07-17 18:07:23 +08003024 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003025 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003026
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003027 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003028 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003029 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003030
3031 // Synthesized PTR record doesn't exist on DNS server
3032 // Reverse IPv6 DNS64 query while DNS server doesn't have an answer for synthesized address.
3033 // After querying synthesized address failed, expect that prefix is removed from IPv6
3034 // synthesized address and do reverse IPv4 query instead.
3035 struct in6_addr v6addr;
3036 inet_pton(AF_INET6, "64:ff9b::1.2.3.4", &v6addr);
3037 struct hostent* result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
3038 ASSERT_TRUE(result != nullptr);
3039 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_nomapping)); // PTR record not exist
3040 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v4)); // PTR record exist
3041 std::string result_str = result->h_name ? result->h_name : "null";
3042 EXPECT_EQ(result_str, "v4only.example.com");
3043 // Check that return address has been mapped from IPv4 to IPv6 address because Netd
3044 // removes NAT64 prefix and does IPv4 DNS reverse lookup in this case. Then, Netd
3045 // fakes the return IPv4 address as original queried IPv6 address.
3046 result_str = ToString(result);
3047 EXPECT_EQ(result_str, "64:ff9b::102:304");
3048 dns.clearQueries();
3049
3050 // Synthesized PTR record exists on DNS server
3051 // Reverse IPv6 DNS64 query while DNS server has an answer for synthesized address.
3052 // Expect to Netd pass through synthesized address for DNS queries.
3053 inet_pton(AF_INET6, "64:ff9b::5.6.7.8", &v6addr);
3054 result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
3055 ASSERT_TRUE(result != nullptr);
3056 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_synthesis));
3057 result_str = result->h_name ? result->h_name : "null";
3058 EXPECT_EQ(result_str, "v6synthesis.example.com");
3059}
3060
3061TEST_F(ResolverTest, GetHostByAddr_ReverseDns64QueryFromHostFile) {
3062 constexpr char dns64_name[] = "ipv4only.arpa.";
3063 constexpr char host_name[] = "localhost";
3064 // The address is synthesized by prefix64:localhost.
3065 constexpr char host_addr[] = "64:ff9b::7f00:1";
nuccachena26cc2a2018-07-17 18:07:23 +08003066 constexpr char listen_addr[] = "::1";
Xiao Ma09b71022018-12-11 17:56:32 +09003067
3068 test::DNSResponder dns(listen_addr);
3069 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"}});
nuccachena26cc2a2018-07-17 18:07:23 +08003070 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003071 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003072
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003073 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003074 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003075 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003076
3077 // Using synthesized "localhost" address to be a trick for resolving host name
3078 // from host file /etc/hosts and "localhost" is the only name in /etc/hosts. Note that this is
3079 // not realistic: the code never synthesizes AAAA records for addresses in 127.0.0.0/8.
3080 struct in6_addr v6addr;
3081 inet_pton(AF_INET6, host_addr, &v6addr);
3082 struct hostent* result = gethostbyaddr(&v6addr, sizeof(v6addr), AF_INET6);
3083 ASSERT_TRUE(result != nullptr);
3084 // Expect no DNS queries; localhost is resolved via /etc/hosts.
3085 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
3086
Luke Huangf8215372019-11-22 11:53:41 +08003087 ASSERT_EQ(sizeof(in6_addr), (unsigned)result->h_length);
nuccachena26cc2a2018-07-17 18:07:23 +08003088 ASSERT_EQ(AF_INET6, result->h_addrtype);
3089 std::string result_str = ToString(result);
3090 EXPECT_EQ(result_str, host_addr);
3091 result_str = result->h_name ? result->h_name : "null";
3092 EXPECT_EQ(result_str, host_name);
3093}
3094
Hungming Chen9e6185a2019-06-04 16:09:19 +08003095TEST_F(ResolverTest, GetHostByAddr_cnamesClasslessReverseDelegation) {
3096 // IPv4 addresses in the subnet with notation '/' or '-'.
3097 constexpr char addr_slash[] = "192.0.2.1";
3098 constexpr char addr_hyphen[] = "192.0.3.1";
3099
3100 // Used to verify DNS reverse query for classless reverse lookup zone. See detail in RFC 2317
3101 // section 4.
3102 const static std::vector<DnsRecord> records = {
3103 // The records for reverse querying "192.0.2.1" in the subnet with notation '/'.
3104 {"1.2.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0/25.2.0.192.in-addr.arpa."},
3105 {"1.0/25.2.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3106
3107 // The records for reverse querying "192.0.3.1" in the subnet with notation '-'.
3108 {"1.3.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0-127.3.0.192.in-addr.arpa."},
3109 {"1.0-127.3.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3110 };
3111
3112 test::DNSResponder dns;
3113 StartDns(dns, records);
3114 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3115
3116 for (const auto& address : {addr_slash, addr_hyphen}) {
3117 SCOPED_TRACE(address);
3118
3119 in_addr v4addr;
3120 ASSERT_TRUE(inet_pton(AF_INET, address, &v4addr));
3121 hostent* result = gethostbyaddr(&v4addr, sizeof(v4addr), AF_INET);
3122 ASSERT_TRUE(result != nullptr);
3123 EXPECT_STREQ("hello.example.com", result->h_name);
3124 }
3125}
3126
nuccachena26cc2a2018-07-17 18:07:23 +08003127TEST_F(ResolverTest, GetNameInfo_ReverseDnsQueryWithHavingNat64Prefix) {
3128 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003129 constexpr char dns64_name[] = "ipv4only.arpa.";
3130 constexpr char ptr_name[] = "v4v6.example.com.";
3131 // PTR record for IPv4 address 1.2.3.4
3132 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
3133 // PTR record for IPv6 address 2001:db8::102:304
3134 constexpr char ptr_addr_v6[] =
3135 "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 +09003136 const std::vector<DnsRecord> records = {
3137 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3138 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
3139 {ptr_addr_v6, ns_type::ns_t_ptr, ptr_name},
3140 };
nuccachena26cc2a2018-07-17 18:07:23 +08003141
Xiao Ma09b71022018-12-11 17:56:32 +09003142 test::DNSResponder dns(listen_addr);
3143 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003144 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003145 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003146
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003147 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003148 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003149 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003150
Luke Huangf8215372019-11-22 11:53:41 +08003151 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08003152 static const struct TestConfig {
3153 int flag;
3154 int family;
3155 std::string addr;
3156 std::string host;
3157
3158 std::string asParameters() const {
3159 return StringPrintf("flag=%d, family=%d, addr=%s, host=%s", flag, family, addr.c_str(),
3160 host.c_str());
3161 }
3162 } testConfigs[]{
3163 {NI_NAMEREQD, AF_INET, "1.2.3.4", "v4v6.example.com"},
3164 {NI_NUMERICHOST, AF_INET, "1.2.3.4", "1.2.3.4"},
3165 {0, AF_INET, "1.2.3.4", "v4v6.example.com"},
3166 {0, AF_INET, "5.6.7.8", "5.6.7.8"}, // unmapped
3167 {NI_NAMEREQD, AF_INET6, "2001:db8::102:304", "v4v6.example.com"},
3168 {NI_NUMERICHOST, AF_INET6, "2001:db8::102:304", "2001:db8::102:304"},
3169 {0, AF_INET6, "2001:db8::102:304", "v4v6.example.com"},
3170 {0, AF_INET6, "2001:db8::506:708", "2001:db8::506:708"}, // unmapped
3171 };
Luke Huangf8215372019-11-22 11:53:41 +08003172 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08003173
3174 // Reverse IPv4/IPv6 DNS query. Prefix should have no effect on it.
3175 for (const auto& config : testConfigs) {
3176 SCOPED_TRACE(config.asParameters());
3177
3178 int rv;
3179 char host[NI_MAXHOST];
3180 struct sockaddr_in sin;
3181 struct sockaddr_in6 sin6;
3182 if (config.family == AF_INET) {
3183 memset(&sin, 0, sizeof(sin));
3184 sin.sin_family = AF_INET;
3185 inet_pton(AF_INET, config.addr.c_str(), &sin.sin_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003186 rv = getnameinfo((const struct sockaddr*)&sin, sizeof(sin), host, sizeof(host), nullptr,
3187 0, config.flag);
nuccachena26cc2a2018-07-17 18:07:23 +08003188 if (config.flag == NI_NAMEREQD) EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v4));
3189 } else if (config.family == AF_INET6) {
3190 memset(&sin6, 0, sizeof(sin6));
3191 sin6.sin6_family = AF_INET6;
3192 inet_pton(AF_INET6, config.addr.c_str(), &sin6.sin6_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003193 rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host),
nuccachena26cc2a2018-07-17 18:07:23 +08003194 nullptr, 0, config.flag);
3195 if (config.flag == NI_NAMEREQD) EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6));
3196 }
3197 ASSERT_EQ(0, rv);
3198 std::string result_str = host;
3199 EXPECT_EQ(result_str, config.host);
3200 dns.clearQueries();
3201 }
3202}
3203
3204TEST_F(ResolverTest, GetNameInfo_ReverseDns64Query) {
3205 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003206 constexpr char dns64_name[] = "ipv4only.arpa.";
3207 constexpr char ptr_name[] = "v4only.example.com.";
3208 // PTR record for IPv4 address 1.2.3.4
3209 constexpr char ptr_addr_v4[] = "4.3.2.1.in-addr.arpa.";
3210 // PTR record for IPv6 address 64:ff9b::1.2.3.4
3211 constexpr char ptr_addr_v6_nomapping[] =
3212 "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.";
3213 constexpr char ptr_name_v6_synthesis[] = "v6synthesis.example.com.";
3214 // PTR record for IPv6 address 64:ff9b::5.6.7.8
3215 constexpr char ptr_addr_v6_synthesis[] =
3216 "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 +09003217 const std::vector<DnsRecord> records = {
3218 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3219 {ptr_addr_v4, ns_type::ns_t_ptr, ptr_name},
3220 {ptr_addr_v6_synthesis, ns_type::ns_t_ptr, ptr_name_v6_synthesis},
3221 };
nuccachena26cc2a2018-07-17 18:07:23 +08003222
Xiao Ma09b71022018-12-11 17:56:32 +09003223 test::DNSResponder dns(listen_addr);
3224 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003225 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003226 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003227
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003228 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003229 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003230 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003231
Luke Huangf8215372019-11-22 11:53:41 +08003232 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08003233 static const struct TestConfig {
3234 bool hasSynthesizedPtrRecord;
3235 int flag;
3236 std::string addr;
3237 std::string host;
3238
3239 std::string asParameters() const {
3240 return StringPrintf("hasSynthesizedPtrRecord=%d, flag=%d, addr=%s, host=%s",
3241 hasSynthesizedPtrRecord, flag, addr.c_str(), host.c_str());
3242 }
3243 } testConfigs[]{
3244 {false, NI_NAMEREQD, "64:ff9b::102:304", "v4only.example.com"},
3245 {false, NI_NUMERICHOST, "64:ff9b::102:304", "64:ff9b::102:304"},
3246 {false, 0, "64:ff9b::102:304", "v4only.example.com"},
3247 {true, NI_NAMEREQD, "64:ff9b::506:708", "v6synthesis.example.com"},
3248 {true, NI_NUMERICHOST, "64:ff9b::506:708", "64:ff9b::506:708"},
3249 {true, 0, "64:ff9b::506:708", "v6synthesis.example.com"}
3250 };
Luke Huangf8215372019-11-22 11:53:41 +08003251 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08003252
3253 // hasSynthesizedPtrRecord = false
3254 // Synthesized PTR record doesn't exist on DNS server
3255 // Reverse IPv6 DNS64 query while DNS server doesn't have an answer for synthesized address.
3256 // After querying synthesized address failed, expect that prefix is removed from IPv6
3257 // synthesized address and do reverse IPv4 query instead.
3258 //
3259 // hasSynthesizedPtrRecord = true
3260 // Synthesized PTR record exists on DNS server
3261 // Reverse IPv6 DNS64 query while DNS server has an answer for synthesized address.
3262 // Expect to just pass through synthesized address for DNS queries.
3263 for (const auto& config : testConfigs) {
3264 SCOPED_TRACE(config.asParameters());
3265
3266 char host[NI_MAXHOST];
3267 struct sockaddr_in6 sin6;
3268 memset(&sin6, 0, sizeof(sin6));
3269 sin6.sin6_family = AF_INET6;
3270 inet_pton(AF_INET6, config.addr.c_str(), &sin6.sin6_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003271 int rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host),
nuccachena26cc2a2018-07-17 18:07:23 +08003272 nullptr, 0, config.flag);
3273 ASSERT_EQ(0, rv);
3274 if (config.flag == NI_NAMEREQD) {
3275 if (config.hasSynthesizedPtrRecord) {
3276 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_synthesis));
3277 } else {
3278 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6_nomapping)); // PTR record not exist.
3279 EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v4)); // PTR record exist.
3280 }
3281 }
3282 std::string result_str = host;
3283 EXPECT_EQ(result_str, config.host);
3284 dns.clearQueries();
3285 }
3286}
3287
3288TEST_F(ResolverTest, GetNameInfo_ReverseDns64QueryFromHostFile) {
3289 constexpr char dns64_name[] = "ipv4only.arpa.";
3290 constexpr char host_name[] = "localhost";
3291 // The address is synthesized by prefix64:localhost.
3292 constexpr char host_addr[] = "64:ff9b::7f00:1";
nuccachena26cc2a2018-07-17 18:07:23 +08003293 constexpr char listen_addr[] = "::1";
Xiao Ma09b71022018-12-11 17:56:32 +09003294
3295 test::DNSResponder dns(listen_addr);
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003296
Xiao Ma09b71022018-12-11 17:56:32 +09003297 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"}});
nuccachena26cc2a2018-07-17 18:07:23 +08003298 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003299 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003300
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003301 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003302 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003303 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003304
3305 // Using synthesized "localhost" address to be a trick for resolving host name
3306 // from host file /etc/hosts and "localhost" is the only name in /etc/hosts. Note that this is
3307 // not realistic: the code never synthesizes AAAA records for addresses in 127.0.0.0/8.
3308 char host[NI_MAXHOST];
Xiao Ma09b71022018-12-11 17:56:32 +09003309 struct sockaddr_in6 sin6 = {.sin6_family = AF_INET6};
nuccachena26cc2a2018-07-17 18:07:23 +08003310 inet_pton(AF_INET6, host_addr, &sin6.sin6_addr);
Luke Huangf8215372019-11-22 11:53:41 +08003311 int rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host), nullptr,
nuccachena26cc2a2018-07-17 18:07:23 +08003312 0, NI_NAMEREQD);
3313 ASSERT_EQ(0, rv);
3314 // Expect no DNS queries; localhost is resolved via /etc/hosts.
3315 EXPECT_EQ(0U, GetNumQueries(dns, host_name));
3316
3317 std::string result_str = host;
3318 EXPECT_EQ(result_str, host_name);
3319}
3320
Hungming Chen9e6185a2019-06-04 16:09:19 +08003321TEST_F(ResolverTest, GetNameInfo_cnamesClasslessReverseDelegation) {
3322 // IPv4 addresses in the subnet with notation '/' or '-'.
3323 constexpr char addr_slash[] = "192.0.2.1";
3324 constexpr char addr_hyphen[] = "192.0.3.1";
3325
3326 // Used to verify DNS reverse query for classless reverse lookup zone. See detail in RFC 2317
3327 // section 4.
3328 const static std::vector<DnsRecord> records = {
3329 // The records for reverse querying "192.0.2.1" in the subnet with notation '/'.
3330 {"1.2.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0/25.2.0.192.in-addr.arpa."},
3331 {"1.0/25.2.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3332
3333 // The records for reverse querying "192.0.3.1" in the subnet with notation '-'.
3334 {"1.3.0.192.in-addr.arpa.", ns_type::ns_t_cname, "1.0-127.3.0.192.in-addr.arpa."},
3335 {"1.0-127.3.0.192.in-addr.arpa.", ns_type::ns_t_ptr, kHelloExampleCom},
3336 };
3337
3338 test::DNSResponder dns;
3339 StartDns(dns, records);
3340 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3341
3342 for (const auto& address : {addr_slash, addr_hyphen}) {
3343 SCOPED_TRACE(address);
3344
3345 char host[NI_MAXHOST];
3346 sockaddr_in sin = {.sin_family = AF_INET};
3347 ASSERT_TRUE(inet_pton(AF_INET, address, &sin.sin_addr));
3348 int rv = getnameinfo((const sockaddr*)&sin, sizeof(sin), host, sizeof(host), nullptr, 0,
3349 NI_NAMEREQD);
3350 ASSERT_EQ(0, rv);
3351 EXPECT_STREQ("hello.example.com", host);
3352 }
3353}
3354
nuccachena26cc2a2018-07-17 18:07:23 +08003355TEST_F(ResolverTest, GetHostByName2_Dns64Synthesize) {
Xiao Ma09b71022018-12-11 17:56:32 +09003356 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003357 constexpr char dns64_name[] = "ipv4only.arpa.";
3358 constexpr char host_name[] = "ipv4only.example.com.";
Xiao Ma09b71022018-12-11 17:56:32 +09003359 const std::vector<DnsRecord> records = {
3360 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3361 {host_name, ns_type::ns_t_a, "1.2.3.4"},
3362 };
nuccachena26cc2a2018-07-17 18:07:23 +08003363
Xiao Ma09b71022018-12-11 17:56:32 +09003364 test::DNSResponder dns(listen_addr);
3365 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003366 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003367 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003368
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003369 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003370 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003371 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003372
3373 // Query an IPv4-only hostname. Expect that gets a synthesized address.
3374 struct hostent* result = gethostbyname2("ipv4only", AF_INET6);
3375 ASSERT_TRUE(result != nullptr);
3376 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3377 std::string result_str = ToString(result);
3378 EXPECT_EQ(result_str, "64:ff9b::102:304");
3379}
nuccachena26cc2a2018-07-17 18:07:23 +08003380
3381TEST_F(ResolverTest, GetHostByName2_DnsQueryWithHavingNat64Prefix) {
3382 constexpr char dns64_name[] = "ipv4only.arpa.";
3383 constexpr char host_name[] = "v4v6.example.com.";
nuccachena26cc2a2018-07-17 18:07:23 +08003384 constexpr char listen_addr[] = "::1";
Xiao Ma09b71022018-12-11 17:56:32 +09003385 const std::vector<DnsRecord> records = {
3386 {dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"},
3387 {host_name, ns_type::ns_t_a, "1.2.3.4"},
3388 {host_name, ns_type::ns_t_aaaa, "2001:db8::1.2.3.4"},
3389 };
3390
3391 test::DNSResponder dns(listen_addr);
3392 StartDns(dns, records);
nuccachena26cc2a2018-07-17 18:07:23 +08003393 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003394 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003395
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003396 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003397 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003398 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003399
3400 // IPv4 DNS query. Prefix should have no effect on it.
3401 struct hostent* result = gethostbyname2("v4v6", AF_INET);
3402 ASSERT_TRUE(result != nullptr);
3403 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3404 std::string result_str = ToString(result);
3405 EXPECT_EQ(result_str, "1.2.3.4");
3406 dns.clearQueries();
3407
3408 // IPv6 DNS query. Prefix should have no effect on it.
3409 result = gethostbyname2("v4v6", AF_INET6);
3410 ASSERT_TRUE(result != nullptr);
3411 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3412 result_str = ToString(result);
3413 EXPECT_EQ(result_str, "2001:db8::102:304");
3414}
3415
3416TEST_F(ResolverTest, GetHostByName2_Dns64QuerySpecialUseIPv4Addresses) {
3417 constexpr char THIS_NETWORK[] = "this_network";
3418 constexpr char LOOPBACK[] = "loopback";
3419 constexpr char LINK_LOCAL[] = "link_local";
3420 constexpr char MULTICAST[] = "multicast";
3421 constexpr char LIMITED_BROADCAST[] = "limited_broadcast";
3422
3423 constexpr char ADDR_THIS_NETWORK[] = "0.0.0.1";
3424 constexpr char ADDR_LOOPBACK[] = "127.0.0.1";
3425 constexpr char ADDR_LINK_LOCAL[] = "169.254.0.1";
3426 constexpr char ADDR_MULTICAST[] = "224.0.0.1";
3427 constexpr char ADDR_LIMITED_BROADCAST[] = "255.255.255.255";
3428
3429 constexpr char listen_addr[] = "::1";
nuccachena26cc2a2018-07-17 18:07:23 +08003430 constexpr char dns64_name[] = "ipv4only.arpa.";
3431
Xiao Ma09b71022018-12-11 17:56:32 +09003432 test::DNSResponder dns(listen_addr);
3433 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::"}});
nuccachena26cc2a2018-07-17 18:07:23 +08003434 const std::vector<std::string> servers = {listen_addr};
Xiao Ma09b71022018-12-11 17:56:32 +09003435 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
nuccachena26cc2a2018-07-17 18:07:23 +08003436
Lorenzo Colittid39345c2019-02-18 10:59:29 +09003437 // Start NAT64 prefix discovery and wait for it to complete.
Luke Huang5bd827c2019-03-14 16:10:04 +08003438 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003439 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
nuccachena26cc2a2018-07-17 18:07:23 +08003440
Luke Huangf8215372019-11-22 11:53:41 +08003441 // clang-format off
nuccachena26cc2a2018-07-17 18:07:23 +08003442 static const struct TestConfig {
3443 std::string name;
3444 std::string addr;
3445
3446 std::string asHostName() const {
Luke Huangf8215372019-11-22 11:53:41 +08003447 return StringPrintf("%s.example.com.", name.c_str());
nuccachena26cc2a2018-07-17 18:07:23 +08003448 }
3449 } testConfigs[]{
3450 {THIS_NETWORK, ADDR_THIS_NETWORK},
3451 {LOOPBACK, ADDR_LOOPBACK},
3452 {LINK_LOCAL, ADDR_LINK_LOCAL},
3453 {MULTICAST, ADDR_MULTICAST},
3454 {LIMITED_BROADCAST, ADDR_LIMITED_BROADCAST}
3455 };
Luke Huangf8215372019-11-22 11:53:41 +08003456 // clang-format on
nuccachena26cc2a2018-07-17 18:07:23 +08003457
3458 for (const auto& config : testConfigs) {
3459 const std::string testHostName = config.asHostName();
3460 SCOPED_TRACE(testHostName);
3461
3462 const char* host_name = testHostName.c_str();
3463 dns.addMapping(host_name, ns_type::ns_t_a, config.addr.c_str());
3464
3465 struct hostent* result = gethostbyname2(config.name.c_str(), AF_INET6);
3466 EXPECT_LE(1U, GetNumQueries(dns, host_name));
3467
3468 // In AF_INET6 case, don't synthesize special use IPv4 address.
3469 // Expect to have no answer
3470 EXPECT_EQ(nullptr, result);
3471
3472 dns.clearQueries();
3473 }
Bernie Innocenti2fef2b82018-12-20 15:56:40 +09003474}
Mike Yuf14e1a92019-05-10 13:54:58 +08003475
3476TEST_F(ResolverTest, PrefixDiscoveryBypassTls) {
3477 constexpr char listen_addr[] = "::1";
3478 constexpr char cleartext_port[] = "53";
3479 constexpr char tls_port[] = "853";
3480 constexpr char dns64_name[] = "ipv4only.arpa.";
3481 const std::vector<std::string> servers = {listen_addr};
3482
3483 test::DNSResponder dns(listen_addr);
3484 StartDns(dns, {{dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170"}});
3485 test::DnsTlsFrontend tls(listen_addr, tls_port, listen_addr, cleartext_port);
3486 ASSERT_TRUE(tls.startServer());
3487
3488 // Setup OPPORTUNISTIC mode and wait for the validation complete.
waynema0e73c2e2019-07-31 15:04:08 +08003489 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams, ""));
Mike Yu724f77d2019-08-16 11:14:50 +08003490 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003491 EXPECT_TRUE(tls.waitForQueries(1));
Mike Yuf14e1a92019-05-10 13:54:58 +08003492 tls.clearQueries();
3493
3494 // Start NAT64 prefix discovery and wait for it complete.
3495 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003496 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
Mike Yuf14e1a92019-05-10 13:54:58 +08003497
3498 // Verify it bypassed TLS even though there's a TLS server available.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003499 EXPECT_EQ(0, tls.queries()) << dns.dumpQueries();
3500 EXPECT_EQ(1U, GetNumQueries(dns, dns64_name)) << dns.dumpQueries();
Mike Yuf14e1a92019-05-10 13:54:58 +08003501
3502 // Restart the testing network to reset the cache.
3503 mDnsClient.TearDown();
3504 mDnsClient.SetUp();
3505 dns.clearQueries();
3506
3507 // Setup STRICT mode and wait for the validation complete.
waynema0e73c2e2019-07-31 15:04:08 +08003508 ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, kDefaultSearchDomains, kDefaultParams,
3509 kDefaultPrivateDnsHostName));
Mike Yu724f77d2019-08-16 11:14:50 +08003510 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003511 EXPECT_TRUE(tls.waitForQueries(1));
Mike Yuf14e1a92019-05-10 13:54:58 +08003512 tls.clearQueries();
3513
3514 // Start NAT64 prefix discovery and wait for it to complete.
3515 EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
Hungming Chene8f970c2019-04-10 17:34:06 +08003516 EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
Mike Yuf14e1a92019-05-10 13:54:58 +08003517
3518 // Verify it bypassed TLS despite STRICT mode.
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003519 EXPECT_EQ(0, tls.queries()) << dns.dumpQueries();
3520 EXPECT_EQ(1U, GetNumQueries(dns, dns64_name)) << dns.dumpQueries();
Mike Yuf14e1a92019-05-10 13:54:58 +08003521}
Luke Huang9807e6b2019-05-20 16:17:12 +08003522
3523namespace {
3524
Luke Huang0d592bc2019-05-25 18:24:03 +08003525class ScopedSetNetworkForProcess {
3526 public:
3527 explicit ScopedSetNetworkForProcess(unsigned netId) {
3528 mStoredNetId = getNetworkForProcess();
3529 if (netId == mStoredNetId) return;
3530 EXPECT_EQ(0, setNetworkForProcess(netId));
3531 }
3532 ~ScopedSetNetworkForProcess() { EXPECT_EQ(0, setNetworkForProcess(mStoredNetId)); }
3533
3534 private:
3535 unsigned mStoredNetId;
3536};
3537
3538class ScopedSetNetworkForResolv {
3539 public:
3540 explicit ScopedSetNetworkForResolv(unsigned netId) { EXPECT_EQ(0, setNetworkForResolv(netId)); }
3541 ~ScopedSetNetworkForResolv() { EXPECT_EQ(0, setNetworkForResolv(NETID_UNSET)); }
3542};
3543
Luke Huang9807e6b2019-05-20 16:17:12 +08003544void sendCommand(int fd, const std::string& cmd) {
3545 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size() + 1));
3546 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size() + 1));
3547}
3548
3549int32_t readBE32(int fd) {
3550 int32_t tmp;
3551 int n = TEMP_FAILURE_RETRY(read(fd, &tmp, sizeof(tmp)));
3552 EXPECT_TRUE(n > 0);
3553 return ntohl(tmp);
3554}
3555
Luke Huang0d592bc2019-05-25 18:24:03 +08003556int readResponseCode(int fd) {
Luke Huang9807e6b2019-05-20 16:17:12 +08003557 char buf[4];
3558 int n = TEMP_FAILURE_RETRY(read(fd, &buf, sizeof(buf)));
3559 EXPECT_TRUE(n > 0);
3560 // The format of response code is that 4 bytes for the code & null.
3561 buf[3] = '\0';
3562 int result;
3563 EXPECT_TRUE(ParseInt(buf, &result));
3564 return result;
3565}
3566
Luke Huang0d592bc2019-05-25 18:24:03 +08003567bool checkAndClearUseLocalNameserversFlag(unsigned* netid) {
3568 if (netid == nullptr || ((*netid) & NETID_USE_LOCAL_NAMESERVERS) == 0) {
3569 return false;
3570 }
3571 *netid = (*netid) & ~NETID_USE_LOCAL_NAMESERVERS;
3572 return true;
3573}
3574
Luke Huangf8215372019-11-22 11:53:41 +08003575aidl::android::net::UidRangeParcel makeUidRangeParcel(int start, int stop) {
3576 aidl::android::net::UidRangeParcel res;
Luke Huang0d592bc2019-05-25 18:24:03 +08003577 res.start = start;
3578 res.stop = stop;
3579
3580 return res;
3581}
3582
3583void expectNetIdWithLocalNameserversFlag(unsigned netId) {
3584 unsigned dnsNetId = 0;
3585 EXPECT_EQ(0, getNetworkForDns(&dnsNetId));
3586 EXPECT_TRUE(checkAndClearUseLocalNameserversFlag(&dnsNetId));
3587 EXPECT_EQ(netId, static_cast<unsigned>(dnsNetId));
3588}
3589
3590void expectDnsNetIdEquals(unsigned netId) {
3591 unsigned dnsNetId = 0;
3592 EXPECT_EQ(0, getNetworkForDns(&dnsNetId));
3593 EXPECT_EQ(netId, static_cast<unsigned>(dnsNetId));
3594}
3595
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003596void expectDnsNetIdIsDefaultNetwork(INetd* netdService) {
Luke Huang0d592bc2019-05-25 18:24:03 +08003597 int currentNetid;
3598 EXPECT_TRUE(netdService->networkGetDefault(&currentNetid).isOk());
3599 expectDnsNetIdEquals(currentNetid);
3600}
3601
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003602void expectDnsNetIdWithVpn(INetd* netdService, unsigned vpnNetId, unsigned expectedNetId) {
Luke Huang0d592bc2019-05-25 18:24:03 +08003603 EXPECT_TRUE(netdService->networkCreateVpn(vpnNetId, false /* secure */).isOk());
3604 uid_t uid = getuid();
3605 // Add uid to VPN
3606 EXPECT_TRUE(netdService->networkAddUidRanges(vpnNetId, {makeUidRangeParcel(uid, uid)}).isOk());
3607 expectDnsNetIdEquals(expectedNetId);
3608 EXPECT_TRUE(netdService->networkDestroy(vpnNetId).isOk());
3609}
3610
Luke Huang9807e6b2019-05-20 16:17:12 +08003611} // namespace
3612
3613TEST_F(ResolverTest, getDnsNetId) {
3614 // We've called setNetworkForProcess in SetupOemNetwork, so reset to default first.
3615 setNetworkForProcess(NETID_UNSET);
Luke Huang0d592bc2019-05-25 18:24:03 +08003616
3617 expectDnsNetIdIsDefaultNetwork(mDnsClient.netdService());
3618 expectDnsNetIdWithVpn(mDnsClient.netdService(), TEST_VPN_NETID, TEST_VPN_NETID);
Luke Huang9807e6b2019-05-20 16:17:12 +08003619
3620 // Test with setNetworkForProcess
Luke Huang0d592bc2019-05-25 18:24:03 +08003621 {
3622 ScopedSetNetworkForProcess scopedSetNetworkForProcess(TEST_NETID);
3623 expectDnsNetIdEquals(TEST_NETID);
3624 }
3625
3626 // Test with setNetworkForProcess with NETID_USE_LOCAL_NAMESERVERS
3627 {
3628 ScopedSetNetworkForProcess scopedSetNetworkForProcess(TEST_NETID |
3629 NETID_USE_LOCAL_NAMESERVERS);
3630 expectNetIdWithLocalNameserversFlag(TEST_NETID);
3631 }
Luke Huang9807e6b2019-05-20 16:17:12 +08003632
3633 // Test with setNetworkForResolv
Luke Huang0d592bc2019-05-25 18:24:03 +08003634 {
3635 ScopedSetNetworkForResolv scopedSetNetworkForResolv(TEST_NETID);
3636 expectDnsNetIdEquals(TEST_NETID);
3637 }
3638
3639 // Test with setNetworkForResolv with NETID_USE_LOCAL_NAMESERVERS
3640 {
3641 ScopedSetNetworkForResolv scopedSetNetworkForResolv(TEST_NETID |
3642 NETID_USE_LOCAL_NAMESERVERS);
3643 expectNetIdWithLocalNameserversFlag(TEST_NETID);
3644 }
3645
3646 // Test with setNetworkForResolv under bypassable vpn
3647 {
3648 ScopedSetNetworkForResolv scopedSetNetworkForResolv(TEST_NETID);
3649 expectDnsNetIdWithVpn(mDnsClient.netdService(), TEST_VPN_NETID, TEST_NETID);
3650 }
Luke Huang9807e6b2019-05-20 16:17:12 +08003651
3652 // Create socket connected to DnsProxyListener
3653 int fd = dns_open_proxy();
3654 EXPECT_TRUE(fd > 0);
3655 unique_fd ufd(fd);
3656
3657 // Test command with wrong netId
3658 sendCommand(fd, "getdnsnetid abc");
Luke Huang0d592bc2019-05-25 18:24:03 +08003659 EXPECT_EQ(ResponseCode::DnsProxyQueryResult, readResponseCode(fd));
Luke Huang9807e6b2019-05-20 16:17:12 +08003660 EXPECT_EQ(-EINVAL, readBE32(fd));
3661
3662 // Test unsupported command
3663 sendCommand(fd, "getdnsnetidNotSupported");
3664 // Keep in sync with FrameworkListener.cpp (500, "Command not recognized")
Luke Huang0d592bc2019-05-25 18:24:03 +08003665 EXPECT_EQ(500, readResponseCode(fd));
Luke Huang9807e6b2019-05-20 16:17:12 +08003666}
Sehee Park2c118782019-05-07 13:02:45 +09003667
3668TEST_F(ResolverTest, BlockDnsQueryWithUidRule) {
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003669 // This test relies on blocking traffic on loopback, which xt_qtaguid does not do.
3670 // See aosp/358413 and b/34444781 for why.
3671 SKIP_IF_BPF_NOT_SUPPORTED;
3672
Sehee Park2c118782019-05-07 13:02:45 +09003673 constexpr char listen_addr1[] = "127.0.0.4";
3674 constexpr char listen_addr2[] = "::1";
3675 constexpr char host_name[] = "howdy.example.com.";
3676 const std::vector<DnsRecord> records = {
3677 {host_name, ns_type::ns_t_a, "1.2.3.4"},
3678 {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},
3679 };
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003680 INetd* netdService = mDnsClient.netdService();
Sehee Park2c118782019-05-07 13:02:45 +09003681
3682 test::DNSResponder dns1(listen_addr1);
3683 test::DNSResponder dns2(listen_addr2);
3684 StartDns(dns1, records);
3685 StartDns(dns2, records);
3686
3687 std::vector<std::string> servers = {listen_addr1, listen_addr2};
3688 ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers));
3689 dns1.clearQueries();
3690 dns2.clearQueries();
3691
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003692 // Add drop rule for TEST_UID. Also enable the standby chain because it might not be enabled.
3693 // Unfortunately we cannot use FIREWALL_CHAIN_NONE, or custom iptables rules, for this purpose
3694 // because netd calls fchown() on the DNS query sockets, and "iptables -m owner" matches the
3695 // UID of the socket creator, not the UID set by fchown().
3696 //
3697 // TODO: migrate FIREWALL_CHAIN_NONE to eBPF as well.
3698 EXPECT_TRUE(netdService->firewallEnableChildChain(INetd::FIREWALL_CHAIN_STANDBY, true).isOk());
3699 EXPECT_TRUE(netdService
Sehee Park2c118782019-05-07 13:02:45 +09003700 ->firewallSetUidRule(INetd::FIREWALL_CHAIN_STANDBY, TEST_UID,
3701 INetd::FIREWALL_RULE_DENY)
3702 .isOk());
3703
3704 // Save uid
3705 int suid = getuid();
3706
3707 // Switch to TEST_UID
3708 EXPECT_TRUE(seteuid(TEST_UID) == 0);
3709
3710 // Dns Query
3711 int fd1 = resNetworkQuery(TEST_NETID, host_name, ns_c_in, ns_t_a, 0);
3712 int fd2 = resNetworkQuery(TEST_NETID, host_name, ns_c_in, ns_t_aaaa, 0);
3713 EXPECT_TRUE(fd1 != -1);
3714 EXPECT_TRUE(fd2 != -1);
3715
3716 uint8_t buf[MAXPACKET] = {};
3717 int rcode;
3718 int res = getAsyncResponse(fd2, &rcode, buf, MAXPACKET);
3719 EXPECT_EQ(-ECONNREFUSED, res);
3720
3721 memset(buf, 0, MAXPACKET);
3722 res = getAsyncResponse(fd1, &rcode, buf, MAXPACKET);
3723 EXPECT_EQ(-ECONNREFUSED, res);
3724
3725 // Restore uid
3726 EXPECT_TRUE(seteuid(suid) == 0);
3727
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003728 // Remove drop rule for TEST_UID, and disable the standby chain.
3729 EXPECT_TRUE(netdService
Sehee Park2c118782019-05-07 13:02:45 +09003730 ->firewallSetUidRule(INetd::FIREWALL_CHAIN_STANDBY, TEST_UID,
3731 INetd::FIREWALL_RULE_ALLOW)
3732 .isOk());
Lorenzo Colittieb9aeec2019-06-26 19:53:55 +09003733 EXPECT_TRUE(netdService->firewallEnableChildChain(INetd::FIREWALL_CHAIN_STANDBY, false).isOk());
Sehee Park2c118782019-05-07 13:02:45 +09003734}
Mike Yua772c202019-09-23 17:47:21 +08003735
Mike Yu40e67072019-10-09 21:14:09 +08003736namespace {
3737
3738const std::string kDotConnectTimeoutMsFlag(
3739 "persist.device_config.netd_native.dot_connect_timeout_ms");
3740
3741class ScopedSystemProperties {
3742 public:
3743 explicit ScopedSystemProperties(const std::string& key, const std::string& value)
3744 : mStoredKey(key) {
3745 mStoredValue = android::base::GetProperty(key, "");
3746 android::base::SetProperty(key, value);
3747 }
3748 ~ScopedSystemProperties() { android::base::SetProperty(mStoredKey, mStoredValue); }
3749
3750 private:
3751 std::string mStoredKey;
3752 std::string mStoredValue;
3753};
3754
3755} // namespace
3756
Mike Yua772c202019-09-23 17:47:21 +08003757TEST_F(ResolverTest, ConnectTlsServerTimeout) {
Mike Yu40e67072019-10-09 21:14:09 +08003758 constexpr int expectedTimeout = 1000;
3759 constexpr char hostname1[] = "query1.example.com.";
3760 constexpr char hostname2[] = "query2.example.com.";
Mike Yua772c202019-09-23 17:47:21 +08003761 const std::vector<DnsRecord> records = {
Mike Yu40e67072019-10-09 21:14:09 +08003762 {hostname1, ns_type::ns_t_a, "1.2.3.4"},
3763 {hostname2, ns_type::ns_t_a, "1.2.3.5"},
Mike Yua772c202019-09-23 17:47:21 +08003764 };
3765
3766 test::DNSResponder dns;
3767 StartDns(dns, records);
Mike Yu40e67072019-10-09 21:14:09 +08003768 test::DnsTlsFrontend tls;
Mike Yua772c202019-09-23 17:47:21 +08003769 ASSERT_TRUE(tls.startServer());
3770
Mike Yu40e67072019-10-09 21:14:09 +08003771 // The resolver will adjust the timeout value to 1000ms since the value is too small.
3772 ScopedSystemProperties scopedSystemProperties(kDotConnectTimeoutMsFlag, "100");
Mike Yua772c202019-09-23 17:47:21 +08003773
Mike Yu40e67072019-10-09 21:14:09 +08003774 // Set up resolver to opportunistic mode with the default configuration.
Mike Yu8ac63402019-12-02 15:28:38 +08003775 const ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
Mike Yu40e67072019-10-09 21:14:09 +08003776 ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
Mike Yua772c202019-09-23 17:47:21 +08003777 EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003778 EXPECT_TRUE(tls.waitForQueries(1));
Mike Yua772c202019-09-23 17:47:21 +08003779 tls.clearQueries();
Bernie Innocenti0ad80e92020-01-23 22:20:44 +09003780 dns.clearQueries();
Mike Yua772c202019-09-23 17:47:21 +08003781
3782 // The server becomes unresponsive to the handshake request.
3783 tls.setHangOnHandshakeForTesting(true);
3784
3785 // Expect the things happening in getaddrinfo():
3786 // 1. Connect to the private DNS server.
3787 // 2. SSL handshake times out.
3788 // 3. Fallback to UDP transport, and then get the answer.
Mike Yu40e67072019-10-09 21:14:09 +08003789 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
3790 auto [result, timeTakenMs] = safe_getaddrinfo_time_taken(hostname1, nullptr, hints);
Mike Yua772c202019-09-23 17:47:21 +08003791
Mike Yu40e67072019-10-09 21:14:09 +08003792 EXPECT_NE(nullptr, result);
Mike Yua772c202019-09-23 17:47:21 +08003793 EXPECT_EQ(0, tls.queries());
Mike Yu40e67072019-10-09 21:14:09 +08003794 EXPECT_EQ(1U, GetNumQueries(dns, hostname1));
3795 EXPECT_EQ(records.at(0).addr, ToString(result));
Mike Yua772c202019-09-23 17:47:21 +08003796
Mike Yu40e67072019-10-09 21:14:09 +08003797 // A loose upper bound is set by adding 2000ms buffer time. Theoretically, getaddrinfo()
3798 // should just take a bit more than expetTimeout milliseconds.
3799 EXPECT_GE(timeTakenMs, expectedTimeout);
3800 EXPECT_LE(timeTakenMs, expectedTimeout + 2000);
3801
3802 // Set the server to be responsive. Verify that the resolver will attempt to reconnect
3803 // to the server and then get the result within the timeout.
3804 tls.setHangOnHandshakeForTesting(false);
3805 std::tie(result, timeTakenMs) = safe_getaddrinfo_time_taken(hostname2, nullptr, hints);
3806
3807 EXPECT_NE(nullptr, result);
3808 EXPECT_EQ(1, tls.queries());
3809 EXPECT_EQ(1U, GetNumQueries(dns, hostname2));
3810 EXPECT_EQ(records.at(1).addr, ToString(result));
3811
3812 EXPECT_LE(timeTakenMs, expectedTimeout);
Mike Yua772c202019-09-23 17:47:21 +08003813}
Hungming Chenbb90ab32019-10-28 18:20:31 +08003814
Ken Chen766feae2019-10-30 15:13:44 +08003815TEST_F(ResolverTest, FlushNetworkCache) {
Luke Huang0b5a76c2019-11-23 03:00:00 +08003816 SKIP_IF_REMOTE_VERSION_LESS_THAN(mDnsClient.resolvService(), 4);
Ken Chen766feae2019-10-30 15:13:44 +08003817 test::DNSResponder dns;
3818 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
3819 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3820
3821 const hostent* result = gethostbyname("hello");
3822 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
3823
3824 // get result from cache
3825 result = gethostbyname("hello");
3826 EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
3827
3828 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
3829
3830 result = gethostbyname("hello");
3831 EXPECT_EQ(2U, GetNumQueriesForType(dns, ns_type::ns_t_a, kHelloExampleCom));
3832}
3833
3834TEST_F(ResolverTest, FlushNetworkCache_random) {
Luke Huang0b5a76c2019-11-23 03:00:00 +08003835 SKIP_IF_REMOTE_VERSION_LESS_THAN(mDnsClient.resolvService(), 4);
Ken Chen766feae2019-10-30 15:13:44 +08003836 constexpr int num_flush = 10;
3837 constexpr int num_queries = 20;
3838 test::DNSResponder dns;
3839 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
3840 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3841 const addrinfo hints = {.ai_family = AF_INET};
3842
3843 std::thread t([this]() {
3844 for (int i = 0; i < num_flush; ++i) {
3845 unsigned delay = arc4random_uniform(10 * 1000); // 10ms
3846 usleep(delay);
3847 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
3848 }
3849 });
3850
3851 for (int i = 0; i < num_queries; ++i) {
3852 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
3853 EXPECT_TRUE(result != nullptr);
3854 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
3855 }
3856 t.join();
3857}
3858
3859// flush cache while one query is wait-for-response, another is pending.
3860TEST_F(ResolverTest, FlushNetworkCache_concurrent) {
Luke Huang0b5a76c2019-11-23 03:00:00 +08003861 SKIP_IF_REMOTE_VERSION_LESS_THAN(mDnsClient.resolvService(), 4);
Ken Chen766feae2019-10-30 15:13:44 +08003862 const char* listen_addr1 = "127.0.0.9";
3863 const char* listen_addr2 = "127.0.0.10";
3864 test::DNSResponder dns1(listen_addr1);
3865 test::DNSResponder dns2(listen_addr2);
3866 StartDns(dns1, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
3867 StartDns(dns2, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
3868 addrinfo hints = {.ai_family = AF_INET};
3869
3870 // step 1: set server#1 into deferred responding mode
3871 dns1.setDeferredResp(true);
3872 std::thread t1([&listen_addr1, &hints, this]() {
3873 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr1}));
3874 // step 3: query
3875 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
3876 // step 9: check result
3877 EXPECT_TRUE(result != nullptr);
3878 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
3879 });
3880
3881 // step 2: wait for the query to reach the server
3882 while (GetNumQueries(dns1, kHelloExampleCom) == 0) {
3883 usleep(1000); // 1ms
3884 }
3885
3886 std::thread t2([&listen_addr2, &hints, &dns2, this]() {
3887 ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr2}));
3888 // step 5: query (should be blocked in resolver)
3889 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
3890 // step 7: check result
3891 EXPECT_TRUE(result != nullptr);
3892 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
3893 EXPECT_EQ(1U, GetNumQueriesForType(dns2, ns_type::ns_t_a, kHelloExampleCom));
3894 });
3895
3896 // step 4: wait a bit for the 2nd query to enter pending state
3897 usleep(100 * 1000); // 100ms
3898 // step 6: flush cache (will unblock pending queries)
3899 EXPECT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
3900 t2.join();
3901
3902 // step 8: resume server#1
3903 dns1.setDeferredResp(false);
3904 t1.join();
3905
3906 // step 10: verify if result is correctly cached
3907 dns2.clearQueries();
3908 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
3909 EXPECT_EQ(0U, GetNumQueries(dns2, kHelloExampleCom));
3910 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
3911}
3912
waynema29253052019-08-20 11:26:08 +08003913// TODO: Perhaps to have a boundary conditions test for TCP and UDP.
3914TEST_F(ResolverTest, TcpQueryWithOversizePayload) {
3915 test::DNSResponder dns;
3916 StartDns(dns, {{kHelloExampleCom, ns_type::ns_t_a, kHelloExampleComAddrV4}});
3917 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
3918
3919 int fd = dns_open_proxy();
3920 ASSERT_TRUE(fd > 0);
3921
3922 // Sending DNS query over TCP once the packet sizes exceed 512 bytes.
3923 // The raw data is combined with Question section and Additional section
3924 // Question section : query "hello.example.com", type A, class IN
3925 // Additional section : type OPT (41), Option PADDING, Option Length 546
3926 // Padding option which allows DNS clients and servers to artificially
3927 // increase the size of a DNS message by a variable number of bytes.
3928 // See also RFC7830, section 3
3929 const std::string query =
3930 "+c0BAAABAAAAAAABBWhlbGxvB2V4YW1wbGUDY29tAAABAAEAACkgAAAAgAACJgAMAiIAAAAAAAAAAAAAAAAAA"
3931 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3932 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3933 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3934 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3935 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3936 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3937 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3938 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
3939 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
3940 const std::string cmd =
3941 "resnsend " + std::to_string(TEST_NETID) + " 0 " /* ResNsendFlags */ + query + '\0';
3942 ssize_t rc = TEMP_FAILURE_RETRY(write(fd, cmd.c_str(), cmd.size()));
3943 EXPECT_EQ(rc, static_cast<ssize_t>(cmd.size()));
3944 expectAnswersValid(fd, AF_INET, kHelloExampleComAddrV4);
3945 EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom));
3946 EXPECT_EQ(0U, GetNumQueriesForProtocol(dns, IPPROTO_UDP, kHelloExampleCom));
3947}
3948
Ken Chen99344882020-01-01 14:59:38 +08003949TEST_F(ResolverTest, TruncatedRspMode) {
3950 constexpr char listen_addr[] = "127.0.0.4";
3951 constexpr char listen_addr2[] = "127.0.0.5";
3952 constexpr char listen_srv[] = "53";
3953
3954 test::DNSResponder dns(listen_addr, listen_srv, static_cast<ns_rcode>(-1));
3955 test::DNSResponder dns2(listen_addr2, listen_srv, static_cast<ns_rcode>(-1));
3956 // dns supports UDP only, dns2 support UDP and TCP
3957 dns.setResponseProbability(0.0, IPPROTO_TCP);
3958 StartDns(dns, kLargeCnameChainRecords);
3959 StartDns(dns2, kLargeCnameChainRecords);
3960
3961 const struct TestConfig {
3962 const std::optional<int32_t> tcMode;
3963 const bool ret;
3964 const unsigned numQueries;
3965 std::string asParameters() const {
3966 return StringPrintf("tcMode: %d, ret: %s, numQueries: %u", tcMode.value_or(-1),
3967 ret ? "true" : "false", numQueries);
3968 }
3969 } testConfigs[]{
3970 // clang-format off
3971 {std::nullopt, true, 0}, /* mode unset */
3972 {aidl::android::net::IDnsResolver::TC_MODE_DEFAULT, true, 0}, /* default mode */
3973 {aidl::android::net::IDnsResolver::TC_MODE_UDP_TCP, true, 1}, /* alternative mode */
3974 {-666, false, 1}, /* invalid input */
3975 // clang-format on
3976 };
3977
3978 for (const auto& config : testConfigs) {
3979 SCOPED_TRACE(config.asParameters());
3980
3981 ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
3982 parcel.servers = {listen_addr, listen_addr2};
3983 if (config.tcMode) {
3984 parcel.experimentalOptions.tcMode = config.tcMode.value();
3985 }
3986 ASSERT_EQ(mDnsClient.resolvService()->setResolverConfiguration(parcel).isOk(), config.ret);
3987
3988 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
3989 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
3990 ASSERT_TRUE(result != nullptr);
3991 EXPECT_EQ(ToString(result), kHelloExampleComAddrV4);
3992 // TC_MODE_DEFAULT: resolver retries on TCP-only on each name server.
3993 // TC_MODE_UDP_TCP: resolver retries on TCP on the same server, falls back to UDP from next.
3994 ASSERT_EQ(GetNumQueriesForProtocol(dns, IPPROTO_UDP, kHelloExampleCom), 1U);
3995 ASSERT_EQ(GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom), 1U);
3996 ASSERT_EQ(GetNumQueriesForProtocol(dns2, IPPROTO_UDP, kHelloExampleCom), config.numQueries);
3997 ASSERT_EQ(GetNumQueriesForProtocol(dns2, IPPROTO_TCP, kHelloExampleCom), 1U);
3998
3999 dns.clearQueries();
4000 dns2.clearQueries();
4001 ASSERT_TRUE(mDnsClient.resolvService()->flushNetworkCache(TEST_NETID).isOk());
4002 }
4003}
4004
Hungming Chenbb90ab32019-10-28 18:20:31 +08004005// Parameterized tests.
4006// TODO: Merge the existing tests as parameterized test if possible.
4007// TODO: Perhaps move parameterized tests to an independent file.
4008enum class CallType { GETADDRINFO, GETHOSTBYNAME };
4009class ResolverParameterizedTest : public ResolverTest,
Hungming Chen63779052019-10-30 15:06:13 +08004010 public testing::WithParamInterface<CallType> {
4011 protected:
Hungming Chen22617fd2019-12-06 12:15:45 +08004012 void VerifyQueryHelloExampleComV4(const test::DNSResponder& dns, const CallType calltype,
4013 const bool verifyNumQueries = true) {
Hungming Chen63779052019-10-30 15:06:13 +08004014 if (calltype == CallType::GETADDRINFO) {
4015 const addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
4016 ScopedAddrinfo result = safe_getaddrinfo("hello", nullptr, &hints);
4017 ASSERT_TRUE(result != nullptr);
4018 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4019 } else if (calltype == CallType::GETHOSTBYNAME) {
4020 const hostent* result = gethostbyname("hello");
4021 ASSERT_TRUE(result != nullptr);
4022 ASSERT_EQ(4, result->h_length);
4023 ASSERT_FALSE(result->h_addr_list[0] == nullptr);
4024 EXPECT_EQ(kHelloExampleComAddrV4, ToString(result));
4025 EXPECT_TRUE(result->h_addr_list[1] == nullptr);
4026 } else {
4027 FAIL() << "Unsupported call type: " << static_cast<uint32_t>(calltype);
4028 }
Hungming Chen22617fd2019-12-06 12:15:45 +08004029 if (verifyNumQueries) EXPECT_EQ(1U, GetNumQueries(dns, kHelloExampleCom));
Hungming Chen63779052019-10-30 15:06:13 +08004030 }
4031};
Hungming Chenbb90ab32019-10-28 18:20:31 +08004032
Hungming Chen63779052019-10-30 15:06:13 +08004033INSTANTIATE_TEST_SUITE_P(QueryCallTest, ResolverParameterizedTest,
Hungming Chenbb90ab32019-10-28 18:20:31 +08004034 testing::Values(CallType::GETADDRINFO, CallType::GETHOSTBYNAME),
4035 [](const testing::TestParamInfo<CallType>& info) {
Hungming Chenbb90ab32019-10-28 18:20:31 +08004036 switch (info.param) {
4037 case CallType::GETADDRINFO:
Hungming Chen63779052019-10-30 15:06:13 +08004038 return "GetAddrInfo";
Hungming Chenbb90ab32019-10-28 18:20:31 +08004039 case CallType::GETHOSTBYNAME:
Hungming Chen63779052019-10-30 15:06:13 +08004040 return "GetHostByName";
Hungming Chenbb90ab32019-10-28 18:20:31 +08004041 default:
Hungming Chen63779052019-10-30 15:06:13 +08004042 return "InvalidParameter"; // Should not happen.
Hungming Chenbb90ab32019-10-28 18:20:31 +08004043 }
Hungming Chenbb90ab32019-10-28 18:20:31 +08004044 });
4045
4046TEST_P(ResolverParameterizedTest, AuthoritySectionAndAdditionalSection) {
4047 // DNS response may have more information in authority section and additional section.
4048 // Currently, getanswer() of packages/modules/DnsResolver/getaddrinfo.cpp doesn't parse the
4049 // content of authority section and additional section. Test these sections if they crash
4050 // the resolver, just in case. See also RFC 1035 section 4.1.
4051 const auto& calltype = GetParam();
4052 test::DNSHeader header(kDefaultDnsHeader);
4053
4054 // Create a DNS response which has a authoritative nameserver record in authority
4055 // section and its relevant address record in additional section.
4056 //
4057 // Question
4058 // hello.example.com. IN A
4059 // Answer
4060 // hello.example.com. IN A 1.2.3.4
4061 // Authority:
4062 // hello.example.com. IN NS ns1.example.com.
4063 // Additional:
4064 // ns1.example.com. IN A 5.6.7.8
4065 //
4066 // A response may have only question, answer, and authority section. Current testing response
4067 // should be able to cover this condition.
4068
4069 // Question section.
4070 test::DNSQuestion question{
4071 .qname = {.name = kHelloExampleCom},
4072 .qtype = ns_type::ns_t_a,
4073 .qclass = ns_c_in,
4074 };
4075 header.questions.push_back(std::move(question));
4076
4077 // Answer section.
4078 test::DNSRecord recordAnswer{
4079 .name = {.name = kHelloExampleCom},
4080 .rtype = ns_type::ns_t_a,
4081 .rclass = ns_c_in,
4082 .ttl = 0, // no cache
4083 };
Hungming Chen63779052019-10-30 15:06:13 +08004084 EXPECT_TRUE(test::DNSResponder::fillRdata(kHelloExampleComAddrV4, recordAnswer));
Hungming Chenbb90ab32019-10-28 18:20:31 +08004085 header.answers.push_back(std::move(recordAnswer));
4086
4087 // Authority section.
4088 test::DNSRecord recordAuthority{
4089 .name = {.name = kHelloExampleCom},
4090 .rtype = ns_type::ns_t_ns,
4091 .rclass = ns_c_in,
4092 .ttl = 0, // no cache
4093 };
4094 EXPECT_TRUE(test::DNSResponder::fillRdata("ns1.example.com.", recordAuthority));
4095 header.authorities.push_back(std::move(recordAuthority));
4096
4097 // Additional section.
4098 test::DNSRecord recordAdditional{
4099 .name = {.name = "ns1.example.com."},
4100 .rtype = ns_type::ns_t_a,
4101 .rclass = ns_c_in,
4102 .ttl = 0, // no cache
4103 };
4104 EXPECT_TRUE(test::DNSResponder::fillRdata("5.6.7.8", recordAdditional));
4105 header.additionals.push_back(std::move(recordAdditional));
4106
4107 // Start DNS server.
4108 test::DNSResponder dns(test::DNSResponder::MappingType::DNS_HEADER);
4109 dns.addMappingDnsHeader(kHelloExampleCom, ns_type::ns_t_a, header);
4110 ASSERT_TRUE(dns.startServer());
4111 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4112 dns.clearQueries();
4113
4114 // Expect that get the address and the resolver doesn't crash.
Hungming Chen63779052019-10-30 15:06:13 +08004115 VerifyQueryHelloExampleComV4(dns, calltype);
4116}
4117
4118TEST_P(ResolverParameterizedTest, MessageCompression) {
4119 const auto& calltype = GetParam();
4120
4121 // The response with compressed domain name by a pointer. See RFC 1035 section 4.1.4.
4122 //
4123 // Ignoring the other fields of the message, the domain name of question section and answer
4124 // section are presented as:
4125 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4126 // 12 | 5 | h |
4127 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4128 // 14 | e | l |
4129 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4130 // 16 | l | o |
4131 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4132 // 18 | 7 | e |
4133 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4134 // 20 | x | a |
4135 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4136 // 22 | m | p |
4137 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4138 // 24 | l | e |
4139 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4140 // 26 | 3 | c |
4141 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4142 // 28 | o | m |
4143 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4144 // 30 | 0 | ... |
4145 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4146 //
4147 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4148 // 35 | 1 1| 12 |
4149 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4150 const std::vector<uint8_t> kResponseAPointer = {
4151 /* Header */
4152 0x00, 0x00, /* Transaction ID: 0x0000 */
4153 0x81, 0x80, /* Flags: qr rd ra */
4154 0x00, 0x01, /* Questions: 1 */
4155 0x00, 0x01, /* Answer RRs: 1 */
4156 0x00, 0x00, /* Authority RRs: 0 */
4157 0x00, 0x00, /* Additional RRs: 0 */
4158 /* Queries */
4159 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
4160 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name: hello.example.com */
4161 0x00, 0x01, /* Type: A */
4162 0x00, 0x01, /* Class: IN */
4163 /* Answers */
4164 0xc0, 0x0c, /* Name: hello.example.com (a pointer) */
4165 0x00, 0x01, /* Type: A */
4166 0x00, 0x01, /* Class: IN */
4167 0x00, 0x00, 0x00, 0x00, /* Time to live: 0 */
4168 0x00, 0x04, /* Data length: 4 */
4169 0x01, 0x02, 0x03, 0x04 /* Address: 1.2.3.4 */
4170 };
4171
4172 // The response with compressed domain name by a sequence of labels ending with a pointer. See
4173 // RFC 1035 section 4.1.4.
4174 //
4175 // Ignoring the other fields of the message, the domain name of question section and answer
4176 // section are presented as:
4177 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4178 // 12 | 5 | h |
4179 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4180 // 14 | e | l |
4181 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4182 // 16 | l | o |
4183 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4184 // 18 | 7 | e |
4185 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4186 // 20 | x | a |
4187 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4188 // 22 | m | p |
4189 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4190 // 24 | l | e |
4191 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4192 // 26 | 3 | c |
4193 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4194 // 28 | o | m |
4195 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4196 // 30 | 0 | ... |
4197 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4198 //
4199 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4200 // 35 | 5 | h |
4201 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4202 // 37 | e | l |
4203 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4204 // 39 | l | o |
4205 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4206 // 41 | 1 1| 18 |
4207 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4208 const std::vector<uint8_t> kResponseLabelEndingWithAPointer = {
4209 /* Header */
4210 0x00, 0x00, /* Transaction ID: 0x0000 */
4211 0x81, 0x80, /* Flags: qr rd ra */
4212 0x00, 0x01, /* Questions: 1 */
4213 0x00, 0x01, /* Answer RRs: 1 */
4214 0x00, 0x00, /* Authority RRs: 0 */
4215 0x00, 0x00, /* Additional RRs: 0 */
4216 /* Queries */
4217 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
4218 0x03, 0x63, 0x6f, 0x6d, 0x00, /* Name: hello.example.com */
4219 0x00, 0x01, /* Type: A */
4220 0x00, 0x01, /* Class: IN */
4221 /* Answers */
4222 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xc0,
4223 0x12, /* Name: hello.example.com (a label ending with a pointer) */
4224 0x00, 0x01, /* Type: A */
4225 0x00, 0x01, /* Class: IN */
4226 0x00, 0x00, 0x00, 0x00, /* Time to live: 0 */
4227 0x00, 0x04, /* Data length: 4 */
4228 0x01, 0x02, 0x03, 0x04 /* Address: 1.2.3.4 */
4229 };
4230
4231 for (const auto& response : {kResponseAPointer, kResponseLabelEndingWithAPointer}) {
4232 SCOPED_TRACE(StringPrintf("Hex dump: %s", toHex(makeSlice(response)).c_str()));
4233
4234 test::DNSResponder dns(test::DNSResponder::MappingType::BINARY_PACKET);
4235 dns.addMappingBinaryPacket(kHelloExampleComQueryV4, response);
4236 StartDns(dns, {});
4237 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4238
4239 // Expect no cache because the TTL of testing responses are 0.
4240 VerifyQueryHelloExampleComV4(dns, calltype);
Hungming Chenbb90ab32019-10-28 18:20:31 +08004241 }
Mike Yu40e67072019-10-09 21:14:09 +08004242}
Hungming Chen22617fd2019-12-06 12:15:45 +08004243
4244TEST_P(ResolverParameterizedTest, TruncatedResponse) {
4245 const auto& calltype = GetParam();
4246
Hungming Chen22617fd2019-12-06 12:15:45 +08004247 test::DNSResponder dns;
Ken Chen99344882020-01-01 14:59:38 +08004248 StartDns(dns, kLargeCnameChainRecords);
Hungming Chen22617fd2019-12-06 12:15:45 +08004249 ASSERT_TRUE(mDnsClient.SetResolversForNetwork());
4250
4251 // Expect UDP response is truncated. The resolver retries over TCP. See RFC 1035 section 4.2.1.
4252 VerifyQueryHelloExampleComV4(dns, calltype, false);
4253 EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_UDP, kHelloExampleCom));
4254 EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom));
4255}