tests/netd_test.cpp

   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 <testUtil.h>
  48
  49 #include "dns_responder.h"
  50 #include "resolv_params.h"
  51 #include "ResolverStats.h"
  52
  53 #include "android/net/INetd.h"
  54 #include "binder/IServiceManager.h"
  55
  56 using android::base::StringPrintf;
  57 using android::base::StringAppendF;
  58 using android::net::ResolverStats;
  59
  60 // Emulates the behavior of UnorderedElementsAreArray, which currently cannot be used.
  61 // TODO: Use UnorderedElementsAreArray, which depends on being able to compile libgmock_host,
  62 // if that is not possible, improve this hacky algorithm, which is O(n**2)
  63 template <class A, class B>
  64 bool UnorderedCompareArray(const A& a, const B& b) {
  65     if (a.size() != b.size()) return false;
  66     for (const auto& a_elem : a) {
  67         size_t a_count = 0;
  68         for (const auto& a_elem2 : a) {
  69             if (a_elem == a_elem2) {
  70                 ++a_count;
  71             }
  72         }
  73         size_t b_count = 0;
  74         for (const auto& b_elem : b) {
  75             if (a_elem == b_elem) ++b_count;
  76         }
  77         if (a_count != b_count) return false;
  78     }
  79     return true;
  80 }
  81
  82 // The only response code used in this test, see
  83 // frameworks/base/services/java/com/android/server/NetworkManagementService.java
  84 // for others.
  85 static constexpr int ResponseCodeOK = 200;
  86
  87 // Returns ResponseCode.
  88 int netdCommand(const char* sockname, const char* command) {
  89     int sock = socket_local_client(sockname,
  90                                    ANDROID_SOCKET_NAMESPACE_RESERVED,
  91                                    SOCK_STREAM);
  92     if (sock < 0) {
  93         perror("Error connecting");
  94         return -1;
  95     }
  96
  97     // FrameworkListener expects the whole command in one read.
  98     char buffer[256];
  99     int nwritten = snprintf(buffer, sizeof(buffer), "0 %s", command);
 100     if (write(sock, buffer, nwritten + 1) < 0) {
 101         perror("Error sending netd command");
 102         close(sock);
 103         return -1;
 104     }
 105
 106     int nread = read(sock, buffer, sizeof(buffer));
 107     if (nread < 0) {
 108         perror("Error reading response");
 109         close(sock);
 110         return -1;
 111     }
 112     close(sock);
 113     return atoi(buffer);
 114 }
 115
 116 bool expectNetdResult(int expected, const char* sockname, const char* format, ...) {
 117     char command[256];
 118     va_list args;
 119     va_start(args, format);
 120     vsnprintf(command, sizeof(command), format, args);
 121     va_end(args);
 122     int result = netdCommand(sockname, command);
 123     EXPECT_EQ(expected, result) << command;
 124     return (200 <= expected && expected < 300);
 125 }
 126
 127 class AddrInfo {
 128   public:
 129     AddrInfo() : ai_(nullptr), error_(0) {}
 130
 131     AddrInfo(const char* node, const char* service, const addrinfo& hints) : ai_(nullptr) {
 132         init(node, service, hints);
 133     }
 134
 135     AddrInfo(const char* node, const char* service) : ai_(nullptr) {
 136         init(node, service);
 137     }
 138
 139     ~AddrInfo() { clear(); }
 140
 141     int init(const char* node, const char* service, const addrinfo& hints) {
 142         clear();
 143         error_ = getaddrinfo(node, service, &hints, &ai_);
 144         return error_;
 145     }
 146
 147     int init(const char* node, const char* service) {
 148         clear();
 149         error_ = getaddrinfo(node, service, nullptr, &ai_);
 150         return error_;
 151     }
 152
 153     void clear() {
 154         if (ai_ != nullptr) {
 155             freeaddrinfo(ai_);
 156             ai_ = nullptr;
 157             error_ = 0;
 158         }
 159     }
 160
 161     const addrinfo& operator*() const { return *ai_; }
 162     const addrinfo* get() const { return ai_; }
 163     const addrinfo* operator&() const { return ai_; }
 164     int error() const { return error_; }
 165
 166   private:
 167     addrinfo* ai_;
 168     int error_;
 169 };
 170
 171 class ResolverTest : public ::testing::Test {
 172 protected:
 173     struct Mapping {
 174         std::string host;
 175         std::string entry;
 176         std::string ip4;
 177         std::string ip6;
 178     };
 179
 180     virtual void SetUp() {
 181         // Ensure resolutions go via proxy.
 182         setenv("ANDROID_DNS_MODE", "", 1);
 183         uid = getuid();
 184         pid = getpid();
 185         SetupOemNetwork();
 186
 187         // binder setup
 188         auto binder = android::defaultServiceManager()->getService(android::String16("netd"));
 189         ASSERT_TRUE(binder != nullptr);
 190         mNetdSrv = android::interface_cast<android::net::INetd>(binder);
 191     }
 192
 193     virtual void TearDown() {
 194         TearDownOemNetwork();
 195         netdCommand("netd", "network destroy " TEST_OEM_NETWORK);
 196     }
 197
 198     void SetupOemNetwork() {
 199         netdCommand("netd", "network destroy " TEST_OEM_NETWORK);
 200         if (expectNetdResult(ResponseCodeOK, "netd",
 201                              "network create %s", TEST_OEM_NETWORK)) {
 202             oemNetId = TEST_NETID;
 203         }
 204         setNetworkForProcess(oemNetId);
 205         ASSERT_EQ((unsigned) oemNetId, getNetworkForProcess());
 206     }
 207
 208     void SetupMappings(unsigned num_hosts, const std::vector<std::string>& domains,
 209             std::vector<Mapping>* mappings) const {
 210         mappings->resize(num_hosts * domains.size());
 211         auto mappings_it = mappings->begin();
 212         for (unsigned i = 0 ; i < num_hosts ; ++i) {
 213             for (const auto& domain : domains) {
 214                 ASSERT_TRUE(mappings_it != mappings->end());
 215                 mappings_it->host = StringPrintf("host%u", i);
 216                 mappings_it->entry = StringPrintf("%s.%s.", mappings_it->host.c_str(),
 217                         domain.c_str());
 218                 mappings_it->ip4 = StringPrintf("192.0.2.%u", i%253 + 1);
 219                 mappings_it->ip6 = StringPrintf("2001:db8::%x", i%65534 + 1);
 220                 ++mappings_it;
 221             }
 222         }
 223     }
 224
 225     void SetupDNSServers(unsigned num_servers, const std::vector<Mapping>& mappings,
 226             std::vector<std::unique_ptr<test::DNSResponder>>* dns,
 227             std::vector<std::string>* servers) const {
 228         ASSERT_TRUE(num_servers != 0 && num_servers < 100);
 229         const char* listen_srv = "53";
 230         dns->resize(num_servers);
 231         servers->resize(num_servers);
 232         for (unsigned i = 0 ; i < num_servers ; ++i) {
 233             auto& server = (*servers)[i];
 234             auto& d = (*dns)[i];
 235             server = StringPrintf("127.0.0.%u", i + 100);
 236             d = std::make_unique<test::DNSResponder>(server, listen_srv, 250,
 237                     ns_rcode::ns_r_servfail, 1.0);
 238             ASSERT_TRUE(d.get() != nullptr);
 239             for (const auto& mapping : mappings) {
 240                 d->addMapping(mapping.entry.c_str(), ns_type::ns_t_a, mapping.ip4.c_str());
 241                 d->addMapping(mapping.entry.c_str(), ns_type::ns_t_aaaa, mapping.ip6.c_str());
 242             }
 243             ASSERT_TRUE(d->startServer());
 244         }
 245     }
 246
 247     void ShutdownDNSServers(std::vector<std::unique_ptr<test::DNSResponder>>* dns) const {
 248         for (const auto& d : *dns) {
 249             ASSERT_TRUE(d.get() != nullptr);
 250             d->stopServer();
 251         }
 252         dns->clear();
 253     }
 254
 255     void TearDownOemNetwork() {
 256         if (oemNetId != -1) {
 257             expectNetdResult(ResponseCodeOK, "netd",
 258                              "network destroy %s", TEST_OEM_NETWORK);
 259         }
 260     }
 261
 262     bool SetResolversForNetwork(const std::vector<std::string>& servers,
 263             const std::vector<std::string>& domains, const std::vector<int>& params) {
 264         auto rv = mNetdSrv->setResolverConfiguration(TEST_NETID, servers, domains, params);
 265         return rv.isOk();
 266     }
 267
 268     bool SetResolversForNetwork(const std::vector<std::string>& searchDomains,
 269             const std::vector<std::string>& servers, const std::string& params) {
 270         std::string cmd = StringPrintf("resolver setnetdns %d \"", oemNetId);
 271         if (!searchDomains.empty()) {
 272             cmd += searchDomains[0].c_str();
 273             for (size_t i = 1 ; i < searchDomains.size() ; ++i) {
 274                 cmd += " ";
 275                 cmd += searchDomains[i];
 276             }
 277         }
 278         cmd += "\"";
 279
 280         for (const auto& str : servers) {
 281             cmd += " ";
 282             cmd += str;
 283         }
 284
 285         if (!params.empty()) {
 286             cmd += " --params \"";
 287             cmd += params;
 288             cmd += "\"";
 289         }
 290
 291         int rv = netdCommand("netd", cmd.c_str());
 292         if (rv != ResponseCodeOK) {
 293             return false;
 294         }
 295         return true;
 296     }
 297
 298     bool GetResolverInfo(std::vector<std::string>* servers, std::vector<std::string>* domains,
 299             __res_params* params, std::vector<ResolverStats>* stats) {
 300         using android::net::INetd;
 301         std::vector<int32_t> params32;
 302         std::vector<int32_t> stats32;
 303         auto rv = mNetdSrv->getResolverInfo(TEST_NETID, servers, domains, &params32, &stats32);
 304         if (!rv.isOk() || params32.size() != INetd::RESOLVER_PARAMS_COUNT) {
 305             return false;
 306         }
 307         *params = __res_params {
 308             .sample_validity = static_cast<uint16_t>(
 309                     params32[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY]),
 310             .success_threshold = static_cast<uint8_t>(
 311                     params32[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD]),
 312             .min_samples = static_cast<uint8_t>(
 313                     params32[INetd::RESOLVER_PARAMS_MIN_SAMPLES]),
 314             .max_samples = static_cast<uint8_t>(
 315                     params32[INetd::RESOLVER_PARAMS_MAX_SAMPLES])
 316         };
 317         return ResolverStats::decodeAll(stats32, stats);
 318     }
 319
 320     std::string ToString(const hostent* he) const {
 321         if (he == nullptr) return "<null>";
 322         char buffer[INET6_ADDRSTRLEN];
 323         if (!inet_ntop(he->h_addrtype, he->h_addr_list[0], buffer, sizeof(buffer))) {
 324             return "<invalid>";
 325         }
 326         return buffer;
 327     }
 328
 329     std::string ToString(const addrinfo* ai) const {
 330         if (!ai)
 331             return "<null>";
 332         for (const auto* aip = ai ; aip != nullptr ; aip = aip->ai_next) {
 333             char host[NI_MAXHOST];
 334             int rv = getnameinfo(aip->ai_addr, aip->ai_addrlen, host, sizeof(host), nullptr, 0,
 335                     NI_NUMERICHOST);
 336             if (rv != 0)
 337                 return gai_strerror(rv);
 338             return host;
 339         }
 340         return "<invalid>";
 341     }
 342
 343     size_t GetNumQueries(const test::DNSResponder& dns, const char* name) const {
 344         auto queries = dns.queries();
 345         size_t found = 0;
 346         for (const auto& p : queries) {
 347             if (p.first == name) {
 348                 ++found;
 349             }
 350         }
 351         return found;
 352     }
 353
 354     size_t GetNumQueriesForType(const test::DNSResponder& dns, ns_type type,
 355             const char* name) const {
 356         auto queries = dns.queries();
 357         size_t found = 0;
 358         for (const auto& p : queries) {
 359             if (p.second == type && p.first == name) {
 360                 ++found;
 361             }
 362         }
 363         return found;
 364     }
 365
 366     void RunGetAddrInfoStressTest_Binder(unsigned num_hosts, unsigned num_threads,
 367             unsigned num_queries) {
 368         std::vector<std::string> domains = { "example.com" };
 369         std::vector<std::unique_ptr<test::DNSResponder>> dns;
 370         std::vector<std::string> servers;
 371         std::vector<Mapping> mappings;
 372         ASSERT_NO_FATAL_FAILURE(SetupMappings(num_hosts, domains, &mappings));
 373         ASSERT_NO_FATAL_FAILURE(SetupDNSServers(MAXNS, mappings, &dns, &servers));
 374
 375         std::vector<int> params = { 300, 25, 8, 8 };
 376         ASSERT_TRUE(SetResolversForNetwork(servers, domains, params));
 377
 378         auto t0 = std::chrono::steady_clock::now();
 379         std::vector<std::thread> threads(num_threads);
 380         for (std::thread& thread : threads) {
 381            thread = std::thread([this, &servers, &dns, &mappings, num_queries]() {
 382                 for (unsigned i = 0 ; i < num_queries ; ++i) {
 383                     uint32_t ofs = arc4random_uniform(mappings.size());
 384                     ASSERT_TRUE(ofs < mappings.size());
 385                     auto& mapping = mappings[i];
 386                     addrinfo* result = nullptr;
 387                     int rv = getaddrinfo(mapping.host.c_str(), nullptr, nullptr, &result);
 388                     EXPECT_EQ(0, rv) << "error [" << rv << "] " << gai_strerror(rv);
 389                     if (rv == 0) {
 390                         std::string result_str = ToString(result);
 391                         EXPECT_TRUE(result_str == mapping.ip4 || result_str == mapping.ip6)
 392                             << "result='" << result_str << "', ip4='" << mapping.ip4
 393                             << "', ip6='" << mapping.ip6;
 394                     }
 395                     if (result) {
 396                         freeaddrinfo(result);
 397                         result = nullptr;
 398                     }
 399                 }
 400             });
 401         }
 402
 403         for (std::thread& thread : threads) {
 404             thread.join();
 405         }
 406         auto t1 = std::chrono::steady_clock::now();
 407         ALOGI("%u hosts, %u threads, %u queries, %Es", num_hosts, num_threads, num_queries,
 408                 std::chrono::duration<double>(t1 - t0).count());
 409         ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
 410     }
 411
 412     int pid;
 413     int uid;
 414     int oemNetId = -1;
 415     android::sp<android::net::INetd> mNetdSrv = nullptr;
 416     const std::vector<std::string> mDefaultSearchDomains = { "example.com" };
 417     // <sample validity in s> <success threshold in percent> <min samples> <max samples>
 418     const std::string mDefaultParams = "300 25 8 8";
 419 };
 420
 421 TEST_F(ResolverTest, GetHostByName) {
 422     const char* listen_addr = "127.0.0.3";
 423     const char* listen_srv = "53";
 424     const char* host_name = "hello.example.com.";
 425     test::DNSResponder dns(listen_addr, listen_srv, 250, ns_rcode::ns_r_servfail, 1.0);
 426     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.3");
 427     ASSERT_TRUE(dns.startServer());
 428     std::vector<std::string> servers = { listen_addr };
 429     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
 430
 431     dns.clearQueries();
 432     const hostent* result = gethostbyname("hello");
 433     EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
 434     ASSERT_FALSE(result == nullptr);
 435     ASSERT_EQ(4, result->h_length);
 436     ASSERT_FALSE(result->h_addr_list[0] == nullptr);
 437     EXPECT_EQ("1.2.3.3", ToString(result));
 438     EXPECT_TRUE(result->h_addr_list[1] == nullptr);
 439     dns.stopServer();
 440 }
 441
 442 TEST_F(ResolverTest, TestBinderSerialization) {
 443     using android::net::INetd;
 444     std::vector<int> params_offsets = {
 445         INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY,
 446         INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD,
 447         INetd::RESOLVER_PARAMS_MIN_SAMPLES,
 448         INetd::RESOLVER_PARAMS_MAX_SAMPLES
 449     };
 450     int size = static_cast<int>(params_offsets.size());
 451     EXPECT_EQ(size, INetd::RESOLVER_PARAMS_COUNT);
 452     std::sort(params_offsets.begin(), params_offsets.end());
 453     for (int i = 0 ; i < size ; ++i) {
 454         EXPECT_EQ(params_offsets[i], i);
 455     }
 456 }
 457
 458 TEST_F(ResolverTest, GetHostByName_Binder) {
 459     using android::net::INetd;
 460
 461     std::vector<std::string> domains = { "example.com" };
 462     std::vector<std::unique_ptr<test::DNSResponder>> dns;
 463     std::vector<std::string> servers;
 464     std::vector<Mapping> mappings;
 465     ASSERT_NO_FATAL_FAILURE(SetupMappings(1, domains, &mappings));
 466     ASSERT_NO_FATAL_FAILURE(SetupDNSServers(4, mappings, &dns, &servers));
 467     ASSERT_EQ(1U, mappings.size());
 468     const Mapping& mapping = mappings[0];
 469
 470     std::vector<int> params = { 300, 25, 8, 8 };
 471     ASSERT_TRUE(SetResolversForNetwork(servers, domains, params));
 472
 473     const hostent* result = gethostbyname(mapping.host.c_str());
 474     size_t total_queries = std::accumulate(dns.begin(), dns.end(), 0,
 475             [this, &mapping](size_t total, auto& d) {
 476                 return total + GetNumQueriesForType(*d, ns_type::ns_t_a, mapping.entry.c_str());
 477             });
 478
 479     EXPECT_LE(1U, total_queries);
 480     ASSERT_FALSE(result == nullptr);
 481     ASSERT_EQ(4, result->h_length);
 482     ASSERT_FALSE(result->h_addr_list[0] == nullptr);
 483     EXPECT_EQ(mapping.ip4, ToString(result));
 484     EXPECT_TRUE(result->h_addr_list[1] == nullptr);
 485
 486     std::vector<std::string> res_servers;
 487     std::vector<std::string> res_domains;
 488     __res_params res_params;
 489     std::vector<ResolverStats> res_stats;
 490     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_params, &res_stats));
 491     EXPECT_EQ(servers.size(), res_servers.size());
 492     EXPECT_EQ(domains.size(), res_domains.size());
 493     ASSERT_EQ(INetd::RESOLVER_PARAMS_COUNT, params.size());
 494     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY], res_params.sample_validity);
 495     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD], res_params.success_threshold);
 496     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
 497     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
 498     EXPECT_EQ(servers.size(), res_stats.size());
 499
 500     EXPECT_TRUE(UnorderedCompareArray(res_servers, servers));
 501     EXPECT_TRUE(UnorderedCompareArray(res_domains, domains));
 502
 503     ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
 504 }
 505
 506 TEST_F(ResolverTest, GetAddrInfo) {
 507     addrinfo* result = nullptr;
 508
 509     const char* listen_addr = "127.0.0.4";
 510     const char* listen_addr2 = "127.0.0.5";
 511     const char* listen_srv = "53";
 512     const char* host_name = "howdy.example.com.";
 513     test::DNSResponder dns(listen_addr, listen_srv, 250,
 514                            ns_rcode::ns_r_servfail, 1.0);
 515     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.4");
 516     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
 517     ASSERT_TRUE(dns.startServer());
 518
 519     test::DNSResponder dns2(listen_addr2, listen_srv, 250,
 520                             ns_rcode::ns_r_servfail, 1.0);
 521     dns2.addMapping(host_name, ns_type::ns_t_a, "1.2.3.4");
 522     dns2.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
 523     ASSERT_TRUE(dns2.startServer());
 524
 525     for (size_t i = 0 ; i < 1000 ; ++i) {
 526         std::vector<std::string> servers = { listen_addr };
 527         ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
 528         dns.clearQueries();
 529         dns2.clearQueries();
 530
 531         EXPECT_EQ(0, getaddrinfo("howdy", nullptr, nullptr, &result));
 532         size_t found = GetNumQueries(dns, host_name);
 533         EXPECT_LE(1U, found);
 534         // Could be A or AAAA
 535         std::string result_str = ToString(result);
 536         EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
 537             << ", result_str='" << result_str << "'";
 538         // TODO: Use ScopedAddrinfo or similar once it is available in a common header file.
 539         if (result) {
 540             freeaddrinfo(result);
 541             result = nullptr;
 542         }
 543
 544         // Verify that the name is cached.
 545         size_t old_found = found;
 546         EXPECT_EQ(0, getaddrinfo("howdy", nullptr, nullptr, &result));
 547         found = GetNumQueries(dns, host_name);
 548         EXPECT_LE(1U, found);
 549         EXPECT_EQ(old_found, found);
 550         result_str = ToString(result);
 551         EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
 552             << result_str;
 553         if (result) {
 554             freeaddrinfo(result);
 555             result = nullptr;
 556         }
 557
 558         // Change the DNS resolver, ensure that queries are no longer cached.
 559         servers = { listen_addr2 };
 560         ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
 561         dns.clearQueries();
 562         dns2.clearQueries();
 563
 564         EXPECT_EQ(0, getaddrinfo("howdy", nullptr, nullptr, &result));
 565         found = GetNumQueries(dns, host_name);
 566         size_t found2 = GetNumQueries(dns2, host_name);
 567         EXPECT_EQ(0U, found);
 568         EXPECT_LE(1U, found2);
 569
 570         // Could be A or AAAA
 571         result_str = ToString(result);
 572         EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
 573             << ", result_str='" << result_str << "'";
 574         if (result) {
 575             freeaddrinfo(result);
 576             result = nullptr;
 577         }
 578     }
 579     dns.stopServer();
 580     dns2.stopServer();
 581 }
 582
 583 TEST_F(ResolverTest, GetAddrInfoV4) {
 584     addrinfo* result = nullptr;
 585
 586     const char* listen_addr = "127.0.0.5";
 587     const char* listen_srv = "53";
 588     const char* host_name = "hola.example.com.";
 589     test::DNSResponder dns(listen_addr, listen_srv, 250,
 590                            ns_rcode::ns_r_servfail, 1.0);
 591     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.5");
 592     ASSERT_TRUE(dns.startServer());
 593     std::vector<std::string> servers = { listen_addr };
 594     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, mDefaultParams));
 595
 596     addrinfo hints;
 597     memset(&hints, 0, sizeof(hints));
 598     hints.ai_family = AF_INET;
 599     EXPECT_EQ(0, getaddrinfo("hola", nullptr, &hints, &result));
 600     EXPECT_EQ(1U, GetNumQueries(dns, host_name));
 601     EXPECT_EQ("1.2.3.5", ToString(result));
 602     if (result) {
 603         freeaddrinfo(result);
 604         result = nullptr;
 605     }
 606 }
 607
 608 TEST_F(ResolverTest, MultidomainResolution) {
 609     std::vector<std::string> searchDomains = { "example1.com", "example2.com", "example3.com" };
 610     const char* listen_addr = "127.0.0.6";
 611     const char* listen_srv = "53";
 612     const char* host_name = "nihao.example2.com.";
 613     test::DNSResponder dns(listen_addr, listen_srv, 250,
 614                            ns_rcode::ns_r_servfail, 1.0);
 615     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.3");
 616     ASSERT_TRUE(dns.startServer());
 617     std::vector<std::string> servers = { listen_addr };
 618     ASSERT_TRUE(SetResolversForNetwork(searchDomains, servers, mDefaultParams));
 619
 620     dns.clearQueries();
 621     const hostent* result = gethostbyname("nihao");
 622     EXPECT_EQ(1U, GetNumQueriesForType(dns, ns_type::ns_t_a, host_name));
 623     ASSERT_FALSE(result == nullptr);
 624     ASSERT_EQ(4, result->h_length);
 625     ASSERT_FALSE(result->h_addr_list[0] == nullptr);
 626     EXPECT_EQ("1.2.3.3", ToString(result));
 627     EXPECT_TRUE(result->h_addr_list[1] == nullptr);
 628     dns.stopServer();
 629 }
 630
 631 TEST_F(ResolverTest, GetAddrInfoV6_failing) {
 632     addrinfo* result = nullptr;
 633
 634     const char* listen_addr0 = "127.0.0.7";
 635     const char* listen_addr1 = "127.0.0.8";
 636     const char* listen_srv = "53";
 637     const char* host_name = "ohayou.example.com.";
 638     test::DNSResponder dns0(listen_addr0, listen_srv, 250,
 639                             ns_rcode::ns_r_servfail, 0.0);
 640     test::DNSResponder dns1(listen_addr1, listen_srv, 250,
 641                             ns_rcode::ns_r_servfail, 1.0);
 642     dns0.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::5");
 643     dns1.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::6");
 644     ASSERT_TRUE(dns0.startServer());
 645     ASSERT_TRUE(dns1.startServer());
 646     std::vector<std::string> servers = { listen_addr0, listen_addr1 };
 647     // <sample validity in s> <success threshold in percent> <min samples> <max samples>
 648     unsigned sample_validity = 300;
 649     int success_threshold = 25;
 650     int sample_count = 8;
 651     std::string params = StringPrintf("%u %d %d %d", sample_validity, success_threshold,
 652             sample_count, sample_count);
 653     ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, servers, params));
 654
 655     // Repeatedly perform resolutions for non-existing domains until MAXNSSAMPLES resolutions have
 656     // reached the dns0, which is set to fail. No more requests should then arrive at that server
 657     // for the next sample_lifetime seconds.
 658     // TODO: This approach is implementation-dependent, change once metrics reporting is available.
 659     addrinfo hints;
 660     memset(&hints, 0, sizeof(hints));
 661     hints.ai_family = AF_INET6;
 662     for (int i = 0 ; i < sample_count ; ++i) {
 663         std::string domain = StringPrintf("nonexistent%d", i);
 664         getaddrinfo(domain.c_str(), nullptr, &hints, &result);
 665         if (result) {
 666             freeaddrinfo(result);
 667             result = nullptr;
 668         }
 669     }
 670     // Due to 100% errors for all possible samples, the server should be ignored from now on and
 671     // only the second one used for all following queries, until NSSAMPLE_VALIDITY is reached.
 672     dns0.clearQueries();
 673     dns1.clearQueries();
 674     EXPECT_EQ(0, getaddrinfo("ohayou", nullptr, &hints, &result));
 675     EXPECT_EQ(0U, GetNumQueries(dns0, host_name));
 676     EXPECT_EQ(1U, GetNumQueries(dns1, host_name));
 677     if (result) {
 678         freeaddrinfo(result);
 679         result = nullptr;
 680     }
 681 }
 682
 683 TEST_F(ResolverTest, GetAddrInfoV6_concurrent) {
 684     const char* listen_addr0 = "127.0.0.9";
 685     const char* listen_addr1 = "127.0.0.10";
 686     const char* listen_addr2 = "127.0.0.11";
 687     const char* listen_srv = "53";
 688     const char* host_name = "konbanha.example.com.";
 689     test::DNSResponder dns0(listen_addr0, listen_srv, 250,
 690                             ns_rcode::ns_r_servfail, 1.0);
 691     test::DNSResponder dns1(listen_addr1, listen_srv, 250,
 692                             ns_rcode::ns_r_servfail, 1.0);
 693     test::DNSResponder dns2(listen_addr2, listen_srv, 250,
 694                             ns_rcode::ns_r_servfail, 1.0);
 695     dns0.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::5");
 696     dns1.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::6");
 697     dns2.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::7");
 698     ASSERT_TRUE(dns0.startServer());
 699     ASSERT_TRUE(dns1.startServer());
 700     ASSERT_TRUE(dns2.startServer());
 701     const std::vector<std::string> servers = { listen_addr0, listen_addr1, listen_addr2 };
 702     std::vector<std::thread> threads(10);
 703     for (std::thread& thread : threads) {
 704        thread = std::thread([this, &servers, &dns0, &dns1, &dns2]() {
 705             unsigned delay = arc4random_uniform(1*1000*1000); // <= 1s
 706             usleep(delay);
 707             std::vector<std::string> serverSubset;
 708             for (const auto& server : servers) {
 709                 if (arc4random_uniform(2)) {
 710                     serverSubset.push_back(server);
 711                 }
 712             }
 713             if (serverSubset.empty()) serverSubset = servers;
 714             ASSERT_TRUE(SetResolversForNetwork(mDefaultSearchDomains, serverSubset,
 715                     mDefaultParams));
 716             addrinfo hints;
 717             memset(&hints, 0, sizeof(hints));
 718             hints.ai_family = AF_INET6;
 719             addrinfo* result = nullptr;
 720             int rv = getaddrinfo("konbanha", nullptr, &hints, &result);
 721             EXPECT_EQ(0, rv) << "error [" << rv << "] " << gai_strerror(rv);
 722             if (result) {
 723                 freeaddrinfo(result);
 724                 result = nullptr;
 725             }
 726         });
 727     }
 728     for (std::thread& thread : threads) {
 729         thread.join();
 730     }
 731 }
 732
 733 TEST_F(ResolverTest, GetAddrInfoStressTest_Binder_100) {
 734     const unsigned num_hosts = 100;
 735     const unsigned num_threads = 100;
 736     const unsigned num_queries = 100;
 737     ASSERT_NO_FATAL_FAILURE(RunGetAddrInfoStressTest_Binder(num_hosts, num_threads, num_queries));
 738 }
 739
 740 TEST_F(ResolverTest, GetAddrInfoStressTest_Binder_100000) {
 741     const unsigned num_hosts = 100000;
 742     const unsigned num_threads = 100;
 743     const unsigned num_queries = 100;
 744     ASSERT_NO_FATAL_FAILURE(RunGetAddrInfoStressTest_Binder(num_hosts, num_threads, num_queries));
 745 }
 746
 747 TEST_F(ResolverTest, EmptySetup) {
 748     using android::net::INetd;
 749     std::vector<std::string> servers;
 750     std::vector<std::string> domains;
 751     std::vector<int> params = { 300, 25, 8, 8 };
 752     ASSERT_TRUE(SetResolversForNetwork(servers, domains, params));
 753     std::vector<std::string> res_servers;
 754     std::vector<std::string> res_domains;
 755     __res_params res_params;
 756     std::vector<ResolverStats> res_stats;
 757     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_params, &res_stats));
 758     EXPECT_EQ(0U, res_servers.size());
 759     EXPECT_EQ(0U, res_domains.size());
 760     ASSERT_EQ(INetd::RESOLVER_PARAMS_COUNT, params.size());
 761     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY], res_params.sample_validity);
 762     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD], res_params.success_threshold);
 763     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
 764     EXPECT_EQ(params[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
 765 }
 766
 767 TEST_F(ResolverTest, SearchPathChange) {
 768     addrinfo* result = nullptr;
 769
 770     const char* listen_addr = "127.0.0.13";
 771     const char* listen_srv = "53";
 772     const char* host_name1 = "test13.domain1.org.";
 773     const char* host_name2 = "test13.domain2.org.";
 774     test::DNSResponder dns(listen_addr, listen_srv, 250,
 775                            ns_rcode::ns_r_servfail, 1.0);
 776     dns.addMapping(host_name1, ns_type::ns_t_aaaa, "2001:db8::13");
 777     dns.addMapping(host_name2, ns_type::ns_t_aaaa, "2001:db8::1:13");
 778     ASSERT_TRUE(dns.startServer());
 779     std::vector<std::string> servers = { listen_addr };
 780     std::vector<std::string> domains = { "domain1.org" };
 781     ASSERT_TRUE(SetResolversForNetwork(domains, servers, mDefaultParams));
 782
 783     addrinfo hints;
 784     memset(&hints, 0, sizeof(hints));
 785     hints.ai_family = AF_INET6;
 786     EXPECT_EQ(0, getaddrinfo("test13", nullptr, &hints, &result));
 787     EXPECT_EQ(1U, dns.queries().size());
 788     EXPECT_EQ(1U, GetNumQueries(dns, host_name1));
 789     EXPECT_EQ("2001:db8::13", ToString(result));
 790     if (result) freeaddrinfo(result);
 791
 792     // Test that changing the domain search path on its own works.
 793     domains = { "domain2.org" };
 794     ASSERT_TRUE(SetResolversForNetwork(domains, servers, mDefaultParams));
 795     dns.clearQueries();
 796
 797     EXPECT_EQ(0, getaddrinfo("test13", nullptr, &hints, &result));
 798     EXPECT_EQ(1U, dns.queries().size());
 799     EXPECT_EQ(1U, GetNumQueries(dns, host_name2));
 800     EXPECT_EQ("2001:db8::1:13", ToString(result));
 801     if (result) freeaddrinfo(result);
 802 }