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

DnsQueryLog.cpp

+3 −19

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

		#include "DnsQueryLog.h"

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

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

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

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

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

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

+7 −9

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

		#pragma once

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

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

		#include "LockedQueue.h"

		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 {
		public:
		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.
		DnsQueryLog(size_t size = kDefaultLogSize,
		std::chrono::milliseconds time = kDefaultValidityMinutes)
		: mCapacity(size), mValidityTimeMs(time) {}
		: mQueue(size), mValidityTimeMs(time) {}

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

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

		// The capacity of the circular buffer.

+3 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@
		#include "DnsResolver.h"
		#include "Experiments.h"
		#include "NetdPermissions.h" // PERM_*
		#include "PrivateDnsConfiguration.h"
		#include "ResolverEventReporter.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);
		dw.blankline();
		}

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

+24 −0

Original line number	Diff line number	Diff line
		@@ -46,6 +46,30 @@ class LockedQueue {
		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 android

+30 −0

Original line number	Diff line number	Diff line
		@@ -35,4 +35,34 @@ enum class PrivateDnsMode : uint8_t {
		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