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

Commit 9b748ee3 authored by Mike Yu's avatar Mike Yu
Browse files

Skip res_doh_send() if there is no validated DoH servers 

Since res_doh_send() can take around 2 milliseconds, skip calling
it when there is no DoH servers validated.

Bug: 212364676
Test: ran "dnschk --attempts 1000 --randomname"
      w/o this change it takes 36 seconds
      w/ this change it takes 32 seconds
Test: checked the log to ensure that "performing query over Https"
      is not printed when the DNS doesn't support DoH
Change-Id: I1718534889b097eb89ba12a291da0fb19f13bbbd
parent 229fedcb

PrivateDnsConfiguration.cpp

+13 −3
Original line number Diff line number Diff line
@@ -109,7 +109,11 @@ int PrivateDnsConfiguration::set(int32_t netId, uint32_t mark, 
}



PrivateDnsStatus PrivateDnsConfiguration::getStatus(unsigned netId) const {

    PrivateDnsStatus status{PrivateDnsMode::OFF, {}};

    PrivateDnsStatus status{

            .mode = PrivateDnsMode::OFF,

            .dotServersMap = {},

            .dohServersMap = {},

    };

    std::lock_guard guard(mPrivateDnsLock);



    const auto mode = mPrivateDnsModes.find(netId);
@@ -121,10 +125,16 @@ PrivateDnsStatus PrivateDnsConfiguration::getStatus(unsigned netId) const { 
        for (const auto& [_, server] : netPair->second) {

            if (server->isDot() && server->active()) {

                DnsTlsServer& dotServer = *static_cast<DnsTlsServer*>(server.get());

                status.serversMap.emplace(dotServer, server->validationState());

                status.dotServersMap.emplace(dotServer, server->validationState());

            }

        }

            // TODO: also add DoH server to the map.

    }



    auto it = mDohTracker.find(netId);

    if (it != mDohTracker.end()) {

        status.dohServersMap.emplace(

                netdutils::IPSockAddr::toIPSockAddr(it->second.ipAddr, kDohPort),

                it->second.status);

    }



    return status;

PrivateDnsConfiguration.h

+13 −2
Original line number Diff line number Diff line
@@ -44,18 +44,29 @@ struct PrivateDnsStatus { 
    PrivateDnsMode mode;



    // TODO: change the type to std::vector<DnsTlsServer>.

    std::map<DnsTlsServer, Validation, AddressComparator> serversMap;

    std::map<DnsTlsServer, Validation, AddressComparator> dotServersMap;



    std::map<netdutils::IPSockAddr, Validation> dohServersMap;



    std::list<DnsTlsServer> validatedServers() const {

        std::list<DnsTlsServer> servers;



        for (const auto& pair : serversMap) {

        for (const auto& pair : dotServersMap) {

            if (pair.second == Validation::success) {

                servers.push_back(pair.first);

            }

        }

        return servers;

    }



    bool hasValidatedDohServers() const {

        for (const auto& [_, status] : dohServersMap) {

            if (status == Validation::success) {

                return true;

            }

        }

        return false;

    }

};



class PrivateDnsConfiguration {

PrivateDnsConfigurationTest.cpp

+2 −2
Original line number Diff line number Diff line
@@ -110,7 +110,7 @@ class PrivateDnsConfigurationTest : public ::testing::Test { 
        if (status.mode != mode) return false;



        std::map<std::string, Validation> serverStateMap;

        for (const auto& [server, validation] : status.serversMap) {

        for (const auto& [server, validation] : status.dotServersMap) {

            serverStateMap[ToString(&server.ss)] = validation;

        }

        return (serverStateMap == mObserver.getServerStateMap());
@@ -275,7 +275,7 @@ TEST_F(PrivateDnsConfigurationTest, NoValidation) { 
    const auto expectStatus = [&]() {

        const PrivateDnsStatus status = mPdc.getStatus(kNetId);

        EXPECT_EQ(status.mode, PrivateDnsMode::OFF);

        EXPECT_THAT(status.serversMap, testing::IsEmpty());

        EXPECT_THAT(status.dotServersMap, testing::IsEmpty());

    };



    EXPECT_EQ(mPdc.set(kNetId, kMark, {"invalid_addr"}, {}, {}), -EINVAL);

ResolverController.cpp

+4 −4
Original line number Diff line number Diff line
@@ -268,7 +268,7 @@ int ResolverController::getResolverInfo(int32_t netId, std::vector<std::string>* 
    ResolverStats::encodeAll(res_stats, stats);



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

    for (const auto& [server, _] : privateDnsStatus.serversMap) {

    for (const auto& [server, _] : privateDnsStatus.dotServersMap) {

        tlsServers->push_back(server.toIpString());

    }
@@ -362,13 +362,13 @@ void ResolverController::dump(DumpWriter& dw, unsigned netId) { 
        mDns64Configuration.dump(dw, netId);

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

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

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

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

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

        } else {

            dw.println("Private DNS configuration (%u entries)",

                       static_cast<uint32_t>(privateDnsStatus.serversMap.size()));

                       static_cast<uint32_t>(privateDnsStatus.dotServersMap.size()));

            dw.incIndent();

            for (const auto& [server, validation] : privateDnsStatus.serversMap) {

            for (const auto& [server, validation] : privateDnsStatus.dotServersMap) {

                dw.println("%s name{%s} status{%s}", server.toIpString().c_str(),

                           server.name.c_str(), validationStatusToString(validation));

            }

res_send.cpp

+12 −8
Original line number Diff line number Diff line
@@ -1337,7 +1337,7 @@ static int res_private_dns_send(ResState* statp, const Slice query, const Slice 
        }

        case PrivateDnsMode::OPPORTUNISTIC: {

            *fallback = true;

            if (enableDoH) {

            if (enableDoH && privateDnsStatus.hasValidatedDohServers()) {

                result = res_doh_send(statp, query, answer, rcode);

                if (result != DOH_RESULT_CAN_NOT_SEND) return result;

            }
@@ -1346,7 +1346,7 @@ static int res_private_dns_send(ResState* statp, const Slice query, const Slice 
        }

        case PrivateDnsMode::STRICT: {

            *fallback = false;

            if (enableDoH) {

            if (enableDoH && privateDnsStatus.hasValidatedDohServers()) {

                result = res_doh_send(statp, query, answer, rcode);

                if (result != DOH_RESULT_CAN_NOT_SEND) return result;

            }
@@ -1366,15 +1366,19 @@ static int res_private_dns_send(ResState* statp, const Slice query, const Slice 
                // default network change.

                for (int i = 0; i < 42; i++) {

                    std::this_thread::sleep_for(std::chrono::milliseconds(100));

                    if (enableDoH) {

                        result = res_doh_send(statp, query, answer, rcode);

                        if (result != DOH_RESULT_CAN_NOT_SEND) return result;

                    }



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

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

                    // ups.

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

                    privateDnsStatus = privateDnsConfiguration.getStatus(netId);



                    if (enableDoH && privateDnsStatus.hasValidatedDohServers()) {

                        result = res_doh_send(statp, query, answer, rcode);

                        if (result != DOH_RESULT_CAN_NOT_SEND) return result;

                    }



                    // Switch to use the DoT servers if they are validated.

                    if (!privateDnsStatus.validatedServers().empty()) {

                        break;

                    }

                }