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

Commit ef35fe23 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 6121193 from ea6dde14 to rvc-release 

Change-Id: Idb75bedea9e4703a5d8c375b3edb248cb8d794e9
parents ae9bd873 ea6dde14

Android.bp

+2 −2
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ aidl_interface { 
    local_include_dir: "binder",

    srcs: [

        "binder/android/net/IDnsResolver.aidl",

        "binder/android/net/ResolverHostsParcel.aidl",

        "binder/android/net/ResolverParamsParcel.aidl",

    ],

    imports: [
@@ -185,8 +186,7 @@ cc_test { 
        "libbinder_ndk",

    ],

    static_libs: [

        "dnsresolver_aidl_interface-cpp",

        "dnsresolver_aidl_interface-ndk_platform",

        "dnsresolver_aidl_interface-unstable-ndk_platform",

        "netd_event_listener_interface-ndk_platform",

        "libgmock",

        "liblog",

DnsStats.h

+2 −2
Original line number Diff line number Diff line
@@ -106,10 +106,10 @@ class DnsStats { 
    // TODO: Compatible support for getResolverInfo().

    // TODO: Support getSortedServers().



    static constexpr size_t kLogSize = 128;



  private:

    std::map<Protocol, ServerStatsMap> mStats;



    static constexpr size_t kLogSize = 128;

};



}  // namespace android::net

DnsStatsTest.cpp

+100 −10
Original line number Diff line number Diff line
@@ -14,6 +14,9 @@ 
 * limitations under the License.

 */



#include <array>



#include <android-base/test_utils.h>

#include <gmock/gmock.h>

#include <gtest/gtest.h>
@@ -81,10 +84,60 @@ TEST_F(StatsRecordsTest, PushRecord) { 


class DnsStatsTest : public ::testing::Test {

  protected:

    std::string captureDumpOutput() {

        netdutils::DumpWriter dw(STDOUT_FILENO);

        CapturedStdout captured;

        mDnsStats.dump(dw);

        return captured.str();

    }



    // Get the output string from dump() and check the content.

    void verifyDumpOutput(const std::vector<StatsData>& tcpData,

                          const std::vector<StatsData>& udpData,

                          const std::vector<StatsData>& dotData) {

        // A simple pattern to capture two matches:

        //     server address (empty allowed) and its statistics.

        const std::regex pattern(R"(\s{4,}([0-9a-fA-F:\.]*) ([<(].*[>)]))");

        std::string dumpString = captureDumpOutput();



        const auto check = [&](const std::vector<StatsData>& statsData, const std::string& protocol,

                               std::string* dumpString) {

            SCOPED_TRACE(protocol);

            ASSERT_NE(dumpString->find(protocol), std::string::npos);

            std::smatch sm;



            // Expect to show something even if none of servers is set.

            if (statsData.empty()) {

                ASSERT_TRUE(std::regex_search(*dumpString, sm, pattern));

                EXPECT_TRUE(sm[1].str().empty());

                EXPECT_EQ(sm[2], "<no server>");

                *dumpString = sm.suffix();

                return;

            }



            for (const auto& stats : statsData) {

                ASSERT_TRUE(std::regex_search(*dumpString, sm, pattern));

                EXPECT_EQ(sm[1], stats.serverSockAddr.ip().toString());

                EXPECT_FALSE(sm[2].str().empty());

                *dumpString = sm.suffix();

            }

        };



        check(udpData, "UDP", &dumpString);

        check(dotData, "TLS", &dumpString);

        check(tcpData, "TCP", &dumpString);



        // Ensure the whole string has been checked.

        EXPECT_EQ(dumpString, "\n");

    }



    DnsStats mDnsStats;

};



TEST_F(DnsStatsTest, SetServers) {

    // Check before any operation to mDnsStats.

    verifyDumpOutput({}, {}, {});



    static const struct {

        std::vector<std::string> servers;

        std::vector<std::string> expectation;
@@ -139,6 +192,8 @@ TEST_F(DnsStatsTest, SetServers) { 
        EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStats));

        EXPECT_THAT(mDnsStats.getStats(PROTO_DOT), UnorderedElementsAreArray(expectedStats));

    }



    verifyDumpOutput({}, {}, {});

}



TEST_F(DnsStatsTest, SetServersDifferentPorts) {
@@ -157,6 +212,7 @@ TEST_F(DnsStatsTest, SetServersDifferentPorts) { 
    EXPECT_THAT(mDnsStats.getStats(PROTO_TCP), IsEmpty());

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), IsEmpty());

    EXPECT_THAT(mDnsStats.getStats(PROTO_DOT), IsEmpty());

    verifyDumpOutput({}, {}, {});



    EXPECT_TRUE(mDnsStats.setServers(std::vector(servers.begin() + 2, servers.end()), PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setServers(std::vector(servers.begin() + 2, servers.end()), PROTO_UDP));
@@ -171,6 +227,7 @@ TEST_F(DnsStatsTest, SetServersDifferentPorts) { 
    EXPECT_THAT(mDnsStats.getStats(PROTO_TCP), UnorderedElementsAreArray(expectedStats));

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStats));

    EXPECT_THAT(mDnsStats.getStats(PROTO_DOT), UnorderedElementsAreArray(expectedStats));

    verifyDumpOutput(expectedStats, expectedStats, expectedStats);

}



TEST_F(DnsStatsTest, AddStatsAndClear) {
@@ -203,6 +260,7 @@ TEST_F(DnsStatsTest, AddStatsAndClear) { 
    EXPECT_THAT(mDnsStats.getStats(PROTO_TCP), UnorderedElementsAreArray(expectedStatsForTcp));

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStatsForUdp));

    EXPECT_THAT(mDnsStats.getStats(PROTO_DOT), IsEmpty());

    verifyDumpOutput(expectedStatsForTcp, expectedStatsForUdp, {});



    // Clear stats.

    EXPECT_TRUE(mDnsStats.setServers({}, PROTO_TCP));
@@ -211,6 +269,7 @@ TEST_F(DnsStatsTest, AddStatsAndClear) { 
    EXPECT_THAT(mDnsStats.getStats(PROTO_TCP), IsEmpty());

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), IsEmpty());

    EXPECT_THAT(mDnsStats.getStats(PROTO_DOT), IsEmpty());

    verifyDumpOutput({}, {}, {});

}



