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    */
PbSerializerVisitor(StringPool * source_pool,StringPool * symbol_pool,pb::Value * out_pb_value)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    */
PbSerializerVisitor(StringPool * sourcePool,StringPool * symbolPool,pb::Item * outPbItem)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 
Visit(Reference * ref)59   void Visit(Reference* ref) override {
60     SerializeReferenceToPb(*ref, pb_item()->mutable_ref());
61   }
62 
Visit(String * str)63   void Visit(String* str) override {
64     pb_item()->mutable_str()->set_idx(str->value.index());
65   }
66 
Visit(StyledString * str)67   void Visit(StyledString* str) override {
68     pb_item()->mutable_str()->set_idx(str->value.index());
69   }
70 
Visit(FileReference * file)71   void Visit(FileReference* file) override {
72     pb_item()->mutable_file()->set_path_idx(file->path.index());
73   }
74 
Visit(Id * id)75   void Visit(Id* id) override { pb_item()->mutable_id(); }
76 
Visit(RawString * raw_str)77   void Visit(RawString* raw_str) override {
78     pb_item()->mutable_raw_str()->set_idx(raw_str->value.index());
79   }
80 
Visit(BinaryPrimitive * prim)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 
VisitItem(Item * item)90   void VisitItem(Item* item) override { LOG(FATAL) << "unimplemented item"; }
91 
Visit(Attribute * attr)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 
Visit(Style * style)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 
Visit(Styleable * styleable)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 
Visit(Array * array)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 
Visit(Plural * plural)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 
pb_item()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 
pb_compound_value()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>
SerializeItemCommonToPb(const Item & item,T * pb_item)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 
SerializeReferenceToPb(const Reference & ref,pb::Reference * pb_ref)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 
SerializeTableToPb(ResourceTable * table)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 
SerializeCompiledFileToPb(const ResourceFile & file)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 
CompiledFileOutputStream(ZeroCopyOutputStream * out)302 CompiledFileOutputStream::CompiledFileOutputStream(ZeroCopyOutputStream* out)
303     : out_(out) {}
304 
EnsureAlignedWrite()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 
WriteLittleEndian32(uint32_t val)313 void CompiledFileOutputStream::WriteLittleEndian32(uint32_t val) {
314   EnsureAlignedWrite();
315   out_.WriteLittleEndian32(val);
316 }
317 
WriteCompiledFile(const pb::CompiledFile * compiled_file)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 
WriteData(const BigBuffer * buffer)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 
WriteData(const void * data,size_t len)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 
HadError()339 bool CompiledFileOutputStream::HadError() { return out_.HadError(); }
340 
CompiledFileInputStream(const void * data,size_t size)341 CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size)
342     : in_(static_cast<const uint8_t*>(data), size) {}
343 
EnsureAlignedRead()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 
ReadLittleEndian32(uint32_t * out_val)352 bool CompiledFileInputStream::ReadLittleEndian32(uint32_t* out_val) {
353   EnsureAlignedRead();
354   return in_.ReadLittleEndian32(out_val);
355 }
356 
ReadCompiledFile(pb::CompiledFile * out_val)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 
ReadDataMetaData(uint64_t * out_offset,uint64_t * out_len)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