Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 26e6113f authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 7567469 from 79cbc90e to tm-release 

Change-Id: I18b96b1c6f139421b4ec3012437a3d9e42702580
parents 931f2837 79cbc90e

Android.bp

+2 −1
Original line number Diff line number Diff line
@@ -400,7 +400,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) => {