383 lines
16 KiB
C++
383 lines
16 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#include <array>
|
|
|
|
#include <android-base/test_utils.h>
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "DnsStats.h"
|
|
|
|
namespace android::net {
|
|
|
|
using namespace std::chrono_literals;
|
|
using android::netdutils::IPSockAddr;
|
|
using std::chrono::milliseconds;
|
|
using ::testing::IsEmpty;
|
|
using ::testing::UnorderedElementsAreArray;
|
|
|
|
namespace {
|
|
|
|
DnsQueryEvent makeDnsQueryEvent(const Protocol protocol, const NsRcode rcode,
|
|
const milliseconds& latency) {
|
|
DnsQueryEvent event;
|
|
event.set_protocol(protocol);
|
|
event.set_rcode(rcode);
|
|
event.set_latency_micros(latency.count() * 1000);
|
|
return event;
|
|
}
|
|
|
|
StatsData makeStatsData(const IPSockAddr& server, const int total, const milliseconds& latencyMs,
|
|
const std::map<int, int>& rcodeCounts) {
|
|
StatsData ret(server);
|
|
ret.total = total;
|
|
ret.latencyUs = latencyMs;
|
|
ret.rcodeCounts = rcodeCounts;
|
|
return ret;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
class StatsRecordsTest : public ::testing::Test {};
|
|
|
|
TEST_F(StatsRecordsTest, PushRecord) {
|
|
const IPSockAddr server = IPSockAddr::toIPSockAddr("127.0.0.2", 53);
|
|
constexpr size_t size = 3;
|
|
const StatsRecords::Record recordNoError = {NS_R_NO_ERROR, 10ms};
|
|
const StatsRecords::Record recordTimeout = {NS_R_TIMEOUT, 250ms};
|
|
|
|
StatsRecords sr(server, size);
|
|
EXPECT_EQ(sr.getStatsData(), makeStatsData(server, 0, 0ms, {}));
|
|
|
|
sr.push(recordNoError);
|
|
EXPECT_EQ(sr.getStatsData(), makeStatsData(server, 1, 10ms, {{NS_R_NO_ERROR, 1}}));
|
|
|
|
sr.push(recordNoError);
|
|
EXPECT_EQ(sr.getStatsData(), makeStatsData(server, 2, 20ms, {{NS_R_NO_ERROR, 2}}));
|
|
|
|
sr.push(recordTimeout);
|
|
EXPECT_EQ(sr.getStatsData(),
|
|
makeStatsData(server, 3, 270ms, {{NS_R_NO_ERROR, 2}, {NS_R_TIMEOUT, 1}}));
|
|
|
|
sr.push(recordTimeout);
|
|
EXPECT_EQ(sr.getStatsData(),
|
|
makeStatsData(server, 3, 510ms, {{NS_R_NO_ERROR, 1}, {NS_R_TIMEOUT, 2}}));
|
|
|
|
sr.push(recordTimeout);
|
|
EXPECT_EQ(sr.getStatsData(),
|
|
makeStatsData(server, 3, 750ms, {{NS_R_NO_ERROR, 0}, {NS_R_TIMEOUT, 3}}));
|
|
}
|
|
|
|
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;
|
|
bool isSuccess;
|
|
} tests[] = {
|
|
// Normal case.
|
|
{
|
|
{"127.0.0.1", "127.0.0.2", "fe80::1%22", "2001:db8::2", "::1"},
|
|
{"127.0.0.1", "127.0.0.2", "fe80::1%22", "2001:db8::2", "::1"},
|
|
true,
|
|
},
|
|
// Duplicate servers.
|
|
{
|
|
{"127.0.0.1", "2001:db8::2", "127.0.0.1", "2001:db8::2"},
|
|
{"127.0.0.1", "2001:db8::2"},
|
|
true,
|
|
},
|
|
// Invalid server addresses. The state remains in previous state.
|
|
{
|
|
{"not_an_ip", "127.0.0.3", "127.a.b.2"},
|
|
{"127.0.0.1", "2001:db8::2"},
|
|
false,
|
|
},
|
|
// Clean up the old servers 127.0.0.1 and 127.0.0.2.
|
|
{
|
|
{"127.0.0.4", "2001:db8::5"},
|
|
{"127.0.0.4", "2001:db8::5"},
|
|
true,
|
|
},
|
|
// Empty list.
|
|
{{}, {}, true},
|
|
};
|
|
|
|
for (const auto& [servers, expectation, isSuccess] : tests) {
|
|
std::vector<IPSockAddr> ipSockAddrs;
|
|
ipSockAddrs.reserve(servers.size());
|
|
for (const auto& server : servers) {
|
|
ipSockAddrs.push_back(IPSockAddr::toIPSockAddr(server, 53));
|
|
}
|
|
|
|
EXPECT_TRUE(mDnsStats.setServers(ipSockAddrs, PROTO_TCP) == isSuccess);
|
|
EXPECT_TRUE(mDnsStats.setServers(ipSockAddrs, PROTO_UDP) == isSuccess);
|
|
EXPECT_TRUE(mDnsStats.setServers(ipSockAddrs, PROTO_DOT) == isSuccess);
|
|
|
|
std::vector<StatsData> expectedStats;
|
|
expectedStats.reserve(expectation.size());
|
|
for (const auto& exp : expectation) {
|
|
expectedStats.push_back(makeStatsData(IPSockAddr::toIPSockAddr(exp, 53), 0, 0ms, {}));
|
|
}
|
|
|
|
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({}, {}, {});
|
|
}
|
|
|
|
TEST_F(DnsStatsTest, SetServersDifferentPorts) {
|
|
const std::vector<IPSockAddr> servers = {
|
|
IPSockAddr::toIPSockAddr("127.0.0.1", 0), IPSockAddr::toIPSockAddr("fe80::1", 0),
|
|
IPSockAddr::toIPSockAddr("127.0.0.1", 53), IPSockAddr::toIPSockAddr("127.0.0.1", 5353),
|
|
IPSockAddr::toIPSockAddr("127.0.0.1", 853), IPSockAddr::toIPSockAddr("fe80::1", 53),
|
|
IPSockAddr::toIPSockAddr("fe80::1", 5353), IPSockAddr::toIPSockAddr("fe80::1", 853),
|
|
};
|
|
|
|
// Servers setup fails due to port unset.
|
|
EXPECT_FALSE(mDnsStats.setServers(servers, PROTO_TCP));
|
|
EXPECT_FALSE(mDnsStats.setServers(servers, PROTO_UDP));
|
|
EXPECT_FALSE(mDnsStats.setServers(servers, PROTO_DOT));
|
|
|
|
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));
|
|
EXPECT_TRUE(mDnsStats.setServers(std::vector(servers.begin() + 2, servers.end()), PROTO_DOT));
|
|
|
|
const std::vector<StatsData> expectedStats = {
|
|
makeStatsData(servers[2], 0, 0ms, {}), makeStatsData(servers[3], 0, 0ms, {}),
|
|
makeStatsData(servers[4], 0, 0ms, {}), makeStatsData(servers[5], 0, 0ms, {}),
|
|
makeStatsData(servers[6], 0, 0ms, {}), makeStatsData(servers[7], 0, 0ms, {}),
|
|
};
|
|
|
|
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) {
|
|
const std::vector<IPSockAddr> servers = {
|
|
IPSockAddr::toIPSockAddr("127.0.0.1", 53),
|
|
IPSockAddr::toIPSockAddr("127.0.0.2", 53),
|
|
};
|
|
const DnsQueryEvent record = makeDnsQueryEvent(PROTO_UDP, NS_R_NO_ERROR, 10ms);
|
|
|
|
EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_TCP));
|
|
EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));
|
|
|
|
// Fail to add stats because of incorrect arguments.
|
|
EXPECT_FALSE(mDnsStats.addStats(IPSockAddr::toIPSockAddr("127.0.0.4", 53), record));
|
|
EXPECT_FALSE(mDnsStats.addStats(IPSockAddr::toIPSockAddr("127.a.b.4", 53), record));
|
|
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[0], record));
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[0], record));
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[1], record));
|
|
|
|
const std::vector<StatsData> expectedStatsForTcp = {
|
|
makeStatsData(servers[0], 0, 0ms, {}),
|
|
makeStatsData(servers[1], 0, 0ms, {}),
|
|
};
|
|
const std::vector<StatsData> expectedStatsForUdp = {
|
|
makeStatsData(servers[0], 2, 20ms, {{NS_R_NO_ERROR, 2}}),
|
|
makeStatsData(servers[1], 1, 10ms, {{NS_R_NO_ERROR, 1}}),
|
|
};
|
|
|
|
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));
|
|
EXPECT_TRUE(mDnsStats.setServers({}, PROTO_UDP));
|
|
EXPECT_TRUE(mDnsStats.setServers({}, PROTO_DOT));
|
|
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) {
|
|
std::vector<IPSockAddr> servers = {
|
|
IPSockAddr::toIPSockAddr("127.0.0.1", 53),
|
|
IPSockAddr::toIPSockAddr("127.0.0.2", 53),
|
|
};
|
|
const DnsQueryEvent recordNoError = makeDnsQueryEvent(PROTO_UDP, NS_R_NO_ERROR, 10ms);
|
|
const DnsQueryEvent recordTimeout = makeDnsQueryEvent(PROTO_UDP, NS_R_TIMEOUT, 250ms);
|
|
|
|
EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));
|
|
|
|
// Add a record to 127.0.0.1.
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[0], recordNoError));
|
|
|
|
// Add four records to 127.0.0.2.
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[1], recordNoError));
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[1], recordNoError));
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[1], recordTimeout));
|
|
EXPECT_TRUE(mDnsStats.addStats(servers[1], recordTimeout));
|
|
|
|
std::vector<StatsData> expectedStats = {
|
|
makeStatsData(servers[0], 1, 10ms, {{NS_R_NO_ERROR, 1}}),
|
|
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 = {
|
|
IPSockAddr::toIPSockAddr("127.0.0.2", 53),
|
|
IPSockAddr::toIPSockAddr("127.0.0.3", 53),
|
|
IPSockAddr::toIPSockAddr("127.0.0.4", 53),
|
|
};
|
|
EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));
|
|
expectedStats = {
|
|
makeStatsData(servers[0], 4, 520ms, {{NS_R_NO_ERROR, 2}, {NS_R_TIMEOUT, 2}}),
|
|
makeStatsData(servers[1], 0, 0ms, {}),
|
|
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));
|
|
expectedStats = {
|
|
makeStatsData(servers[0], 5, 530ms, {{NS_R_NO_ERROR, 3}, {NS_R_TIMEOUT, 2}}),
|
|
makeStatsData(servers[1], 0, 0ms, {}),
|
|
makeStatsData(servers[2], 0, 0ms, {}),
|
|
};
|
|
EXPECT_THAT(mDnsStats.getStats(PROTO_UDP), UnorderedElementsAreArray(expectedStats));
|
|
verifyDumpOutput({}, expectedStats, {});
|
|
}
|
|
|
|
TEST_F(DnsStatsTest, AddStatsRecords_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),
|
|
IPSockAddr::toIPSockAddr("127.0.0.3", 53),
|
|
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 (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) {
|
|
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
|