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

Commit a0c18b82 authored by Paul Hu's avatar Paul Hu Committed by Automerger Merge Worker
Browse files

Merge "[DRUEL03] Implement unsolicited private DNS validation event" am: 34c67cbd 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/DnsResolver/+/1527454

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: Ie05a32c65c44e98bb3b373ac62dad0a5efea4f1d
parents 9eb8ce96 34c67cbd

PrivateDnsConfiguration.cpp

+33 −13
Original line number Diff line number Diff line
@@ -30,6 +30,8 @@ 
#include "netdutils/BackoffSequence.h"

#include "util.h"



using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;

using aidl::android::net::resolv::aidl::PrivateDnsValidationEventParcel;

using android::base::StringPrintf;

using android::netdutils::setThreadName;

using std::chrono::milliseconds;
@@ -222,6 +224,35 @@ void PrivateDnsConfiguration::startValidation(const DnsTlsServer& server, unsign 
    validate_thread.detach();

}



void PrivateDnsConfiguration::sendPrivateDnsValidationEvent(const DnsTlsServer& server,

                                                            unsigned netId, bool success) {

    LOG(DEBUG) << "Sending validation " << (success ? "success" : "failure") << " event on netId "

               << netId << " for " << server.toIpString() << " with hostname {" << server.name

               << "}";

    // Send a validation event to NetdEventListenerService.

    const auto& listeners = ResolverEventReporter::getInstance().getListeners();

    if (listeners.empty()) {

        LOG(ERROR)

                << "Validation event not sent since no INetdEventListener receiver is available.";

    }

    for (const auto& it : listeners) {

        it->onPrivateDnsValidationEvent(netId, server.toIpString(), server.name, success);

    }



    // Send a validation event to unsolicited event listeners.

    const auto& unsolEventListeners = ResolverEventReporter::getInstance().getUnsolEventListeners();

    const PrivateDnsValidationEventParcel validationEvent = {

            .netId = static_cast<int32_t>(netId),

            .ipAddress = server.toIpString(),

            .hostname = server.name,

            .validation = success ? IDnsResolverUnsolicitedEventListener::VALIDATION_RESULT_SUCCESS

                                  : IDnsResolverUnsolicitedEventListener::VALIDATION_RESULT_FAILURE,

    };

    for (const auto& it : unsolEventListeners) {

        it->onPrivateDnsValidationEvent(validationEvent);

    }

}



