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

Commit 38789a8b authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Get rid of libnetd_test_dnsresponder from DnsResolver tests am: 638d7e4e 

Change-Id: I347d53e7508cb7ce43c93ff97b60875f170aff7c
parents d2dd755b 638d7e4e

Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -266,7 +266,7 @@ cc_test { 
        "libcutils",

        "libgmock",

        "libnetd_resolv",

        "libnetd_test_dnsresponder",

        "libnetd_test_dnsresponder_ndk",

        "libnetd_test_resolv_utils",

        "libnetdutils",

        "libprotobuf-cpp-lite",

tests/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -11,7 +11,7 @@ cc_test_library { 
        "libutils",

    ],

    static_libs: [

        "libnetd_test_dnsresponder",

        "libnetd_test_dnsresponder_ndk",

        "libnetdutils",

    ],

}

tests/dns_responder/Android.bp

+0 −25
Original line number Diff line number Diff line 
// TODO: Remove libnetd_test_dnsresponder after eliminating all users.

cc_test_library {

    name: "libnetd_test_dnsresponder",

    defaults: ["netd_defaults", "resolv_test_defaults"],

    shared_libs: [

        "libbinder",

        "libnetd_client",

    ],

    static_libs: [

        "dnsresolver_aidl_interface-unstable-cpp",

        "libcrypto_static",

        "libnetdutils",

        "libssl",

        "libutils",

        "netd_aidl_interface-cpp",

        "netd_event_listener_interface-cpp",

    ],

    srcs: [

        "dns_responder.cpp",

        "dns_responder_client.cpp",

        "dns_tls_frontend.cpp",

    ],

    export_include_dirs: ["."],

}



cc_test_library {

    name: "libnetd_test_dnsresponder_ndk",

    defaults: ["netd_defaults", "resolv_test_defaults"],

tests/dns_responder/dns_responder_client.cpp

deleted100644 → 0
+0 −189
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "dns_responder_client"



#include "dns_responder_client.h"



#include <android-base/logging.h>

#include <android-base/stringprintf.h>



#include "NetdClient.h"

#include "binder/IServiceManager.h"



// TODO: make this dynamic and stop depending on implementation details.

#define TEST_OEM_NETWORK "oem29"

#define TEST_NETID 30



// TODO: move this somewhere shared.

static const char* ANDROID_DNS_MODE = "ANDROID_DNS_MODE";



using android::base::StringPrintf;

using android::net::INetd;

using android::net::ResolverParamsParcel;



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

                                       std::vector<Mapping>* mappings) {

    mappings->resize(numHosts * domains.size());

    auto mappingsIt = mappings->begin();

    for (unsigned i = 0; i < numHosts; ++i) {

        for (const auto& domain : domains) {

            mappingsIt->host = StringPrintf("host%u", i);

            mappingsIt->entry = StringPrintf("%s.%s.", mappingsIt->host.c_str(), domain.c_str());

            mappingsIt->ip4 = StringPrintf("192.0.2.%u", i % 253 + 1);

            mappingsIt->ip6 = StringPrintf("2001:db8::%x", i % 65534 + 1);

            ++mappingsIt;

        }

    }

}



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

// DEPRECATED: Use SetResolverConfiguration() in new code

static 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) {

    using android::net::IDnsResolver;

    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;



    return paramsParcel;

}



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, "", {}, "");

    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);

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

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

    return rv.isOk();

}



bool DnsResponderClient::SetResolversFromParcel(const ResolverParamsParcel& resolverParams) {

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

    if (!rv.isOk()) LOG(ERROR) << "SetResolversFromParcel() -> " << rv.toString8();

    return rv.isOk();

}



ResolverParamsParcel DnsResponderClient::GetDefaultResolverParamsParcel() {

    return makeResolverParamsParcel(TEST_NETID, kDefaultParams, kDefaultServers,

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

                                    kCaCert);

}



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

                                         std::vector<std::unique_ptr<test::DNSResponder>>* dns,

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

    const char* listenSrv = "53";

    dns->resize(numServers);

    servers->resize(numServers);

    for (unsigned i = 0; i < numServers; ++i) {

        auto& server = (*servers)[i];

        auto& d = (*dns)[i];

        server = StringPrintf("127.0.0.%u", i + 100);

        d = std::make_unique<test::DNSResponder>(server, listenSrv, ns_rcode::ns_r_servfail);

        for (const auto& mapping : mappings) {

            d->addMapping(mapping.entry.c_str(), ns_type::ns_t_a, mapping.ip4.c_str());

            d->addMapping(mapping.entry.c_str(), ns_type::ns_t_aaaa, mapping.ip6.c_str());

        }

        d->startServer();

    }

}



