Get rid of libnetd_test_dnsresponder from DnsResolver tests (638d7e4e) · Commits · e / os / android_packages_modules_DnsResolver

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