1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "androidfw/ApkAssets.h"
18
19 #include "android-base/errors.h"
20 #include "android-base/logging.h"
21 #include "android-base/utf8.h"
22
23 namespace android {
24
25 using base::SystemErrorCodeToString;
26 using base::unique_fd;
27
28 constexpr const char* kResourcesArsc = "resources.arsc";
29
ApkAssets(PrivateConstructorUtil,std::unique_ptr<Asset> resources_asset,std::unique_ptr<LoadedArsc> loaded_arsc,std::unique_ptr<AssetsProvider> assets,package_property_t property_flags,std::unique_ptr<Asset> idmap_asset,std::unique_ptr<LoadedIdmap> loaded_idmap)30 ApkAssets::ApkAssets(PrivateConstructorUtil, std::unique_ptr<Asset> resources_asset,
31 std::unique_ptr<LoadedArsc> loaded_arsc,
32 std::unique_ptr<AssetsProvider> assets, package_property_t property_flags,
33 std::unique_ptr<Asset> idmap_asset, std::unique_ptr<LoadedIdmap> loaded_idmap)
34 : resources_asset_(std::move(resources_asset)),
35 loaded_arsc_(std::move(loaded_arsc)),
36 assets_provider_(std::move(assets)),
37 property_flags_(property_flags),
38 idmap_asset_(std::move(idmap_asset)),
39 loaded_idmap_(std::move(loaded_idmap)) {
40 }
41
Load(const std::string & path,package_property_t flags)42 ApkAssetsPtr ApkAssets::Load(const std::string& path, package_property_t flags) {
43 return LoadImpl(ZipAssetsProvider::Create(path, flags), flags);
44 }
45
LoadFromFd(base::unique_fd fd,const std::string & debug_name,package_property_t flags,off64_t offset,off64_t len)46 ApkAssetsPtr ApkAssets::LoadFromFd(base::unique_fd fd, const std::string& debug_name,
47 package_property_t flags, off64_t offset, off64_t len) {
48 return LoadImpl(ZipAssetsProvider::Create(std::move(fd), debug_name, offset, len), flags);
49 }
50
LoadImpl(std::unique_ptr<AssetsProvider> && assets,package_property_t flags)51 ApkAssetsPtr ApkAssets::LoadImpl(std::unique_ptr<AssetsProvider>&& assets,
52 package_property_t flags) {
53 return LoadImpl(std::move(assets), flags, nullptr /* idmap_asset */, nullptr /* loaded_idmap */);
54 }
55
LoadTable(std::unique_ptr<Asset> && resources_asset,std::unique_ptr<AssetsProvider> && assets,package_property_t flags)56 ApkAssetsPtr ApkAssets::LoadTable(std::unique_ptr<Asset>&& resources_asset,
57 std::unique_ptr<AssetsProvider>&& assets,
58 package_property_t flags) {
59 if (resources_asset == nullptr) {
60 return {};
61 }
62 return LoadImpl(std::move(resources_asset), std::move(assets), flags, nullptr /* idmap_asset */,
63 nullptr /* loaded_idmap */);
64 }
65
LoadOverlay(const std::string & idmap_path,package_property_t flags)66 ApkAssetsPtr ApkAssets::LoadOverlay(const std::string& idmap_path, package_property_t flags) {
67 CHECK((flags & PROPERTY_LOADER) == 0U) << "Cannot load RROs through loaders";
68 auto idmap_asset = AssetsProvider::CreateAssetFromFile(idmap_path);
69 if (idmap_asset == nullptr) {
70 LOG(ERROR) << "failed to read IDMAP " << idmap_path;
71 return {};
72 }
73
74 StringPiece idmap_data(reinterpret_cast<const char*>(idmap_asset->getBuffer(true /* aligned */)),
75 static_cast<size_t>(idmap_asset->getLength()));
76 auto loaded_idmap = LoadedIdmap::Load(idmap_path, idmap_data);
77 if (loaded_idmap == nullptr) {
78 LOG(ERROR) << "failed to load IDMAP " << idmap_path;
79 return {};
80 }
81
82 std::string overlay_path(loaded_idmap->OverlayApkPath());
83 auto fd = unique_fd(base::utf8::open(overlay_path.c_str(), O_RDONLY | O_CLOEXEC));
84 std::unique_ptr<AssetsProvider> overlay_assets;
85 if (IsFabricatedOverlayName(overlay_path) && IsFabricatedOverlay(fd)) {
86 // Fabricated overlays do not contain resource definitions. All of the overlay resource values
87 // are defined inline in the idmap.
88 overlay_assets = EmptyAssetsProvider::Create(std::move(overlay_path));
89 } else {
90 // The overlay should be an APK.
91 overlay_assets = ZipAssetsProvider::Create(std::move(overlay_path), flags, std::move(fd));
92 }
93 if (overlay_assets == nullptr) {
94 return {};
95 }
96
97 return LoadImpl(std::move(overlay_assets), flags | PROPERTY_OVERLAY, std::move(idmap_asset),
98 std::move(loaded_idmap));
99 }
100
LoadImpl(std::unique_ptr<AssetsProvider> && assets,package_property_t property_flags,std::unique_ptr<Asset> && idmap_asset,std::unique_ptr<LoadedIdmap> && loaded_idmap)101 ApkAssetsPtr ApkAssets::LoadImpl(std::unique_ptr<AssetsProvider>&& assets,
102 package_property_t property_flags,
103 std::unique_ptr<Asset>&& idmap_asset,
104 std::unique_ptr<LoadedIdmap>&& loaded_idmap) {
105 if (assets == nullptr) {
106 return {};
107 }
108
109 // Open the resource table via mmap unless it is compressed. This logic is taken care of by Open.
110 bool resources_asset_exists = false;
111 auto resources_asset = assets->Open(kResourcesArsc, Asset::AccessMode::ACCESS_BUFFER,
112 &resources_asset_exists);
113 if (resources_asset == nullptr && resources_asset_exists) {
114 LOG(ERROR) << "Failed to open '" << kResourcesArsc << "' in APK '" << assets->GetDebugName()
115 << "'.";
116 return {};
117 }
118
119 return LoadImpl(std::move(resources_asset), std::move(assets), property_flags,
120 std::move(idmap_asset), std::move(loaded_idmap));
121 }
122
LoadImpl(std::unique_ptr<Asset> && resources_asset,std::unique_ptr<AssetsProvider> && assets,package_property_t property_flags,std::unique_ptr<Asset> && idmap_asset,std::unique_ptr<LoadedIdmap> && loaded_idmap)123 ApkAssetsPtr ApkAssets::LoadImpl(std::unique_ptr<Asset>&& resources_asset,
124 std::unique_ptr<AssetsProvider>&& assets,
125 package_property_t property_flags,
126 std::unique_ptr<Asset>&& idmap_asset,
127 std::unique_ptr<LoadedIdmap>&& loaded_idmap) {
128 if (assets == nullptr ) {
129 return {};
130 }
131
132 std::unique_ptr<LoadedArsc> loaded_arsc;
133 if (resources_asset != nullptr) {
134 const auto data = resources_asset->getIncFsBuffer(true /* aligned */);
135 const size_t length = resources_asset->getLength();
136 if (!data || length == 0) {
137 LOG(ERROR) << "Failed to read resources table in APK '" << assets->GetDebugName() << "'.";
138 return {};
139 }
140 loaded_arsc = LoadedArsc::Load(data, length, loaded_idmap.get(), property_flags);
141 } else if (loaded_idmap != nullptr && IsFabricatedOverlay(loaded_idmap->OverlayApkPath())) {
142 loaded_arsc = LoadedArsc::Load(loaded_idmap.get());
143 } else {
144 loaded_arsc = LoadedArsc::CreateEmpty();
145 }
146
147 if (loaded_arsc == nullptr) {
148 LOG(ERROR) << "Failed to load resources table in APK '" << assets->GetDebugName() << "'.";
149 return {};
150 }
151
152 return ApkAssetsPtr::make(PrivateConstructorUtil{}, std::move(resources_asset),
153 std::move(loaded_arsc), std::move(assets), property_flags,
154 std::move(idmap_asset), std::move(loaded_idmap));
155 }
156
GetPath() const157 std::optional<std::string_view> ApkAssets::GetPath() const {
158 return assets_provider_->GetPath();
159 }
160
GetDebugName() const161 const std::string& ApkAssets::GetDebugName() const {
162 return assets_provider_->GetDebugName();
163 }
164
IsUpToDate() const165 bool ApkAssets::IsUpToDate() const {
166 // Loaders are invalidated by the app, not the system, so assume they are up to date.
167 return IsLoader() || ((!loaded_idmap_ || loaded_idmap_->IsUpToDate())
168 && assets_provider_->IsUpToDate());
169 }
170
171 } // namespace android
172