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 "Resource.h"
18 #include "ResourceUtils.h"
19 #include "ResourceValues.h"
20 #include "ValueVisitor.h"
21 #include "io/File.h"
22 #include "util/Util.h"
23 
24 #include <androidfw/ResourceTypes.h>
25 #include <limits>
26 
27 namespace aapt {
28 
29 template <typename Derived>
accept(RawValueVisitor * visitor)30 void BaseValue<Derived>::accept(RawValueVisitor* visitor) {
31     visitor->visit(static_cast<Derived*>(this));
32 }
33 
34 template <typename Derived>
accept(RawValueVisitor * visitor)35 void BaseItem<Derived>::accept(RawValueVisitor* visitor) {
36     visitor->visit(static_cast<Derived*>(this));
37 }
38 
RawString(const StringPool::Ref & ref)39 RawString::RawString(const StringPool::Ref& ref) : value(ref) {
40 }
41 
clone(StringPool * newPool) const42 RawString* RawString::clone(StringPool* newPool) const {
43     RawString* rs = new RawString(newPool->makeRef(*value));
44     rs->mComment = mComment;
45     rs->mSource = mSource;
46     return rs;
47 }
48 
flatten(android::Res_value * outValue) const49 bool RawString::flatten(android::Res_value* outValue) const {
50     outValue->dataType = android::Res_value::TYPE_STRING;
51     outValue->data = util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
52     return true;
53 }
54 
print(std::ostream * out) const55 void RawString::print(std::ostream* out) const {
56     *out << "(raw string) " << *value;
57 }
58 
Reference()59 Reference::Reference() : referenceType(Reference::Type::kResource) {
60 }
61 
Reference(const ResourceNameRef & n,Type t)62 Reference::Reference(const ResourceNameRef& n, Type t) :
63         name(n.toResourceName()), referenceType(t) {
64 }
65 
Reference(const ResourceId & i,Type type)66 Reference::Reference(const ResourceId& i, Type type) : id(i), referenceType(type) {
67 }
68 
flatten(android::Res_value * outValue) const69 bool Reference::flatten(android::Res_value* outValue) const {
70     outValue->dataType = (referenceType == Reference::Type::kResource) ?
71             android::Res_value::TYPE_REFERENCE : android::Res_value::TYPE_ATTRIBUTE;
72     outValue->data = util::hostToDevice32(id ? id.value().id : 0);
73     return true;
74 }
75 
clone(StringPool *) const76 Reference* Reference::clone(StringPool* /*newPool*/) const {
77     return new Reference(*this);
78 }
79 
print(std::ostream * out) const80 void Reference::print(std::ostream* out) const {
81     *out << "(reference) ";
82     if (referenceType == Reference::Type::kResource) {
83         *out << "@";
84         if (privateReference) {
85             *out << "*";
86         }
87     } else {
88         *out << "?";
89     }
90 
91     if (name) {
92         *out << name.value();
93     }
94 
95     if (id && !Res_INTERNALID(id.value().id)) {
96         *out << " " << id.value();
97     }
98 }
99 
flatten(android::Res_value * out) const100 bool Id::flatten(android::Res_value* out) const {
101     out->dataType = android::Res_value::TYPE_INT_BOOLEAN;
102     out->data = util::hostToDevice32(0);
103     return true;
104 }
105 
clone(StringPool *) const106 Id* Id::clone(StringPool* /*newPool*/) const {
107     return new Id(*this);
108 }
109 
print(std::ostream * out) const110 void Id::print(std::ostream* out) const {
111     *out << "(id)";
112 }
113 
String(const StringPool::Ref & ref)114 String::String(const StringPool::Ref& ref) : value(ref), mTranslateable(true) {
115 }
116 
setTranslateable(bool val)117 void String::setTranslateable(bool val) {
118     mTranslateable = val;
119 }
120 
isTranslateable() const121 bool String::isTranslateable() const {
122     return mTranslateable;
123 }
124 
flatten(android::Res_value * outValue) const125 bool String::flatten(android::Res_value* outValue) const {
126     // Verify that our StringPool index is within encode-able limits.
127     if (value.getIndex() > std::numeric_limits<uint32_t>::max()) {
128         return false;
129     }
130 
131     outValue->dataType = android::Res_value::TYPE_STRING;
132     outValue->data = util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
133     return true;
134 }
135 
clone(StringPool * newPool) const136 String* String::clone(StringPool* newPool) const {
137     String* str = new String(newPool->makeRef(*value));
138     str->mComment = mComment;
139     str->mSource = mSource;
140     return str;
141 }
142 
print(std::ostream * out) const143 void String::print(std::ostream* out) const {
144     *out << "(string) \"" << *value << "\"";
145 }
146 
StyledString(const StringPool::StyleRef & ref)147 StyledString::StyledString(const StringPool::StyleRef& ref) : value(ref), mTranslateable(true) {
148 }
149 
setTranslateable(bool val)150 void StyledString::setTranslateable(bool val) {
151     mTranslateable = val;
152 }
153 
isTranslateable() const154 bool StyledString::isTranslateable() const {
155     return mTranslateable;
156 }
157 
flatten(android::Res_value * outValue) const158 bool StyledString::flatten(android::Res_value* outValue) const {
159     if (value.getIndex() > std::numeric_limits<uint32_t>::max()) {
160         return false;
161     }
162 
163     outValue->dataType = android::Res_value::TYPE_STRING;
164     outValue->data = util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
165     return true;
166 }
167 
clone(StringPool * newPool) const168 StyledString* StyledString::clone(StringPool* newPool) const {
169     StyledString* str = new StyledString(newPool->makeRef(value));
170     str->mComment = mComment;
171     str->mSource = mSource;
172     return str;
173 }
174 
print(std::ostream * out) const175 void StyledString::print(std::ostream* out) const {
176     *out << "(styled string) \"" << *value->str << "\"";
177 }
178 
FileReference(const StringPool::Ref & _path)179 FileReference::FileReference(const StringPool::Ref& _path) : path(_path) {
180 }
181 
flatten(android::Res_value * outValue) const182 bool FileReference::flatten(android::Res_value* outValue) const {
183     if (path.getIndex() > std::numeric_limits<uint32_t>::max()) {
184         return false;
185     }
186 
187     outValue->dataType = android::Res_value::TYPE_STRING;
188     outValue->data = util::hostToDevice32(static_cast<uint32_t>(path.getIndex()));
189     return true;
190 }
191 
clone(StringPool * newPool) const192 FileReference* FileReference::clone(StringPool* newPool) const {
193     FileReference* fr = new FileReference(newPool->makeRef(*path));
194     fr->file = file;
195     fr->mComment = mComment;
196     fr->mSource = mSource;
197     return fr;
198 }
199 
print(std::ostream * out) const200 void FileReference::print(std::ostream* out) const {
201     *out << "(file) " << *path;
202 }
203 
BinaryPrimitive(const android::Res_value & val)204 BinaryPrimitive::BinaryPrimitive(const android::Res_value& val) : value(val) {
205 }
206 
BinaryPrimitive(uint8_t dataType,uint32_t data)207 BinaryPrimitive::BinaryPrimitive(uint8_t dataType, uint32_t data) {
208     value.dataType = dataType;
209     value.data = data;
210 }
211 
flatten(android::Res_value * outValue) const212 bool BinaryPrimitive::flatten(android::Res_value* outValue) const {
213     outValue->dataType = value.dataType;
214     outValue->data = util::hostToDevice32(value.data);
215     return true;
216 }
217 
clone(StringPool *) const218 BinaryPrimitive* BinaryPrimitive::clone(StringPool* /*newPool*/) const {
219     return new BinaryPrimitive(*this);
220 }
221 
print(std::ostream * out) const222 void BinaryPrimitive::print(std::ostream* out) const {
223     switch (value.dataType) {
224         case android::Res_value::TYPE_NULL:
225             *out << "(null)";
226             break;
227         case android::Res_value::TYPE_INT_DEC:
228             *out << "(integer) " << static_cast<int32_t>(value.data);
229             break;
230         case android::Res_value::TYPE_INT_HEX:
231             *out << "(integer) " << std::hex << value.data << std::dec;
232             break;
233         case android::Res_value::TYPE_INT_BOOLEAN:
234             *out << "(boolean) " << (value.data != 0 ? "true" : "false");
235             break;
236         case android::Res_value::TYPE_INT_COLOR_ARGB8:
237         case android::Res_value::TYPE_INT_COLOR_RGB8:
238         case android::Res_value::TYPE_INT_COLOR_ARGB4:
239         case android::Res_value::TYPE_INT_COLOR_RGB4:
240             *out << "(color) #" << std::hex << value.data << std::dec;
241             break;
242         default:
243             *out << "(unknown 0x" << std::hex << (int) value.dataType << ") 0x"
244                  << std::hex << value.data << std::dec;
245             break;
246     }
247 }
248 
Attribute(bool w,uint32_t t)249 Attribute::Attribute(bool w, uint32_t t) :
250         typeMask(t),
251         minInt(std::numeric_limits<int32_t>::min()),
252         maxInt(std::numeric_limits<int32_t>::max()) {
253     mWeak = w;
254 }
255 
clone(StringPool *) const256 Attribute* Attribute::clone(StringPool* /*newPool*/) const {
257     return new Attribute(*this);
258 }
259 
printMask(std::ostream * out) const260 void Attribute::printMask(std::ostream* out) const {
261     if (typeMask == android::ResTable_map::TYPE_ANY) {
262         *out << "any";
263         return;
264     }
265 
266     bool set = false;
267     if ((typeMask & android::ResTable_map::TYPE_REFERENCE) != 0) {
268         if (!set) {
269             set = true;
270         } else {
271             *out << "|";
272         }
273         *out << "reference";
274     }
275 
276     if ((typeMask & android::ResTable_map::TYPE_STRING) != 0) {
277         if (!set) {
278             set = true;
279         } else {
280             *out << "|";
281         }
282         *out << "string";
283     }
284 
285     if ((typeMask & android::ResTable_map::TYPE_INTEGER) != 0) {
286         if (!set) {
287             set = true;
288         } else {
289             *out << "|";
290         }
291         *out << "integer";
292     }
293 
294     if ((typeMask & android::ResTable_map::TYPE_BOOLEAN) != 0) {
295         if (!set) {
296             set = true;
297         } else {
298             *out << "|";
299         }
300         *out << "boolean";
301     }
302 
303     if ((typeMask & android::ResTable_map::TYPE_COLOR) != 0) {
304         if (!set) {
305             set = true;
306         } else {
307             *out << "|";
308         }
309         *out << "color";
310     }
311 
312     if ((typeMask & android::ResTable_map::TYPE_FLOAT) != 0) {
313         if (!set) {
314             set = true;
315         } else {
316             *out << "|";
317         }
318         *out << "float";
319     }
320 
321     if ((typeMask & android::ResTable_map::TYPE_DIMENSION) != 0) {
322         if (!set) {
323             set = true;
324         } else {
325             *out << "|";
326         }
327         *out << "dimension";
328     }
329 
330     if ((typeMask & android::ResTable_map::TYPE_FRACTION) != 0) {
331         if (!set) {
332             set = true;
333         } else {
334             *out << "|";
335         }
336         *out << "fraction";
337     }
338 
339     if ((typeMask & android::ResTable_map::TYPE_ENUM) != 0) {
340         if (!set) {
341             set = true;
342         } else {
343             *out << "|";
344         }
345         *out << "enum";
346     }
347 
348     if ((typeMask & android::ResTable_map::TYPE_FLAGS) != 0) {
349         if (!set) {
350             set = true;
351         } else {
352             *out << "|";
353         }
354         *out << "flags";
355     }
356 }
357 
print(std::ostream * out) const358 void Attribute::print(std::ostream* out) const {
359     *out << "(attr) ";
360     printMask(out);
361 
362     if (!symbols.empty()) {
363         *out << " ["
364             << util::joiner(symbols.begin(), symbols.end(), ", ")
365             << "]";
366     }
367 
368     if (isWeak()) {
369         *out << " [weak]";
370     }
371 }
372 
buildAttributeMismatchMessage(DiagMessage * msg,const Attribute * attr,const Item * value)373 static void buildAttributeMismatchMessage(DiagMessage* msg, const Attribute* attr,
374                                           const Item* value) {
375     *msg << "expected";
376     if (attr->typeMask & android::ResTable_map::TYPE_BOOLEAN) {
377         *msg << " boolean";
378     }
379 
380     if (attr->typeMask & android::ResTable_map::TYPE_COLOR) {
381         *msg << " color";
382     }
383 
384     if (attr->typeMask & android::ResTable_map::TYPE_DIMENSION) {
385         *msg << " dimension";
386     }
387 
388     if (attr->typeMask & android::ResTable_map::TYPE_ENUM) {
389         *msg << " enum";
390     }
391 
392     if (attr->typeMask & android::ResTable_map::TYPE_FLAGS) {
393         *msg << " flags";
394     }
395 
396     if (attr->typeMask & android::ResTable_map::TYPE_FLOAT) {
397         *msg << " float";
398     }
399 
400     if (attr->typeMask & android::ResTable_map::TYPE_FRACTION) {
401         *msg << " fraction";
402     }
403 
404     if (attr->typeMask & android::ResTable_map::TYPE_INTEGER) {
405         *msg << " integer";
406     }
407 
408     if (attr->typeMask & android::ResTable_map::TYPE_REFERENCE) {
409         *msg << " reference";
410     }
411 
412     if (attr->typeMask & android::ResTable_map::TYPE_STRING) {
413         *msg << " string";
414     }
415 
416     *msg << " but got " << *value;
417 }
418 
matches(const Item * item,DiagMessage * outMsg) const419 bool Attribute::matches(const Item* item, DiagMessage* outMsg) const {
420     android::Res_value val = {};
421     item->flatten(&val);
422 
423     // Always allow references.
424     const uint32_t mask = typeMask | android::ResTable_map::TYPE_REFERENCE;
425     if (!(mask & ResourceUtils::androidTypeToAttributeTypeMask(val.dataType))) {
426         if (outMsg) {
427             buildAttributeMismatchMessage(outMsg, this, item);
428         }
429         return false;
430 
431     } else if (ResourceUtils::androidTypeToAttributeTypeMask(val.dataType) &
432             android::ResTable_map::TYPE_INTEGER) {
433         if (static_cast<int32_t>(util::deviceToHost32(val.data)) < minInt) {
434             if (outMsg) {
435                 *outMsg << *item << " is less than minimum integer " << minInt;
436             }
437             return false;
438         } else if (static_cast<int32_t>(util::deviceToHost32(val.data)) > maxInt) {
439             if (outMsg) {
440                 *outMsg << *item << " is greater than maximum integer " << maxInt;
441             }
442             return false;
443         }
444     }
445     return true;
446 }
447 
clone(StringPool * newPool) const448 Style* Style::clone(StringPool* newPool) const {
449     Style* style = new Style();
450     style->parent = parent;
451     style->parentInferred = parentInferred;
452     style->mComment = mComment;
453     style->mSource = mSource;
454     for (auto& entry : entries) {
455         style->entries.push_back(Entry{
456                 entry.key,
457                 std::unique_ptr<Item>(entry.value->clone(newPool))
458         });
459     }
460     return style;
461 }
462 
print(std::ostream * out) const463 void Style::print(std::ostream* out) const {
464     *out << "(style) ";
465     if (parent && parent.value().name) {
466         if (parent.value().privateReference) {
467             *out << "*";
468         }
469         *out << parent.value().name.value();
470     }
471     *out << " ["
472         << util::joiner(entries.begin(), entries.end(), ", ")
473         << "]";
474 }
475 
operator <<(::std::ostream & out,const Style::Entry & value)476 static ::std::ostream& operator<<(::std::ostream& out, const Style::Entry& value) {
477     if (value.key.name) {
478         out << value.key.name.value();
479     } else {
480         out << "???";
481     }
482     out << " = ";
483     value.value->print(&out);
484     return out;
485 }
486 
clone(StringPool * newPool) const487 Array* Array::clone(StringPool* newPool) const {
488     Array* array = new Array();
489     array->mComment = mComment;
490     array->mSource = mSource;
491     for (auto& item : items) {
492         array->items.emplace_back(std::unique_ptr<Item>(item->clone(newPool)));
493     }
494     return array;
495 }
496 
print(std::ostream * out) const497 void Array::print(std::ostream* out) const {
498     *out << "(array) ["
499         << util::joiner(items.begin(), items.end(), ", ")
500         << "]";
501 }
502 
clone(StringPool * newPool) const503 Plural* Plural::clone(StringPool* newPool) const {
504     Plural* p = new Plural();
505     p->mComment = mComment;
506     p->mSource = mSource;
507     const size_t count = values.size();
508     for (size_t i = 0; i < count; i++) {
509         if (values[i]) {
510             p->values[i] = std::unique_ptr<Item>(values[i]->clone(newPool));
511         }
512     }
513     return p;
514 }
515 
print(std::ostream * out) const516 void Plural::print(std::ostream* out) const {
517     *out << "(plural)";
518 }
519 
operator <<(::std::ostream & out,const std::unique_ptr<Item> & item)520 static ::std::ostream& operator<<(::std::ostream& out, const std::unique_ptr<Item>& item) {
521     return out << *item;
522 }
523 
clone(StringPool *) const524 Styleable* Styleable::clone(StringPool* /*newPool*/) const {
525     return new Styleable(*this);
526 }
527 
print(std::ostream * out) const528 void Styleable::print(std::ostream* out) const {
529     *out << "(styleable) " << " ["
530         << util::joiner(entries.begin(), entries.end(), ", ")
531         << "]";
532 }
533 
534 } // namespace aapt
535