1 /*
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  *
10  * Unless requied by applicable law or agreed to in writing, software
11  * 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 
18 #include <arpa/inet.h>
19 #include <errno.h>
20 #include <netdb.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 
26 #include <cutils/sockets.h>
27 #include <android-base/stringprintf.h>
28 #include <private/android_filesystem_config.h>
29 
30 #include <algorithm>
31 #include <chrono>
32 #include <iterator>
33 #include <numeric>
34 #include <thread>
35 
36 #define LOG_TAG "netd_test"
37 // TODO: make this dynamic and stop depending on implementation details.
38 #define TEST_OEM_NETWORK "oem29"
39 #define TEST_NETID 30
40 
41 #include "NetdClient.h"
42 
43 #include <gtest/gtest.h>
44 
45 #include <utils/Log.h>
46 
47 #include "dns_responder.h"
48 #include "dns_responder_client.h"
49 #include "resolv_params.h"
50 #include "ResolverStats.h"
51 
52 #include "android/net/INetd.h"
53 #include "android/net/metrics/INetdEventListener.h"
54 #include "binder/IServiceManager.h"
55 
56 using android::base::StringPrintf;
57 using android::base::StringAppendF;
58 using android::net::ResolverStats;
59 using android::net::metrics::INetdEventListener;
60 
61 // Emulates the behavior of UnorderedElementsAreArray, which currently cannot be used.
62 // TODO: Use UnorderedElementsAreArray, which depends on being able to compile libgmock_host,
63 // if that is not possible, improve this hacky algorithm, which is O(n**2)
64 template <class A, class B>
UnorderedCompareArray(const A & a,const B & b)65 bool UnorderedCompareArray(const A& a, const B& b) {
66     if (a.size() != b.size()) return false;
67     for (const auto& a_elem : a) {
68         size_t a_count = 0;
69         for (const auto& a_elem2 : a) {
70             if (a_elem == a_elem2) {
71                 ++a_count;
72             }
73         }
74         size_t b_count = 0;
75         for (const auto& b_elem : b) {
76             if (a_elem == b_elem) ++b_count;
77         }
78         if (a_count != b_count) return false;
79     }
80     return true;
81 }
82 
83 class AddrInfo {
84   public:
AddrInfo()85     AddrInfo() : ai_(nullptr), error_(0) {}
86 
AddrInfo(const char * node,const char * service,const addrinfo & hints)87     AddrInfo(const char* node, const char* service, const addrinfo& hints) : ai_(nullptr) {
88         init(node, service, hints);
89     }
90 
AddrInfo(const char * node,const char * service)91     AddrInfo(const char* node, const char* service) : ai_(nullptr) {
92         init(node, service);
93     }
94 
~AddrInfo()95     ~AddrInfo() { clear(); }
96 
init(const char * node,const char * service,const addrinfo & hints)97     int init(const char* node, const char* service, const addrinfo& hints) {
98         clear();
99         error_ = getaddrinfo(node, service, &hints, &ai_);
100         return error_;
101     }
102 
init(const char * node,const char * service)103     int init(const char* node, const char* service) {
104         clear();
105         error_ = getaddrinfo(node, service, nullptr, &ai_);
106         return error_;
107     }
108 
clear()109     void clear() {
110         if (ai_ != nullptr) {
111             freeaddrinfo(ai_);
112             ai_ = nullptr;
113             error_ = 0;
114         }
115     }
116 
operator *() const117     const addrinfo& operator*() const { return *ai_; }
get() const118     const addrinfo* get() const { return ai_; }
operator &() const119     const addrinfo* operator&() const { return ai_; }
error() const120     int error() const { return error_; }
121 
122   private:
123     addrinfo* ai_;
124     int error_;
125 };
126 
127 class ResolverTest : public ::testing::Test, public DnsResponderClient {
128 private:
129     int mOriginalMetricsLevel;
130 
131 protected:
SetUp()132     virtual void SetUp() {
133         // Ensure resolutions go via proxy.
134         DnsResponderClient::SetUp();
135 
136         // If DNS reporting is off: turn it on so we run through everything.
137         auto rv = mNetdSrv->getMetricsReportingLevel(&mOriginalMetricsLevel);
138         ASSERT_TRUE(rv.isOk());
139         if (mOriginalMetricsLevel != INetdEventListener::REPORTING_LEVEL_FULL) {
140             rv = mNetdSrv->setMetricsReportingLevel(INetdEventListener::REPORTING_LEVEL_FULL);
141             ASSERT_TRUE(rv.isOk());
142         }
143     }
144 
TearDown()145     virtual void TearDown() {
146         if (mOriginalMetricsLevel != INetdEventListener::REPORTING_LEVEL_FULL) {
147             auto rv = mNetdSrv->setMetricsReportingLevel(mOriginalMetricsLevel);
148             ASSERT_TRUE(rv.isOk());
149         }
150 
151         DnsResponderClient::TearDown();
152     }
153 
GetResolverInfo(std::vector<std::string> * servers,std::vector<std::string> * domains,__res_params * params,std::vector<ResolverStats> * stats)154     bool GetResolverInfo(std::vector<std::string>* servers, std::vector<std::string>* domains,
155             __res_params* params, std::vector<ResolverStats>* stats) {
156         using android::net::INetd;
157         std::vector<int32_t> params32;
158         std::vector<int32_t> stats32;
159         auto rv = mNetdSrv->getResolverInfo(TEST_NETID, servers, domains, &params32, &stats32);
160         if (!rv.isOk() || params32.size() != INetd::RESOLVER_PARAMS_COUNT) {
161             return false;
162         }
163         *params = __res_params {
164             .sample_validity = static_cast<uint16_t>(
165                     params32[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY]),
166             .success_threshold = static_cast<uint8_t>(
167                     params32[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD]),
168             .min_samples = static_cast<uint8_t>(
169                     params32[INetd::RESOLVER_PARAMS_MIN_SAMPLES]),
170             .max_samples = static_cast<uint8_t>(
171                     params32[INetd::RESOLVER_PARAMS_MAX_SAMPLES])
172         };
173         return ResolverStats::decodeAll(stats32, stats);
174     }
175 
ToString(const hostent * he) const176     std::string ToString(const hostent* he) const {
177         if (he == nullptr) return "<null>";
178         char buffer[INET6_ADDRSTRLEN];
179         if (!inet_ntop(he->h_addrtype, he->h_addr_list[0], buffer, sizeof(buffer))) {
180             return "<invalid>";
181         }
182         return buffer;
183     }
184 
ToString(const addrinfo * ai) const185     std::string ToString(const addrinfo* ai) const {
186         if (!ai)
187             return "<null>";
188         for (const auto* aip = ai ; aip != nullptr ; aip = aip->ai_next) {
189             char host[NI_MAXHOST];
190             int rv = getnameinfo(aip->ai_addr, aip->ai_addrlen, host, sizeof(host), nullptr, 0,
191                     NI_NUMERICHOST);
192             if (rv != 0)
193                 return gai_strerror(rv);
194             return host;
195         }
196         return "<invalid>";
197     }
198 
GetNumQueries(const test::DNSResponder & dns,const char * name) const199     size_t GetNumQueries(const test::DNSResponder& dns, const char* name) const {
200         auto queries = dns.queries();
201         size_t found = 0;
202         for (const auto& p : queries) {
203             if (p.first == name) {
204                 ++found;
205             }
206         }
207         return found;
208     }
209 
GetNumQueriesForType(const test::DNSResponder & dns,ns_type type,const char * name) const210     size_t GetNumQueriesForType(const test::DNSResponder& dns, ns_type type,
211             const char* name) const {
212         auto queries = dns.queries();
213         size_t found = 0;
214         for (const auto& p : queries) {
215             if (p.second == type && p.first == name) {
216                 ++found;
217             }
218         }
219         return found;
220     }
221 
RunGetAddrInfoStressTest_Binder(unsigned num_hosts,unsigned num_threads,unsigned num_queries)222     void RunGetAddrInfoStressTest_Binder(unsigned num_hosts, unsigned num_threads,
223             unsigned num_queries) {
224         std::vector<std::string> domains = { "example.com" };
225         std::vector<std::unique_ptr<test::DNSResponder>> dns;
226         std::vector<std::string> servers;
227         std::vector<DnsResponderClient::Mapping> mappings;
228         ASSERT_NO_FATAL_FAILURE(SetupMappings(num_hosts, domains, &mappings));
229         ASSERT_NO_FATAL_FAILURE(SetupDNSServers(MAXNS, mappings, &dns, &servers));
230 
231         ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
232 
233         auto t0 = std::chrono::steady_clock::now();
234         std::vector<std::thread> threads(num_threads);
235         for (std::thread& thread : threads) {
236            thread = std::thread([this, &servers, &dns, &mappings, num_queries]() {
237                 for (unsigned i = 0 ; i < num_queries ; ++i) {
238                     uint32_t ofs = arc4random_uniform(mappings.size());
239                     auto& mapping = mappings[ofs];
240                     addrinfo* result = nullptr;
241                     int rv = getaddrinfo(mapping.host.c_str(), nullptr, nullptr, &result);
242                     EXPECT_EQ(0, rv) << "error [" << rv << "] " << gai_strerror(rv);
243                     if (rv == 0) {
244                         std::string result_str = ToString(result);
245                         EXPECT_TRUE(result_str == mapping.ip4 || result_str == mapping.ip6)
246                             << "result='" << result_str << "', ip4='" << mapping.ip4
247                             << "', ip6='" << mapping.ip6;
248                     }
249                     if (result) {
250                         freeaddrinfo(result);
251                         result = nullptr;
252                     }
253                 }
254             });
255         }
256 
257         for (std::thread& thread : threads) {
258             thread.join();
259         }
260         auto t1 = std::chrono::steady_clock::now();
261         ALOGI("%u hosts, %u threads, %u queries, %Es", num_hosts, num_threads, num_queries,
262                 std::chrono::duration<double>(t1 - t0).count());
263         ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
264     }
265 
266     const std::vector<std::string> mDefaultSearchDomains = { "example.com" };
267     // <sample validity in s> <success threshold in percent> <min samples> <max samples>
268     const std::string mDefaultParams = "300 25 8 8";
269     const std::vector<int> mDefaultParams_Binder = { 300, 25, 8, 8 };
270 };
271 
TEST_F(ResolverTest,GetHostByName)272 TEST_F(ResolverTest, GetHostByName) {
273     const char* listen_addr = "127.0.0.3";
274     const char* listen_srv = "53";
275     const char* host_name = "hello.example.com.";
276     const char *nonexistent_host_name = "nonexistent.example.com.";
277     test::DNSResponder dns(listen_addr, listen_srv, 250, ns_rcode::ns_r_servfail, 1.0);
278     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.3");
279     ASSERT_TRUE(dns.startServer());
280     std::vector<std::string> servers = { listen_addr };
281     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
282 
283     const hostent* result;
284 
285     dns.clearQueries();
286     result = gethostbyname("nonexistent");
287     EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, nonexistent_host_name));
288     ASSERT_TRUE(result == nullptr);
289     ASSERT_EQ(HOST_NOT_FOUND, h_errno);
290 
291     dns.clearQueries();
292     result = gethostbyname("hello");
293     EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
294     ASSERT_FALSE(result == nullptr);
295     ASSERT_EQ(4, result->h_length);
296     ASSERT_FALSE(result->h_addr_list[0] == nullptr);
297     EXPECT_EQ("1.2.3.3", ToString(result));
298     EXPECT_TRUE(result->h_addr_list[1] == nullptr);
299 
300     dns.stopServer();
301 }
302 
TEST_F(ResolverTest,TestBinderSerialization)303 TEST_F(ResolverTest, TestBinderSerialization) {
304     using android::net::INetd;
305     std::vector<int> params_offsets = {
306         INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY,
307         INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD,
308         INetd::RESOLVER_PARAMS_MIN_SAMPLES,
309         INetd::RESOLVER_PARAMS_MAX_SAMPLES
310     };
311     int size = static_cast<int>(params_offsets.size());
312     EXPECT_EQ(size, INetd::RESOLVER_PARAMS_COUNT);
313     std::sort(params_offsets.begin(), params_offsets.end());
314     for (int i = 0 ; i < size ; ++i) {
315         EXPECT_EQ(params_offsets[i], i);
316     }
317 }
318 
TEST_F(ResolverTest,GetHostByName_Binder)319 TEST_F(ResolverTest, GetHostByName_Binder) {
320     using android::net::INetd;
321 
322     std::vector<std::string> domains = { "example.com" };
323     std::vector<std::unique_ptr<test::DNSResponder>> dns;
324     std::vector<std::string> servers;
325     std::vector<Mapping> mappings;
326     ASSERT_NO_FATAL_FAILURE(SetupMappings(1, domains, &mappings));
327     ASSERT_NO_FATAL_FAILURE(SetupDNSServers(4, mappings, &dns, &servers));
328     ASSERT_EQ(1U, mappings.size());
329     const Mapping& mapping = mappings[0];
330 
331     ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
332 
333     const hostent* result = gethostbyname(mapping.host.c_str());
334     size_t total_queries = std::accumulate(dns.begin(), dns.end(), 0,
335             [this, &mapping](size_t total, auto& d) {
336                 return total + GetNumQueriesForType(*d, ns_type::ns_t_a, mapping.entry.c_str());
337             });
338 
339     EXPECT_LE(1U, total_queries);
340     ASSERT_FALSE(result == nullptr);
341     ASSERT_EQ(4, result->h_length);
342     ASSERT_FALSE(result->h_addr_list[0] == nullptr);
343     EXPECT_EQ(mapping.ip4, ToString(result));
344     EXPECT_TRUE(result->h_addr_list[1] == nullptr);
345 
346     std::vector<std::string> res_servers;
347     std::vector<std::string> res_domains;
348     __res_params res_params;
349     std::vector<ResolverStats> res_stats;
350     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_params, &res_stats));
351     EXPECT_EQ(servers.size(), res_servers.size());
352     EXPECT_EQ(domains.size(), res_domains.size());
353     ASSERT_EQ(INetd::RESOLVER_PARAMS_COUNT, mDefaultParams_Binder.size());
354     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY],
355             res_params.sample_validity);
356     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
357             res_params.success_threshold);
358     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
359     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
360     EXPECT_EQ(servers.size(), res_stats.size());
361 
362     EXPECT_TRUE(UnorderedCompareArray(res_servers, servers));
363     EXPECT_TRUE(UnorderedCompareArray(res_domains, domains));
364 
365     ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
366 }
367 
TEST_F(ResolverTest,GetAddrInfo)368 TEST_F(ResolverTest, GetAddrInfo) {
369     addrinfo* result = nullptr;
370 
371     const char* listen_addr = "127.0.0.4";
372     const char* listen_addr2 = "127.0.0.5";
373     const char* listen_srv = "53";
374     const char* host_name = "howdy.example.com.";
375     test::DNSResponder dns(listen_addr, listen_srv, 250,
376                            ns_rcode::ns_r_servfail, 1.0);
377     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.4");
378     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
379     ASSERT_TRUE(dns.startServer());
380 
381     test::DNSResponder dns2(listen_addr2, listen_srv, 250,
382                             ns_rcode::ns_r_servfail, 1.0);
383     dns2.addMapping(host_name, ns_type::ns_t_a, "1.2.3.4");
384     dns2.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
385     ASSERT_TRUE(dns2.startServer());
386 
387 
388     std::vector<std::string> servers = { listen_addr };
389     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
390     dns.clearQueries();
391     dns2.clearQueries();
392 
393     EXPECT_EQ(0, getaddrinfo("howdy", nullptr, nullptr, &result));
394     size_t found = GetNumQueries(dns, host_name);
395     EXPECT_LE(1U, found);
396     // Could be A or AAAA
397     std::string result_str = ToString(result);
398     EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
399         << ", result_str='" << result_str << "'";
400     // TODO: Use ScopedAddrinfo or similar once it is available in a common header file.
401     if (result) {
402         freeaddrinfo(result);
403         result = nullptr;
404     }
405 
406     // Verify that the name is cached.
407     size_t old_found = found;
408     EXPECT_EQ(0, getaddrinfo("howdy", nullptr, nullptr, &result));
409     found = GetNumQueries(dns, host_name);
410     EXPECT_LE(1U, found);
411     EXPECT_EQ(old_found, found);
412     result_str = ToString(result);
413     EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
414         << result_str;
415     if (result) {
416         freeaddrinfo(result);
417         result = nullptr;
418     }
419 
420     // Change the DNS resolver, ensure that queries are still cached.
421     servers = { listen_addr2 };
422     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
423     dns.clearQueries();
424     dns2.clearQueries();
425 
426     EXPECT_EQ(0, getaddrinfo("howdy", nullptr, nullptr, &result));
427     found = GetNumQueries(dns, host_name);
428     size_t found2 = GetNumQueries(dns2, host_name);
429     EXPECT_EQ(0U, found);
430     EXPECT_LE(0U, found2);
431 
432     // Could be A or AAAA
433     result_str = ToString(result);
434     EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
435         << ", result_str='" << result_str << "'";
436     if (result) {
437         freeaddrinfo(result);
438         result = nullptr;
439     }
440 
441     dns.stopServer();
442     dns2.stopServer();
443 }
444 
TEST_F(ResolverTest,GetAddrInfoV4)445 TEST_F(ResolverTest, GetAddrInfoV4) {
446     addrinfo* result = nullptr;
447 
448     const char* listen_addr = "127.0.0.5";
449     const char* listen_srv = "53";
450     const char* host_name = "hola.example.com.";
451     test::DNSResponder dns(listen_addr, listen_srv, 250,
452                            ns_rcode::ns_r_servfail, 1.0);
453     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.5");
454     ASSERT_TRUE(dns.startServer());
455     std::vector<std::string> servers = { listen_addr };
456     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
457 
458     addrinfo hints;
459     memset(&hints, 0, sizeof(hints));
460     hints.ai_family = AF_INET;
461     EXPECT_EQ(0, getaddrinfo("hola", nullptr, &hints, &result));
462     EXPECT_EQ(1U, GetNumQueries(dns, host_name));
463     EXPECT_EQ("1.2.3.5", ToString(result));
464     if (result) {
465         freeaddrinfo(result);
466         result = nullptr;
467     }
468 }
469 
TEST_F(ResolverTest,MultidomainResolution)470 TEST_F(ResolverTest, MultidomainResolution) {
471     std::vector<std::string> searchDomains = { "example1.com", "example2.com", "example3.com" };
472     const char* listen_addr = "127.0.0.6";
473     const char* listen_srv = "53";
474     const char* host_name = "nihao.example2.com.";
475     test::DNSResponder dns(listen_addr, listen_srv, 250,
476                            ns_rcode::ns_r_servfail, 1.0);
477     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.3");
478     ASSERT_TRUE(dns.startServer());
479     std::vector<std::string> servers = { listen_addr };
480     ASSERT_TRUE(SetResolversForNetwork(searchDomains, servers, mDefaultParams));
481 
482     dns.clearQueries();
483     const hostent* result = gethostbyname("nihao");
484     EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
485     ASSERT_FALSE(result == nullptr);
486     ASSERT_EQ(4, result->h_length);
487     ASSERT_FALSE(result->h_addr_list[0] == nullptr);
488     EXPECT_EQ("1.2.3.3", ToString(result));
489     EXPECT_TRUE(result->h_addr_list[1] == nullptr);
490     dns.stopServer();
491 }
492 
TEST_F(ResolverTest,GetAddrInfoV6_failing)493 TEST_F(ResolverTest, GetAddrInfoV6_failing) {
494     addrinfo* result = nullptr;
495 
496     const char* listen_addr0 = "127.0.0.7";
497     const char* listen_addr1 = "127.0.0.8";
498     const char* listen_srv = "53";
499     const char* host_name = "ohayou.example.com.";
500     test::DNSResponder dns0(listen_addr0, listen_srv, 250,
501                             ns_rcode::ns_r_servfail, 0.0);
502     test::DNSResponder dns1(listen_addr1, listen_srv, 250,
503                             ns_rcode::ns_r_servfail, 1.0);
504     dns0.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::5");
505     dns1.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::6");
506     ASSERT_TRUE(dns0.startServer());
507     ASSERT_TRUE(dns1.startServer());
508     std::vector<std::string> servers = { listen_addr0, listen_addr1 };
509     // <sample validity in s> <success threshold in percent> <min samples> <max samples>
510     unsigned sample_validity = 300;
511     int success_threshold = 25;
512     int sample_count = 8;
513     std::string params = StringPrintf("%u %d %d %d", sample_validity, success_threshold,
514             sample_count, sample_count);
515     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, params));
516 
517     // Repeatedly perform resolutions for non-existing domains until MAXNSSAMPLES resolutions have
518     // reached the dns0, which is set to fail. No more requests should then arrive at that server
519     // for the next sample_lifetime seconds.
520     // TODO: This approach is implementation-dependent, change once metrics reporting is available.
521     addrinfo hints;
522     memset(&hints, 0, sizeof(hints));
523     hints.ai_family = AF_INET6;
524     for (int i = 0 ; i < sample_count ; ++i) {
525         std::string domain = StringPrintf("nonexistent%d", i);
526         getaddrinfo(domain.c_str(), nullptr, &hints, &result);
527         if (result) {
528             freeaddrinfo(result);
529             result = nullptr;
530         }
531     }
532     // Due to 100% errors for all possible samples, the server should be ignored from now on and
533     // only the second one used for all following queries, until NSSAMPLE_VALIDITY is reached.
534     dns0.clearQueries();
535     dns1.clearQueries();
536     EXPECT_EQ(0, getaddrinfo("ohayou", nullptr, &hints, &result));
537     EXPECT_EQ(0U, GetNumQueries(dns0, host_name));
538     EXPECT_EQ(1U, GetNumQueries(dns1, host_name));
539     if (result) {
540         freeaddrinfo(result);
541         result = nullptr;
542     }
543 }
544 
TEST_F(ResolverTest,GetAddrInfoV6_concurrent)545 TEST_F(ResolverTest, GetAddrInfoV6_concurrent) {
546     const char* listen_addr0 = "127.0.0.9";
547     const char* listen_addr1 = "127.0.0.10";
548     const char* listen_addr2 = "127.0.0.11";
549     const char* listen_srv = "53";
550     const char* host_name = "konbanha.example.com.";
551     test::DNSResponder dns0(listen_addr0, listen_srv, 250,
552                             ns_rcode::ns_r_servfail, 1.0);
553     test::DNSResponder dns1(listen_addr1, listen_srv, 250,
554                             ns_rcode::ns_r_servfail, 1.0);
555     test::DNSResponder dns2(listen_addr2, listen_srv, 250,
556                             ns_rcode::ns_r_servfail, 1.0);
557     dns0.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::5");
558     dns1.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::6");
559     dns2.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::7");
560     ASSERT_TRUE(dns0.startServer());
561     ASSERT_TRUE(dns1.startServer());
562     ASSERT_TRUE(dns2.startServer());
563     const std::vector<std::string> servers = { listen_addr0, listen_addr1, listen_addr2 };
564     std::vector<std::thread> threads(10);
565     for (std::thread& thread : threads) {
566        thread = std::thread([this, &servers, &dns0, &dns1, &dns2]() {
567             unsigned delay = arc4random_uniform(1*1000*1000); // <= 1s
568             usleep(delay);
569             std::vector<std::string> serverSubset;
570             for (const auto& server : servers) {
571                 if (arc4random_uniform(2)) {
572                     serverSubset.push_back(server);
573                 }
574             }
575             if (serverSubset.empty()) serverSubset = servers;
576             ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, serverSubset,
577                     mDefaultParams));
578             addrinfo hints;
579             memset(&hints, 0, sizeof(hints));
580             hints.ai_family = AF_INET6;
581             addrinfo* result = nullptr;
582             int rv = getaddrinfo("konbanha", nullptr, &hints, &result);
583             EXPECT_EQ(0, rv) << "error [" << rv << "] " << gai_strerror(rv);
584             if (result) {
585                 freeaddrinfo(result);
586                 result = nullptr;
587             }
588         });
589     }
590     for (std::thread& thread : threads) {
591         thread.join();
592     }
593 }
594 
TEST_F(ResolverTest,GetAddrInfoStressTest_Binder_100)595 TEST_F(ResolverTest, GetAddrInfoStressTest_Binder_100) {
596     const unsigned num_hosts = 100;
597     const unsigned num_threads = 100;
598     const unsigned num_queries = 100;
599     ASSERT_NO_FATAL_FAILURE(RunGetAddrInfoStressTest_Binder(num_hosts, num_threads, num_queries));
600 }
601 
TEST_F(ResolverTest,GetAddrInfoStressTest_Binder_100000)602 TEST_F(ResolverTest, GetAddrInfoStressTest_Binder_100000) {
603     const unsigned num_hosts = 100000;
604     const unsigned num_threads = 100;
605     const unsigned num_queries = 100;
606     ASSERT_NO_FATAL_FAILURE(RunGetAddrInfoStressTest_Binder(num_hosts, num_threads, num_queries));
607 }
608 
TEST_F(ResolverTest,EmptySetup)609 TEST_F(ResolverTest, EmptySetup) {
610     using android::net::INetd;
611     std::vector<std::string> servers;
612     std::vector<std::string> domains;
613     ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
614     std::vector<std::string> res_servers;
615     std::vector<std::string> res_domains;
616     __res_params res_params;
617     std::vector<ResolverStats> res_stats;
618     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_params, &res_stats));
619     EXPECT_EQ(0U, res_servers.size());
620     EXPECT_EQ(0U, res_domains.size());
621     ASSERT_EQ(INetd::RESOLVER_PARAMS_COUNT, mDefaultParams_Binder.size());
622     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY],
623             res_params.sample_validity);
624     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
625             res_params.success_threshold);
626     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
627     EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
628 }
629 
TEST_F(ResolverTest,SearchPathChange)630 TEST_F(ResolverTest, SearchPathChange) {
631     addrinfo* result = nullptr;
632 
633     const char* listen_addr = "127.0.0.13";
634     const char* listen_srv = "53";
635     const char* host_name1 = "test13.domain1.org.";
636     const char* host_name2 = "test13.domain2.org.";
637     test::DNSResponder dns(listen_addr, listen_srv, 250,
638                            ns_rcode::ns_r_servfail, 1.0);
639     dns.addMapping(host_name1, ns_type::ns_t_aaaa, "2001:db8::13");
640     dns.addMapping(host_name2, ns_type::ns_t_aaaa, "2001:db8::1:13");
641     ASSERT_TRUE(dns.startServer());
642     std::vector<std::string> servers = { listen_addr };
643     std::vector<std::string> domains = { "domain1.org" };
644     ASSERT_TRUE(SetResolversForNetwork(domains, servers, mDefaultParams));
645 
646     addrinfo hints;
647     memset(&hints, 0, sizeof(hints));
648     hints.ai_family = AF_INET6;
649     EXPECT_EQ(0, getaddrinfo("test13", nullptr, &hints, &result));
650     EXPECT_EQ(1U, dns.queries().size());
651     EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
652     EXPECT_EQ("2001:db8::13", ToString(result));
653     if (result) freeaddrinfo(result);
654 
655     // Test that changing the domain search path on its own works.
656     domains = { "domain2.org" };
657     ASSERT_TRUE(SetResolversForNetwork(domains, servers, mDefaultParams));
658     dns.clearQueries();
659 
660     EXPECT_EQ(0, getaddrinfo("test13", nullptr, &hints, &result));
661     EXPECT_EQ(1U, dns.queries().size());
662     EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
663     EXPECT_EQ("2001:db8::1:13", ToString(result));
664     if (result) freeaddrinfo(result);
665 }
666 
TEST_F(ResolverTest,MaxServerPrune_Binder)667 TEST_F(ResolverTest, MaxServerPrune_Binder) {
668     using android::net::INetd;
669 
670     std::vector<std::string> domains = { "example.com" };
671     std::vector<std::unique_ptr<test::DNSResponder>> dns;
672     std::vector<std::string> servers;
673     std::vector<Mapping> mappings;
674     ASSERT_NO_FATAL_FAILURE(SetupMappings(1, domains, &mappings));
675     ASSERT_NO_FATAL_FAILURE(SetupDNSServers(MAXNS + 1, mappings, &dns, &servers));
676 
677     ASSERT_TRUE(SetResolversForNetwork(servers, domains,  mDefaultParams_Binder));
678 
679     std::vector<std::string> res_servers;
680     std::vector<std::string> res_domains;
681     __res_params res_params;
682     std::vector<ResolverStats> res_stats;
683     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_params, &res_stats));
684     EXPECT_EQ(static_cast<size_t>(MAXNS), res_servers.size());
685 
686     ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
687 }
688