Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7df62a92 authored by Mike Yu's avatar Mike Yu
Browse files

Test: Add ResolverParams Builder and use it 

- Change the type of kDefaultParams from vector to array. The tests
  are modified to pass a full list of params accordingly.
- Delete SetResolversWithTls(). Use SetResolversFromParcel() instead.
- Delete makeResolverParamsParcel().
- Replace kDefaultServers with kDefaultServer; replace kDefaultSearchDomain
  with kDefaultSearchDomains

Bug: 237766689
Test: atest
Test: atest netd_benchmark
Change-Id: I447ac6acda653653ce781abca2799f9d46d51d07
parent 65fda8b3

tests/dns_responder/dns_responder_client_ndk.cpp

+34 −53
Original line number Diff line number Diff line
@@ -32,6 +32,22 @@ using aidl::android::net::ResolverOptionsParcel; 
using aidl::android::net::ResolverParamsParcel;

using android::net::ResolverStats;



ResolverParams::Builder::Builder() {

    // Default resolver configuration for opportunistic mode.

    mParcel.netId = TEST_NETID;

    mParcel.sampleValiditySeconds = kDefaultParams[0];

    mParcel.successThreshold = kDefaultParams[1];

    mParcel.minSamples = kDefaultParams[2];

    mParcel.maxSamples = kDefaultParams[3];

    mParcel.baseTimeoutMsec = kDefaultParams[4];

    mParcel.retryCount = kDefaultParams[5];

    mParcel.servers = {kDefaultServer};

    mParcel.domains = {kDefaultSearchDomain};

    mParcel.tlsServers = {kDefaultServer};

    mParcel.caCertificate = kCaCert;

    mParcel.resolverOptions = ResolverOptionsParcel{};  // optional, must be explicitly set.

}



void DnsResponderClient::SetupMappings(unsigned numHosts, const std::vector<std::string>& domains,

                                       std::vector<Mapping>* mappings) {

    mappings->resize(numHosts * domains.size());
@@ -47,45 +63,6 @@ void DnsResponderClient::SetupMappings(unsigned numHosts, const std::vector<std: 
    }

}



// TODO: Use SetResolverConfiguration() with ResolverParamsParcel struct directly.

// DEPRECATED: Use SetResolverConfiguration() in new code

ResolverParamsParcel DnsResponderClient::makeResolverParamsParcel(

        int netId, const std::vector<int>& params, const std::vector<std::string>& servers,

        const std::vector<std::string>& domains, const std::string& tlsHostname,

        const std::vector<std::string>& tlsServers, const std::string& caCert) {

    ResolverParamsParcel paramsParcel;



    paramsParcel.netId = netId;

    paramsParcel.sampleValiditySeconds = params[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY];

    paramsParcel.successThreshold = params[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD];

    paramsParcel.minSamples = params[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES];

    paramsParcel.maxSamples = params[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES];

    if (params.size() > IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC) {

        paramsParcel.baseTimeoutMsec = params[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC];

    } else {

        paramsParcel.baseTimeoutMsec = 0;

    }

    if (params.size() > IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT) {

        paramsParcel.retryCount = params[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT];

    } else {

        paramsParcel.retryCount = 0;

    }

    paramsParcel.servers = servers;

    paramsParcel.domains = domains;

    paramsParcel.tlsName = tlsHostname;

    paramsParcel.tlsServers = tlsServers;

    paramsParcel.tlsFingerprints = {};

    paramsParcel.caCertificate = caCert;

    paramsParcel.resolverOptions = ResolverOptionsParcel{};  // optional, must be explicitly set.



    // Note, do not remove this otherwise the ResolverTest#ConnectTlsServerTimeout won't pass in M4

    // module.

    // TODO: remove after 2020-01 rolls out.

    paramsParcel.tlsConnectTimeoutMs = 1000;



    return paramsParcel;

}



