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

Commit c6bbbe71 authored by Luke Huang's avatar Luke Huang
Browse files

Add log and dump for dnsResolver service 

Use log callback from netd server to print binder log.
Also add dump functionality.

blueline:/ # dumpsys dnsresolver
NetId: 100
  DNS servers: # IP (total, successes, errors, timeouts, internal errors, RTT avg, last sample)
    2001:4860:4860::8844 (1, 1, 0, 0, 0, 15ms, 5195s)
    2001:4860:4860::8888 <no data>
    8.8.8.8 <no data>
    8.8.4.4 <no data>
  No search domains defined
  DNS parameters: sample validity = 1800s, success threshold = 25%, samples (min, max) = (8, 64), base_timeout = 5000msec, retry count = 2times
  DNS64 config: none
  Private DNS mode: OPPORTUNISTIC
  Private DNS configuration (4 entries)
    8.8.4.4 name{} status{success}
    8.8.8.8 name{} status{success}
    2001:4860:4860::8844 name{} status{success}
    2001:4860:4860::8888 name{} status{success}
  Concurrent DNS query timeout: 0


Bug: 126141549
Test: built, flashed, booted
      system/netd/tests/runtests.sh pass
      Verified that log is shown in both "dumpsys netd"
      and "dumpsys dnsresolver"

Change-Id: I06382f811343f3dd52f246da5c5e03b70eeda0e1
parent a4be3c8e

DnsResolver.cpp

+1 −0
Original line number Diff line number Diff line
@@ -51,6 +51,7 @@ bool verifyCallbacks() { 


DnsResolver* gDnsResolv = nullptr;

ResolverNetdCallbacks gResNetdCallbacks;

netdutils::Log gDnsResolverLog("dnsResolver");



DnsResolver* DnsResolver::getInstance() {

    // Instantiated on first use.

DnsResolver.h

+2 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include "DnsProxyListener.h"

#include "ResolverController.h"

#include "netd_resolv/resolv.h"

#include "netdutils/Log.h"



namespace android {

namespace net {
@@ -41,6 +42,7 @@ class DnsResolver { 


extern DnsResolver* gDnsResolv;

extern ResolverNetdCallbacks gResNetdCallbacks;

extern netdutils::Log gDnsResolverLog;



}  // namespace net

}  // namespace android

DnsResolverService.cpp

+40 −3
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
#include "NetdPermissions.h"  // PERM_*

#include "ResolverEventReporter.h"

#include "netdutils/DumpWriter.h"

#include "resolv_cache.h"



using android::base::Join;

using android::base::StringPrintf;
@@ -85,9 +86,21 @@ binder_status_t DnsResolverService::start() { 
    return STATUS_OK;

}



binder_status_t DnsResolverService::dump(int, const char**, uint32_t) {

    // TODO: Implement it. Netd binder dump resolver related log based on all stored network.

    //       However, resolver doesn't know that informations.

binder_status_t DnsResolverService::dump(int fd, const char**, uint32_t) {

    auto dump_permission = checkAnyPermission({PERM_DUMP});

    if (!dump_permission.isOk()) {

        return STATUS_PERMISSION_DENIED;

    }



    // This method does not grab any locks. If individual classes need locking

    // their dump() methods MUST handle locking appropriately.

    DumpWriter dw(fd);

    for (auto netId : resolv_list_caches()) {

        dw.println("NetId: %u", netId);

        gDnsResolv->resolverCtrl.dump(dw, netId);

        dw.blankline();

    }



    return STATUS_OK;

}
@@ -102,9 +115,11 @@ binder_status_t DnsResolverService::dump(int, const char**, uint32_t) { 
::ndk::ScopedAStatus DnsResolverService::registerEventListener(

        const std::shared_ptr<aidl::android::net::metrics::INetdEventListener>& listener) {

    ENFORCE_NETWORK_STACK_PERMISSIONS();

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



    int res = ResolverEventReporter::getInstance().addListener(listener);



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

    return statusFromErrcode(res);

}
@@ -177,6 +192,10 @@ static std::vector<uint8_t> parseBase64(const std::string& input) { 
        const std::vector<std::string>& tlsFingerprints) {

    // Locking happens in PrivateDnsConfiguration and res_* functions.

    ENFORCE_INTERNAL_PERMISSIONS();

    auto entry =

            gDnsResolverLog.newEntry()

                    .prettyFunction(__PRETTY_FUNCTION__)

                    .args(netId, servers, domains, params, tlsName, tlsServers, tlsFingerprints);



    std::set<std::vector<uint8_t>> decoded_fingerprints;

    for (const std::string& fingerprint : tlsFingerprints) {
@@ -190,6 +209,8 @@ static std::vector<uint8_t> parseBase64(const std::string& input) { 


    int err = gDnsResolv->resolverCtrl.setResolverConfiguration(

            netId, servers, domains, params, tlsName, tlsServers, decoded_fingerprints);



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

    if (err != 0) {

        return ::ndk::ScopedAStatus(AStatus_fromServiceSpecificErrorWithMessage(

                -err, StringPrintf("ResolverController error: %s", strerror(-err)).c_str()));
@@ -203,9 +224,12 @@ static std::vector<uint8_t> parseBase64(const std::string& input) { 
        std::vector<int32_t>* stats, std::vector<int32_t>* wait_for_pending_req_timeout_count) {

    // Locking happens in PrivateDnsConfiguration and res_* functions.

    ENFORCE_NETWORK_STACK_PERMISSIONS();

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



    int err = gDnsResolv->resolverCtrl.getResolverInfo(netId, servers, domains, tlsServers, params,

                                                       stats, wait_for_pending_req_timeout_count);



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

    if (err != 0) {

        return ::ndk::ScopedAStatus(AStatus_fromServiceSpecificErrorWithMessage(

                -err, StringPrintf("ResolverController error: %s", strerror(-err)).c_str()));
@@ -216,23 +240,33 @@ static std::vector<uint8_t> parseBase64(const std::string& input) { 
::ndk::ScopedAStatus DnsResolverService::startPrefix64Discovery(int32_t netId) {

    // Locking happens in Dns64Configuration.

    ENFORCE_NETWORK_STACK_PERMISSIONS();

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



    gDnsResolv->resolverCtrl.startPrefix64Discovery(netId);



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

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

}



::ndk::ScopedAStatus DnsResolverService::stopPrefix64Discovery(int32_t netId) {

    // Locking happens in Dns64Configuration.

    ENFORCE_NETWORK_STACK_PERMISSIONS();

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



    gDnsResolv->resolverCtrl.stopPrefix64Discovery(netId);



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

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

}



::ndk::ScopedAStatus DnsResolverService::getPrefix64(int netId, std::string* stringPrefix) {

    ENFORCE_NETWORK_STACK_PERMISSIONS();

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



    netdutils::IPPrefix prefix{};

    int err = gDnsResolv->resolverCtrl.getPrefix64(netId, &prefix);



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

    if (err != 0) {

        return ::ndk::ScopedAStatus(AStatus_fromServiceSpecificErrorWithMessage(

                -err, StringPrintf("ResolverController error: %s", strerror(-err)).c_str()));
@@ -244,8 +278,11 @@ static std::vector<uint8_t> parseBase64(const std::string& input) { 


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

    ENFORCE_NETWORK_STACK_PERMISSIONS();

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



    gDnsResolv->resolverCtrl.clearDnsServers(netId);



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

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

}