1 /* 2 * Copyright (C) 2015 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 "format/binary/TableFlattener.h" 18 19 #include <algorithm> 20 #include <numeric> 21 #include <sstream> 22 #include <type_traits> 23 24 #include "android-base/logging.h" 25 #include "android-base/macros.h" 26 #include "android-base/stringprintf.h" 27 #include "androidfw/ResourceUtils.h" 28 29 #include "ResourceTable.h" 30 #include "ResourceValues.h" 31 #include "SdkConstants.h" 32 #include "ValueVisitor.h" 33 #include "format/binary/ChunkWriter.h" 34 #include "format/binary/ResourceTypeExtensions.h" 35 #include "trace/TraceBuffer.h" 36 #include "util/BigBuffer.h" 37 38 using namespace android; 39 40 namespace aapt { 41 42 namespace { 43 44 template <typename T> 45 static bool cmp_ids(const T* a, const T* b) { 46 return a->id.value() < b->id.value(); 47 } 48 49 static void strcpy16_htod(uint16_t* dst, size_t len, const StringPiece16& src) { 50 if (len == 0) { 51 return; 52 } 53 54 size_t i; 55 const char16_t* src_data = src.data(); 56 for (i = 0; i < len - 1 && i < src.size(); i++) { 57 dst[i] = util::HostToDevice16((uint16_t)src_data[i]); 58 } 59 dst[i] = 0; 60 } 61 62 static bool cmp_style_entries(const Style::Entry& a, const Style::Entry& b) { 63 if (a.key.id) { 64 if (b.key.id) { 65 return a.key.id.value() < b.key.id.value(); 66 } 67 return true; 68 } else if (!b.key.id) { 69 return a.key.name.value() < b.key.name.value(); 70 } 71 return false; 72 } 73 74 struct FlatEntry { 75 ResourceEntry* entry; 76 Value* value; 77 78 // The entry string pool index to the entry's name. 79 uint32_t entry_key; 80 }; 81 82 class MapFlattenVisitor : public ValueVisitor { 83 public: 84 using ValueVisitor::Visit; 85 86 MapFlattenVisitor(ResTable_entry_ext* out_entry, BigBuffer* buffer) 87 : out_entry_(out_entry), buffer_(buffer) { 88 } 89 90 void Visit(Attribute* attr) override { 91 { 92 Reference key = Reference(ResourceId(ResTable_map::ATTR_TYPE)); 93 BinaryPrimitive val(Res_value::TYPE_INT_DEC, attr->type_mask); 94 FlattenEntry(&key, &val); 95 } 96 97 if (attr->min_int != std::numeric_limits<int32_t>::min()) { 98 Reference key = Reference(ResourceId(ResTable_map::ATTR_MIN)); 99 BinaryPrimitive val(Res_value::TYPE_INT_DEC, static_cast<uint32_t>(attr->min_int)); 100 FlattenEntry(&key, &val); 101 } 102 103 if (attr->max_int != std::numeric_limits<int32_t>::max()) { 104 Reference key = Reference(ResourceId(ResTable_map::ATTR_MAX)); 105 BinaryPrimitive val(Res_value::TYPE_INT_DEC, static_cast<uint32_t>(attr->max_int)); 106 FlattenEntry(&key, &val); 107 } 108 109 for (Attribute::Symbol& s : attr->symbols) { 110 BinaryPrimitive val(Res_value::TYPE_INT_DEC, s.value); 111 FlattenEntry(&s.symbol, &val); 112 } 113 } 114 115 void Visit(Style* style) override { 116 if (style->parent) { 117 const Reference& parent_ref = style->parent.value(); 118 CHECK(bool(parent_ref.id)) << "parent has no ID"; 119 out_entry_->parent.ident = util::HostToDevice32(parent_ref.id.value().id); 120 } 121 122 // Sort the style. 123 std::sort(style->entries.begin(), style->entries.end(), cmp_style_entries); 124 125 for (Style::Entry& entry : style->entries) { 126 FlattenEntry(&entry.key, entry.value.get()); 127 } 128 } 129 130 void Visit(Styleable* styleable) override { 131 for (auto& attr_ref : styleable->entries) { 132 BinaryPrimitive val(Res_value{}); 133 FlattenEntry(&attr_ref, &val); 134 } 135 } 136 137 void Visit(Array* array) override { 138 const size_t count = array->elements.size(); 139 for (size_t i = 0; i < count; i++) { 140 Reference key(android::ResTable_map::ATTR_MIN + i); 141 FlattenEntry(&key, array->elements[i].get()); 142 } 143 } 144 145 void Visit(Plural* plural) override { 146 const size_t count = plural->values.size(); 147 for (size_t i = 0; i < count; i++) { 148 if (!plural->values[i]) { 149 continue; 150 } 151 152 ResourceId q; 153 switch (i) { 154 case Plural::Zero: 155 q.id = android::ResTable_map::ATTR_ZERO; 156 break; 157 158 case Plural::One: 159 q.id = android::ResTable_map::ATTR_ONE; 160 break; 161 162 case Plural::Two: 163 q.id = android::ResTable_map::ATTR_TWO; 164 break; 165 166 case Plural::Few: 167 q.id = android::ResTable_map::ATTR_FEW; 168 break; 169 170 case Plural::Many: 171 q.id = android::ResTable_map::ATTR_MANY; 172 break; 173 174 case Plural::Other: 175 q.id = android::ResTable_map::ATTR_OTHER; 176 break; 177 178 default: 179 LOG(FATAL) << "unhandled plural type"; 180 break; 181 } 182 183 Reference key(q); 184 FlattenEntry(&key, plural->values[i].get()); 185 } 186 } 187 188 /** 189 * Call this after visiting a Value. This will finish any work that 190 * needs to be done to prepare the entry. 191 */ 192 void Finish() { 193 out_entry_->count = util::HostToDevice32(entry_count_); 194 } 195 196 private: 197 DISALLOW_COPY_AND_ASSIGN(MapFlattenVisitor); 198 199 void FlattenKey(Reference* key, ResTable_map* out_entry) { 200 CHECK(bool(key->id)) << "key has no ID"; 201 out_entry->name.ident = util::HostToDevice32(key->id.value().id); 202 } 203 204 void FlattenValue(Item* value, ResTable_map* out_entry) { 205 CHECK(value->Flatten(&out_entry->value)) << "flatten failed"; 206 } 207 208 void FlattenEntry(Reference* key, Item* value) { 209 ResTable_map* out_entry = buffer_->NextBlock<ResTable_map>(); 210 FlattenKey(key, out_entry); 211 FlattenValue(value, out_entry); 212 out_entry->value.size = util::HostToDevice16(sizeof(out_entry->value)); 213 entry_count_++; 214 } 215 216 ResTable_entry_ext* out_entry_; 217 BigBuffer* buffer_; 218 size_t entry_count_ = 0; 219 }; 220 221 struct OverlayableChunk { 222 std::string actor; 223 Source source; 224 std::map<OverlayableItem::PolicyFlags, std::set<ResourceId>> policy_ids; 225 }; 226 227 class PackageFlattener { 228 public: 229 PackageFlattener(IAaptContext* context, ResourceTablePackage* package, 230 const std::map<size_t, std::string>* shared_libs, bool use_sparse_entries, 231 bool collapse_key_stringpool, const std::set<std::string>& whitelisted_resources) 232 : context_(context), 233 diag_(context->GetDiagnostics()), 234 package_(package), 235 shared_libs_(shared_libs), 236 use_sparse_entries_(use_sparse_entries), 237 collapse_key_stringpool_(collapse_key_stringpool), 238 whitelisted_resources_(whitelisted_resources) { 239 } 240 241 bool FlattenPackage(BigBuffer* buffer) { 242 TRACE_CALL(); 243 ChunkWriter pkg_writer(buffer); 244 ResTable_package* pkg_header = pkg_writer.StartChunk<ResTable_package>(RES_TABLE_PACKAGE_TYPE); 245 pkg_header->id = util::HostToDevice32(package_->id.value()); 246 247 // AAPT truncated the package name, so do the same. 248 // Shared libraries require full package names, so don't truncate theirs. 249 if (context_->GetPackageType() != PackageType::kApp && 250 package_->name.size() >= arraysize(pkg_header->name)) { 251 diag_->Error(DiagMessage() << "package name '" << package_->name 252 << "' is too long. " 253 "Shared libraries cannot have truncated package names"); 254 return false; 255 } 256 257 // Copy the package name in device endianness. 258 strcpy16_htod(pkg_header->name, arraysize(pkg_header->name), util::Utf8ToUtf16(package_->name)); 259 260 // Serialize the types. We do this now so that our type and key strings 261 // are populated. We write those first. 262 BigBuffer type_buffer(1024); 263 FlattenTypes(&type_buffer); 264 265 pkg_header->typeStrings = util::HostToDevice32(pkg_writer.size()); 266 StringPool::FlattenUtf16(pkg_writer.buffer(), type_pool_, diag_); 267 268 pkg_header->keyStrings = util::HostToDevice32(pkg_writer.size()); 269 StringPool::FlattenUtf8(pkg_writer.buffer(), key_pool_, diag_); 270 271 // Append the types. 272 buffer->AppendBuffer(std::move(type_buffer)); 273 274 // If there are libraries (or if the package ID is 0x00), encode a library chunk. 275 if (package_->id.value() == 0x00 || !shared_libs_->empty()) { 276 FlattenLibrarySpec(buffer); 277 } 278 279 if (!FlattenOverlayable(buffer)) { 280 return false; 281 } 282 283 pkg_writer.Finish(); 284 return true; 285 } 286 287 private: 288 DISALLOW_COPY_AND_ASSIGN(PackageFlattener); 289 290 template <typename T, bool IsItem> 291 T* WriteEntry(FlatEntry* entry, BigBuffer* buffer) { 292 static_assert( 293 std::is_same<ResTable_entry, T>::value || std::is_same<ResTable_entry_ext, T>::value, 294 "T must be ResTable_entry or ResTable_entry_ext"); 295 296 T* result = buffer->NextBlock<T>(); 297 ResTable_entry* out_entry = (ResTable_entry*)result; 298 if (entry->entry->visibility.level == Visibility::Level::kPublic) { 299 out_entry->flags |= ResTable_entry::FLAG_PUBLIC; 300 } 301 302 if (entry->value->IsWeak()) { 303 out_entry->flags |= ResTable_entry::FLAG_WEAK; 304 } 305 306 if (!IsItem) { 307 out_entry->flags |= ResTable_entry::FLAG_COMPLEX; 308 } 309 310 out_entry->flags = util::HostToDevice16(out_entry->flags); 311 out_entry->key.index = util::HostToDevice32(entry->entry_key); 312 out_entry->size = util::HostToDevice16(sizeof(T)); 313 return result; 314 } 315 316 bool FlattenValue(FlatEntry* entry, BigBuffer* buffer) { 317 if (Item* item = ValueCast<Item>(entry->value)) { 318 WriteEntry<ResTable_entry, true>(entry, buffer); 319 Res_value* outValue = buffer->NextBlock<Res_value>(); 320 CHECK(item->Flatten(outValue)) << "flatten failed"; 321 outValue->size = util::HostToDevice16(sizeof(*outValue)); 322 } else { 323 ResTable_entry_ext* out_entry = WriteEntry<ResTable_entry_ext, false>(entry, buffer); 324 MapFlattenVisitor visitor(out_entry, buffer); 325 entry->value->Accept(&visitor); 326 visitor.Finish(); 327 } 328 return true; 329 } 330 331 bool FlattenConfig(const ResourceTableType* type, const ConfigDescription& config, 332 const size_t num_total_entries, std::vector<FlatEntry>* entries, 333 BigBuffer* buffer) { 334 CHECK(num_total_entries != 0); 335 CHECK(num_total_entries <= std::numeric_limits<uint16_t>::max()); 336 337 ChunkWriter type_writer(buffer); 338 ResTable_type* type_header = type_writer.StartChunk<ResTable_type>(RES_TABLE_TYPE_TYPE); 339 type_header->id = type->id.value(); 340 type_header->config = config; 341 type_header->config.swapHtoD(); 342 343 std::vector<uint32_t> offsets; 344 offsets.resize(num_total_entries, 0xffffffffu); 345 346 BigBuffer values_buffer(512); 347 for (FlatEntry& flat_entry : *entries) { 348 CHECK(static_cast<size_t>(flat_entry.entry->id.value()) < num_total_entries); 349 offsets[flat_entry.entry->id.value()] = values_buffer.size(); 350 if (!FlattenValue(&flat_entry, &values_buffer)) { 351 diag_->Error(DiagMessage() 352 << "failed to flatten resource '" 353 << ResourceNameRef(package_->name, type->type, flat_entry.entry->name) 354 << "' for configuration '" << config << "'"); 355 return false; 356 } 357 } 358 359 bool sparse_encode = use_sparse_entries_; 360 361 // Only sparse encode if the entries will be read on platforms O+. 362 sparse_encode = 363 sparse_encode && (context_->GetMinSdkVersion() >= SDK_O || config.sdkVersion >= SDK_O); 364 365 // Only sparse encode if the offsets are representable in 2 bytes. 366 sparse_encode = 367 sparse_encode && (values_buffer.size() / 4u) <= std::numeric_limits<uint16_t>::max(); 368 369 // Only sparse encode if the ratio of populated entries to total entries is below some 370 // threshold. 371 sparse_encode = 372 sparse_encode && ((100 * entries->size()) / num_total_entries) < kSparseEncodingThreshold; 373 374 if (sparse_encode) { 375 type_header->entryCount = util::HostToDevice32(entries->size()); 376 type_header->flags |= ResTable_type::FLAG_SPARSE; 377 ResTable_sparseTypeEntry* indices = 378 type_writer.NextBlock<ResTable_sparseTypeEntry>(entries->size()); 379 for (size_t i = 0; i < num_total_entries; i++) { 380 if (offsets[i] != ResTable_type::NO_ENTRY) { 381 CHECK((offsets[i] & 0x03) == 0); 382 indices->idx = util::HostToDevice16(i); 383 indices->offset = util::HostToDevice16(offsets[i] / 4u); 384 indices++; 385 } 386 } 387 } else { 388 type_header->entryCount = util::HostToDevice32(num_total_entries); 389 uint32_t* indices = type_writer.NextBlock<uint32_t>(num_total_entries); 390 for (size_t i = 0; i < num_total_entries; i++) { 391 indices[i] = util::HostToDevice32(offsets[i]); 392 } 393 } 394 395 type_header->entriesStart = util::HostToDevice32(type_writer.size()); 396 type_writer.buffer()->AppendBuffer(std::move(values_buffer)); 397 type_writer.Finish(); 398 return true; 399 } 400 401 std::vector<ResourceTableType*> CollectAndSortTypes() { 402 std::vector<ResourceTableType*> sorted_types; 403 for (auto& type : package_->types) { 404 if (type->type == ResourceType::kStyleable) { 405 // Styleables aren't real Resource Types, they are represented in the 406 // R.java file. 407 continue; 408 } 409 410 CHECK(bool(type->id)) << "type must have an ID set"; 411 412 sorted_types.push_back(type.get()); 413 } 414 std::sort(sorted_types.begin(), sorted_types.end(), cmp_ids<ResourceTableType>); 415 return sorted_types; 416 } 417 418 std::vector<ResourceEntry*> CollectAndSortEntries(ResourceTableType* type) { 419 // Sort the entries by entry ID. 420 std::vector<ResourceEntry*> sorted_entries; 421 for (auto& entry : type->entries) { 422 CHECK(bool(entry->id)) << "entry must have an ID set"; 423 sorted_entries.push_back(entry.get()); 424 } 425 std::sort(sorted_entries.begin(), sorted_entries.end(), cmp_ids<ResourceEntry>); 426 return sorted_entries; 427 } 428 429 bool FlattenOverlayable(BigBuffer* buffer) { 430 std::set<ResourceId> seen_ids; 431 std::map<std::string, OverlayableChunk> overlayable_chunks; 432 433 CHECK(bool(package_->id)) << "package must have an ID set when flattening <overlayable>"; 434 for (auto& type : package_->types) { 435 CHECK(bool(type->id)) << "type must have an ID set when flattening <overlayable>"; 436 for (auto& entry : type->entries) { 437 CHECK(bool(type->id)) << "entry must have an ID set when flattening <overlayable>"; 438 if (!entry->overlayable_item) { 439 continue; 440 } 441 442 OverlayableItem& item = entry->overlayable_item.value(); 443 444 // Resource ids should only appear once in the resource table 445 ResourceId id = android::make_resid(package_->id.value(), type->id.value(), 446 entry->id.value()); 447 CHECK(seen_ids.find(id) == seen_ids.end()) 448 << "multiple overlayable definitions found for resource " 449 << ResourceName(package_->name, type->type, entry->name).to_string(); 450 seen_ids.insert(id); 451 452 // Find the overlayable chunk with the specified name 453 OverlayableChunk* overlayable_chunk = nullptr; 454 auto iter = overlayable_chunks.find(item.overlayable->name); 455 if (iter == overlayable_chunks.end()) { 456 OverlayableChunk chunk{item.overlayable->actor, item.overlayable->source}; 457 overlayable_chunk = 458 &overlayable_chunks.insert({item.overlayable->name, chunk}).first->second; 459 } else { 460 OverlayableChunk& chunk = iter->second; 461 if (!(chunk.source == item.overlayable->source)) { 462 // The name of an overlayable set of resources must be unique 463 context_->GetDiagnostics()->Error(DiagMessage(item.overlayable->source) 464 << "duplicate overlayable name" 465 << item.overlayable->name << "'"); 466 context_->GetDiagnostics()->Error(DiagMessage(chunk.source) 467 << "previous declaration here"); 468 return false; 469 } 470 471 CHECK(chunk.actor == item.overlayable->actor); 472 overlayable_chunk = &chunk; 473 } 474 475 if (item.policies == 0) { 476 context_->GetDiagnostics()->Error(DiagMessage(item.overlayable->source) 477 << "overlayable " 478 << entry->name 479 << " does not specify policy"); 480 return false; 481 } 482 483 uint32_t policy_flags = 0; 484 if (item.policies & OverlayableItem::Policy::kPublic) { 485 policy_flags |= ResTable_overlayable_policy_header::POLICY_PUBLIC; 486 } 487 if (item.policies & OverlayableItem::Policy::kSystem) { 488 policy_flags |= ResTable_overlayable_policy_header::POLICY_SYSTEM_PARTITION; 489 } 490 if (item.policies & OverlayableItem::Policy::kVendor) { 491 policy_flags |= ResTable_overlayable_policy_header::POLICY_VENDOR_PARTITION; 492 } 493 if (item.policies & OverlayableItem::Policy::kProduct) { 494 policy_flags |= ResTable_overlayable_policy_header::POLICY_PRODUCT_PARTITION; 495 } 496 if (item.policies & OverlayableItem::Policy::kSignature) { 497 policy_flags |= ResTable_overlayable_policy_header::POLICY_SIGNATURE; 498 } 499 if (item.policies & OverlayableItem::Policy::kOdm) { 500 policy_flags |= ResTable_overlayable_policy_header::POLICY_ODM_PARTITION; 501 } 502 if (item.policies & OverlayableItem::Policy::kOem) { 503 policy_flags |= ResTable_overlayable_policy_header::POLICY_OEM_PARTITION; 504 } 505 506 auto policy = overlayable_chunk->policy_ids.find(policy_flags); 507 if (policy != overlayable_chunk->policy_ids.end()) { 508 policy->second.insert(id); 509 } else { 510 overlayable_chunk->policy_ids.insert( 511 std::make_pair(policy_flags, std::set<ResourceId>{id})); 512 } 513 } 514 } 515 516 for (auto& overlayable_pair : overlayable_chunks) { 517 std::string name = overlayable_pair.first; 518 OverlayableChunk& overlayable = overlayable_pair.second; 519 520 // Write the header of the overlayable chunk 521 ChunkWriter overlayable_writer(buffer); 522 auto* overlayable_type = 523 overlayable_writer.StartChunk<ResTable_overlayable_header>(RES_TABLE_OVERLAYABLE_TYPE); 524 if (name.size() >= arraysize(overlayable_type->name)) { 525 diag_->Error(DiagMessage() << "overlayable name '" << name 526 << "' exceeds maximum length (" 527 << arraysize(overlayable_type->name) 528 << " utf16 characters)"); 529 return false; 530 } 531 strcpy16_htod(overlayable_type->name, arraysize(overlayable_type->name), 532 util::Utf8ToUtf16(name)); 533 534 if (overlayable.actor.size() >= arraysize(overlayable_type->actor)) { 535 diag_->Error(DiagMessage() << "overlayable name '" << overlayable.actor 536 << "' exceeds maximum length (" 537 << arraysize(overlayable_type->actor) 538 << " utf16 characters)"); 539 return false; 540 } 541 strcpy16_htod(overlayable_type->actor, arraysize(overlayable_type->actor), 542 util::Utf8ToUtf16(overlayable.actor)); 543 544 // Write each policy block for the overlayable 545 for (auto& policy_ids : overlayable.policy_ids) { 546 ChunkWriter policy_writer(buffer); 547 auto* policy_type = policy_writer.StartChunk<ResTable_overlayable_policy_header>( 548 RES_TABLE_OVERLAYABLE_POLICY_TYPE); 549 policy_type->policy_flags = util::HostToDevice32(static_cast<uint32_t>(policy_ids.first)); 550 policy_type->entry_count = util::HostToDevice32(static_cast<uint32_t>( 551 policy_ids.second.size())); 552 // Write the ids after the policy header 553 auto* id_block = policy_writer.NextBlock<ResTable_ref>(policy_ids.second.size()); 554 for (const ResourceId& id : policy_ids.second) { 555 id_block->ident = util::HostToDevice32(id.id); 556 id_block++; 557 } 558 policy_writer.Finish(); 559 } 560 overlayable_writer.Finish(); 561 } 562 563 return true; 564 } 565 566 bool FlattenTypeSpec(ResourceTableType* type, std::vector<ResourceEntry*>* sorted_entries, 567 BigBuffer* buffer) { 568 ChunkWriter type_spec_writer(buffer); 569 ResTable_typeSpec* spec_header = 570 type_spec_writer.StartChunk<ResTable_typeSpec>(RES_TABLE_TYPE_SPEC_TYPE); 571 spec_header->id = type->id.value(); 572 573 if (sorted_entries->empty()) { 574 type_spec_writer.Finish(); 575 return true; 576 } 577 578 // We can't just take the size of the vector. There may be holes in the 579 // entry ID space. 580 // Since the entries are sorted by ID, the last one will be the biggest. 581 const size_t num_entries = sorted_entries->back()->id.value() + 1; 582 583 spec_header->entryCount = util::HostToDevice32(num_entries); 584 585 // Reserve space for the masks of each resource in this type. These 586 // show for which configuration axis the resource changes. 587 uint32_t* config_masks = type_spec_writer.NextBlock<uint32_t>(num_entries); 588 589 const size_t actual_num_entries = sorted_entries->size(); 590 for (size_t entryIndex = 0; entryIndex < actual_num_entries; entryIndex++) { 591 ResourceEntry* entry = sorted_entries->at(entryIndex); 592 593 // Populate the config masks for this entry. 594 595 if (entry->visibility.level == Visibility::Level::kPublic) { 596 config_masks[entry->id.value()] |= util::HostToDevice32(ResTable_typeSpec::SPEC_PUBLIC); 597 } 598 599 const size_t config_count = entry->values.size(); 600 for (size_t i = 0; i < config_count; i++) { 601 const ConfigDescription& config = entry->values[i]->config; 602 for (size_t j = i + 1; j < config_count; j++) { 603 config_masks[entry->id.value()] |= 604 util::HostToDevice32(config.diff(entry->values[j]->config)); 605 } 606 } 607 } 608 type_spec_writer.Finish(); 609 return true; 610 } 611 612 bool FlattenTypes(BigBuffer* buffer) { 613 // Sort the types by their IDs. They will be inserted into the StringPool in 614 // this order. 615 std::vector<ResourceTableType*> sorted_types = CollectAndSortTypes(); 616 617 size_t expected_type_id = 1; 618 for (ResourceTableType* type : sorted_types) { 619 // If there is a gap in the type IDs, fill in the StringPool 620 // with empty values until we reach the ID we expect. 621 while (type->id.value() > expected_type_id) { 622 std::stringstream type_name; 623 type_name << "?" << expected_type_id; 624 type_pool_.MakeRef(type_name.str()); 625 expected_type_id++; 626 } 627 expected_type_id++; 628 type_pool_.MakeRef(to_string(type->type)); 629 630 std::vector<ResourceEntry*> sorted_entries = CollectAndSortEntries(type); 631 if (sorted_entries.empty()) { 632 continue; 633 } 634 635 if (!FlattenTypeSpec(type, &sorted_entries, buffer)) { 636 return false; 637 } 638 639 // Since the entries are sorted by ID, the last ID will be the largest. 640 const size_t num_entries = sorted_entries.back()->id.value() + 1; 641 642 // The binary resource table lists resource entries for each 643 // configuration. 644 // We store them inverted, where a resource entry lists the values for 645 // each 646 // configuration available. Here we reverse this to match the binary 647 // table. 648 std::map<ConfigDescription, std::vector<FlatEntry>> config_to_entry_list_map; 649 650 // hardcoded string uses characters which make it an invalid resource name 651 const std::string obfuscated_resource_name = "0_resource_name_obfuscated"; 652 653 for (ResourceEntry* entry : sorted_entries) { 654 uint32_t local_key_index; 655 if (!collapse_key_stringpool_ || 656 whitelisted_resources_.find(entry->name) != whitelisted_resources_.end()) { 657 local_key_index = (uint32_t)key_pool_.MakeRef(entry->name).index(); 658 } else { 659 // resource isn't whitelisted, add it as obfuscated value 660 local_key_index = (uint32_t)key_pool_.MakeRef(obfuscated_resource_name).index(); 661 } 662 // Group values by configuration. 663 for (auto& config_value : entry->values) { 664 config_to_entry_list_map[config_value->config].push_back( 665 FlatEntry{entry, config_value->value.get(), local_key_index}); 666 } 667 } 668 669 // Flatten a configuration value. 670 for (auto& entry : config_to_entry_list_map) { 671 if (!FlattenConfig(type, entry.first, num_entries, &entry.second, buffer)) { 672 return false; 673 } 674 } 675 } 676 return true; 677 } 678 679 void FlattenLibrarySpec(BigBuffer* buffer) { 680 ChunkWriter lib_writer(buffer); 681 ResTable_lib_header* lib_header = 682 lib_writer.StartChunk<ResTable_lib_header>(RES_TABLE_LIBRARY_TYPE); 683 684 const size_t num_entries = (package_->id.value() == 0x00 ? 1 : 0) + shared_libs_->size(); 685 CHECK(num_entries > 0); 686 687 lib_header->count = util::HostToDevice32(num_entries); 688 689 ResTable_lib_entry* lib_entry = buffer->NextBlock<ResTable_lib_entry>(num_entries); 690 if (package_->id.value() == 0x00) { 691 // Add this package 692 lib_entry->packageId = util::HostToDevice32(0x00); 693 strcpy16_htod(lib_entry->packageName, arraysize(lib_entry->packageName), 694 util::Utf8ToUtf16(package_->name)); 695 ++lib_entry; 696 } 697 698 for (auto& map_entry : *shared_libs_) { 699 lib_entry->packageId = util::HostToDevice32(map_entry.first); 700 strcpy16_htod(lib_entry->packageName, arraysize(lib_entry->packageName), 701 util::Utf8ToUtf16(map_entry.second)); 702 ++lib_entry; 703 } 704 lib_writer.Finish(); 705 } 706 707 IAaptContext* context_; 708 IDiagnostics* diag_; 709 ResourceTablePackage* package_; 710 const std::map<size_t, std::string>* shared_libs_; 711 bool use_sparse_entries_; 712 StringPool type_pool_; 713 StringPool key_pool_; 714 bool collapse_key_stringpool_; 715 const std::set<std::string>& whitelisted_resources_; 716 }; 717 718 } // namespace 719 720 bool TableFlattener::Consume(IAaptContext* context, ResourceTable* table) { 721 TRACE_CALL(); 722 // We must do this before writing the resources, since the string pool IDs may change. 723 table->string_pool.Prune(); 724 table->string_pool.Sort([](const StringPool::Context& a, const StringPool::Context& b) -> int { 725 int diff = util::compare(a.priority, b.priority); 726 if (diff == 0) { 727 diff = a.config.compare(b.config); 728 } 729 return diff; 730 }); 731 732 // Write the ResTable header. 733 ChunkWriter table_writer(buffer_); 734 ResTable_header* table_header = table_writer.StartChunk<ResTable_header>(RES_TABLE_TYPE); 735 table_header->packageCount = util::HostToDevice32(table->packages.size()); 736 737 // Flatten the values string pool. 738 StringPool::FlattenUtf8(table_writer.buffer(), table->string_pool, 739 context->GetDiagnostics()); 740 741 BigBuffer package_buffer(1024); 742 743 // Flatten each package. 744 for (auto& package : table->packages) { 745 if (context->GetPackageType() == PackageType::kApp) { 746 // Write a self mapping entry for this package if the ID is non-standard (0x7f). 747 const uint8_t package_id = package->id.value(); 748 if (package_id != kFrameworkPackageId && package_id != kAppPackageId) { 749 auto result = table->included_packages_.insert({package_id, package->name}); 750 if (!result.second && result.first->second != package->name) { 751 // A mapping for this package ID already exists, and is a different package. Error! 752 context->GetDiagnostics()->Error( 753 DiagMessage() << android::base::StringPrintf( 754 "can't map package ID %02x to '%s'. Already mapped to '%s'", package_id, 755 package->name.c_str(), result.first->second.c_str())); 756 return false; 757 } 758 } 759 } 760 761 PackageFlattener flattener(context, package.get(), &table->included_packages_, 762 options_.use_sparse_entries, options_.collapse_key_stringpool, 763 options_.whitelisted_resources); 764 if (!flattener.FlattenPackage(&package_buffer)) { 765 return false; 766 } 767 } 768 769 // Finally merge all the packages into the main buffer. 770 table_writer.buffer()->AppendBuffer(std::move(package_buffer)); 771 table_writer.Finish(); 772 return true; 773 } 774 775 } // namespace aapt 776
