Adjust the log mechanism for DoH and some minor changes. am: 53d3eb2a49 (8893406e) · Commits · e / os / android_packages_modules_DnsResolver

Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -397,7 +397,8 @@ rust_ffi_static {
		"liburl",
		],
		prefer_rlib: true,
		// For unit tests to run on the Android 10 platform, libunwind must be statically linked..
		// TODO(b/194022174), for unit tests to run on the Android 10 platform,
		// libunwind must be statically linked.
		whole_static_libs: ["libunwind"],
		apex_available: [
		"//apex_available:platform", // Needed by doh_ffi_test

DnsResolver.cpp

+3 −1

Original line number	Diff line number	Diff line
		@@ -31,7 +31,9 @@ bool resolv_init(const ResolverNetdCallbacks* callbacks) {
		android::base::SetDefaultTag("libnetd_resolv");
		LOG(INFO) << __func__ << ": Initializing resolver";
		// TODO(b/170539625): restore log level to WARNING after clarifying flaky tests.
		resolv_set_log_severity(isUserDebugBuild() ? android::base::DEBUG : android::base::WARNING);
		const bool isDebug = isUserDebugBuild();
		resolv_set_log_severity(isDebug ? android::base::DEBUG : android::base::WARNING);
		doh_init_logger(isDebug ? LOG_LEVEL_DEBUG : LOG_LEVEL_WARN);
		using android::net::gApiLevel;
		gApiLevel = getApiLevel();
		using android::net::gResNetdCallbacks;

PrivateDnsConfiguration.cpp

+13 −1

Original line number	Diff line number	Diff line
		@@ -18,6 +18,8 @@

		#include "PrivateDnsConfiguration.h"

		#include <algorithm>

		#include <android-base/format.h>
		#include <android-base/logging.h>
		#include <android-base/stringprintf.h>
		@@ -35,6 +37,7 @@
		using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;
		using aidl::android::net::resolv::aidl::PrivateDnsValidationEventParcel;
		using android::base::StringPrintf;
		using android::netdutils::IPAddress;
		using android::netdutils::setThreadName;
		using android::netdutils::Slice;
		using std::chrono::milliseconds;
		@@ -439,12 +442,21 @@ int PrivateDnsConfiguration::setDoh(int32_t netId, uint32_t mark,
		<< std::dec << ", " << servers.size() << ", " << name << ")";
		std::lock_guard guard(mPrivateDnsLock);

		// Sort the input servers to ensure that we could get the server vector at the same order.
		std::vector<std::string> sortedServers = servers;
		// Prefer ipv6.
		std::sort(sortedServers.begin(), sortedServers.end(), [](std::string a, std::string b) {
		IPAddress ipa = IPAddress::forString(a);
		IPAddress ipb = IPAddress::forString(b);
		return ipa > ipb;
		});

		initDohLocked();

		// TODO: 1. Improve how to choose the server
		// TODO: 2. Support multiple servers
		for (const auto& entry : mAvailableDoHProviders) {
		const auto& doh = entry.getDohIdentity(servers, name);
		const auto& doh = entry.getDohIdentity(sortedServers, name);
		if (!doh.ok()) continue;

		auto it = mDohTracker.find(netId);

doh.h

+22 −1

Original line number	Diff line number	Diff line
		@@ -34,6 +34,21 @@ static const ssize_t RESULT_CAN_NOT_SEND = -2;
		/// The return code of doh_query to indicate that the query timed out.
		static const ssize_t RESULT_TIMEOUT = -255;

		/// The error log level.
		static const uint32_t LOG_LEVEL_ERROR = 0;

		/// The warning log level.
		static const uint32_t LOG_LEVEL_WARN = 1;

		/// The info log level.
		static const uint32_t LOG_LEVEL_INFO = 2;

		/// The debug log level.
		static const uint32_t LOG_LEVEL_DEBUG = 3;

		/// The trace log level.
		static const uint32_t LOG_LEVEL_TRACE = 4;

		/// Context for a running DoH engine.
		struct DohDispatcher;

		@@ -42,7 +57,13 @@ using ValidationCallback = void ()(uint32_t net_id, bool success, const char i

		extern "C" {

		/// Performs static initialization for the DoH engine.
		/// Performs static initialization for android logger.
		void doh_init_logger(uint32_t level);

		/// Set the log level.
		void doh_set_log_level(uint32_t level);

		/// Performs the initialization for the DoH engine.
		/// Creates and returns a DoH engine instance.
		DohDispatcher* doh_dispatcher_new(ValidationCallback ptr);

doh.rs

+45 −7

Original line number	Diff line number	Diff line
		@@ -21,7 +21,7 @@ use futures::future::join_all;
		use futures::stream::FuturesUnordered;
		use futures::StreamExt;
		use libc::{c_char, int32_t, size_t, ssize_t, uint32_t, uint64_t};
		use log::{debug, error, info, warn};
		use log::{debug, error, info, trace, warn};
		use quiche::h3;
		use ring::rand::SecureRandom;
		use std::collections::HashMap;
		@@ -31,7 +31,7 @@ use std::ops::Deref;
		use std::os::unix::io::{AsRawFd, RawFd};
		use std::pin::Pin;
		use std::str::FromStr;
		use std::sync::Arc;
		use std::sync::{Arc, Once};
		use std::{ptr, slice};
		use tokio::net::UdpSocket;
		use tokio::runtime::{Builder, Runtime};
		@@ -40,12 +40,24 @@ use tokio::task;
		use tokio::time::{timeout, Duration, Instant};
		use url::Url;

		static INIT: Once = Once::new();

		/// The return code of doh_query means that there is no answer.
		pub const RESULT_INTERNAL_ERROR: ssize_t = -1;
		/// The return code of doh_query means that query can't be sent.
		pub const RESULT_CAN_NOT_SEND: ssize_t = -2;
		/// The return code of doh_query to indicate that the query timed out.
		pub const RESULT_TIMEOUT: ssize_t = -255;
		/// The error log level.
		pub const LOG_LEVEL_ERROR: u32 = 0;
		/// The warning log level.
		pub const LOG_LEVEL_WARN: u32 = 1;
		/// The info log level.
		pub const LOG_LEVEL_INFO: u32 = 2;
		/// The debug log level.
		pub const LOG_LEVEL_DEBUG: u32 = 3;
		/// The trace log level.
		pub const LOG_LEVEL_TRACE: u32 = 4;

		const MAX_BUFFERED_CMD_SIZE: usize = 400;
		const MAX_INCOMING_BUFFER_SIZE_WHOLE: u64 = 10000000;
		@@ -330,7 +342,7 @@ impl DohConnection {
		debug!("quiche::h3::Event::Data");
		let mut buf = vec![0; MAX_DATAGRAM_SIZE];
		if let Ok(read) = h3_conn.recv_body(&mut self.quic_conn, stream_id, &mut buf) {
		debug!(
		trace!(
		"got {} bytes of response data on stream {}: {:x?}",
		read,
		stream_id,
		@@ -648,7 +660,7 @@ async fn doh_handler(
		info!("probe_futures remaining size: {}", probe_futures.len());
		},
		Some(cmd) = cmd_rx.recv() => {
		info!("recv {:?}", cmd);
		trace!("recv {:?}", cmd);
		match cmd {
		DohCommand::Probe { info, timeout: t } => {
		match make_connection_if_needed(&info, &mut doh_conn_map, &mut config_cache) {
		@@ -714,7 +726,7 @@ fn make_doh_udp_socket(peer_addr: SocketAddr, mark: u32) -> Result<std::net::Udp
		}
		udp_sk.connect(peer_addr)?;

		info!("connecting to {:} from {:}", peer_addr, udp_sk.local_addr()?);
		debug!("connecting to {:} from {:}", peer_addr, udp_sk.local_addr()?);
		Ok(udp_sk)
		}

		@@ -784,11 +796,37 @@ fn make_probe_query() -> Result<String> {
		Ok(base64::encode_config(query, base64::URL_SAFE_NO_PAD))
		}

		/// Performs static initialization for the DoH engine.
		/// Performs static initialization for android logger.
		#[no_mangle]
		pub extern "C" fn doh_init_logger(level: u32) {
		INIT.call_once(\|\| {
		let level = match level {
		LOG_LEVEL_WARN => log::Level::Warn,
		LOG_LEVEL_DEBUG => log::Level::Debug,
		_ => log::Level::Error,
		};
		android_logger::init_once(android_logger::Config::default().with_min_level(level));
		});
		}

		/// Set the log level.
		#[no_mangle]
		pub extern "C" fn doh_set_log_level(level: u32) {
		let level = match level {
		LOG_LEVEL_ERROR => log::LevelFilter::Error,
		LOG_LEVEL_WARN => log::LevelFilter::Warn,
		LOG_LEVEL_INFO => log::LevelFilter::Info,
		LOG_LEVEL_DEBUG => log::LevelFilter::Debug,
		LOG_LEVEL_TRACE => log::LevelFilter::Trace,
		_ => log::LevelFilter::Off,
		};
		log::set_max_level(level);
		}

		/// Performs the initialization for the DoH engine.
		/// Creates and returns a DoH engine instance.
		#[no_mangle]
		pub extern "C" fn doh_dispatcher_new(ptr: ValidationCallback) -> *mut DohDispatcher {
		android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Info));
		match DohDispatcher::new(ptr) {
		Ok(c) => Box::into_raw(c),
		Err(e) => {