bool DnsResponderClient::GetResolverInfo(aidl::android::net::IDnsResolver* dnsResolverService,

                                         unsigned netId, std::vector<std::string>* servers,

                                         std::vector<std::string>* domains,
@@ -120,22 +97,28 @@ bool DnsResponderClient::GetResolverInfo(aidl::android::net::IDnsResolver* dnsRe 


bool DnsResponderClient::SetResolversForNetwork(const std::vector<std::string>& servers,

                                                const std::vector<std::string>& domains,

                                                const std::vector<int>& params) {

    const auto& resolverParams =

            makeResolverParamsParcel(TEST_NETID, params, servers, domains, "", {}, "");

                                                std::vector<int> params) {

    params.resize(IDnsResolver::RESOLVER_PARAMS_COUNT);

    std::array<int, IDnsResolver::RESOLVER_PARAMS_COUNT> arr;

    std::copy_n(params.begin(), arr.size(), arr.begin());

    const auto resolverParams = ResolverParams::Builder()

                                        .setDomains(domains)

                                        .setDnsServers(servers)

                                        .setDotServers({})

                                        .setParams(arr)

                                        .build();

    const auto rv = mDnsResolvSrv->setResolverConfiguration(resolverParams);

    return rv.isOk();

}



bool DnsResponderClient::SetResolversWithTls(const std::vector<std::string>& servers,

                                             const std::vector<std::string>& domains,

                                             const std::vector<int>& params,

                                             const std::vector<std::string>& tlsServers,

                                             const std::string& name) {

    const auto& resolverParams = makeResolverParamsParcel(TEST_NETID, params, servers, domains,

                                                          name, tlsServers, kCaCert);

bool DnsResponderClient::SetResolversForNetwork(const std::vector<std::string>& servers,

                                                const std::vector<std::string>& domains) {

    const auto resolverParams = ResolverParams::Builder()

                                        .setDomains(domains)

                                        .setDnsServers(servers)

                                        .setDotServers({})

                                        .build();

    const auto rv = mDnsResolvSrv->setResolverConfiguration(resolverParams);

    if (!rv.isOk()) LOG(ERROR) << "SetResolversWithTls() -> " << rv.getMessage();

    return rv.isOk();

}
@@ -146,9 +129,7 @@ bool DnsResponderClient::SetResolversFromParcel(const ResolverParamsParcel& reso 
}



ResolverParamsParcel DnsResponderClient::GetDefaultResolverParamsParcel() {

    return makeResolverParamsParcel(TEST_NETID, kDefaultParams, kDefaultServers,

                                    kDefaultSearchDomains, {} /* tlsHostname */, kDefaultServers,

                                    kCaCert);

    return ResolverParams::Builder().build();

}



void DnsResponderClient::SetupDNSServers(unsigned numServers, const std::vector<Mapping>& mappings,

tests/dns_responder/dns_responder_client_ndk.h

+58 −32
Original line number Diff line number Diff line
@@ -35,9 +35,10 @@ using aidl::android::net::NativeNetworkConfig; 
using aidl::android::net::NativeNetworkType;

using aidl::android::net::NativeVpnType;



inline const std::vector<std::string> kDefaultServers = {"127.0.0.3"};

inline const std::vector<std::string> kDefaultSearchDomains = {"example.com"};

inline const std::vector<int> kDefaultParams = {

inline constexpr char kDefaultServer[] = "127.0.0.3";

inline constexpr char kDefaultSearchDomain[] = "example.com";

inline const std::array<int, aidl::android::net::IDnsResolver::RESOLVER_PARAMS_COUNT>

        kDefaultParams = {

                300,      // sample validity in seconds

                25,       // success threshod in percent

                8,    8,  // {MIN,MAX}_SAMPLES
@@ -54,6 +55,46 @@ inline const std::vector<int> kDefaultParams = { 
        }                                                                                          \

    } while (0)



class ResolverParams {

  public:

    class Builder {

      public:

        Builder();

        constexpr Builder& setDnsServers(const std::vector<std::string>& servers) {

            mParcel.servers = servers;

            return *this;

        }

        constexpr Builder& setDotServers(const std::vector<std::string>& servers) {

            mParcel.tlsServers = servers;

            return *this;

        }

        constexpr Builder& setDomains(const std::vector<std::string>& domains) {

            mParcel.domains = domains;

            return *this;

        }

        constexpr Builder& setPrivateDnsProvider(const std::string& provider) {

            mParcel.tlsName = provider;

            return *this;

        }

        constexpr Builder& setParams(

                const std::array<int, aidl::android::net::IDnsResolver::RESOLVER_PARAMS_COUNT>&

                        params) {

            using aidl::android::net::IDnsResolver;

            mParcel.sampleValiditySeconds = params[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY];

            mParcel.successThreshold = params[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD];

            mParcel.minSamples = params[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES];

            mParcel.maxSamples = params[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES];

            mParcel.baseTimeoutMsec = params[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC];

            mParcel.retryCount = params[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT];

            return *this;

        }

        aidl::android::net::ResolverParamsParcel build() { return mParcel; }



      private:

        aidl::android::net::ResolverParamsParcel mParcel;

    };

};



// TODO: Remove dns_responder_client_ndk.{h,cpp} after replacing the binder usage of

// dns_responder_client.*

class DnsResponderClient {
@@ -70,26 +111,16 @@ class DnsResponderClient { 
    static void SetupMappings(unsigned num_hosts, const std::vector<std::string>& domains,

                              std::vector<Mapping>* mappings);



    // This function is deprecated. Please use SetResolversFromParcel() instead.

    bool SetResolversForNetwork(const std::vector<std::string>& servers = kDefaultServers,

                                const std::vector<std::string>& domains = kDefaultSearchDomains,

                                const std::vector<int>& params = kDefaultParams);



    // This function is deprecated. Please use SetResolversFromParcel() instead.

    bool SetResolversWithTls(const std::vector<std::string>& servers,

                             const std::vector<std::string>& searchDomains,

                             const std::vector<int>& params, const std::string& name) {

        // Pass servers as both network-assigned and TLS servers.  Tests can

        // determine on which server and by which protocol queries arrived.

        return SetResolversWithTls(servers, searchDomains, params, servers, name);

    }

    // For dns_benchmark built from tm-mainline-prod.

    // TODO: Remove it when possible.

    bool SetResolversForNetwork(const std::vector<std::string>& servers,

                                const std::vector<std::string>& domains, std::vector<int> params);



    // This function is deprecated. Please use SetResolversFromParcel() instead.

    bool SetResolversWithTls(const std::vector<std::string>& servers,

                             const std::vector<std::string>& searchDomains,

                             const std::vector<int>& params,

                             const std::vector<std::string>& tlsServers, const std::string& name);

    // Sets up DnsResolver with given DNS servers. This is used to set up for private DNS off mode.

    bool SetResolversForNetwork(const std::vector<std::string>& servers = {kDefaultServer},

                                const std::vector<std::string>& domains = {kDefaultSearchDomain});



    // Sets up DnsResolver from a given parcel.

    bool SetResolversFromParcel(const aidl::android::net::ResolverParamsParcel& resolverParams);



    template <class T>
@@ -123,11 +154,6 @@ class DnsResponderClient { 
                                std::vector<std::unique_ptr<test::DNSResponder>>* dns,

                                std::vector<std::string>* servers);



    static aidl::android::net::ResolverParamsParcel makeResolverParamsParcel(

            int netId, const std::vector<int>& params, const std::vector<std::string>& servers,

            const std::vector<std::string>& domains, const std::string& tlsHostname,

            const std::vector<std::string>& tlsServers, const std::string& caCert = "");



    // Returns 0 on success and a negative value on failure.

    int SetupOemNetwork(int oemNetId);

    int TearDownOemNetwork(int oemNetId);

tests/dnsresolver_binder_test.cpp

+14 −15
Original line number Diff line number Diff line
@@ -360,19 +360,13 @@ TEST_F(DnsResolverBinderTest, RegisterEventListener_onDnsEvent) { 
    dnsClient.SetUp();



    // Setup DNS responder server.

    constexpr char listen_addr[] = "127.0.0.3";

    constexpr char listen_srv[] = "53";

    test::DNSResponder dns(listen_addr, listen_srv, ns_rcode::ns_r_servfail);

    test::DNSResponder dns(kDefaultServer, listen_srv, ns_rcode::ns_r_servfail);

    dns.addMapping("hi.example.com.", ns_type::ns_t_a, "1.2.3.4");

    ASSERT_TRUE(dns.startServer());



    // Setup DNS configuration.

    const std::vector<std::string> test_servers = {listen_addr};

    std::vector<std::string> test_domains = {"example.com"};

    std::vector<int> test_params = {300 /*sample_validity*/, 25 /*success_threshold*/,

                                    8 /*min_samples*/, 8 /*max_samples*/};



    ASSERT_TRUE(dnsClient.SetResolversForNetwork(test_servers, test_domains, test_params));

    ASSERT_TRUE(dnsClient.SetResolversForNetwork());

    dns.clearQueries();



    // Register event listener.
@@ -419,7 +413,6 @@ TEST_F(DnsResolverBinderTest, SetResolverConfiguration_Tls) { 
    static const std::vector<std::string> invalid_v4_addr = {"192.0.*.5"};

    static const std::vector<std::string> invalid_v6_addr = {"2001:dg8::6"};

    constexpr char valid_tls_name[] = "example.com";

    std::vector<int> test_params = {300, 25, 8, 8};

    // We enumerate valid and invalid v4/v6 address, and several different TLS names

    // to be the input data and verify the binder status.

    static const struct TestData {
@@ -449,9 +442,11 @@ TEST_F(DnsResolverBinderTest, SetResolverConfiguration_Tls) { 


    for (size_t i = 0; i < std::size(kTlsTestData); i++) {

        const auto& td = kTlsTestData[i];



        const auto resolverParams = DnsResponderClient::makeResolverParamsParcel(

                TEST_NETID, test_params, LOCALLY_ASSIGNED_DNS, {}, td.tlsName, td.servers);

        const auto resolverParams = ResolverParams::Builder()

                                            .setDnsServers(LOCALLY_ASSIGNED_DNS)

                                            .setDotServers(td.servers)

                                            .setPrivateDnsProvider(td.tlsName)

                                            .build();

        ::ndk::ScopedAStatus status = mDnsResolver->setResolverConfiguration(resolverParams);



        if (td.expectedReturnCode == 0) {
@@ -505,15 +500,19 @@ TEST_F(DnsResolverBinderTest, SetResolverConfiguration_TransportTypes_Default) { 
TEST_F(DnsResolverBinderTest, GetResolverInfo) {

    std::vector<std::string> servers = {"127.0.0.1", "127.0.0.2"};

    std::vector<std::string> domains = {"example.com"};

    std::vector<int> testParams = {

    std::array<int, aidl::android::net::IDnsResolver::RESOLVER_PARAMS_COUNT> testParams = {

            300,     // sample validity in seconds

            25,      // success threshod in percent

            8,   8,  // {MIN,MAX}_SAMPLES

            100,     // BASE_TIMEOUT_MSEC

            3,       // retry count

    };

    const auto resolverParams = DnsResponderClient::makeResolverParamsParcel(

            TEST_NETID, testParams, servers, domains, "", {});

    const auto resolverParams = ResolverParams::Builder()

                                        .setDomains(domains)

                                        .setDnsServers(servers)

                                        .setDotServers({})

                                        .setParams(testParams)

                                        .build();

    ::ndk::ScopedAStatus status = mDnsResolver->setResolverConfiguration(resolverParams);

    EXPECT_TRUE(status.isOk()) << status.getMessage();

    mExpectedLogDataWithPacel.push_back(toSetResolverConfigurationLogData(resolverParams));

tests/resolv_gold_test.cpp

+2 −2
Original line number Diff line number Diff line
@@ -111,14 +111,14 @@ class TestBase : public NetNativeTestBase { 
        ASSERT_EQ(resolv_set_nameservers(TEST_NETID, servers, domains, kParams, std::nullopt), 0);

    }



    void SetResolvers() { SetResolverConfiguration(kDefaultServers, kDefaultSearchDomains); }

    void SetResolvers() { SetResolverConfiguration({kDefaultServer}, {kDefaultSearchDomain}); }



    void SetResolversWithTls() {

        // Pass servers as both network-assigned and TLS servers. Tests can

        // determine on which server and by which protocol queries arrived.

        // See also DnsClient::SetResolversWithTls() in

        // packages/modules/DnsResolver/tests/dns_responder/dns_responder_client.h.

        SetResolverConfiguration(kDefaultServers, kDefaultSearchDomains, kDefaultServers,

        SetResolverConfiguration({kDefaultServer}, {kDefaultSearchDomain}, {kDefaultServer},

                                 kDefaultPrivateDnsHostName, kCaCert);

    }

tests/resolv_integration_test.cpp

+117 −106

File changed.

Preview size limit exceeded, changes collapsed.