Snap for 9241468 from 2e9e6011e1adc9b308e9182659c5f432bfd6bd03 to mainline-wifi-release (6cad46bb) · Commits · e / os / android_packages_modules_DnsResolver

DnsProxyListener.cpp

+9 −11

Original line number	Diff line number	Diff line
		@@ -263,17 +263,9 @@ bool parseQuery(span<const uint8_t> msg, uint16_t* query_id, int* rr_type, std::
		// Note: Even if it returns PDM_OFF, it doesn't mean there's no DoT stats in the message
		// because Private DNS mode can change at any time.
		PrivateDnsModes getPrivateDnsModeForMetrics(uint32_t netId) {
		switch (PrivateDnsConfiguration::getInstance().getStatus(netId).mode) {
		case PrivateDnsMode::OFF:
		// It can also be due to netId not found.
		return PrivateDnsModes::PDM_OFF;
		case PrivateDnsMode::OPPORTUNISTIC:
		return PrivateDnsModes::PDM_OPPORTUNISTIC;
		case PrivateDnsMode::STRICT:
		return PrivateDnsModes::PDM_STRICT;
		default:
		return PrivateDnsModes::PDM_UNKNOWN;
		}
		// If the network `netId` doesn't exist, getStatus() sets the mode to PrivateDnsMode::OFF and
		// returns it. This is incorrect for the metrics. Consider returning PDM_UNKNOWN in such case.
		return convertEnumType(PrivateDnsConfiguration::getInstance().getStatus(netId).mode);
		}

		void initDnsEvent(NetworkDnsEventReported* event, const android_net_context& netContext) {
		@@ -1243,6 +1235,9 @@ void DnsProxyListener::GetHostByNameHandler::doDns64Synthesis(int32_t* rv, hoste
		}

		void DnsProxyListener::GetHostByNameHandler::run() {
		LOG(INFO) << "GetHostByNameHandler::run: {" << mNetContext.app_netid << " "
		<< mNetContext.app_mark << " " << mNetContext.dns_netid << " " << mNetContext.dns_mark
		<< " " << mNetContext.uid << " " << mNetContext.flags << "}";
		Stopwatch s;
		maybeFixupNetContext(&mNetContext, mClient->getPid());
		const uid_t uid = mClient->getUid();
		@@ -1404,6 +1399,9 @@ void DnsProxyListener::GetHostByAddrHandler::doDns64ReverseLookup(hostent* hbuf,
		}

		void DnsProxyListener::GetHostByAddrHandler::run() {
		LOG(INFO) << "GetHostByAddrHandler::run: {" << mNetContext.app_netid << " "
		<< mNetContext.app_mark << " " << mNetContext.dns_netid << " " << mNetContext.dns_mark
		<< " " << mNetContext.uid << " " << mNetContext.flags << "}";
		Stopwatch s;
		maybeFixupNetContext(&mNetContext, mClient->getPid());
		const uid_t uid = mClient->getUid();

DnsResolver.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -31,7 +31,7 @@
		bool resolv_init(const ResolverNetdCallbacks* callbacks) {
		android::base::InitLogging(/argv=/nullptr);
		LOG(INFO) << __func__ << ": Initializing resolver";
		const bool isDebug = isUserDebugBuild();
		const bool isDebug = isDebuggable();
		resolv_set_log_severity(isDebug ? android::base::INFO : android::base::WARNING);
		doh_init_logger(isDebug ? DOH_LOG_LEVEL_INFO : DOH_LOG_LEVEL_WARN);
		using android::net::gApiLevel;

DnsResolverService.cpp

+6 −1

Original line number	Diff line number	Diff line
		@@ -222,8 +222,13 @@ binder_status_t DnsResolverService::dump(int fd, const char** args, uint32_t num
		// Locking happens in PrivateDnsConfiguration and res_* functions.
		ENFORCE_NETWORK_STACK_PERMISSIONS();

		int timeout_count = 0;
		int res = gDnsResolv->resolverCtrl.getResolverInfo(netId, servers, domains, tlsServers, params,
		stats, wait_for_pending_req_timeout_count);
		stats, &timeout_count);
		// Due to historical reason, wait_for_pending_req_timeout_count couldn't be
		// an int but a vector. See aosp/858377 for more details.
		wait_for_pending_req_timeout_count->clear();
		wait_for_pending_req_timeout_count->push_back(timeout_count);

		return statusFromErrcode(res);
		}

PrivateDnsConfiguration.cpp

+17 −13

Original line number	Diff line number	Diff line
		@@ -61,7 +61,7 @@ bool ensureNoInvalidIp(const std::vector<std::string>& servers) {

		} // namespace

		PrivateDnsModes convert_enum_type(PrivateDnsMode mode) {
		PrivateDnsModes convertEnumType(PrivateDnsMode mode) {
		switch (mode) {
		case PrivateDnsMode::OFF:
		return PrivateDnsModes::PDM_OFF;
		@@ -158,12 +158,16 @@ void PrivateDnsConfiguration::clearDot(int32_t netId) {
		}

		PrivateDnsStatus PrivateDnsConfiguration::getStatus(unsigned netId) const {
		std::lock_guard guard(mPrivateDnsLock);
		return getStatusLocked(netId);
		}

		PrivateDnsStatus PrivateDnsConfiguration::getStatusLocked(unsigned netId) const {
		PrivateDnsStatus status{
		.mode = PrivateDnsMode::OFF,
		.dotServersMap = {},
		.dohServersMap = {},
		};
		std::lock_guard guard(mPrivateDnsLock);

		const auto mode = mPrivateDnsModes.find(netId);
		if (mode == mPrivateDnsModes.end()) return status;
		@@ -189,19 +193,19 @@ PrivateDnsStatus PrivateDnsConfiguration::getStatus(unsigned netId) const {
		}

		NetworkDnsServerSupportReported PrivateDnsConfiguration::getStatusForMetrics(unsigned netId) const {
		NetworkDnsServerSupportReported event;
		{
		const auto networkType = resolv_get_network_types_for_net(netId);
		std::lock_guard guard(mPrivateDnsLock);
		if (const auto it = mPrivateDnsModes.find(netId); it != mPrivateDnsModes.end()) {
		event.set_private_dns_modes(convert_enum_type(it->second));
		} else {
		return event;
		}

		if (mPrivateDnsModes.find(netId) == mPrivateDnsModes.end()) {
		// Return NetworkDnsServerSupportReported with private_dns_modes set to PDM_UNKNOWN.
		return {};
		}
		event.set_network_type(resolv_get_network_types_for_net(netId));

		const PrivateDnsStatus status = getStatus(netId);
		std::lock_guard guard(mPrivateDnsLock);
		const PrivateDnsStatus status = getStatusLocked(netId);
		NetworkDnsServerSupportReported event = {};
		event.set_network_type(networkType);
		event.set_private_dns_modes(convertEnumType(status.mode));

		if (const auto it = mUnorderedDnsTracker.find(netId); it != mUnorderedDnsTracker.end()) {
		for (size_t i = 0; i < it->second.size(); i++) {
		Server* server = event.mutable_servers()->add_server();

PrivateDnsConfiguration.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -40,7 +40,7 @@
		namespace android {
		namespace net {

		PrivateDnsModes convert_enum_type(PrivateDnsMode mode);
		PrivateDnsModes convertEnumType(PrivateDnsMode mode);

		struct PrivateDnsStatus {
		PrivateDnsMode mode;
		@@ -147,6 +147,9 @@ class PrivateDnsConfiguration {
		base::Result<DnsTlsServer*> getDotServerLocked(const ServerIdentity& identity, unsigned netId)
		REQUIRES(mPrivateDnsLock);

		// TODO: change the return type to Result<PrivateDnsStatus>.
		PrivateDnsStatus getStatusLocked(unsigned netId) const REQUIRES(mPrivateDnsLock);

		// Launchs a thread to run the validation for the DoT server \|server\| on the network \|netId\|.
		// \|isRevalidation\| is true if this call is due to a revalidation request.
		void startDotValidation(const ServerIdentity& identity, unsigned netId, bool isRevalidation)