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