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 "Resource.h" 18 #include "ResourceTable.h" 19 #include "StringPool.h" 20 #include "ValueVisitor.h" 21 #include "proto/ProtoHelpers.h" 22 #include "proto/ProtoSerialize.h" 23 #include "util/BigBuffer.h" 24 25 #include "android-base/logging.h" 26 27 using google::protobuf::io::CodedOutputStream; 28 using google::protobuf::io::CodedInputStream; 29 using google::protobuf::io::ZeroCopyOutputStream; 30 31 namespace aapt { 32 33 namespace { 34 35 class PbSerializerVisitor : public RawValueVisitor { 36 public: 37 using RawValueVisitor::Visit; 38 39 /** 40 * Constructor to use when expecting to serialize any value. 41 */ 42 PbSerializerVisitor(StringPool* source_pool, StringPool* symbol_pool, 43 pb::Value* out_pb_value) 44 : source_pool_(source_pool), 45 symbol_pool_(symbol_pool), 46 out_pb_value_(out_pb_value), 47 out_pb_item_(nullptr) {} 48 49 /** 50 * Constructor to use when expecting to serialize an Item. 51 */ 52 PbSerializerVisitor(StringPool* sourcePool, StringPool* symbolPool, 53 pb::Item* outPbItem) 54 : source_pool_(sourcePool), 55 symbol_pool_(symbolPool), 56 out_pb_value_(nullptr), 57 out_pb_item_(outPbItem) {} 58 59 void Visit(Reference* ref) override { 60 SerializeReferenceToPb(*ref, pb_item()->mutable_ref()); 61 } 62 63 void Visit(String* str) override { 64 pb_item()->mutable_str()->set_idx(str->value.index()); 65 } 66 67 void Visit(StyledString* str) override { 68 pb_item()->mutable_str()->set_idx(str->value.index()); 69 } 70 71 void Visit(FileReference* file) override { 72 pb_item()->mutable_file()->set_path_idx(file->path.index()); 73 } 74 75 void Visit(Id* id) override { pb_item()->mutable_id(); } 76 77 void Visit(RawString* raw_str) override { 78 pb_item()->mutable_raw_str()->set_idx(raw_str->value.index()); 79 } 80 81 void Visit(BinaryPrimitive* prim) override { 82 android::Res_value val = {}; 83 prim->Flatten(&val); 84 85 pb::Primitive* pb_prim = pb_item()->mutable_prim(); 86 pb_prim->set_type(val.dataType); 87 pb_prim->set_data(val.data); 88 } 89 90 void VisitItem(Item* item) override { LOG(FATAL) << "unimplemented item"; } 91 92 void Visit(Attribute* attr) override { 93 pb::Attribute* pb_attr = pb_compound_value()->mutable_attr(); 94 pb_attr->set_format_flags(attr->type_mask); 95 pb_attr->set_min_int(attr->min_int); 96 pb_attr->set_max_int(attr->max_int); 97 98 for (auto& symbol : attr->symbols) { 99 pb::Attribute_Symbol* pb_symbol = pb_attr->add_symbols(); 100 SerializeItemCommonToPb(symbol.symbol, pb_symbol); 101 SerializeReferenceToPb(symbol.symbol, pb_symbol->mutable_name()); 102 pb_symbol->set_value(symbol.value); 103 } 104 } 105 106 void Visit(Style* style) override { 107 pb::Style* pb_style = pb_compound_value()->mutable_style(); 108 if (style->parent) { 109 SerializeReferenceToPb(style->parent.value(), pb_style->mutable_parent()); 110 SerializeSourceToPb(style->parent.value().GetSource(), source_pool_, 111 pb_style->mutable_parent_source()); 112 } 113 114 for (Style::Entry& entry : style->entries) { 115 pb::Style_Entry* pb_entry = pb_style->add_entries(); 116 SerializeReferenceToPb(entry.key, pb_entry->mutable_key()); 117 118 pb::Item* pb_item = pb_entry->mutable_item(); 119 SerializeItemCommonToPb(entry.key, pb_entry); 120 PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_, pb_item); 121 entry.value->Accept(&sub_visitor); 122 } 123 } 124 125 void Visit(Styleable* styleable) override { 126 pb::Styleable* pb_styleable = pb_compound_value()->mutable_styleable(); 127 for (Reference& entry : styleable->entries) { 128 pb::Styleable_Entry* pb_entry = pb_styleable->add_entries(); 129 SerializeItemCommonToPb(entry, pb_entry); 130 SerializeReferenceToPb(entry, pb_entry->mutable_attr()); 131 } 132 } 133 134 void Visit(Array* array) override { 135 pb::Array* pb_array = pb_compound_value()->mutable_array(); 136 for (auto& value : array->items) { 137 pb::Array_Entry* pb_entry = pb_array->add_entries(); 138 SerializeItemCommonToPb(*value, pb_entry); 139 PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_, 140 pb_entry->mutable_item()); 141 value->Accept(&sub_visitor); 142 } 143 } 144 145 void Visit(Plural* plural) override { 146 pb::Plural* pb_plural = pb_compound_value()->mutable_plural(); 147 const size_t count = plural->values.size(); 148 for (size_t i = 0; i < count; i++) { 149 if (!plural->values[i]) { 150 // No plural value set here. 151 continue; 152 } 153 154 pb::Plural_Entry* pb_entry = pb_plural->add_entries(); 155 pb_entry->set_arity(SerializePluralEnumToPb(i)); 156 pb::Item* pb_element = pb_entry->mutable_item(); 157 SerializeItemCommonToPb(*plural->values[i], pb_entry); 158 PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_, pb_element); 159 plural->values[i]->Accept(&sub_visitor); 160 } 161 } 162 163 private: 164 DISALLOW_COPY_AND_ASSIGN(PbSerializerVisitor); 165 166 pb::Item* pb_item() { 167 if (out_pb_value_) { 168 return out_pb_value_->mutable_item(); 169 } 170 return out_pb_item_; 171 } 172 173 pb::CompoundValue* pb_compound_value() { 174 CHECK(out_pb_value_ != nullptr); 175 return out_pb_value_->mutable_compound_value(); 176 } 177 178 template <typename T> 179 void SerializeItemCommonToPb(const Item& item, T* pb_item) { 180 SerializeSourceToPb(item.GetSource(), source_pool_, 181 pb_item->mutable_source()); 182 if (!item.GetComment().empty()) { 183 pb_item->set_comment(item.GetComment()); 184 } 185 } 186 187 void SerializeReferenceToPb(const Reference& ref, pb::Reference* pb_ref) { 188 if (ref.id) { 189 pb_ref->set_id(ref.id.value().id); 190 } 191 192 if (ref.name) { 193 StringPool::Ref symbol_ref = symbol_pool_->MakeRef(ref.name.value().ToString()); 194 pb_ref->set_symbol_idx(static_cast<uint32_t>(symbol_ref.index())); 195 } 196 197 pb_ref->set_private_(ref.private_reference); 198 pb_ref->set_type(SerializeReferenceTypeToPb(ref.reference_type)); 199 } 200 201 StringPool* source_pool_; 202 StringPool* symbol_pool_; 203 pb::Value* out_pb_value_; 204 pb::Item* out_pb_item_; 205 }; 206 207 } // namespace 208 209 std::unique_ptr<pb::ResourceTable> SerializeTableToPb(ResourceTable* table) { 210 // We must do this before writing the resources, since the string pool IDs may 211 // change. 212 table->string_pool.Sort( 213 [](const StringPool::Entry& a, const StringPool::Entry& b) -> bool { 214 int diff = a.context.priority - b.context.priority; 215 if (diff < 0) return true; 216 if (diff > 0) return false; 217 diff = a.context.config.compare(b.context.config); 218 if (diff < 0) return true; 219 if (diff > 0) return false; 220 return a.value < b.value; 221 }); 222 table->string_pool.Prune(); 223 224 auto pb_table = util::make_unique<pb::ResourceTable>(); 225 SerializeStringPoolToPb(table->string_pool, pb_table->mutable_string_pool()); 226 227 StringPool source_pool, symbol_pool; 228 229 for (auto& package : table->packages) { 230 pb::Package* pb_package = pb_table->add_packages(); 231 if (package->id) { 232 pb_package->set_package_id(package->id.value()); 233 } 234 pb_package->set_package_name(package->name); 235 236 for (auto& type : package->types) { 237 pb::Type* pb_type = pb_package->add_types(); 238 if (type->id) { 239 pb_type->set_id(type->id.value()); 240 } 241 pb_type->set_name(ToString(type->type).to_string()); 242 243 for (auto& entry : type->entries) { 244 pb::Entry* pb_entry = pb_type->add_entries(); 245 if (entry->id) { 246 pb_entry->set_id(entry->id.value()); 247 } 248 pb_entry->set_name(entry->name); 249 250 // Write the SymbolStatus struct. 251 pb::SymbolStatus* pb_status = pb_entry->mutable_symbol_status(); 252 pb_status->set_visibility(SerializeVisibilityToPb(entry->symbol_status.state)); 253 SerializeSourceToPb(entry->symbol_status.source, &source_pool, pb_status->mutable_source()); 254 pb_status->set_comment(entry->symbol_status.comment); 255 pb_status->set_allow_new(entry->symbol_status.allow_new); 256 257 for (auto& config_value : entry->values) { 258 pb::ConfigValue* pb_config_value = pb_entry->add_config_values(); 259 SerializeConfig(config_value->config, pb_config_value->mutable_config()); 260 if (!config_value->product.empty()) { 261 pb_config_value->mutable_config()->set_product(config_value->product); 262 } 263 264 pb::Value* pb_value = pb_config_value->mutable_value(); 265 SerializeSourceToPb(config_value->value->GetSource(), &source_pool, 266 pb_value->mutable_source()); 267 if (!config_value->value->GetComment().empty()) { 268 pb_value->set_comment(config_value->value->GetComment()); 269 } 270 271 if (config_value->value->IsWeak()) { 272 pb_value->set_weak(true); 273 } 274 275 PbSerializerVisitor visitor(&source_pool, &symbol_pool, pb_value); 276 config_value->value->Accept(&visitor); 277 } 278 } 279 } 280 } 281 282 SerializeStringPoolToPb(source_pool, pb_table->mutable_source_pool()); 283 SerializeStringPoolToPb(symbol_pool, pb_table->mutable_symbol_pool()); 284 return pb_table; 285 } 286 287 std::unique_ptr<pb::CompiledFile> SerializeCompiledFileToPb( 288 const ResourceFile& file) { 289 auto pb_file = util::make_unique<pb::CompiledFile>(); 290 pb_file->set_resource_name(file.name.ToString()); 291 pb_file->set_source_path(file.source.path); 292 SerializeConfig(file.config, pb_file->mutable_config()); 293 294 for (const SourcedResourceName& exported : file.exported_symbols) { 295 pb::CompiledFile_Symbol* pb_symbol = pb_file->add_exported_symbols(); 296 pb_symbol->set_resource_name(exported.name.ToString()); 297 pb_symbol->set_line_no(exported.line); 298 } 299 return pb_file; 300 } 301 302 CompiledFileOutputStream::CompiledFileOutputStream(ZeroCopyOutputStream* out) 303 : out_(out) {} 304 305 void CompiledFileOutputStream::EnsureAlignedWrite() { 306 const int padding = out_.ByteCount() % 4; 307 if (padding > 0) { 308 uint32_t zero = 0u; 309 out_.WriteRaw(&zero, padding); 310 } 311 } 312 313 void CompiledFileOutputStream::WriteLittleEndian32(uint32_t val) { 314 EnsureAlignedWrite(); 315 out_.WriteLittleEndian32(val); 316 } 317 318 void CompiledFileOutputStream::WriteCompiledFile( 319 const pb::CompiledFile* compiled_file) { 320 EnsureAlignedWrite(); 321 out_.WriteLittleEndian64(static_cast<uint64_t>(compiled_file->ByteSize())); 322 compiled_file->SerializeWithCachedSizes(&out_); 323 } 324 325 void CompiledFileOutputStream::WriteData(const BigBuffer* buffer) { 326 EnsureAlignedWrite(); 327 out_.WriteLittleEndian64(static_cast<uint64_t>(buffer->size())); 328 for (const BigBuffer::Block& block : *buffer) { 329 out_.WriteRaw(block.buffer.get(), block.size); 330 } 331 } 332 333 void CompiledFileOutputStream::WriteData(const void* data, size_t len) { 334 EnsureAlignedWrite(); 335 out_.WriteLittleEndian64(static_cast<uint64_t>(len)); 336 out_.WriteRaw(data, len); 337 } 338 339 bool CompiledFileOutputStream::HadError() { return out_.HadError(); } 340 341 CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size) 342 : in_(static_cast<const uint8_t*>(data), size) {} 343 344 void CompiledFileInputStream::EnsureAlignedRead() { 345 const int padding = in_.CurrentPosition() % 4; 346 if (padding > 0) { 347 // Reads are always 4 byte aligned. 348 in_.Skip(padding); 349 } 350 } 351 352 bool CompiledFileInputStream::ReadLittleEndian32(uint32_t* out_val) { 353 EnsureAlignedRead(); 354 return in_.ReadLittleEndian32(out_val); 355 } 356 357 bool CompiledFileInputStream::ReadCompiledFile(pb::CompiledFile* out_val) { 358 EnsureAlignedRead(); 359 360 google::protobuf::uint64 pb_size = 0u; 361 if (!in_.ReadLittleEndian64(&pb_size)) { 362 return false; 363 } 364 365 CodedInputStream::Limit l = in_.PushLimit(static_cast<int>(pb_size)); 366 367 // Check that we haven't tried to read past the end. 368 if (static_cast<uint64_t>(in_.BytesUntilLimit()) != pb_size) { 369 in_.PopLimit(l); 370 in_.PushLimit(0); 371 return false; 372 } 373 374 if (!out_val->ParsePartialFromCodedStream(&in_)) { 375 in_.PopLimit(l); 376 in_.PushLimit(0); 377 return false; 378 } 379 380 in_.PopLimit(l); 381 return true; 382 } 383 384 bool CompiledFileInputStream::ReadDataMetaData(uint64_t* out_offset, 385 uint64_t* out_len) { 386 EnsureAlignedRead(); 387 388 google::protobuf::uint64 pb_size = 0u; 389 if (!in_.ReadLittleEndian64(&pb_size)) { 390 return false; 391 } 392 393 // Check that we aren't trying to read past the end. 394 if (pb_size > static_cast<uint64_t>(in_.BytesUntilLimit())) { 395 in_.PushLimit(0); 396 return false; 397 } 398 399 uint64_t offset = static_cast<uint64_t>(in_.CurrentPosition()); 400 if (!in_.Skip(pb_size)) { 401 return false; 402 } 403 404 *out_offset = offset; 405 *out_len = pb_size; 406 return true; 407 } 408 409 } // namespace aapt 410