blob: b3d6a4dcb955ce4c0a7a4aa2a267bc4dd79de74a [file] [log] [blame]
/*
* Copyright (C) 2016 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.
*/
#ifndef LOADEDARSC_H_
#define LOADEDARSC_H_
#include <map>
#include <memory>
#include <set>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <android-base/macros.h>
#include <android-base/result.h>
#include "androidfw/ByteBucketArray.h"
#include "androidfw/Chunk.h"
#include "androidfw/Idmap.h"
#include "androidfw/ResourceTypes.h"
#include "androidfw/Util.h"
namespace android {
class DynamicPackageEntry {
public:
DynamicPackageEntry() = default;
DynamicPackageEntry(std::string&& package_name, int package_id)
: package_name(std::move(package_name)), package_id(package_id) {}
std::string package_name;
int package_id = 0;
};
// TypeSpec is going to be immediately proceeded by
// an array of Type structs, all in the same block of memory.
struct TypeSpec {
struct TypeEntry {
incfs::verified_map_ptr<ResTable_type> type;
// Type configurations are accessed frequently when setting up an AssetManager and querying
// resources. Access this cached configuration to minimize page faults.
ResTable_config config;
};
// Pointer to the mmapped data where flags are kept. Flags denote whether the resource entry is
// public and under which configurations it varies.
incfs::verified_map_ptr<ResTable_typeSpec> type_spec;
std::vector<TypeEntry> type_entries;
base::expected<uint32_t, NullOrIOError> GetFlagsForEntryIndex(uint16_t entry_index) const {
if (entry_index >= dtohl(type_spec->entryCount)) {
return 0U;
}
const auto entry_flags_ptr = ((type_spec + 1).convert<uint32_t>() + entry_index);
if (!entry_flags_ptr) {
return base::unexpected(IOError::PAGES_MISSING);
}
return entry_flags_ptr.value();
}
};
// Flags that change the behavior of loaded packages.
// Keep in sync with f/b/android/content/res/ApkAssets.java
using package_property_t = uint32_t;
enum : package_property_t {
// The package contains framework resource values specified by the system.
// This allows some functions to filter out this package when computing
// what configurations/resources are available.
PROPERTY_SYSTEM = 1U << 0U,
// The package is a shared library or has a package id of 7f and is loaded as a shared library by
// force.
PROPERTY_DYNAMIC = 1U << 1U,
// The package has been loaded dynamically using a ResourcesProvider.
PROPERTY_LOADER = 1U << 2U,
// The package is a RRO.
PROPERTY_OVERLAY = 1U << 3U,
// The apk assets is owned by the application running in this process and incremental crash
// protections for this APK must be disabled.
PROPERTY_DISABLE_INCREMENTAL_HARDENING = 1U << 4U,
};
struct OverlayableInfo {
std::string name;
std::string actor;
uint32_t policy_flags;
};
class LoadedPackage {
public:
class iterator {
public:
iterator& operator=(const iterator& rhs) {
loadedPackage_ = rhs.loadedPackage_;
typeIndex_ = rhs.typeIndex_;
entryIndex_ = rhs.entryIndex_;
return *this;
}
bool operator==(const iterator& rhs) const {
return loadedPackage_ == rhs.loadedPackage_ &&
typeIndex_ == rhs.typeIndex_ &&
entryIndex_ == rhs.entryIndex_;
}
bool operator!=(const iterator& rhs) const {
return !(*this == rhs);
}
iterator operator++(int) {
size_t prevTypeIndex_ = typeIndex_;
size_t prevEntryIndex_ = entryIndex_;
operator++();
return iterator(loadedPackage_, prevTypeIndex_, prevEntryIndex_);
}
iterator& operator++();
uint32_t operator*() const;
private:
friend class LoadedPackage;
iterator(const LoadedPackage* lp, size_t ti, size_t ei);
const LoadedPackage* loadedPackage_;
size_t typeIndex_;
size_t entryIndex_;
const size_t typeIndexEnd_; // STL style end, so one past the last element
};
iterator begin() const {
return iterator(this, 0, 0);
}
iterator end() const {
return iterator(this, resource_ids_.size() + 1, 0);
}
static std::unique_ptr<const LoadedPackage> Load(const Chunk& chunk,
package_property_t property_flags);
// Finds the entry with the specified type name and entry name. The names are in UTF-16 because
// the underlying ResStringPool API expects this. For now this is acceptable, but since
// the default policy in AAPT2 is to build UTF-8 string pools, this needs to change.
// Returns a partial resource ID, with the package ID left as 0x00. The caller is responsible
// for patching the correct package ID to the resource ID.
base::expected<uint32_t, NullOrIOError> FindEntryByName(const std::u16string& type_name,
const std::u16string& entry_name) const;
static base::expected<incfs::map_ptr<ResTable_entry>, NullOrIOError> GetEntry(
incfs::verified_map_ptr<ResTable_type> type_chunk, uint16_t entry_index);
static base::expected<uint32_t, NullOrIOError> GetEntryOffset(
incfs::verified_map_ptr<ResTable_type> type_chunk, uint16_t entry_index);
static base::expected<incfs::map_ptr<ResTable_entry>, NullOrIOError> GetEntryFromOffset(
incfs::verified_map_ptr<ResTable_type> type_chunk, uint32_t offset);
// Returns the string pool where type names are stored.
const ResStringPool* GetTypeStringPool() const {
return &type_string_pool_;
}
// Returns the string pool where the names of resource entries are stored.
const ResStringPool* GetKeyStringPool() const {
return &key_string_pool_;
}
const std::string& GetPackageName() const {
return package_name_;
}
int GetPackageId() const {
return package_id_;
}
// Returns true if this package is dynamic (shared library) and needs to have an ID assigned.
bool IsDynamic() const {
return (property_flags_ & PROPERTY_DYNAMIC) != 0;
}
// Returns true if this package is a Runtime Resource Overlay.
bool IsOverlay() const {
return (property_flags_ & PROPERTY_OVERLAY) != 0;
}
// Returns true if this package originates from a system provided resource.
bool IsSystem() const {
return (property_flags_ & PROPERTY_SYSTEM) != 0;
}
// Returns true if this package is a custom loader and should behave like an overlay.
bool IsCustomLoader() const {
return (property_flags_ & PROPERTY_LOADER) != 0;
}
package_property_t GetPropertyFlags() const {
return property_flags_;
}
// Returns the map of package name to package ID used in this LoadedPackage. At runtime, a
// package could have been assigned a different package ID than what this LoadedPackage was
// compiled with. AssetManager rewrites the package IDs so that they are compatible at runtime.
const std::vector<DynamicPackageEntry>& GetDynamicPackageMap() const {
return dynamic_package_map_;
}
// Populates a set of ResTable_config structs, possibly excluding configurations defined for
// the mipmap type.
base::expected<std::monostate, IOError> CollectConfigurations(
bool exclude_mipmap, std::set<ResTable_config>* out_configs) const;
// Populates a set of strings representing locales.
// If `canonicalize` is set to true, each locale is transformed into its canonical format
// before being inserted into the set. This may cause some equivalent locales to de-dupe.
void CollectLocales(bool canonicalize, std::set<std::string>* out_locales) const;
// type_idx is TT - 1 from 0xPPTTEEEE.
inline const TypeSpec* GetTypeSpecByTypeIndex(uint8_t type_index) const {
// If the type IDs are offset in this package, we need to take that into account when searching
// for a type.
const auto& type_spec = type_specs_.find(type_index + 1 - type_id_offset_);
if (type_spec == type_specs_.end()) {
return nullptr;
}
return &type_spec->second;
}
template <typename Func>
void ForEachTypeSpec(Func f) const {
for (const auto& type_spec : type_specs_) {
f(type_spec.second, type_spec.first);
}
}
// Retrieves the overlayable properties of the specified resource. If the resource is not
// overlayable, this will return a null pointer.
const OverlayableInfo* GetOverlayableInfo(uint32_t resid) const {
for (const std::pair<OverlayableInfo, std::unordered_set<uint32_t>>& overlayable_info_ids
: overlayable_infos_) {
if (overlayable_info_ids.second.find(resid) != overlayable_info_ids.second.end()) {
return &overlayable_info_ids.first;
}
}
return nullptr;
}
// Retrieves whether or not the package defines overlayable resources.
// TODO(123905379): Remove this when the enforcement of overlayable is turned on for all APK and
// not just those that defined overlayable resources.
bool DefinesOverlayable() const {
return defines_overlayable_;
}
const std::unordered_map<std::string, std::string>& GetOverlayableMap() const {
return overlayable_map_;
}
const std::map<uint32_t, uint32_t>& GetAliasResourceIdMap() const {
return alias_id_map_;
}
private:
DISALLOW_COPY_AND_ASSIGN(LoadedPackage);
LoadedPackage() = default;
ResStringPool type_string_pool_;
ResStringPool key_string_pool_;
std::string package_name_;
bool defines_overlayable_ = false;
int package_id_ = -1;
int type_id_offset_ = 0;
package_property_t property_flags_ = 0U;
std::unordered_map<uint8_t, TypeSpec> type_specs_;
ByteBucketArray<uint32_t> resource_ids_;
std::vector<DynamicPackageEntry> dynamic_package_map_;
std::vector<const std::pair<OverlayableInfo, std::unordered_set<uint32_t>>> overlayable_infos_;
std::map<uint32_t, uint32_t> alias_id_map_;
// A map of overlayable name to actor
std::unordered_map<std::string, std::string> overlayable_map_;
};
// Read-only view into a resource table. This class validates all data
// when loading, including offsets and lengths.
class LoadedArsc {
public:
// Load a resource table from memory pointed to by `data` of size `len`.
// The lifetime of `data` must out-live the LoadedArsc returned from this method.
static std::unique_ptr<LoadedArsc> Load(incfs::map_ptr<void> data,
size_t length,
const LoadedIdmap* loaded_idmap = nullptr,
package_property_t property_flags = 0U);
// Create an empty LoadedArsc. This is used when an APK has no resources.arsc.
static std::unique_ptr<LoadedArsc> CreateEmpty();
// Returns the string pool where all string resource values
// (Res_value::dataType == Res_value::TYPE_STRING) are indexed.
inline const ResStringPool* GetStringPool() const {
return global_string_pool_.get();
}
// Gets a pointer to the package with the specified package ID, or nullptr if no such package
// exists.
const LoadedPackage* GetPackageById(uint8_t package_id) const;
// Returns a vector of LoadedPackage pointers, representing the packages in this LoadedArsc.
inline const std::vector<std::unique_ptr<const LoadedPackage>>& GetPackages() const {
return packages_;
}
private:
DISALLOW_COPY_AND_ASSIGN(LoadedArsc);
LoadedArsc() = default;
bool LoadTable(
const Chunk& chunk, const LoadedIdmap* loaded_idmap, package_property_t property_flags);
std::unique_ptr<ResStringPool> global_string_pool_ = util::make_unique<ResStringPool>();
std::vector<std::unique_ptr<const LoadedPackage>> packages_;
};
} // namespace android
#endif /* LOADEDARSC_H_ */