int DnsResponderClient::SetupOemNetwork() {

    mNetdSrv->networkDestroy(TEST_NETID);

    mDnsResolvSrv->destroyNetworkCache(TEST_NETID);

    auto ret = mNetdSrv->networkCreatePhysical(TEST_NETID, INetd::PERMISSION_NONE);

    if (!ret.isOk()) {

        fprintf(stderr, "Creating physical network %d failed, %s\n", TEST_NETID,

                ret.toString8().string());

        return -1;

    }

    ret = mDnsResolvSrv->createNetworkCache(TEST_NETID);

    if (!ret.isOk()) {

        fprintf(stderr, "Creating network cache %d failed, %s\n", TEST_NETID,

                ret.toString8().string());

        return -1;

    }

    setNetworkForProcess(TEST_NETID);

    if ((unsigned)TEST_NETID != getNetworkForProcess()) {

        return -1;

    }

    return TEST_NETID;

}



void DnsResponderClient::TearDownOemNetwork(int oemNetId) {

    if (oemNetId != -1) {

        mNetdSrv->networkDestroy(oemNetId);

        mDnsResolvSrv->destroyNetworkCache(oemNetId);

    }

}



void DnsResponderClient::SetUp() {

    // binder setup

    auto binder = android::defaultServiceManager()->getService(android::String16("netd"));

    mNetdSrv = android::interface_cast<android::net::INetd>(binder);

    if (mNetdSrv == nullptr) {

        LOG(FATAL) << "Can't connect to service 'netd'. Missing root privileges? uid=" << getuid();

    }



    auto resolvBinder =

            android::defaultServiceManager()->getService(android::String16("dnsresolver"));

    mDnsResolvSrv = android::interface_cast<android::net::IDnsResolver>(resolvBinder);



    // Ensure resolutions go via proxy.

    setenv(ANDROID_DNS_MODE, "", 1);

    mOemNetId = SetupOemNetwork();

}



void DnsResponderClient::TearDown() {

    TearDownOemNetwork(mOemNetId);

}

tests/dns_responder/dns_responder_client.h

deleted100644 → 0
+0 −101
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 */



#ifndef DNS_RESPONDER_CLIENT_H

#define DNS_RESPONDER_CLIENT_H



#include <memory>

#include <string>

#include <vector>



#include "android/net/IDnsResolver.h"

#include "android/net/INetd.h"

#include "dns_responder.h"

#include "dns_tls_certificate.h"



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 = {

        300,      // sample validity in seconds

        25,       // success threshod in percent

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

        1000,     // BASE_TIMEOUT_MSEC

        2,        // retry count

};



// TODO: Replace binder service related code to ndk version after finishing all tests migration

// from libbinder to libbinder_ndk.

class DnsResponderClient {

  public:

    struct Mapping {

        std::string host;

        std::string entry;

        std::string ip4;

        std::string ip6;

    };



    virtual ~DnsResponderClient() = default;



    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);

    }



    // 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);



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



    // Return a default resolver configuration for opportunistic mode.

    static android::net::ResolverParamsParcel GetDefaultResolverParamsParcel();



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

                                std::vector<std::unique_ptr<test::DNSResponder>>* dns,

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



    int SetupOemNetwork();



    void TearDownOemNetwork(int oemNetId);



    virtual void SetUp();

    virtual void TearDown();



    android::net::IDnsResolver* resolvService() const { return mDnsResolvSrv.get(); }

    android::net::INetd* netdService() const { return mNetdSrv.get(); }



  private:

    android::sp<android::net::INetd> mNetdSrv = nullptr;

    android::sp<android::net::IDnsResolver> mDnsResolvSrv = nullptr;

    int mOemNetId = -1;

};



#endif  // DNS_RESPONDER_CLIENT_H