Snap for 7124398 from c6fde4f2609e787e8b73de1d6bbe46993fa82065 to mainline-permission-release (7c5b71c8) · Commits · e / os / android_packages_modules_DnsResolver

DnsProxyListener.cpp

+31 −2

Original line number	Diff line number	Diff line
		@@ -62,6 +62,8 @@
		#include "stats.pb.h"

		using aidl::android::net::metrics::INetdEventListener;
		using aidl::android::net::resolv::aidl::DnsHealthEventParcel;
		using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;
		using android::net::NetworkDnsEventReported;

		namespace android {
		@@ -347,16 +349,43 @@ void reportDnsEvent(int eventType, const android_net_context& netContext, int la
		maybeLogQuery(eventType, netContext, event, query_name, ip_addrs);

		const auto& listeners = ResolverEventReporter::getInstance().getListeners();
		if (listeners.size() == 0) {
		if (listeners.empty()) {
		LOG(ERROR) << __func__
		<< ": DNS event not sent since no INetdEventListener receiver is available.";
		return;
		}
		const int latencyMs = latencyUs / 1000;
		for (const auto& it : listeners) {
		it->onDnsEvent(netContext.dns_netid, eventType, returnCode, latencyMs, query_name, ip_addrs,
		total_ip_addr_count, netContext.uid);
		}

		const auto& unsolEventListeners = ResolverEventReporter::getInstance().getUnsolEventListeners();

		if (returnCode == NETD_RESOLV_TIMEOUT) {
		const DnsHealthEventParcel dnsHealthEvent = {
		.netId = static_cast<int32_t>(netContext.dns_netid),
		.healthResult = IDnsResolverUnsolicitedEventListener::DNS_HEALTH_RESULT_TIMEOUT,
		};
		for (const auto& it : unsolEventListeners) {
		it->onDnsHealthEvent(dnsHealthEvent);
		}
		} else if (returnCode == NOERROR) {
		DnsHealthEventParcel dnsHealthEvent = {
		.netId = static_cast<int32_t>(netContext.dns_netid),
		.healthResult = IDnsResolverUnsolicitedEventListener::DNS_HEALTH_RESULT_OK,
		};
		for (const auto& query : event.dns_query_events().dns_query_event()) {
		if (query.cache_hit() != CS_FOUND && query.rcode() == NS_R_NO_ERROR) {
		dnsHealthEvent.successRttMicros.push_back(query.latency_micros());
		}
		}

		if (!dnsHealthEvent.successRttMicros.empty()) {
		for (const auto& it : unsolEventListeners) {
		it->onDnsHealthEvent(dnsHealthEvent);
		}
		}
		}
		}

		bool onlyIPv4Answers(const addrinfo* res) {

DnsResolverService.cpp

+4 −2

Original line number	Diff line number	Diff line
		@@ -143,10 +143,12 @@ binder_status_t DnsResolverService::dump(int fd, const char** args, uint32_t num

		::ndk::ScopedAStatus DnsResolverService::registerUnsolicitedEventListener(
		const std::shared_ptr<
		aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener>&) {
		aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener>& listener) {
		ENFORCE_NETWORK_STACK_PERMISSIONS();

		return ::ndk::ScopedAStatus(AStatus_newOk());
		int res = ResolverEventReporter::getInstance().addUnsolEventListener(listener);

		return statusFromErrcode(res);
		}

		::ndk::ScopedAStatus DnsResolverService::checkAnyPermission(

PrivateDnsConfiguration.cpp

+33 −13

Original line number	Diff line number	Diff line
		@@ -30,6 +30,8 @@
		#include "netdutils/BackoffSequence.h"
		#include "util.h"

		using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;
		using aidl::android::net::resolv::aidl::PrivateDnsValidationEventParcel;
		using android::base::StringPrintf;
		using android::netdutils::setThreadName;
		using std::chrono::milliseconds;
		@@ -222,6 +224,35 @@ void PrivateDnsConfiguration::startValidation(const DnsTlsServer& server, unsign
		validate_thread.detach();
		}

		void PrivateDnsConfiguration::sendPrivateDnsValidationEvent(const DnsTlsServer& server,
		unsigned netId, bool success) {
		LOG(DEBUG) << "Sending validation " << (success ? "success" : "failure") << " event on netId "
		<< netId << " for " << server.toIpString() << " with hostname {" << server.name
		<< "}";
		// Send a validation event to NetdEventListenerService.
		const auto& listeners = ResolverEventReporter::getInstance().getListeners();
		if (listeners.empty()) {
		LOG(ERROR)
		<< "Validation event not sent since no INetdEventListener receiver is available.";
		}
		for (const auto& it : listeners) {
		it->onPrivateDnsValidationEvent(netId, server.toIpString(), server.name, success);
		}

		// Send a validation event to unsolicited event listeners.
		const auto& unsolEventListeners = ResolverEventReporter::getInstance().getUnsolEventListeners();
		const PrivateDnsValidationEventParcel validationEvent = {
		.netId = static_cast<int32_t>(netId),
		.ipAddress = server.toIpString(),
		.hostname = server.name,
		.validation = success ? IDnsResolverUnsolicitedEventListener::VALIDATION_RESULT_SUCCESS
		: IDnsResolverUnsolicitedEventListener::VALIDATION_RESULT_FAILURE,
		};
		for (const auto& it : unsolEventListeners) {
		it->onPrivateDnsValidationEvent(validationEvent);
		}
		}

		bool PrivateDnsConfiguration::recordPrivateDnsValidation(const DnsTlsServer& server, unsigned netId,
		bool success) {
		constexpr bool NEEDS_REEVALUATION = true;
		@@ -268,19 +299,8 @@ bool PrivateDnsConfiguration::recordPrivateDnsValidation(const DnsTlsServer& ser
		reevaluationStatus = DONT_REEVALUATE;
		}

		// Send a validation event to NetdEventListenerService.
		const auto& listeners = ResolverEventReporter::getInstance().getListeners();
		if (listeners.size() != 0) {
		for (const auto& it : listeners) {
		it->onPrivateDnsValidationEvent(netId, server.toIpString(), server.name, success);
		}
		LOG(DEBUG) << "Sent validation " << (success ? "success" : "failure") << " event on netId "
		<< netId << " for " << server.toIpString() << " with hostname {" << server.name
		<< "}";
		} else {
		LOG(ERROR)
		<< "Validation event not sent since no INetdEventListener receiver is available.";
		}
		// Send private dns validation result to listeners.
		sendPrivateDnsValidationEvent(server, netId, success);

		if (success) {
		updateServerState(identity, Validation::success, netId);

PrivateDnsConfiguration.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -103,6 +103,9 @@ class PrivateDnsConfiguration {
		bool recordPrivateDnsValidation(const DnsTlsServer& server, unsigned netId, bool success)
		EXCLUDES(mPrivateDnsLock);

		void sendPrivateDnsValidationEvent(const DnsTlsServer& server, unsigned netId, bool success)
		REQUIRES(mPrivateDnsLock);

		// Decide if a validation for \|server\| is needed. Note that servers that have failed
		// multiple validation attempts but for which there is still a validating
		// thread running are marked as being Validation::in_process.

ResolverController.cpp

+21 −3

Original line number	Diff line number	Diff line
		@@ -35,6 +35,8 @@
		#include "stats.h"

		using aidl::android::net::ResolverParamsParcel;
		using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;
		using aidl::android::net::resolv::aidl::Nat64PrefixEventParcel;

		namespace android {

		@@ -45,14 +47,30 @@ namespace net {
		namespace {

		void sendNat64PrefixEvent(const Dns64Configuration::Nat64PrefixInfo& args) {
		LOG(DEBUG) << "Sending Nat64Prefix " << (args.added ? "added" : "removed") << " event on netId "
		<< args.netId << " with address {" << args.prefixString << "(" << args.prefixLength
		<< ")}";
		// Send a nat64 prefix event to NetdEventListenerService.
		const auto& listeners = ResolverEventReporter::getInstance().getListeners();
		if (listeners.size() == 0) {
		LOG(ERROR) << __func__ << ": No available listener. dropping NAT64 prefix event";
		return;
		if (listeners.empty()) {
		LOG(ERROR) << __func__ << ": No available listener. Skipping NAT64 prefix event";
		}
		for (const auto& it : listeners) {
		it->onNat64PrefixEvent(args.netId, args.added, args.prefixString, args.prefixLength);
		}

		const auto& unsolEventListeners = ResolverEventReporter::getInstance().getUnsolEventListeners();
		const Nat64PrefixEventParcel nat64PrefixEvent = {
		.netId = static_cast<int32_t>(args.netId),
		.prefixOperation =
		args.added ? IDnsResolverUnsolicitedEventListener::PREFIX_OPERATION_ADDED
		: IDnsResolverUnsolicitedEventListener::PREFIX_OPERATION_REMOVED,
		.prefixAddress = args.prefixString,
		.prefixLength = args.prefixLength,
		};
		for (const auto& it : unsolEventListeners) {
		it->onNat64PrefixEvent(nat64PrefixEvent);
		}
		}

		int getDnsInfo(unsigned netId, std::vector<std::string>* servers, std::vector<std::string>* domains,