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

Commit b44e2b58 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker Committed by Automerger Merge Worker
Browse files

Snap for 9690662 from 344d7eeb to udc-release am: 678c9625 

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



Change-Id: Ice674ceb4b5fe8f5ce16f0f3f805c4fb2c12ed30
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 429c1527 678c9625

Android.bp

+1 −1
Original line number Original line Diff line number Diff line
@@ -53,7 +53,7 @@ cc_library_headers { 
    ],

    ],

}

}





dnsresolver_aidl_interface_lateststable_version = "V10"

dnsresolver_aidl_interface_lateststable_version = "V11"





cc_library_static {

cc_library_static {

    name: "dnsresolver_aidl_interface-lateststable-ndk",

    name: "dnsresolver_aidl_interface-lateststable-ndk",

tests/resolv_integration_test.cpp

+49 −40
Original line number Original line Diff line number Diff line
@@ -6097,6 +6097,12 @@ TEST_P(ResolverParameterizedTest, TruncatedResponse) { 
    EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom));

    EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom));

}

}





// Tests that the DnsResolver can keep listening to the DNS response from previous DNS servers.

// Test scenarios (The timeout for each server is 1 second):

//   1. (During the first iteration of DNS servers) While waiting for the DNS response from the

//      second server, the DnsResolver receives the DNS response from the first server.

//   2. (During the second iteration of DNS servers) While waiting for the DNS response from the

//      second server, the DnsResolver receives the DNS response from the first server.

