742 lines
32 KiB
C++
742 lines
32 KiB
C++
// Copyright (C) 2017 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 "packages/UidMap.h"
|
|
|
|
#include <android/util/ProtoOutputStream.h>
|
|
#include <gtest/gtest.h>
|
|
#include <src/uid_data.pb.h>
|
|
#include <stdio.h>
|
|
|
|
#include "StatsLogProcessor.h"
|
|
#include "StatsService.h"
|
|
#include "config/ConfigKey.h"
|
|
#include "gtest_matchers.h"
|
|
#include "guardrail/StatsdStats.h"
|
|
#include "hash.h"
|
|
#include "logd/LogEvent.h"
|
|
#include "statsd_test_util.h"
|
|
#include "statslog_statsdtest.h"
|
|
|
|
using namespace android;
|
|
|
|
namespace android {
|
|
namespace os {
|
|
namespace statsd {
|
|
|
|
using android::util::ProtoOutputStream;
|
|
using android::util::ProtoReader;
|
|
using ::ndk::SharedRefBase;
|
|
|
|
#ifdef __ANDROID__
|
|
|
|
namespace {
|
|
const string kApp1 = "app1.sharing.1";
|
|
const string kApp2 = "app2.sharing.1";
|
|
const string kApp3 = "app3";
|
|
|
|
const vector<int32_t> kUids{1000, 1000, 1500};
|
|
const vector<int64_t> kVersions{4, 5, 6};
|
|
const vector<string> kVersionStrings{"v1", "v1", "v2"};
|
|
const vector<string> kApps{kApp1, kApp2, kApp3};
|
|
const vector<string> kInstallers{"", "", "com.android.vending"};
|
|
const vector<vector<uint8_t>> kCertificateHashes{{'a', 'z'}, {'b', 'c'}, {'d', 'e'}};
|
|
const vector<bool> kDeleted(3, false);
|
|
|
|
void sendPackagesToStatsd(shared_ptr<StatsService> service, const vector<int32_t>& uids,
|
|
const vector<int64_t>& versions, const vector<string>& versionStrings,
|
|
const vector<string>& apps, const vector<string>& installers,
|
|
const vector<vector<uint8_t>>& certificateHashes) {
|
|
// Populate UidData from app data.
|
|
UidData uidData;
|
|
for (size_t i = 0; i < uids.size(); i++) {
|
|
ApplicationInfo* appInfo = uidData.add_app_info();
|
|
appInfo->set_uid(uids[i]);
|
|
appInfo->set_version(versions[i]);
|
|
appInfo->set_version_string(versionStrings[i]);
|
|
appInfo->set_package_name(apps[i]);
|
|
appInfo->set_installer(installers[i]);
|
|
appInfo->set_certificate_hash(certificateHashes[i].data(), certificateHashes[i].size());
|
|
}
|
|
|
|
// Create file descriptor from serialized UidData.
|
|
// Create a file that lives in memory.
|
|
ScopedFileDescriptor scopedFd(memfd_create("doesn't matter", MFD_CLOEXEC));
|
|
const int fd = scopedFd.get();
|
|
int f = fcntl(fd, F_GETFD); // Read the file descriptor flags.
|
|
ASSERT_NE(-1, f); // Ensure there was no error while reading file descriptor flags.
|
|
ASSERT_TRUE(f & FD_CLOEXEC);
|
|
ASSERT_TRUE(uidData.SerializeToFileDescriptor(fd));
|
|
ASSERT_EQ(0, lseek(fd, 0, SEEK_SET));
|
|
|
|
// Send file descriptor containing app data to statsd.
|
|
service->informAllUidData(scopedFd);
|
|
}
|
|
|
|
// Returns a vector of the same length as values param. Each i-th element in the returned vector is
|
|
// the index at which values[i] appears in the list denoted by the begin and end iterators.
|
|
template <typename Iterator, typename ValueType>
|
|
vector<uint32_t> computeIndices(const Iterator begin, const Iterator end,
|
|
const vector<ValueType>& values) {
|
|
vector<uint32_t> indices;
|
|
for (const ValueType& value : values) {
|
|
Iterator it = find(begin, end, value);
|
|
indices.emplace_back(distance(begin, it));
|
|
}
|
|
return indices;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
TEST(UidMapTest, TestIsolatedUID) {
|
|
sp<UidMap> m = new UidMap();
|
|
sp<StatsPullerManager> pullerManager = new StatsPullerManager();
|
|
sp<AlarmMonitor> anomalyAlarmMonitor;
|
|
sp<AlarmMonitor> subscriberAlarmMonitor;
|
|
// Construct the processor with a no-op sendBroadcast function that does nothing.
|
|
StatsLogProcessor p(
|
|
m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
|
|
[](const ConfigKey& key) { return true; },
|
|
[](const int&, const vector<int64_t>&) { return true; },
|
|
[](const ConfigKey&, const string&, const vector<int64_t>&) {}, nullptr);
|
|
|
|
std::unique_ptr<LogEvent> addEvent = CreateIsolatedUidChangedEvent(
|
|
1 /*timestamp*/, 100 /*hostUid*/, 101 /*isolatedUid*/, 1 /*is_create*/);
|
|
EXPECT_EQ(101, m->getHostUidOrSelf(101));
|
|
p.OnLogEvent(addEvent.get());
|
|
EXPECT_EQ(100, m->getHostUidOrSelf(101));
|
|
|
|
std::unique_ptr<LogEvent> removeEvent = CreateIsolatedUidChangedEvent(
|
|
1 /*timestamp*/, 100 /*hostUid*/, 101 /*isolatedUid*/, 0 /*is_create*/);
|
|
p.OnLogEvent(removeEvent.get());
|
|
EXPECT_EQ(101, m->getHostUidOrSelf(101));
|
|
}
|
|
|
|
TEST(UidMapTest, TestUpdateMap) {
|
|
const sp<UidMap> uidMap = new UidMap();
|
|
const shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(
|
|
uidMap, /* queue */ nullptr, /* LogEventFilter */ nullptr);
|
|
sendPackagesToStatsd(service, kUids, kVersions, kVersionStrings, kApps, kInstallers,
|
|
kCertificateHashes);
|
|
|
|
EXPECT_TRUE(uidMap->hasApp(1000, kApp1));
|
|
EXPECT_TRUE(uidMap->hasApp(1000, kApp2));
|
|
EXPECT_TRUE(uidMap->hasApp(1500, kApp3));
|
|
EXPECT_FALSE(uidMap->hasApp(1000, "not.app"));
|
|
|
|
std::set<string> name_set = uidMap->getAppNamesFromUid(1000u, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre(kApp1, kApp2));
|
|
|
|
name_set = uidMap->getAppNamesFromUid(1500u, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre(kApp3));
|
|
|
|
name_set = uidMap->getAppNamesFromUid(12345, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, IsEmpty());
|
|
|
|
vector<PackageInfo> expectedPackageInfos =
|
|
buildPackageInfos(kApps, kUids, kVersions, kVersionStrings, kInstallers,
|
|
kCertificateHashes, kDeleted, /* installerIndices */ {},
|
|
/* hashStrings */ false);
|
|
|
|
PackageInfoSnapshot packageInfoSnapshot = getPackageInfoSnapshot(uidMap);
|
|
|
|
EXPECT_THAT(packageInfoSnapshot.package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
}
|
|
|
|
TEST(UidMapTest, TestUpdateMapMultiple) {
|
|
const sp<UidMap> uidMap = new UidMap();
|
|
const shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(
|
|
uidMap, /* queue */ nullptr, /* LogEventFilter */ nullptr);
|
|
sendPackagesToStatsd(service, kUids, kVersions, kVersionStrings, kApps, kInstallers,
|
|
kCertificateHashes);
|
|
|
|
// Remove kApp3, and add NewApp
|
|
vector<int32_t> uids(kUids);
|
|
uids.back() = 2000;
|
|
vector<string> apps(kApps);
|
|
apps.back() = "NewApp";
|
|
vector<string> installers(kInstallers);
|
|
installers.back() = "NewInstaller";
|
|
|
|
sendPackagesToStatsd(service, uids, kVersions, kVersionStrings, apps, installers,
|
|
kCertificateHashes);
|
|
|
|
EXPECT_TRUE(uidMap->hasApp(1000, kApp1));
|
|
EXPECT_TRUE(uidMap->hasApp(1000, kApp2));
|
|
EXPECT_TRUE(uidMap->hasApp(2000, "NewApp"));
|
|
EXPECT_FALSE(uidMap->hasApp(1500, kApp3));
|
|
EXPECT_FALSE(uidMap->hasApp(1000, "not.app"));
|
|
|
|
std::set<string> name_set = uidMap->getAppNamesFromUid(1000u, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre(kApp1, kApp2));
|
|
|
|
name_set = uidMap->getAppNamesFromUid(2000, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre("newapp"));
|
|
|
|
name_set = uidMap->getAppNamesFromUid(1500, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, IsEmpty());
|
|
|
|
vector<PackageInfo> expectedPackageInfos =
|
|
buildPackageInfos(apps, uids, kVersions, kVersionStrings, installers,
|
|
kCertificateHashes, kDeleted, /* installerIndices */ {},
|
|
/* hashStrings */ false);
|
|
|
|
PackageInfoSnapshot packageInfoSnapshot = getPackageInfoSnapshot(uidMap);
|
|
|
|
EXPECT_THAT(packageInfoSnapshot.package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
}
|
|
|
|
TEST(UidMapTest, TestRemoveApp) {
|
|
const sp<UidMap> uidMap = new UidMap();
|
|
const shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(
|
|
uidMap, /* queue */ nullptr, /* LogEventFilter */ nullptr);
|
|
sendPackagesToStatsd(service, kUids, kVersions, kVersionStrings, kApps, kInstallers,
|
|
kCertificateHashes);
|
|
|
|
service->informOnePackageRemoved(kApp1, 1000);
|
|
EXPECT_FALSE(uidMap->hasApp(1000, kApp1));
|
|
EXPECT_TRUE(uidMap->hasApp(1000, kApp2));
|
|
EXPECT_TRUE(uidMap->hasApp(1500, kApp3));
|
|
std::set<string> name_set = uidMap->getAppNamesFromUid(1000, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre(kApp2));
|
|
|
|
vector<bool> deleted(kDeleted);
|
|
deleted[0] = true;
|
|
vector<PackageInfo> expectedPackageInfos =
|
|
buildPackageInfos(kApps, kUids, kVersions, kVersionStrings, kInstallers,
|
|
kCertificateHashes, deleted, /* installerIndices */ {},
|
|
/* hashStrings */ false);
|
|
PackageInfoSnapshot packageInfoSnapshot = getPackageInfoSnapshot(uidMap);
|
|
EXPECT_THAT(packageInfoSnapshot.package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
|
|
service->informOnePackageRemoved(kApp2, 1000);
|
|
EXPECT_FALSE(uidMap->hasApp(1000, kApp1));
|
|
EXPECT_FALSE(uidMap->hasApp(1000, kApp2));
|
|
EXPECT_TRUE(uidMap->hasApp(1500, kApp3));
|
|
EXPECT_FALSE(uidMap->hasApp(1000, "not.app"));
|
|
name_set = uidMap->getAppNamesFromUid(1000, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, IsEmpty());
|
|
|
|
deleted[1] = true;
|
|
expectedPackageInfos = buildPackageInfos(kApps, kUids, kVersions, kVersionStrings, kInstallers,
|
|
kCertificateHashes, deleted, /* installerIndices */ {},
|
|
/* hashStrings */ false);
|
|
packageInfoSnapshot = getPackageInfoSnapshot(uidMap);
|
|
EXPECT_THAT(packageInfoSnapshot.package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
|
|
service->informOnePackageRemoved(kApp3, 1500);
|
|
EXPECT_FALSE(uidMap->hasApp(1000, kApp1));
|
|
EXPECT_FALSE(uidMap->hasApp(1000, kApp2));
|
|
EXPECT_FALSE(uidMap->hasApp(1500, kApp3));
|
|
EXPECT_FALSE(uidMap->hasApp(1000, "not.app"));
|
|
name_set = uidMap->getAppNamesFromUid(1500, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, IsEmpty());
|
|
|
|
deleted[2] = true;
|
|
expectedPackageInfos = buildPackageInfos(kApps, kUids, kVersions, kVersionStrings, kInstallers,
|
|
kCertificateHashes, deleted, /* installerIndices */ {},
|
|
/* hashStrings */ false);
|
|
packageInfoSnapshot = getPackageInfoSnapshot(uidMap);
|
|
EXPECT_THAT(packageInfoSnapshot.package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
}
|
|
|
|
TEST(UidMapTest, TestUpdateApp) {
|
|
const sp<UidMap> uidMap = new UidMap();
|
|
const shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(
|
|
uidMap, /* queue */ nullptr, /* LogEventFilter */ nullptr);
|
|
sendPackagesToStatsd(service, kUids, kVersions, kVersionStrings, kApps, kInstallers,
|
|
kCertificateHashes);
|
|
|
|
// Update app1 version.
|
|
service->informOnePackage(kApps[0].c_str(), kUids[0], /* version */ 40,
|
|
/* versionString */ "v40", kInstallers[0], kCertificateHashes[0]);
|
|
EXPECT_THAT(uidMap->getAppVersion(kUids[0], kApps[0]), Eq(40));
|
|
std::set<string> name_set = uidMap->getAppNamesFromUid(1000, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre(kApp1, kApp2));
|
|
|
|
// Add a new name for uid 1000.
|
|
service->informOnePackage("NeW_aPP1_NAmE", 1000, /* version */ 40,
|
|
/* versionString */ "v40", /* installer */ "com.android.vending",
|
|
/* certificateHash */ {'a'});
|
|
name_set = uidMap->getAppNamesFromUid(1000, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre(kApp1, kApp2, "new_app1_name"));
|
|
|
|
// Re-add the same name for another uid 2000
|
|
service->informOnePackage("NeW_aPP1_NAmE", 2000, /* version */ 1,
|
|
/* versionString */ "v1", /* installer */ "",
|
|
/* certificateHash */ {'b'});
|
|
name_set = uidMap->getAppNamesFromUid(2000, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre("new_app1_name"));
|
|
|
|
// Re-add existing package with different installer
|
|
service->informOnePackage("NeW_aPP1_NAmE", 2000, /* version */ 1,
|
|
/* versionString */ "v1", /* installer */ "new_installer",
|
|
/* certificateHash */ {'b'});
|
|
name_set = uidMap->getAppNamesFromUid(2000, true /* returnNormalized */);
|
|
EXPECT_THAT(name_set, UnorderedElementsAre("new_app1_name"));
|
|
|
|
vector<int32_t> uids = concatenate(kUids, {1000, 2000});
|
|
vector<int64_t> versions = concatenate(kVersions, {40, 1});
|
|
versions[0] = 40;
|
|
vector<string> versionStrings = concatenate(kVersionStrings, {"v40", "v1"});
|
|
versionStrings[0] = "v40";
|
|
vector<string> apps = concatenate(kApps, {"NeW_aPP1_NAmE", "NeW_aPP1_NAmE"});
|
|
vector<string> installers = concatenate(kInstallers, {"com.android.vending", "new_installer"});
|
|
vector<bool> deleted = concatenate(kDeleted, {false, false});
|
|
vector<vector<uint8_t>> certHashes = concatenate(kCertificateHashes, {{'a'}, {'b'}});
|
|
vector<PackageInfo> expectedPackageInfos =
|
|
buildPackageInfos(apps, uids, versions, versionStrings, installers, certHashes, deleted,
|
|
/* installerIndices */ {},
|
|
/* hashStrings */ false);
|
|
|
|
PackageInfoSnapshot packageInfoSnapshot = getPackageInfoSnapshot(uidMap);
|
|
EXPECT_THAT(packageInfoSnapshot.package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
}
|
|
|
|
// Test that uid map returns at least one snapshot even if we already obtained
|
|
// this snapshot from a previous call to getData.
|
|
TEST(UidMapTest, TestOutputIncludesAtLeastOneSnapshot) {
|
|
UidMap m;
|
|
// Initialize single config key.
|
|
ConfigKey config1(1, StringToId("config1"));
|
|
m.OnConfigUpdated(config1);
|
|
const vector<int32_t> uids{1000};
|
|
const vector<int64_t> versions{5};
|
|
const vector<String16> versionStrings{String16("v1")};
|
|
const vector<String16> apps{String16(kApp2.c_str())};
|
|
const vector<String16> installers{String16("")};
|
|
const vector<vector<uint8_t>> certificateHashes{{}};
|
|
|
|
m.updateMap(1 /* timestamp */, uids, versions, versionStrings, apps, installers,
|
|
certificateHashes);
|
|
|
|
// Set the last timestamp for this config key to be newer.
|
|
m.mLastUpdatePerConfigKey[config1] = 2;
|
|
|
|
ProtoOutputStream proto;
|
|
m.appendUidMap(/* timestamp */ 3, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
|
|
// Check there's still a uidmap attached this one.
|
|
UidMapping results;
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(1, results.snapshots_size());
|
|
EXPECT_EQ("v1", results.snapshots(0).package_info(0).version_string());
|
|
}
|
|
|
|
TEST(UidMapTest, TestRemovedAppRetained) {
|
|
UidMap m;
|
|
// Initialize single config key.
|
|
ConfigKey config1(1, StringToId("config1"));
|
|
m.OnConfigUpdated(config1);
|
|
const vector<int32_t> uids{1000};
|
|
const vector<int64_t> versions{5};
|
|
const vector<String16> versionStrings{String16("v5")};
|
|
const vector<String16> apps{String16(kApp2.c_str())};
|
|
const vector<String16> installers{String16("")};
|
|
const vector<vector<uint8_t>> certificateHashes{{}};
|
|
|
|
m.updateMap(1 /* timestamp */, uids, versions, versionStrings, apps, installers,
|
|
certificateHashes);
|
|
m.removeApp(2, String16(kApp2.c_str()), 1000);
|
|
|
|
ProtoOutputStream proto;
|
|
m.appendUidMap(/* timestamp */ 3, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
|
|
// Snapshot should still contain this item as deleted.
|
|
UidMapping results;
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(1, results.snapshots(0).package_info_size());
|
|
EXPECT_EQ(true, results.snapshots(0).package_info(0).deleted());
|
|
}
|
|
|
|
TEST(UidMapTest, TestRemovedAppOverGuardrail) {
|
|
UidMap m;
|
|
// Initialize single config key.
|
|
ConfigKey config1(1, StringToId("config1"));
|
|
m.OnConfigUpdated(config1);
|
|
vector<int32_t> uids;
|
|
vector<int64_t> versions;
|
|
vector<String16> versionStrings;
|
|
vector<String16> installers;
|
|
vector<String16> apps;
|
|
vector<vector<uint8_t>> certificateHashes;
|
|
const int maxDeletedApps = StatsdStats::kMaxDeletedAppsInUidMap;
|
|
for (int j = 0; j < maxDeletedApps + 10; j++) {
|
|
uids.push_back(j);
|
|
apps.push_back(String16(kApp1.c_str()));
|
|
versions.push_back(j);
|
|
versionStrings.push_back(String16("v"));
|
|
installers.push_back(String16(""));
|
|
certificateHashes.push_back({});
|
|
}
|
|
m.updateMap(1 /* timestamp */, uids, versions, versionStrings, apps, installers,
|
|
certificateHashes);
|
|
|
|
// First, verify that we have the expected number of items.
|
|
UidMapping results;
|
|
ProtoOutputStream proto;
|
|
m.appendUidMap(/* timestamp */ 3, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(maxDeletedApps + 10, results.snapshots(0).package_info_size());
|
|
|
|
// Now remove all the apps.
|
|
m.updateMap(1 /* timestamp */, uids, versions, versionStrings, apps, installers,
|
|
certificateHashes);
|
|
for (int j = 0; j < maxDeletedApps + 10; j++) {
|
|
m.removeApp(4, String16(kApp1.c_str()), j);
|
|
}
|
|
|
|
proto.clear();
|
|
m.appendUidMap(/* timestamp */ 5, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
// Snapshot drops the first nine items.
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(maxDeletedApps, results.snapshots(0).package_info_size());
|
|
}
|
|
|
|
TEST(UidMapTest, TestClearingOutput) {
|
|
UidMap m;
|
|
|
|
ConfigKey config1(1, StringToId("config1"));
|
|
ConfigKey config2(1, StringToId("config2"));
|
|
|
|
m.OnConfigUpdated(config1);
|
|
|
|
const vector<int32_t> uids{1000, 1000};
|
|
const vector<int64_t> versions{4, 5};
|
|
const vector<String16> versionStrings{String16("v4"), String16("v5")};
|
|
const vector<String16> apps{String16(kApp1.c_str()), String16(kApp2.c_str())};
|
|
const vector<String16> installers{String16(""), String16("")};
|
|
const vector<vector<uint8_t>> certificateHashes{{}, {}};
|
|
m.updateMap(1 /* timestamp */, uids, versions, versionStrings, apps, installers,
|
|
certificateHashes);
|
|
|
|
ProtoOutputStream proto;
|
|
m.appendUidMap(/* timestamp */ 2, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
UidMapping results;
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(1, results.snapshots_size());
|
|
|
|
// We have to keep at least one snapshot in memory at all times.
|
|
proto.clear();
|
|
m.appendUidMap(/* timestamp */ 2, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(1, results.snapshots_size());
|
|
|
|
// Now add another configuration.
|
|
m.OnConfigUpdated(config2);
|
|
m.updateApp(5, String16(kApp1.c_str()), 1000, 40, String16("v40"), String16(""),
|
|
/* certificateHash */ {});
|
|
ASSERT_EQ(1U, m.mChanges.size());
|
|
proto.clear();
|
|
m.appendUidMap(/* timestamp */ 6, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(1, results.snapshots_size());
|
|
ASSERT_EQ(1, results.changes_size());
|
|
ASSERT_EQ(1U, m.mChanges.size());
|
|
|
|
// Add another delta update.
|
|
m.updateApp(7, String16(kApp2.c_str()), 1001, 41, String16("v41"), String16(""),
|
|
/* certificateHash */ {});
|
|
ASSERT_EQ(2U, m.mChanges.size());
|
|
|
|
// We still can't remove anything.
|
|
proto.clear();
|
|
m.appendUidMap(/* timestamp */ 8, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(1, results.snapshots_size());
|
|
ASSERT_EQ(1, results.changes_size());
|
|
ASSERT_EQ(2U, m.mChanges.size());
|
|
|
|
proto.clear();
|
|
m.appendUidMap(/* timestamp */ 9, config2, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
outputStreamToProto(&proto, &results);
|
|
ASSERT_EQ(1, results.snapshots_size());
|
|
ASSERT_EQ(2, results.changes_size());
|
|
// At this point both should be cleared.
|
|
ASSERT_EQ(0U, m.mChanges.size());
|
|
}
|
|
|
|
TEST(UidMapTest, TestMemoryComputed) {
|
|
UidMap m;
|
|
|
|
ConfigKey config1(1, StringToId("config1"));
|
|
m.OnConfigUpdated(config1);
|
|
|
|
size_t startBytes = m.mBytesUsed;
|
|
const vector<int32_t> uids{1000};
|
|
const vector<int64_t> versions{1};
|
|
const vector<String16> versionStrings{String16("v1")};
|
|
const vector<String16> apps{String16(kApp1.c_str())};
|
|
const vector<String16> installers{String16("")};
|
|
const vector<vector<uint8_t>> certificateHashes{{}};
|
|
m.updateMap(1 /* timestamp */, uids, versions, versionStrings, apps, installers,
|
|
certificateHashes);
|
|
|
|
m.updateApp(3, String16(kApp1.c_str()), 1000, 40, String16("v40"), String16(""),
|
|
/* certificateHash */ {});
|
|
|
|
ProtoOutputStream proto;
|
|
m.appendUidMap(/* timestamp */ 2, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
size_t prevBytes = m.mBytesUsed;
|
|
|
|
m.appendUidMap(/* timestamp */ 4, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
EXPECT_TRUE(m.mBytesUsed < prevBytes);
|
|
}
|
|
|
|
TEST(UidMapTest, TestMemoryGuardrail) {
|
|
UidMap m;
|
|
string buf;
|
|
|
|
ConfigKey config1(1, StringToId("config1"));
|
|
m.OnConfigUpdated(config1);
|
|
|
|
size_t startBytes = m.mBytesUsed;
|
|
vector<int32_t> uids;
|
|
vector<int64_t> versions;
|
|
vector<String16> versionStrings;
|
|
vector<String16> installers;
|
|
vector<String16> apps;
|
|
vector<vector<uint8_t>> certificateHashes;
|
|
for (int i = 0; i < 100; i++) {
|
|
uids.push_back(1);
|
|
buf = "EXTREMELY_LONG_STRING_FOR_APP_TO_WASTE_MEMORY." + to_string(i);
|
|
apps.push_back(String16(buf.c_str()));
|
|
versions.push_back(1);
|
|
versionStrings.push_back(String16("v1"));
|
|
installers.push_back(String16(""));
|
|
certificateHashes.push_back({});
|
|
}
|
|
m.updateMap(1 /* timestamp */, uids, versions, versionStrings, apps, installers,
|
|
certificateHashes);
|
|
|
|
m.updateApp(3, String16("EXTREMELY_LONG_STRING_FOR_APP_TO_WASTE_MEMORY.0"), 1000, 2,
|
|
String16("v2"), String16(""), /* certificateHash */ {});
|
|
ASSERT_EQ(1U, m.mChanges.size());
|
|
|
|
// Now force deletion by limiting the memory to hold one delta change.
|
|
m.maxBytesOverride = 120; // Since the app string alone requires >45 characters.
|
|
m.updateApp(5, String16("EXTREMELY_LONG_STRING_FOR_APP_TO_WASTE_MEMORY.0"), 1000, 4,
|
|
String16("v4"), String16(""), /* certificateHash */ {});
|
|
ASSERT_EQ(1U, m.mChanges.size());
|
|
}
|
|
|
|
class UidMapTestAppendUidMap : public Test {
|
|
protected:
|
|
const ConfigKey config1;
|
|
const sp<UidMap> uidMap;
|
|
const shared_ptr<StatsService> service;
|
|
|
|
set<string> installersSet;
|
|
set<uint64_t> installerHashSet;
|
|
vector<uint64_t> installerHashes;
|
|
|
|
UidMapTestAppendUidMap()
|
|
: config1(1, StringToId("config1")),
|
|
uidMap(new UidMap()),
|
|
service(SharedRefBase::make<StatsService>(uidMap, /* queue */ nullptr,
|
|
/* LogEventFilter */ nullptr)) {
|
|
}
|
|
|
|
void SetUp() override {
|
|
sendPackagesToStatsd(service, kUids, kVersions, kVersionStrings, kApps, kInstallers,
|
|
kCertificateHashes);
|
|
|
|
for (const string& installer : kInstallers) {
|
|
installersSet.insert(installer);
|
|
uint64_t installerHash = Hash64(installer);
|
|
installerHashes.emplace_back(installerHash);
|
|
installerHashSet.insert(installerHash);
|
|
}
|
|
}
|
|
};
|
|
|
|
TEST_F(UidMapTestAppendUidMap, TestInstallersInReportIncludeInstallerAndHashStrings) {
|
|
ProtoOutputStream proto;
|
|
set<string> strSet;
|
|
uidMap->appendUidMap(/* timestamp */ 3, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0, &strSet,
|
|
&proto);
|
|
|
|
UidMapping results;
|
|
outputStreamToProto(&proto, &results);
|
|
|
|
// Verify hashes for all installers are in the installer_hash list.
|
|
EXPECT_THAT(results.installer_hash(), UnorderedElementsAreArray(installerHashSet));
|
|
|
|
EXPECT_THAT(results.installer_name(), IsEmpty());
|
|
|
|
// Verify all installer names are added to the strSet argument.
|
|
EXPECT_THAT(strSet, IsSupersetOf(installersSet));
|
|
|
|
ASSERT_THAT(results.snapshots_size(), Eq(1));
|
|
|
|
// Compute installer indices for each package.
|
|
// Find the location of each installerHash from the input in the results.
|
|
// installerIndices[i] is the index in results.installer_hash() that matches installerHashes[i].
|
|
vector<uint32_t> installerIndices = computeIndices(
|
|
results.installer_hash().begin(), results.installer_hash().end(), installerHashes);
|
|
|
|
vector<PackageInfo> expectedPackageInfos =
|
|
buildPackageInfos(kApps, kUids, kVersions, kVersionStrings, kInstallers,
|
|
/* certHashes */ {}, kDeleted, installerIndices,
|
|
/* hashStrings */ true);
|
|
|
|
EXPECT_THAT(strSet, IsSupersetOf(kApps));
|
|
|
|
EXPECT_THAT(results.snapshots(0).package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
}
|
|
|
|
TEST_F(UidMapTestAppendUidMap, TestInstallersInReportIncludeInstallerAndDontHashStrings) {
|
|
ProtoOutputStream proto;
|
|
uidMap->appendUidMap(/* timestamp */ 3, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ true, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ nullptr, &proto);
|
|
|
|
UidMapping results;
|
|
outputStreamToProto(&proto, &results);
|
|
|
|
// Verify all installers are in the installer_name list.
|
|
EXPECT_THAT(results.installer_name(), UnorderedElementsAreArray(installersSet));
|
|
|
|
EXPECT_THAT(results.installer_hash(), IsEmpty());
|
|
|
|
ASSERT_THAT(results.snapshots_size(), Eq(1));
|
|
|
|
vector<uint32_t> installerIndices = computeIndices(results.installer_name().begin(),
|
|
results.installer_name().end(), kInstallers);
|
|
|
|
vector<PackageInfo> expectedPackageInfos =
|
|
buildPackageInfos(kApps, kUids, kVersions, kVersionStrings, kInstallers,
|
|
/* certHashes */ {}, kDeleted, installerIndices,
|
|
/* hashStrings */ false);
|
|
|
|
EXPECT_THAT(results.snapshots(0).package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
}
|
|
|
|
// Set up parameterized test with set<string>* parameter to control whether strings are hashed
|
|
// or not in the report. A value of nullptr indicates strings should not be hashed and non-null
|
|
// values indicates strings are hashed in the report and the original strings are added to this set.
|
|
class UidMapTestAppendUidMapHashStrings : public UidMapTestAppendUidMap,
|
|
public WithParamInterface<set<string>*> {
|
|
public:
|
|
inline static set<string> strSet;
|
|
|
|
protected:
|
|
void SetUp() override {
|
|
strSet.clear();
|
|
}
|
|
};
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
HashStrings, UidMapTestAppendUidMapHashStrings,
|
|
Values(nullptr, &(UidMapTestAppendUidMapHashStrings::strSet)),
|
|
[](const TestParamInfo<UidMapTestAppendUidMapHashStrings::ParamType>& info) {
|
|
return info.param == nullptr ? "NoHashStrings" : "HashStrings";
|
|
});
|
|
|
|
TEST_P(UidMapTestAppendUidMapHashStrings, TestNoIncludeInstallersInReport) {
|
|
ProtoOutputStream proto;
|
|
uidMap->appendUidMap(/* timestamp */ 3, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ false, /* truncatedCertificateHashSize */ 0,
|
|
/* str_set */ GetParam(), &proto);
|
|
|
|
UidMapping results;
|
|
outputStreamToProto(&proto, &results);
|
|
|
|
// Verify installer lists are empty.
|
|
EXPECT_THAT(results.installer_name(), IsEmpty());
|
|
EXPECT_THAT(results.installer_hash(), IsEmpty());
|
|
|
|
ASSERT_THAT(results.snapshots_size(), Eq(1));
|
|
|
|
// Verify that none of installer, installer_hash, installer_index fields in PackageInfo are
|
|
// populated.
|
|
EXPECT_THAT(results.snapshots(0).package_info(),
|
|
Each(Property(&PackageInfo::has_installer, IsFalse())));
|
|
EXPECT_THAT(results.snapshots(0).package_info(),
|
|
Each(Property(&PackageInfo::has_installer_hash, IsFalse())));
|
|
EXPECT_THAT(results.snapshots(0).package_info(),
|
|
Each(Property(&PackageInfo::has_installer_index, IsFalse())));
|
|
}
|
|
|
|
// Set up parameterized test for testing with different truncation hash sizes for the certificates.
|
|
class UidMapTestTruncateCertificateHash : public UidMapTestAppendUidMap,
|
|
public WithParamInterface<uint8_t> {};
|
|
|
|
INSTANTIATE_TEST_SUITE_P(ZeroOneTwoThree, UidMapTestTruncateCertificateHash,
|
|
Range(uint8_t{0}, uint8_t{4}));
|
|
|
|
TEST_P(UidMapTestTruncateCertificateHash, TestCertificateHashesTruncated) {
|
|
const uint8_t hashSize = GetParam();
|
|
ProtoOutputStream proto;
|
|
uidMap->appendUidMap(/* timestamp */ 3, config1, /* includeVersionStrings */ true,
|
|
/* includeInstaller */ false, hashSize, /* str_set */ nullptr, &proto);
|
|
|
|
UidMapping results;
|
|
outputStreamToProto(&proto, &results);
|
|
|
|
ASSERT_THAT(results.snapshots_size(), Eq(1));
|
|
|
|
vector<vector<uint8_t>> certHashes = kCertificateHashes;
|
|
for (vector<uint8_t>& certHash : certHashes) {
|
|
certHash.resize(certHash.size() < hashSize ? certHash.size() : hashSize);
|
|
}
|
|
vector<PackageInfo> expectedPackageInfos =
|
|
buildPackageInfos(kApps, kUids, kVersions, kVersionStrings,
|
|
/* installers */ {}, certHashes, kDeleted,
|
|
/* installerIndices*/ {},
|
|
/* hashStrings */ false);
|
|
|
|
EXPECT_THAT(results.snapshots(0).package_info(),
|
|
UnorderedPointwise(EqPackageInfo(), expectedPackageInfos));
|
|
}
|
|
|
|
#else
|
|
GTEST_LOG_(INFO) << "This test does nothing.\n";
|
|
#endif
|
|
|
|
} // namespace statsd
|
|
} // namespace os
|
|
} // namespace android
|