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

Commit 6024824b authored by Mike Yu's avatar Mike Yu
Browse files

Clean up gPrivateDnsConfiguration 

Use singleton to get an instance of PrivateDnsConfiguration.
The lifetime of the instance is almost aligned with the
DnsResolver service.

Bug: 130686826
Test: cd packages/modules/DnsResolver && atest
Change-Id: Id71f90c7d0508eacd1b20db42408a78d9ea1e03a
parent 914656b6

DnsProxyListener.cpp

+2 −2
Original line number Diff line number Diff line
@@ -116,7 +116,7 @@ constexpr bool requestingUseLocalNameservers(unsigned flags) { 
}



bool queryingViaTls(unsigned dns_netid) {

    const auto privateDnsStatus = gPrivateDnsConfiguration.getStatus(dns_netid);

    const auto privateDnsStatus = PrivateDnsConfiguration::getInstance().getStatus(dns_netid);

    switch (privateDnsStatus.mode) {

        case PrivateDnsMode::OPPORTUNISTIC:

            return !privateDnsStatus.validatedServers().empty();
@@ -294,7 +294,7 @@ bool parseQuery(const uint8_t* msg, size_t msgLen, uint16_t* query_id, int* rr_t 
// Note: Even if it returns PDM_OFF, it doesn't mean there's no DoT stats in the message

// because Private DNS mode can change at any time.

PrivateDnsModes getPrivateDnsModeForMetrics(uint32_t netId) {

    switch (gPrivateDnsConfiguration.getStatus(netId).mode) {

    switch (PrivateDnsConfiguration::getInstance().getStatus(netId).mode) {

        case PrivateDnsMode::OFF:

            // It can also be due to netId not found.

            return PrivateDnsModes::PDM_OFF;

PrivateDnsConfiguration.cpp

+0 −2
Original line number Diff line number Diff line
@@ -350,7 +350,5 @@ bool PrivateDnsConfiguration::needsValidation(const PrivateDnsTracker& tracker, 
    return (iter == tracker.end()) || (iter->second == Validation::fail);

}



PrivateDnsConfiguration gPrivateDnsConfiguration;



}  // namespace net

}  // namespace android

PrivateDnsConfiguration.h

+8 −2
Original line number Diff line number Diff line
@@ -52,6 +52,12 @@ struct PrivateDnsStatus { 


class PrivateDnsConfiguration {

  public:

    // The only instance of PrivateDnsConfiguration.

    static PrivateDnsConfiguration& getInstance() {

        static PrivateDnsConfiguration instance;

        return instance;

    }



    int set(int32_t netId, uint32_t mark, const std::vector<std::string>& servers,

            const std::string& name, const std::string& caCert) EXCLUDES(mPrivateDnsLock);
@@ -63,6 +69,8 @@ class PrivateDnsConfiguration { 
    typedef std::map<DnsTlsServer, Validation, AddressComparator> PrivateDnsTracker;

    typedef std::set<DnsTlsServer, AddressComparator> ThreadTracker;



    PrivateDnsConfiguration() = default;



    void validatePrivateDnsProvider(const DnsTlsServer& server, PrivateDnsTracker& tracker,

                                    unsigned netId, uint32_t mark) REQUIRES(mPrivateDnsLock);
@@ -85,7 +93,5 @@ class PrivateDnsConfiguration { 
    std::map<unsigned, ThreadTracker> mPrivateDnsValidateThreads GUARDED_BY(mPrivateDnsLock);

};



extern PrivateDnsConfiguration gPrivateDnsConfiguration;



}  // namespace net

}  // namespace android

ResolverController.cpp

+6 −6
Original line number Diff line number Diff line
@@ -184,7 +184,7 @@ void ResolverController::destroyNetworkCache(unsigned netId) { 


    resolv_delete_cache_for_net(netId);

    mDns64Configuration.stopPrefixDiscovery(netId);

    gPrivateDnsConfiguration.clear(netId);

    PrivateDnsConfiguration::getInstance().clear(netId);

}



int ResolverController::createNetworkCache(unsigned netId) {
@@ -215,9 +215,9 @@ int ResolverController::setResolverConfiguration(const ResolverParamsParcel& res 
    // through a different network. For example, on a VPN with no DNS servers (Do53), if the VPN

    // applies to UID 0, dns_mark is assigned for default network rathan the VPN. (note that it's

    // possible that a VPN doesn't have any DNS servers but DoT servers in DNS strict mode)

    const int err =

            gPrivateDnsConfiguration.set(resolverParams.netId, netcontext.app_mark, tlsServers,

                                         resolverParams.tlsName, resolverParams.caCertificate);

    const int err = PrivateDnsConfiguration::getInstance().set(

            resolverParams.netId, netcontext.app_mark, tlsServers, resolverParams.tlsName,

            resolverParams.caCertificate);



    if (err != 0) {

        return err;
@@ -254,7 +254,7 @@ int ResolverController::getResolverInfo(int32_t netId, std::vector<std::string>* 
    // Serialize the information for binder.

    ResolverStats::encodeAll(res_stats, stats);



    const auto privateDnsStatus = gPrivateDnsConfiguration.getStatus(netId);

    const auto privateDnsStatus = PrivateDnsConfiguration::getInstance().getStatus(netId);

    for (const auto& pair : privateDnsStatus.serversMap) {

        tlsServers->push_back(addrToString(&pair.first.ss));

    }
@@ -347,7 +347,7 @@ void ResolverController::dump(DumpWriter& dw, unsigned netId) { 
        }



        mDns64Configuration.dump(dw, netId);

        const auto privateDnsStatus = gPrivateDnsConfiguration.getStatus(netId);

        const auto privateDnsStatus = PrivateDnsConfiguration::getInstance().getStatus(netId);

        dw.println("Private DNS mode: %s", getPrivateDnsModeString(privateDnsStatus.mode));

        if (privateDnsStatus.serversMap.size() == 0) {

            dw.println("No Private DNS servers configured");

res_send.cpp

+5 −4
Original line number Diff line number Diff line
@@ -125,7 +125,6 @@ using android::net::CacheStatus; 
using android::net::DnsQueryEvent;

using android::net::DnsTlsDispatcher;

using android::net::DnsTlsTransport;

using android::net::gPrivateDnsConfiguration;

using android::net::IpVersion;

using android::net::IV_IPV4;

using android::net::IV_IPV6;
@@ -135,6 +134,7 @@ using android::net::NetworkDnsEventReported; 
using android::net::NS_T_INVALID;

using android::net::NsRcode;

using android::net::NsType;

using android::net::PrivateDnsConfiguration;

using android::net::PrivateDnsMode;

using android::net::PrivateDnsModes;

using android::net::PrivateDnsStatus;
@@ -1209,7 +1209,8 @@ static int res_tls_send(res_state statp, const Slice query, const Slice answer, 
    int resplen = 0;

    const unsigned netId = statp->netid;



    PrivateDnsStatus privateDnsStatus = gPrivateDnsConfiguration.getStatus(netId);

    auto& privateDnsConfiguration = PrivateDnsConfiguration::getInstance();

    PrivateDnsStatus privateDnsStatus = privateDnsConfiguration.getStatus(netId);

    statp->event->set_private_dns_modes(convertEnumType(privateDnsStatus.mode));



    if (privateDnsStatus.mode == PrivateDnsMode::OFF) {
@@ -1238,8 +1239,8 @@ static int res_tls_send(res_state statp, const Slice query, const Slice answer, 
                std::this_thread::sleep_for(std::chrono::milliseconds(100));

                // Calling getStatus() to merely check if there's any validated server seems

                // wasteful. Consider adding a new method in PrivateDnsConfiguration for speed ups.

                if (!gPrivateDnsConfiguration.getStatus(netId).validatedServers().empty()) {

                    privateDnsStatus = gPrivateDnsConfiguration.getStatus(netId);

                if (!privateDnsConfiguration.getStatus(netId).validatedServers().empty()) {

                    privateDnsStatus = privateDnsConfiguration.getStatus(netId);

                    break;

                }

            }