Merge changes I3afe28f5,Id9fc9b78 am: db91ce9717 am: 2efac57093 (c8ff05f1) · Commits · e / os / android_packages_modules_DnsResolver

DnsQueryLog.cpp

+3 −19

Original line number	Original line	Diff line number	Diff line
	@@ -17,7 +17,7 @@

	#include "DnsQueryLog.h"		#include "DnsQueryLog.h"

	#include <android-base/stringprintf.h>		#include "util.h"

	namespace android::net {		namespace android::net {

	@@ -45,25 +45,10 @@ std::string maskIps(const std::vector<std::string>& ips) {
	return ret.empty() ? "" : ret.substr(0, ret.length() - 2);		return ret.empty() ? "" : ret.substr(0, ret.length() - 2);
	}		}

	// Return the readable string format "hr:min:sec.ms".
	std::string timestampToString(const std::chrono::system_clock::time_point& ts) {
	using std::chrono::duration_cast;
	using std::chrono::milliseconds;
	const auto time_sec = std::chrono::system_clock::to_time_t(ts);
	char buf[32];
	std::strftime(buf, sizeof(buf), "%H:%M:%S", std::localtime(&time_sec));
	int ms = duration_cast<milliseconds>(ts.time_since_epoch()).count() % 1000;
	return android::base::StringPrintf("%s.%03d", buf, ms);
	}

	} // namespace		} // namespace

	void DnsQueryLog::push(Record&& record) {		void DnsQueryLog::push(Record&& record) {
	std::lock_guard guard(mLock);		mQueue.push(std::move(record));
	mQueue.push_back(std::move(record));
	if (mQueue.size() > mCapacity) {
	mQueue.pop_front();
	}
	}		}

	void DnsQueryLog::dump(netdutils::DumpWriter& dw) const {		void DnsQueryLog::dump(netdutils::DumpWriter& dw) const {
	@@ -71,8 +56,7 @@ void DnsQueryLog::dump(netdutils::DumpWriter& dw) const {
	netdutils::ScopedIndent indentStats(dw);		netdutils::ScopedIndent indentStats(dw);
	const auto now = std::chrono::system_clock::now();		const auto now = std::chrono::system_clock::now();

	std::lock_guard guard(mLock);		for (const auto& record : mQueue.copy()) {
	for (const auto& record : mQueue) {
	if (now - record.timestamp > mValidityTimeMs) continue;		if (now - record.timestamp > mValidityTimeMs) continue;

	const std::string maskedHostname = maskHostname(record.hostname);		const std::string maskedHostname = maskHostname(record.hostname);

DnsQueryLog.h

+7 −9

Original line number	Original line	Diff line number	Diff line
	@@ -17,16 +17,16 @@

	#pragma once		#pragma once

	#include <deque>
	#include <string>		#include <string>
	#include <vector>		#include <vector>

	#include <android-base/thread_annotations.h>
	#include <netdutils/DumpWriter.h>		#include <netdutils/DumpWriter.h>

			#include "LockedQueue.h"

	namespace android::net {		namespace android::net {

	// A circular buffer based class used for query logging. It's thread-safe for concurrent access.		// This class stores query records in a locked ring buffer. It's thread-safe for concurrent access.
	class DnsQueryLog {		class DnsQueryLog {
	public:		public:
	static constexpr std::string_view DUMP_KEYWORD = "querylog";		static constexpr std::string_view DUMP_KEYWORD = "querylog";
	@@ -52,15 +52,13 @@ class DnsQueryLog {
	// Allow the tests to set the capacity and the validaty time in milliseconds.		// Allow the tests to set the capacity and the validaty time in milliseconds.
	DnsQueryLog(size_t size = kDefaultLogSize,		DnsQueryLog(size_t size = kDefaultLogSize,
	std::chrono::milliseconds time = kDefaultValidityMinutes)		std::chrono::milliseconds time = kDefaultValidityMinutes)
	: mCapacity(size), mValidityTimeMs(time) {}		: mQueue(size), mValidityTimeMs(time) {}

	void push(Record&& record) EXCLUDES(mLock);		void push(Record&& record);
	void dump(netdutils::DumpWriter& dw) const EXCLUDES(mLock);		void dump(netdutils::DumpWriter& dw) const;

	private:		private:
	mutable std::mutex mLock;		LockedRingBuffer<Record> mQueue;
	std::deque<Record> mQueue GUARDED_BY(mLock);
	const size_t mCapacity;
	const std::chrono::milliseconds mValidityTimeMs;		const std::chrono::milliseconds mValidityTimeMs;

	// The capacity of the circular buffer.		// The capacity of the circular buffer.

DnsResolverService.cpp

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -32,6 +32,7 @@
	#include "DnsResolver.h"		#include "DnsResolver.h"
	#include "Experiments.h"		#include "Experiments.h"
	#include "NetdPermissions.h" // PERM_*		#include "NetdPermissions.h" // PERM_*
			#include "PrivateDnsConfiguration.h"
	#include "ResolverEventReporter.h"		#include "ResolverEventReporter.h"
	#include "resolv_cache.h"		#include "resolv_cache.h"

	@@ -117,6 +118,8 @@ binder_status_t DnsResolverService::dump(int fd, const char** args, uint32_t num
	gDnsResolv->resolverCtrl.dump(dw, netId);		gDnsResolv->resolverCtrl.dump(dw, netId);
	dw.blankline();		dw.blankline();
	}		}

			PrivateDnsConfiguration::getInstance().dump(dw);
	Experiments::getInstance()->dump(dw);		Experiments::getInstance()->dump(dw);
	return STATUS_OK;		return STATUS_OK;
	}		}

LockedQueue.h

+24 −0

Original line number	Original line	Diff line number	Diff line
	@@ -46,6 +46,30 @@ class LockedQueue {
	std::deque<T> mQueue GUARDED_BY(mLock);		std::deque<T> mQueue GUARDED_BY(mLock);
	};		};

			template <typename T>
			class LockedRingBuffer {
			public:
			explicit LockedRingBuffer(size_t size) : mCapacity(size) {}

			void push(T&& record) {
			std::lock_guard guard(mLock);
			mQueue.push_back(std::move(record));
			if (mQueue.size() > mCapacity) {
			mQueue.pop_front();
			}
			}

			std::deque<T> copy() const {
			std::lock_guard guard(mLock);
			return mQueue;
			}

			private:
			mutable std::mutex mLock;
			const size_t mCapacity;
			std::deque<T> mQueue GUARDED_BY(mLock);
			};

	} // end of namespace net		} // end of namespace net
	} // end of namespace android		} // end of namespace android

PrivateDnsCommon.h

+30 −0

Original line number	Original line	Diff line number	Diff line
	@@ -35,4 +35,34 @@ enum class PrivateDnsMode : uint8_t {
	STRICT,		STRICT,
	};		};

			constexpr const char* validationStatusToString(Validation value) {
			switch (value) {
			case Validation::in_process:
			return "in_process";
			case Validation::success:
			return "success";
			case Validation::success_but_expired:
			return "success_but_expired";
			case Validation::fail:
			return "fail";
			case Validation::unknown_server:
			return "unknown_server";
			case Validation::unknown_netid:
			return "unknown_netid";
			default:
			return "unknown_status";
			}
			}

			constexpr const char* getPrivateDnsModeString(PrivateDnsMode mode) {
			switch (mode) {
			case PrivateDnsMode::OFF:
			return "OFF";
			case PrivateDnsMode::OPPORTUNISTIC:
			return "OPPORTUNISTIC";
			case PrivateDnsMode::STRICT:
			return "STRICT";
			}
			}

	} // namespace android::net		} // namespace android::net