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

Commit c01df626 authored by Lorenzo Colitti's avatar Lorenzo Colitti Committed by Luke Huang
Browse files

Make DNS cache lifecycle management explicit 

1. Add binder call to support creating cache by netid.
2. revise call flow in res_cache.cpp, not create cache in
   resolv_set_nameservers_for_net().
3. revise Log method in ResolverController.cpp

Bug: 129453995
Test: built, flashed, booted
      system/netd/tests/runtests.sh pass

Merged-In: If1cefa446c83cf9b35763a03d4076fb565c25841
(cherry picked from commit 06cea11bea6da1df3efa348060ed36f2a592e501)

Change-Id: I70341f4e5604b111a9672e4eff8b34b8da41f989
parent 64168ba8

DnsResolverService.cpp

+14 −2
Original line number Diff line number Diff line
@@ -278,15 +278,27 @@ static std::vector<uint8_t> parseBase64(const std::string& input) { 
    return ::ndk::ScopedAStatus(AStatus_newOk());

}



::ndk::ScopedAStatus DnsResolverService::clearResolverConfiguration(int netId) {

::ndk::ScopedAStatus DnsResolverService::destroyNetworkCache(int netId) {

    // Locking happens in res_cache.cpp functions.

    ENFORCE_NETWORK_STACK_PERMISSIONS();

    auto entry = gDnsResolverLog.newEntry().prettyFunction(__PRETTY_FUNCTION__).arg(netId);



    gDnsResolv->resolverCtrl.clearDnsServers(netId);

    gDnsResolv->resolverCtrl.destroyNetworkCache(netId);



    gResNetdCallbacks.log(entry.withAutomaticDuration().toString().c_str());

    return ::ndk::ScopedAStatus(AStatus_newOk());

}



::ndk::ScopedAStatus DnsResolverService::createNetworkCache(int netId) {

    // Locking happens in res_cache.cpp functions.

    ENFORCE_NETWORK_STACK_PERMISSIONS();

    auto entry = gDnsResolverLog.newEntry().prettyFunction(__PRETTY_FUNCTION__).arg(netId);



    int res = gDnsResolv->resolverCtrl.createNetworkCache(netId);



    gResNetdCallbacks.log(entry.returns(res).withAutomaticDuration().toString().c_str());

    return statusFromErrcode(res);

}



}  // namespace net

}  // namespace android

DnsResolverService.h

+2 −1
Original line number Diff line number Diff line
@@ -48,7 +48,8 @@ class DnsResolverService : public aidl::android::net::BnDnsResolver { 
            std::vector<std::string>* tlsServers, std::vector<int32_t>* params,

            std::vector<int32_t>* stats,

            std::vector<int32_t>* wait_for_pending_req_timeout_count) override;

    ::ndk::ScopedAStatus clearResolverConfiguration(int32_t netId) override;

    ::ndk::ScopedAStatus destroyNetworkCache(int32_t netId) override;

    ::ndk::ScopedAStatus createNetworkCache(int32_t netId) override;



    // DNS64-related commands

    ::ndk::ScopedAStatus startPrefix64Discovery(int32_t netId) override;

ResolverController.cpp

+18 −15
Original line number Diff line number Diff line
@@ -15,7 +15,6 @@ 
 */



#define LOG_TAG "ResolverController"

#define DBG 0



#include "ResolverController.h"
@@ -26,8 +25,8 @@ 
#include <netdb.h>



#include <aidl/android/net/IDnsResolver.h>

#include <android-base/logging.h>

#include <android-base/strings.h>

#include <log/log.h>



#include "Dns64Configuration.h"