bool PrivateDnsConfiguration::recordPrivateDnsValidation(const DnsTlsServer& server, unsigned netId,

                                                         bool success) {

    constexpr bool NEEDS_REEVALUATION = true;
@@ -268,19 +299,8 @@ bool PrivateDnsConfiguration::recordPrivateDnsValidation(const DnsTlsServer& ser 
        reevaluationStatus = DONT_REEVALUATE;

    }



    // Send a validation event to NetdEventListenerService.

    const auto& listeners = ResolverEventReporter::getInstance().getListeners();

    if (listeners.size() != 0) {

        for (const auto& it : listeners) {

            it->onPrivateDnsValidationEvent(netId, server.toIpString(), server.name, success);

        }

        LOG(DEBUG) << "Sent validation " << (success ? "success" : "failure") << " event on netId "

                   << netId << " for " << server.toIpString() << " with hostname {" << server.name

                   << "}";

    } else {

        LOG(ERROR)

                << "Validation event not sent since no INetdEventListener receiver is available.";

    }

    // Send private dns validation result to listeners.

    sendPrivateDnsValidationEvent(server, netId, success);



    if (success) {

        updateServerState(identity, Validation::success, netId);

PrivateDnsConfiguration.h

+3 −0
Original line number Diff line number Diff line
@@ -103,6 +103,9 @@ class PrivateDnsConfiguration { 
    bool recordPrivateDnsValidation(const DnsTlsServer& server, unsigned netId, bool success)

            EXCLUDES(mPrivateDnsLock);



    void sendPrivateDnsValidationEvent(const DnsTlsServer& server, unsigned netId, bool success)

            REQUIRES(mPrivateDnsLock);



    // Decide if a validation for |server| is needed. Note that servers that have failed

    // multiple validation attempts but for which there is still a validating

    // thread running are marked as being Validation::in_process.

tests/dnsresolver_binder_test.cpp

+5 −5
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ using android::base::StringPrintf; 
using android::base::unique_fd;

using android::net::ResolverStats;

using android::net::metrics::TestOnDnsEvent;

using android::net::resolv::aidl::UnsolicitedEventListener;

using android::netdutils::Stopwatch;



// TODO: make this dynamic and stop depending on implementation details.
@@ -302,17 +303,16 @@ TEST_F(DnsResolverBinderTest, RegisterUnsolicitedEventListener_NullListener) { 
}



TEST_F(DnsResolverBinderTest, RegisterUnsolicitedEventListener_DuplicateSubscription) {

    class FakeListener : public android::net::resolv::aidl::UnsolicitedEventListener {};



    // Expect to subscribe successfully.

    std::shared_ptr<FakeListener> fakeListener = ndk::SharedRefBase::make<FakeListener>();

    ::ndk::ScopedAStatus status = mDnsResolver->registerUnsolicitedEventListener(fakeListener);

    std::shared_ptr<UnsolicitedEventListener> listener =

            ndk::SharedRefBase::make<UnsolicitedEventListener>(TEST_NETID);

    ::ndk::ScopedAStatus status = mDnsResolver->registerUnsolicitedEventListener(listener);

    ASSERT_TRUE(status.isOk()) << status.getMessage();

    mExpectedLogData.push_back(

            {"registerUnsolicitedEventListener()", "registerUnsolicitedEventListener.*"});



    // Expect to subscribe failed with registered listener instance.

    status = mDnsResolver->registerUnsolicitedEventListener(fakeListener);

    status = mDnsResolver->registerUnsolicitedEventListener(listener);

    ASSERT_FALSE(status.isOk());

    ASSERT_EQ(EEXIST, status.getServiceSpecificError());

    mExpectedLogData.push_back(

tests/resolv_integration_test.cpp

+21 −2
Original line number Diff line number Diff line
@@ -71,6 +71,7 @@ 
#include "tests/dns_responder/dns_tls_frontend.h"

#include "tests/resolv_test_utils.h"

#include "tests/tun_forwarder.h"

#include "tests/unsolicited_listener/unsolicited_event_listener.h"



// Valid VPN netId range is 100 ~ 65535

constexpr int TEST_VPN_NETID = 65502;
@@ -94,6 +95,8 @@ using aidl::android::net::IDnsResolver; 
using aidl::android::net::INetd;

using aidl::android::net::ResolverParamsParcel;

using aidl::android::net::metrics::INetdEventListener;

using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;

using aidl::android::net::resolv::aidl::PrivateDnsValidationEventParcel;

using android::base::Error;

using android::base::ParseInt;

using android::base::Result;
@@ -102,6 +105,7 @@ using android::base::unique_fd; 
using android::net::ResolverStats;

using android::net::TunForwarder;

using android::net::metrics::DnsMetricsListener;

using android::net::resolv::aidl::UnsolicitedEventListener;

using android::netdutils::enableSockopt;

using android::netdutils::makeSlice;

using android::netdutils::ResponseCode;
@@ -204,6 +208,12 @@ class ResolverTest : public ::testing::Test { 
                TEST_NETID /*monitor specific network*/);

        ASSERT_TRUE(resolvService->registerEventListener(sDnsMetricsListener).isOk());



        // Subscribe the unsolicited event listener for verifying unsolicited event contents.

        sUnsolicitedEventListener = ndk::SharedRefBase::make<UnsolicitedEventListener>(

                TEST_NETID /*monitor specific network*/);

        ASSERT_TRUE(

                resolvService->registerUnsolicitedEventListener(sUnsolicitedEventListener).isOk());



        // Start the binder thread pool for listening DNS metrics events and receiving death

        // recipient.

        ABinderProcess_startThreadPool();
@@ -214,6 +224,7 @@ class ResolverTest : public ::testing::Test { 
    void SetUp() {

        mDnsClient.SetUp();

        sDnsMetricsListener->reset();

        sUnsolicitedEventListener->reset();

    }



    void TearDown() {
@@ -251,11 +262,16 @@ class ResolverTest : public ::testing::Test { 
    }



    bool WaitForPrivateDnsValidation(std::string serverAddr, bool validated) {

        return sDnsMetricsListener->waitForPrivateDnsValidation(serverAddr, validated);

        return sDnsMetricsListener->waitForPrivateDnsValidation(serverAddr, validated) &&

               sUnsolicitedEventListener->waitForPrivateDnsValidation(

                       serverAddr,

                       validated ? IDnsResolverUnsolicitedEventListener::VALIDATION_RESULT_SUCCESS

                                 : IDnsResolverUnsolicitedEventListener::VALIDATION_RESULT_FAILURE);

    }



    bool hasUncaughtPrivateDnsValidation(const std::string& serverAddr) {

        return sDnsMetricsListener->findValidationRecord(serverAddr);

        return sDnsMetricsListener->findValidationRecord(serverAddr) &&

               sUnsolicitedEventListener->findValidationRecord(serverAddr);

    }



    void ExpectDnsEvent(int32_t eventType, int32_t returnCode, const std::string& hostname,
@@ -367,6 +383,9 @@ class ResolverTest : public ::testing::Test { 
    static std::shared_ptr<DnsMetricsListener>

            sDnsMetricsListener;  // Initialized in SetUpTestSuite.



    inline static std::shared_ptr<UnsolicitedEventListener>

            sUnsolicitedEventListener;  // Initialized in SetUpTestSuite.



    // Use a shared static death recipient to monitor the service death. The static death

    // recipient could monitor the death not only during the test but also between tests.

    static AIBinder_DeathRecipient* sResolvDeathRecipient;  // Initialized in SetUpTestSuite.

tests/unsolicited_listener/unsolicited_event_listener.cpp

+46 −5
Original line number Diff line number Diff line
@@ -16,24 +16,65 @@ 


#include "unsolicited_event_listener.h"



#include <thread>



#include <android-base/chrono_utils.h>

#include <android-base/format.h>



namespace android::net::resolv::aidl {



using ::aidl::android::net::resolv::aidl::PrivateDnsValidationEventParcel;

using android::base::ScopedLockAssertion;

using std::chrono::milliseconds;



constexpr milliseconds kEventTimeoutMs{5000};



::ndk::ScopedAStatus UnsolicitedEventListener::onDnsHealthEvent(

        const ::aidl::android::net::resolv::aidl::DnsHealthEventParcel&) {

    // default no-op

    return ::ndk::ScopedAStatus::ok();

};

}



::ndk::ScopedAStatus UnsolicitedEventListener::onNat64PrefixEvent(

        const ::aidl::android::net::resolv::aidl::Nat64PrefixEventParcel&) {

    // default no-op

    return ::ndk::ScopedAStatus::ok();

};

}



::ndk::ScopedAStatus UnsolicitedEventListener::onPrivateDnsValidationEvent(

        const ::aidl::android::net::resolv::aidl::PrivateDnsValidationEventParcel&) {

    // default no-op

        const PrivateDnsValidationEventParcel& event) {

    {

        std::lock_guard lock(mMutex);

        // keep updating the server to have latest validation status.

        mValidationRecords.insert_or_assign({event.netId, event.ipAddress}, event.validation);

    }

    mCv.notify_one();

    return ::ndk::ScopedAStatus::ok();

};

}



bool UnsolicitedEventListener::waitForPrivateDnsValidation(const std::string& serverAddr,

                                                           int validation) {

    const auto now = std::chrono::steady_clock::now();



    std::unique_lock lock(mMutex);

    ScopedLockAssertion assume_lock(mMutex);



    // onPrivateDnsValidationEvent() might already be invoked. Search for the record first.

    do {

        if (findAndRemoveValidationRecord({mNetId, serverAddr}, validation)) return true;

    } while (mCv.wait_until(lock, now + kEventTimeoutMs) != std::cv_status::timeout);



    // Timeout.

    return false;

}



bool UnsolicitedEventListener::findAndRemoveValidationRecord(const ServerKey& key, int value) {

    auto it = mValidationRecords.find(key);

    if (it != mValidationRecords.end() && it->second == value) {

        mValidationRecords.erase(it);

        return true;

    }

    return false;

}



}  // namespace android::net::resolv::aidl