TEST_F(DnsStatsTest, StatsRemainsInExistentServer) {
@@ -237,6 +296,7 @@ TEST_F(DnsStatsTest, StatsRemainsInExistentServer) { 
            makeStatsData(servers[1], 4, 520ms, {{NS_R_NO_ERROR, 2}, {NS_R_TIMEOUT, 2}}),

    };

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStats));

    verifyDumpOutput({}, expectedStats, {});



    // Update the server list, the stats of 127.0.0.2 will remain.

    servers = {
@@ -251,6 +311,7 @@ TEST_F(DnsStatsTest, StatsRemainsInExistentServer) { 
            makeStatsData(servers[2], 0, 0ms, {}),

    };

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStats));

    verifyDumpOutput({}, expectedStats, {});



    // Let's add a record to 127.0.0.2 again.

    EXPECT_TRUE(mDnsStats.addStats(servers[0], recordNoError));
@@ -260,10 +321,15 @@ TEST_F(DnsStatsTest, StatsRemainsInExistentServer) { 
            makeStatsData(servers[2], 0, 0ms, {}),

    };

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStats));

    verifyDumpOutput({}, expectedStats, {});

}



TEST_F(DnsStatsTest, AddStatsRecords_100000) {

    constexpr int num = 100000;

    constexpr size_t operations = 100000;

    constexpr size_t logSize = DnsStats::kLogSize;

    constexpr size_t rcodeNum = 4;  // A value by which kLogSize is divisible.

    ASSERT_EQ(logSize % rcodeNum, 0U);



    const std::vector<IPSockAddr> servers = {

            IPSockAddr::toIPSockAddr("127.0.0.1", 53),

            IPSockAddr::toIPSockAddr("127.0.0.2", 53),
@@ -271,22 +337,46 @@ TEST_F(DnsStatsTest, AddStatsRecords_100000) { 
            IPSockAddr::toIPSockAddr("127.0.0.4", 53),

    };



    // To test unknown rcode in rcodeToName(), store the elements as type int.

    const std::array<int, rcodeNum> rcodes = {

            NS_R_NO_ERROR,        // NOERROR

            NS_R_NXDOMAIN,        // NXDOMAIN

            99,                   // UNKNOWN(99)

            NS_R_INTERNAL_ERROR,  // INTERNAL_ERROR

    };



    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_DOT));



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

        const auto eventTcp = makeDnsQueryEvent(PROTO_TCP, static_cast<NsRcode>(i % 10), 10ms);

        const auto eventUdp = makeDnsQueryEvent(PROTO_UDP, static_cast<NsRcode>(i % 10), 10ms);

        const auto eventDot = makeDnsQueryEvent(PROTO_DOT, static_cast<NsRcode>(i % 10), 10ms);

    for (size_t i = 0; i < operations; i++) {

        const NsRcode rcode = static_cast<NsRcode>(rcodes[i % rcodeNum]);

        const auto eventTcp = makeDnsQueryEvent(PROTO_TCP, rcode, 10ms);

        const auto eventUdp = makeDnsQueryEvent(PROTO_UDP, rcode, 10ms);

        const auto eventDot = makeDnsQueryEvent(PROTO_DOT, rcode, 10ms);

        for (const auto& server : servers) {

            const std::string trace = server.toString() + "-" + std::to_string(i);

            SCOPED_TRACE(trace);

            EXPECT_TRUE(mDnsStats.addStats(server, eventTcp));

            EXPECT_TRUE(mDnsStats.addStats(server, eventUdp));

            EXPECT_TRUE(mDnsStats.addStats(server, eventDot));

            SCOPED_TRACE(server.toString() + "-" + std::to_string(i));

            ASSERT_TRUE(mDnsStats.addStats(server, eventTcp));

            ASSERT_TRUE(mDnsStats.addStats(server, eventUdp));

            ASSERT_TRUE(mDnsStats.addStats(server, eventDot));

        }

    }



    std::map<int, int> expectedRcodeCounts;

    for (const auto& rcode : rcodes) {

        expectedRcodeCounts.try_emplace(rcode, 32);

    }

    const std::vector<StatsData> expectedStats = {

            makeStatsData(servers[0], logSize, logSize * 10ms, expectedRcodeCounts),

            makeStatsData(servers[1], logSize, logSize * 10ms, expectedRcodeCounts),

            makeStatsData(servers[2], logSize, logSize * 10ms, expectedRcodeCounts),

            makeStatsData(servers[3], logSize, logSize * 10ms, expectedRcodeCounts),

    };



    EXPECT_THAT(mDnsStats.getStats(PROTO_TCP), UnorderedElementsAreArray(expectedStats));

    EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStats));

    EXPECT_THAT(mDnsStats.getStats(PROTO_DOT), UnorderedElementsAreArray(expectedStats));

    verifyDumpOutput(expectedStats, expectedStats, expectedStats);

}



}  // namespace android::net

ResolverController.cpp

+1 −1
Original line number Diff line number Diff line
@@ -232,7 +232,7 @@ int ResolverController::setResolverConfiguration(const ResolverParamsParcel& res 
    res_params.retry_count = resolverParams.retryCount;



    return resolv_set_nameservers(resolverParams.netId, resolverParams.servers,

                                  resolverParams.domains, res_params);

                                  resolverParams.domains, res_params, resolverParams.hosts);

}



int ResolverController::getResolverInfo(int32_t netId, std::vector<std::string>* servers,

binder/android/net/ResolverHostsParcel.aidl

0 → 100644
+36 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.net;



/**

 * A mapping list which translates hostnames or domain names to IP addresses

 * locally. Mapping multiple addresses to one hostname is supported.

 * It's similar to /etc/hosts file.

 *

 * {@hide}

 */

parcelable ResolverHostsParcel {

    /**

     * The IPv4 or IPv6 address corresponding to |hostName| field.

     */

    @utf8InCpp String ipAddr;



    /**

     * The hostname is a FQDN.

     */

    @utf8InCpp String hostName = "";

}