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

Commit 9b80e6cb authored by Luke Huang's avatar 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

Change-Id: I31ab521027a08bce3c721b2a36418faca85853c7
parent 11561ffe

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

+19 −16
Original line number Diff line number Diff line
@@ -14,8 +14,7 @@ 
 * limitations under the License.

 */



#define LOG_TAG "resolv"

#define DBG 0

#define LOG_TAG "ResolverController"



#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);

}