TEST_F(ResolverTest, KeepListeningUDP) {

TEST_F(ResolverTest, KeepListeningUDP) {

    constexpr char listen_addr1[] = "127.0.0.4";

    constexpr char listen_addr1[] = "127.0.0.4";

    constexpr char listen_addr2[] = "127.0.0.5";

    constexpr char listen_addr2[] = "127.0.0.5";
@@ -6104,43 +6110,51 @@ TEST_F(ResolverTest, KeepListeningUDP) { 
    const std::vector<DnsRecord> records = {

    const std::vector<DnsRecord> records = {

            {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},

            {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},

    };

    };

    const std::array<int, IDnsResolver::RESOLVER_PARAMS_COUNT> params = {

    auto builder =

            300, 25, 8, 8, 1000 /* BASE_TIMEOUT_MSEC */, 1 /* retry count */};

            ResolverParams::Builder().setDnsServers({listen_addr1, listen_addr2}).setDotServers({});

    const int delayTimeMs = 1500;





    test::DNSResponder neverRespondDns(listen_addr2, "53", static_cast<ns_rcode>(-1));

    test::DNSResponder neverRespondDns(listen_addr2, "53", static_cast<ns_rcode>(-1));

    neverRespondDns.setResponseProbability(0.0);

    neverRespondDns.setResponseProbability(0.0);

    StartDns(neverRespondDns, records);

    StartDns(neverRespondDns, records);

    ScopedSystemProperties scopedSystemProperties(

            "persist.device_config.netd_native.keep_listening_udp", "1");

    // Re-setup test network to make experiment flag take effect.

    resetNetwork();



    ASSERT_TRUE(

            mDnsClient.SetResolversFromParcel(ResolverParams::Builder()

                                                      .setDnsServers({listen_addr1, listen_addr2})

                                                      .setDotServers({})

                                                      .setParams(params)

                                                      .build()));

    // There are 2 DNS servers for this test.

    // |delayedDns| will be blocked for |delayTimeMs|, then start to respond to requests.

    // |neverRespondDns| will never respond.

    // In the first try, resolver will send query to |delayedDns| but get timeout error

    // because |delayTimeMs| > DNS timeout.

    // Then it's the second try, resolver will send query to |neverRespondDns| and

    // listen on both servers. Resolver will receive the answer coming from |delayedDns|.



    test::DNSResponder delayedDns(listen_addr1);

    test::DNSResponder delayedDns(listen_addr1);

    delayedDns.setResponseDelayMs(delayTimeMs);

    StartDns(delayedDns, records);

    StartDns(delayedDns, records);





    // Specify hints to ensure resolver doing query only 1 round.

    const struct TestConfig {

        int retryCount;

        int delayTimeMs;

    } testConfigs[]{

            {1, 1500},

            {2, 3500},

    };

    for (const std::string_view callType : {"getaddrinfo", "resnsend"}) {

        for (const auto& cfg : testConfigs) {

            SCOPED_TRACE(fmt::format("callType={}, retryCount={}, delayTimeMs={}", callType,

                                     cfg.retryCount, cfg.delayTimeMs));

            const std::array<int, IDnsResolver::RESOLVER_PARAMS_COUNT> params = {

                    300, 25, 8, 8, 1000 /* BASE_TIMEOUT_MSEC */, cfg.retryCount /* retry count */};



            ScopedSystemProperties sp(kKeepListeningUdpFlag, "1");

            resetNetwork();

            ASSERT_TRUE(mDnsClient.SetResolversFromParcel(builder.setParams(params).build()));



            delayedDns.setDeferredResp(true);

            std::thread thread([&]() {

                std::this_thread::sleep_for(std::chrono::milliseconds(cfg.delayTimeMs));

                delayedDns.setDeferredResp(false);

            });



            if (callType == "getaddrinfo") {

                const addrinfo hints = {.ai_family = AF_INET6, .ai_socktype = SOCK_DGRAM};

                const addrinfo hints = {.ai_family = AF_INET6, .ai_socktype = SOCK_DGRAM};

                ScopedAddrinfo result = safe_getaddrinfo(host_name, nullptr, &hints);

                ScopedAddrinfo result = safe_getaddrinfo(host_name, nullptr, &hints);

    EXPECT_TRUE(result != nullptr);

                EXPECT_EQ("::1.2.3.4", ToString(result));



            } else {

    std::string result_str = ToString(result);

                int fd = resNetworkQuery(TEST_NETID, host_name, ns_c_in, ns_t_aaaa, 0);

    EXPECT_TRUE(result_str == "::1.2.3.4") << ", result_str='" << result_str << "'";

                expectAnswersValid(fd, AF_INET6, "::1.2.3.4");

            }

            // TODO(b/271405311): check that the DNS stats from getResolverInfo() is correct.

            thread.join();

        }

    }

}

}





TEST_F(ResolverTest, GetAddrInfoParallelLookupTimeout) {

TEST_F(ResolverTest, GetAddrInfoParallelLookupTimeout) {
@@ -6156,8 +6170,7 @@ TEST_F(ResolverTest, GetAddrInfoParallelLookupTimeout) { 
    test::DNSResponder neverRespondDns(kDefaultServer, "53", static_cast<ns_rcode>(-1));

    test::DNSResponder neverRespondDns(kDefaultServer, "53", static_cast<ns_rcode>(-1));

    neverRespondDns.setResponseProbability(0.0);

    neverRespondDns.setResponseProbability(0.0);

    StartDns(neverRespondDns, records);

    StartDns(neverRespondDns, records);

    ScopedSystemProperties scopedSystemProperties(

    ScopedSystemProperties sp(kParallelLookupReleaseFlag, "1");

            "persist.device_config.netd_native.parallel_lookup_release", "1");

    // The default value of parallel_lookup_sleep_time should be very small

    // The default value of parallel_lookup_sleep_time should be very small

    // that we can ignore in this test case.

    // that we can ignore in this test case.

    // Re-setup test network to make experiment flag take effect.

    // Re-setup test network to make experiment flag take effect.
@@ -6191,11 +6204,9 @@ TEST_F(ResolverTest, GetAddrInfoParallelLookupSleepTime) { 
            300, 25, 8, 8, 1000 /* BASE_TIMEOUT_MSEC */, 1 /* retry count */};

            300, 25, 8, 8, 1000 /* BASE_TIMEOUT_MSEC */, 1 /* retry count */};

    test::DNSResponder dns(kDefaultServer);

    test::DNSResponder dns(kDefaultServer);

    StartDns(dns, records);

    StartDns(dns, records);

    ScopedSystemProperties scopedSystemProperties1(

    ScopedSystemProperties sp1(kParallelLookupReleaseFlag, "1");

            "persist.device_config.netd_native.parallel_lookup_release", "1");

    constexpr int PARALLEL_LOOKUP_SLEEP_TIME_MS = 500;

    constexpr int PARALLEL_LOOKUP_SLEEP_TIME_MS = 500;

    ScopedSystemProperties scopedSystemProperties2(

    ScopedSystemProperties sp2(kParallelLookupSleepTimeFlag,

            "persist.device_config.netd_native.parallel_lookup_sleep_time",

                               std::to_string(PARALLEL_LOOKUP_SLEEP_TIME_MS));

                               std::to_string(PARALLEL_LOOKUP_SLEEP_TIME_MS));

    // Re-setup test network to make experiment flag take effect.

    // Re-setup test network to make experiment flag take effect.

    resetNetwork();

    resetNetwork();
@@ -6413,8 +6424,7 @@ TEST_F(ResolverTest, MdnsGetHostByName) { 
    for (int value : keep_listening_udp_enable) {

    for (int value : keep_listening_udp_enable) {

        if (value == true) {

        if (value == true) {

            // Set keep_listening_udp enable

            // Set keep_listening_udp enable

            ScopedSystemProperties scopedSystemProperties(

            ScopedSystemProperties sp(kKeepListeningUdpFlag, "1");

                    "persist.device_config.netd_native.keep_listening_udp", "1");

            // Re-setup test network to make experiment flag take effect.

            // Re-setup test network to make experiment flag take effect.

            resetNetwork();

            resetNetwork();

        }

        }
@@ -6663,8 +6673,7 @@ TEST_F(ResolverTest, MdnsGetAddrInfo) { 
    for (int value : keep_listening_udp_enable) {

    for (int value : keep_listening_udp_enable) {

        if (value == true) {

        if (value == true) {

            // Set keep_listening_udp enable

            // Set keep_listening_udp enable

            ScopedSystemProperties scopedSystemProperties(

            ScopedSystemProperties sp(kKeepListeningUdpFlag, "1");

                    "persist.device_config.netd_native.keep_listening_udp", "1");

            // Re-setup test network to make experiment flag take effect.

            // Re-setup test network to make experiment flag take effect.

            resetNetwork();

            resetNetwork();

        }

        }

tests/resolv_test_utils.h

+3 −0
Original line number Original line Diff line number Diff line
@@ -155,6 +155,9 @@ const std::string kDotXportUnusableThresholdFlag(kFlagPrefix + "dot_xport_unusab 
const std::string kDotValidationLatencyFactorFlag(kFlagPrefix + "dot_validation_latency_factor");

const std::string kDotValidationLatencyFactorFlag(kFlagPrefix + "dot_validation_latency_factor");

const std::string kDotValidationLatencyOffsetMsFlag(kFlagPrefix +

const std::string kDotValidationLatencyOffsetMsFlag(kFlagPrefix +

                                                    "dot_validation_latency_offset_ms");

                                                    "dot_validation_latency_offset_ms");

const std::string kKeepListeningUdpFlag(kFlagPrefix + "keep_listening_udp");

const std::string kParallelLookupReleaseFlag(kFlagPrefix + "parallel_lookup_release");

const std::string kParallelLookupSleepTimeFlag(kFlagPrefix + "parallel_lookup_sleep_time");

const std::string kRetransIntervalFlag(kFlagPrefix + "retransmission_time_interval");

const std::string kRetransIntervalFlag(kFlagPrefix + "retransmission_time_interval");

const std::string kRetryCountFlag(kFlagPrefix + "retry_count");

const std::string kRetryCountFlag(kFlagPrefix + "retry_count");

const std::string kSkip4aQueryOnV6LinklocalAddrFlag(kFlagPrefix +

const std::string kSkip4aQueryOnV6LinklocalAddrFlag(kFlagPrefix +