Home | History | Annotate | Download | only in proto 
      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