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/XmlFlattener.h"
18
19#include <algorithm>
20#include <map>
21#include <vector>
22
23#include "android-base/logging.h"
24#include "android-base/macros.h"
25#include "androidfw/ResourceTypes.h"
26#include "utils/misc.h"
27
28#include "ResourceUtils.h"
29#include "SdkConstants.h"
30#include "ValueVisitor.h"
31#include "format/binary/ChunkWriter.h"
32#include "format/binary/ResourceTypeExtensions.h"
33#include "xml/XmlDom.h"
34
35using namespace android;
36
37using ::aapt::ResourceUtils::StringBuilder;
38
39namespace aapt {
40
41namespace {
42
43constexpr uint32_t kLowPriority = 0xffffffffu;
44
45static bool cmp_xml_attribute_by_id(const xml::Attribute* a, const xml::Attribute* b) {
46  if (a->compiled_attribute && a->compiled_attribute.value().id) {
47    if (b->compiled_attribute && b->compiled_attribute.value().id) {
48      return a->compiled_attribute.value().id.value() < b->compiled_attribute.value().id.value();
49    }
50    return true;
51  } else if (!b->compiled_attribute) {
52    int diff = a->namespace_uri.compare(b->namespace_uri);
53    if (diff < 0) {
54      return true;
55    } else if (diff > 0) {
56      return false;
57    }
58    return a->name < b->name;
59  }
60  return false;
61}
62
63class XmlFlattenerVisitor : public xml::ConstVisitor {
64 public:
65  using xml::ConstVisitor::Visit;
66
67  StringPool pool;
68  std::map<uint8_t, StringPool> package_pools;
69
70  struct StringFlattenDest {
71    StringPool::Ref ref;
72    ResStringPool_ref* dest;
73  };
74
75  std::vector<StringFlattenDest> string_refs;
76
77  XmlFlattenerVisitor(BigBuffer* buffer, XmlFlattenerOptions options)
78      : buffer_(buffer), options_(options) {
79  }
80
81  void Visit(const xml::Text* node) override {
82    std::string text = util::TrimWhitespace(node->text).to_string();
83
84    // Skip whitespace only text nodes.
85    if (text.empty()) {
86      return;
87    }
88
89    // Compact leading and trailing whitespace into a single space
90    if (isspace(node->text[0])) {
91      text = ' ' + text;
92    }
93    if (isspace(node->text[node->text.length() - 1])) {
94      text = text + ' ';
95    }
96
97    ChunkWriter writer(buffer_);
98    ResXMLTree_node* flat_node = writer.StartChunk<ResXMLTree_node>(RES_XML_CDATA_TYPE);
99    flat_node->lineNumber = util::HostToDevice32(node->line_number);
100    flat_node->comment.index = util::HostToDevice32(-1);
101
102    // Process plain strings to make sure they get properly escaped.
103    text = StringBuilder(true /*preserve_spaces*/).AppendText(text).to_string();
104
105    ResXMLTree_cdataExt* flat_text = writer.NextBlock<ResXMLTree_cdataExt>();
106    AddString(text, kLowPriority, &flat_text->data);
107    writer.Finish();
108  }
109
110  void Visit(const xml::Element* node) override {
111    for (const xml::NamespaceDecl& decl : node->namespace_decls) {
112      // Skip dedicated tools namespace.
113      if (decl.uri != xml::kSchemaTools) {
114        WriteNamespace(decl, android::RES_XML_START_NAMESPACE_TYPE);
115      }
116    }
117
118    {
119      ChunkWriter start_writer(buffer_);
120      ResXMLTree_node* flat_node =
121          start_writer.StartChunk<ResXMLTree_node>(RES_XML_START_ELEMENT_TYPE);
122      flat_node->lineNumber = util::HostToDevice32(node->line_number);
123      flat_node->comment.index = util::HostToDevice32(-1);
124
125      ResXMLTree_attrExt* flat_elem = start_writer.NextBlock<ResXMLTree_attrExt>();
126
127      // A missing namespace must be null, not an empty string. Otherwise the runtime complains.
128      AddString(node->namespace_uri, kLowPriority, &flat_elem->ns,
129                true /* treat_empty_string_as_null */);
130      AddString(node->name, kLowPriority, &flat_elem->name, true /* treat_empty_string_as_null */);
131
132      flat_elem->attributeStart = util::HostToDevice16(sizeof(*flat_elem));
133      flat_elem->attributeSize = util::HostToDevice16(sizeof(ResXMLTree_attribute));
134
135      WriteAttributes(node, flat_elem, &start_writer);
136
137      start_writer.Finish();
138    }
139
140    xml::ConstVisitor::Visit(node);
141
142    {
143      ChunkWriter end_writer(buffer_);
144      ResXMLTree_node* flat_end_node =
145          end_writer.StartChunk<ResXMLTree_node>(RES_XML_END_ELEMENT_TYPE);
146      flat_end_node->lineNumber = util::HostToDevice32(node->line_number);
147      flat_end_node->comment.index = util::HostToDevice32(-1);
148
149      ResXMLTree_endElementExt* flat_end_elem = end_writer.NextBlock<ResXMLTree_endElementExt>();
150      AddString(node->namespace_uri, kLowPriority, &flat_end_elem->ns,
151                true /* treat_empty_string_as_null */);
152      AddString(node->name, kLowPriority, &flat_end_elem->name);
153
154      end_writer.Finish();
155    }
156
157    for (auto iter = node->namespace_decls.rbegin(); iter != node->namespace_decls.rend(); ++iter) {
158      // Skip dedicated tools namespace.
159      if (iter->uri != xml::kSchemaTools) {
160        WriteNamespace(*iter, android::RES_XML_END_NAMESPACE_TYPE);
161      }
162    }
163  }
164
165 private:
166  DISALLOW_COPY_AND_ASSIGN(XmlFlattenerVisitor);
167
168  // We are adding strings to a StringPool whose strings will be sorted and merged with other
169  // string pools. That means we can't encode the ID of a string directly. Instead, we defer the
170  // writing of the ID here, until after the StringPool is merged and sorted.
171  void AddString(const StringPiece& str, uint32_t priority, android::ResStringPool_ref* dest,
172                 bool treat_empty_string_as_null = false) {
173    if (str.empty() && treat_empty_string_as_null) {
174      // Some parts of the runtime treat null differently than empty string.
175      dest->index = util::DeviceToHost32(-1);
176    } else {
177      string_refs.push_back(
178          StringFlattenDest{pool.MakeRef(str, StringPool::Context(priority)), dest});
179    }
180  }
181
182  // We are adding strings to a StringPool whose strings will be sorted and merged with other
183  // string pools. That means we can't encode the ID of a string directly. Instead, we defer the
184  // writing of the ID here, until after the StringPool is merged and sorted.
185  void AddString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) {
186    string_refs.push_back(StringFlattenDest{ref, dest});
187  }
188
189  void WriteNamespace(const xml::NamespaceDecl& decl, uint16_t type) {
190    ChunkWriter writer(buffer_);
191
192    ResXMLTree_node* flatNode = writer.StartChunk<ResXMLTree_node>(type);
193    flatNode->lineNumber = util::HostToDevice32(decl.line_number);
194    flatNode->comment.index = util::HostToDevice32(-1);
195
196    ResXMLTree_namespaceExt* flat_ns = writer.NextBlock<ResXMLTree_namespaceExt>();
197    AddString(decl.prefix, kLowPriority, &flat_ns->prefix);
198    AddString(decl.uri, kLowPriority, &flat_ns->uri);
199
200    writer.Finish();
201  }
202
203  void WriteAttributes(const xml::Element* node, ResXMLTree_attrExt* flat_elem,
204                       ChunkWriter* writer) {
205    filtered_attrs_.clear();
206    filtered_attrs_.reserve(node->attributes.size());
207
208    // Filter the attributes.
209    for (const xml::Attribute& attr : node->attributes) {
210      if (attr.namespace_uri != xml::kSchemaTools) {
211        filtered_attrs_.push_back(&attr);
212      }
213    }
214
215    if (filtered_attrs_.empty()) {
216      return;
217    }
218
219    const ResourceId kIdAttr(0x010100d0);
220
221    std::sort(filtered_attrs_.begin(), filtered_attrs_.end(), cmp_xml_attribute_by_id);
222
223    flat_elem->attributeCount = util::HostToDevice16(filtered_attrs_.size());
224
225    ResXMLTree_attribute* flat_attr =
226        writer->NextBlock<ResXMLTree_attribute>(filtered_attrs_.size());
227    uint16_t attribute_index = 1;
228    for (const xml::Attribute* xml_attr : filtered_attrs_) {
229      // Assign the indices for specific attributes.
230      if (xml_attr->compiled_attribute && xml_attr->compiled_attribute.value().id &&
231          xml_attr->compiled_attribute.value().id.value() == kIdAttr) {
232        flat_elem->idIndex = util::HostToDevice16(attribute_index);
233      } else if (xml_attr->namespace_uri.empty()) {
234        if (xml_attr->name == "class") {
235          flat_elem->classIndex = util::HostToDevice16(attribute_index);
236        } else if (xml_attr->name == "style") {
237          flat_elem->styleIndex = util::HostToDevice16(attribute_index);
238        }
239      }
240      attribute_index++;
241
242      // Add the namespaceUri to the list of StringRefs to encode. Use null if the namespace
243      // is empty (doesn't exist).
244      AddString(xml_attr->namespace_uri, kLowPriority, &flat_attr->ns,
245                true /* treat_empty_string_as_null */);
246
247      flat_attr->rawValue.index = util::HostToDevice32(-1);
248
249      if (!xml_attr->compiled_attribute || !xml_attr->compiled_attribute.value().id) {
250        // The attribute has no associated ResourceID, so the string order doesn't matter.
251        AddString(xml_attr->name, kLowPriority, &flat_attr->name);
252      } else {
253        // Attribute names are stored without packages, but we use
254        // their StringPool index to lookup their resource IDs.
255        // This will cause collisions, so we can't dedupe
256        // attribute names from different packages. We use separate
257        // pools that we later combine.
258        //
259        // Lookup the StringPool for this package and make the reference there.
260        const xml::AaptAttribute& aapt_attr = xml_attr->compiled_attribute.value();
261
262        StringPool::Ref name_ref = package_pools[aapt_attr.id.value().package_id()].MakeRef(
263            xml_attr->name, StringPool::Context(aapt_attr.id.value().id));
264
265        // Add it to the list of strings to flatten.
266        AddString(name_ref, &flat_attr->name);
267      }
268
269      std::string processed_str;
270      Maybe<StringPiece> compiled_text;
271      if (xml_attr->compiled_value != nullptr) {
272        // Make sure we're not flattening a String. A String can be referencing a string from
273        // a different StringPool than we're using here to build the binary XML.
274        String* string_value = ValueCast<String>(xml_attr->compiled_value.get());
275        if (string_value != nullptr) {
276          // Mark the String's text as needing to be serialized.
277          compiled_text = StringPiece(*string_value->value);
278        } else {
279          // Serialize this compiled value safely.
280          CHECK(xml_attr->compiled_value->Flatten(&flat_attr->typedValue));
281        }
282      } else {
283        // There is no compiled value, so treat the raw string as compiled, once it is processed to
284        // make sure escape sequences are properly interpreted.
285        processed_str =
286            StringBuilder(true /*preserve_spaces*/).AppendText(xml_attr->value).to_string();
287        compiled_text = StringPiece(processed_str);
288      }
289
290      if (compiled_text) {
291        // Write out the compiled text and raw_text.
292        flat_attr->typedValue.dataType = android::Res_value::TYPE_STRING;
293        AddString(compiled_text.value(), kLowPriority,
294                  reinterpret_cast<ResStringPool_ref*>(&flat_attr->typedValue.data));
295        if (options_.keep_raw_values) {
296          AddString(xml_attr->value, kLowPriority, &flat_attr->rawValue);
297        } else {
298          AddString(compiled_text.value(), kLowPriority, &flat_attr->rawValue);
299        }
300      } else if (options_.keep_raw_values && !xml_attr->value.empty()) {
301        AddString(xml_attr->value, kLowPriority, &flat_attr->rawValue);
302      }
303
304      flat_attr->typedValue.size = util::HostToDevice16(sizeof(flat_attr->typedValue));
305      flat_attr++;
306    }
307  }
308
309  BigBuffer* buffer_;
310  XmlFlattenerOptions options_;
311
312  // Scratch vector to filter attributes. We avoid allocations making this a member.
313  std::vector<const xml::Attribute*> filtered_attrs_;
314};
315
316}  // namespace
317
318bool XmlFlattener::Flatten(IAaptContext* context, const xml::Node* node) {
319  BigBuffer node_buffer(1024);
320  XmlFlattenerVisitor visitor(&node_buffer, options_);
321  node->Accept(&visitor);
322
323  // Merge the package pools into the main pool.
324  for (auto& package_pool_entry : visitor.package_pools) {
325    visitor.pool.Merge(std::move(package_pool_entry.second));
326  }
327
328  // Sort the string pool so that attribute resource IDs show up first.
329  visitor.pool.Sort([](const StringPool::Context& a, const StringPool::Context& b) -> int {
330    return util::compare(a.priority, b.priority);
331  });
332
333  // Now we flatten the string pool references into the correct places.
334  for (const auto& ref_entry : visitor.string_refs) {
335    ref_entry.dest->index = util::HostToDevice32(ref_entry.ref.index());
336  }
337
338  // Write the XML header.
339  ChunkWriter xml_header_writer(buffer_);
340  xml_header_writer.StartChunk<ResXMLTree_header>(RES_XML_TYPE);
341
342  // Flatten the StringPool.
343  if (options_.use_utf16) {
344    StringPool::FlattenUtf16(buffer_, visitor.pool, context->GetDiagnostics());
345  } else {
346    StringPool::FlattenUtf8(buffer_, visitor.pool, context->GetDiagnostics());
347  }
348
349  {
350    // Write the array of resource IDs, indexed by StringPool order.
351    ChunkWriter res_id_map_writer(buffer_);
352    res_id_map_writer.StartChunk<ResChunk_header>(RES_XML_RESOURCE_MAP_TYPE);
353    for (const auto& str : visitor.pool.strings()) {
354      ResourceId id(str->context.priority);
355      if (str->context.priority == kLowPriority || !id.is_valid()) {
356        // When we see the first non-resource ID, we're done.
357        break;
358      }
359      *res_id_map_writer.NextBlock<uint32_t>() = util::HostToDevice32(id.id);
360    }
361    res_id_map_writer.Finish();
362  }
363
364  // Move the nodeBuffer and append it to the out buffer.
365  buffer_->AppendBuffer(std::move(node_buffer));
366
367  // Finish the xml header.
368  xml_header_writer.Finish();
369  return true;
370}
371
372bool XmlFlattener::Consume(IAaptContext* context, const xml::XmlResource* resource) {
373  if (!resource->root) {
374    return false;
375  }
376  return Flatten(context, resource->root.get());
377}
378
379}  // namespace aapt
380