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

Commit 51967c8a authored by Mike Yu's avatar Mike Yu Committed by Automerger Merge Worker
Browse files

Clean up gPrivateDnsConfiguration am: 6024824b 

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

Change-Id: Icfdb066629e5488ec048c5e7610293489373bf8b
parents 5e1cbd5b 6024824b

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;

                }

            }