#include "DnsResolver.h"
@@ -86,7 +85,7 @@ constexpr const char* validationStatusToString(Validation value) { 
void sendNat64PrefixEvent(const Dns64Configuration::Nat64PrefixInfo& args) {

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

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

        ALOGE("No available listener. dropping NAT64 prefix event");

        LOG(ERROR) << __func__ << ": No available listener. dropping NAT64 prefix event";

        return;

    }

    for (const auto& it : listeners) {
@@ -132,7 +131,7 @@ int getDnsInfo(unsigned netId, std::vector<std::string>* servers, std::vector<st 


    // Verify that the returned data is sane.

    if (nscount < 0 || nscount > MAXNS || dcount < 0 || dcount > MAXDNSRCH) {

        ALOGE("%s: nscount=%d, dcount=%d", __FUNCTION__, nscount, dcount);

        LOG(ERROR) << __func__ << ": nscount = " << nscount << ", dcount = " << dcount;

        return -ENOTRECOVERABLE;

    }
@@ -152,7 +151,7 @@ int getDnsInfo(unsigned netId, std::vector<std::string>* servers, std::vector<st 
        if (rv == 0) {

            server_str.assign(hbuf);

        } else {

            ALOGE("getnameinfo() failed for server #%d: %s", i, gai_strerror(rv));

            LOG(ERROR) << "getnameinfo() failed for server #" << i << ": " << gai_strerror(rv);

            server_str.assign("<invalid>");

        }

        servers->push_back(std::move(server_str));
@@ -181,14 +180,18 @@ ResolverController::ResolverController() 
              },

              std::bind(sendNat64PrefixEvent, _1)) {}



int ResolverController::clearDnsServers(unsigned netId) {

    if (DBG) {

        ALOGD("clearDnsServers netId = %u\n", netId);

    }

void ResolverController::destroyNetworkCache(unsigned netId) {

    LOG(VERBOSE) << __func__ << ": netId = " << netId;



    resolv_delete_cache_for_net(netId);

    mDns64Configuration.stopPrefixDiscovery(netId);

    resolv_delete_private_dns_for_net(netId);

    return 0;

}



int ResolverController::createNetworkCache(unsigned netId) {

    LOG(VERBOSE) << __func__ << ": netId = " << netId;



    return resolv_create_cache_for_net(netId);

}



// TODO: remove below functions and call into PrivateDnsConfiguration directly.
@@ -249,10 +252,9 @@ int ResolverController::setResolverConfiguration( 
    res_params.base_timeout_msec = resolverParams.baseTimeoutMsec;

    res_params.retry_count = resolverParams.retryCount;



    if (DBG) {

        ALOGD("setDnsServers netId = %u, numservers = %zu", resolverParams.netId,

              resolverParams.domains.size());

    }

    LOG(VERBOSE) << "setDnsServers netId = " << resolverParams.netId

                 << ", numservers = " << resolverParams.domains.size();



    return -resolv_set_nameservers_for_net(resolverParams.netId, server_ptrs.data(),

                                           server_ptrs.size(), domains_str.c_str(), &res_params);

}
@@ -304,7 +306,8 @@ void ResolverController::stopPrefix64Discovery(int32_t netId) { 
int ResolverController::getPrefix64(unsigned netId, netdutils::IPPrefix* prefix) {

    netdutils::IPPrefix p = mDns64Configuration.getPrefix64(netId);

    if (p.family() != AF_INET6 || p.length() == 0) {

        ALOGE("No valid NAT64 prefix (%d,%s)\n", netId, p.toString().c_str());

        LOG(ERROR) << "No valid NAT64 prefix (" << netId << ", " << p.toString().c_str() << ")";



        return -ENOENT;

    }

    *prefix = p;

ResolverController.h

+2 −1
Original line number Diff line number Diff line
@@ -38,7 +38,8 @@ class ResolverController { 
    ResolverController();

    ~ResolverController() = default;



    int clearDnsServers(unsigned netid);

    void destroyNetworkCache(unsigned netid);

    int createNetworkCache(unsigned netid);



    int getPrefix64(unsigned netId, netdutils::IPPrefix* prefix);

binder/android/net/IDnsResolver.aidl

+12 −3
Original line number Diff line number Diff line
@@ -130,9 +130,18 @@ interface IDnsResolver { 
    @utf8InCpp String getPrefix64(int netId);



    /**

     * Clear DNS servers and resolver configurations for the given network.

     * Create cache for the given network.

     *

     * @param netId the network ID of the network to clear.

     * @param netId the network ID of the network to create.

     * @throws ServiceSpecificException in case of failure, with an error code indicating the

     *         cause of the failure.

     */

    void createNetworkCache(int netId);



    /**

     * Destroy cache for the given network.

     *

     * @param netId the network ID of the network to destroy.

     */

    void clearResolverConfiguration(int netId);

    void destroyNetworkCache(int netId);

}