1 /*
2 * Copyright (C) 2017 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 // Convert objects from and to xml.
18
19 #define LOG_TAG "libvintf"
20 #include <android-base/logging.h>
21
22 #include "parse_xml.h"
23
24 #include <type_traits>
25
26 #include <android-base/parseint.h>
27 #include <android-base/strings.h>
28 #include <tinyxml2.h>
29
30 #include "Regex.h"
31 #include "constants-private.h"
32 #include "constants.h"
33 #include "parse_string.h"
34 #include "parse_xml_for_test.h"
35 #include "utils.h"
36
37 using namespace std::string_literals;
38
39 #ifdef LIBVINTF_TARGET
40 static constexpr bool kDevice = true;
41 #else
42 static constexpr bool kDevice = false;
43 #endif
44
45 namespace android {
46 namespace vintf {
47
48 // --------------- tinyxml2 details
49
50 using NodeType = tinyxml2::XMLElement;
51 using DocType = tinyxml2::XMLDocument;
52
53 // caller is responsible for deleteDocument() call
createDocument()54 inline DocType *createDocument() {
55 return new tinyxml2::XMLDocument();
56 }
57
58 // caller is responsible for deleteDocument() call
createDocument(const std::string & xml)59 inline DocType *createDocument(const std::string &xml) {
60 DocType *doc = new tinyxml2::XMLDocument();
61 if (doc->Parse(xml.c_str()) == tinyxml2::XML_SUCCESS) {
62 return doc;
63 }
64 delete doc;
65 return nullptr;
66 }
67
deleteDocument(DocType * d)68 inline void deleteDocument(DocType *d) {
69 delete d;
70 }
71
printDocument(DocType * d)72 inline std::string printDocument(DocType *d) {
73 tinyxml2::XMLPrinter p;
74 d->Print(&p);
75 return std::string{p.CStr()};
76 }
77
createNode(const std::string & name,DocType * d)78 inline NodeType *createNode(const std::string &name, DocType *d) {
79 return d->NewElement(name.c_str());
80 }
81
appendChild(NodeType * parent,NodeType * child)82 inline void appendChild(NodeType *parent, NodeType *child) {
83 parent->InsertEndChild(child);
84 }
85
appendChild(DocType * parent,NodeType * child)86 inline void appendChild(DocType *parent, NodeType *child) {
87 parent->InsertEndChild(child);
88 }
89
appendStrAttr(NodeType * e,const std::string & attrName,const std::string & attr)90 inline void appendStrAttr(NodeType *e, const std::string &attrName, const std::string &attr) {
91 e->SetAttribute(attrName.c_str(), attr.c_str());
92 }
93
94 // text -> text
appendText(NodeType * parent,const std::string & text,DocType * d)95 inline void appendText(NodeType *parent, const std::string &text, DocType *d) {
96 parent->InsertEndChild(d->NewText(text.c_str()));
97 }
98
nameOf(NodeType * root)99 inline std::string nameOf(NodeType *root) {
100 return root->Name() == NULL ? "" : root->Name();
101 }
102
getText(NodeType * root)103 inline std::string getText(NodeType *root) {
104 return root->GetText() == NULL ? "" : root->GetText();
105 }
106
getChild(NodeType * parent,const std::string & name)107 inline NodeType *getChild(NodeType *parent, const std::string &name) {
108 return parent->FirstChildElement(name.c_str());
109 }
110
getRootChild(DocType * parent)111 inline NodeType *getRootChild(DocType *parent) {
112 return parent->FirstChildElement();
113 }
114
getChildren(NodeType * parent,const std::string & name)115 inline std::vector<NodeType *> getChildren(NodeType *parent, const std::string &name) {
116 std::vector<NodeType *> v;
117 for (NodeType *child = parent->FirstChildElement(name.c_str());
118 child != nullptr;
119 child = child->NextSiblingElement(name.c_str())) {
120 v.push_back(child);
121 }
122 return v;
123 }
124
getAttr(NodeType * root,const std::string & attrName,std::string * s)125 inline bool getAttr(NodeType *root, const std::string &attrName, std::string *s) {
126 const char *c = root->Attribute(attrName.c_str());
127 if (c == NULL)
128 return false;
129 *s = c;
130 return true;
131 }
132
133 // --------------- tinyxml2 details end.
134
135 // Helper functions for XmlConverter
parse(const std::string & attrText,bool * attr)136 static bool parse(const std::string &attrText, bool *attr) {
137 if (attrText == "true" || attrText == "1") {
138 *attr = true;
139 return true;
140 }
141 if (attrText == "false" || attrText == "0") {
142 *attr = false;
143 return true;
144 }
145 return false;
146 }
147
parse(const std::string & attrText,std::optional<std::string> * attr)148 static bool parse(const std::string& attrText, std::optional<std::string>* attr) {
149 *attr = attrText;
150 return true;
151 }
152
parse(const std::string & s,std::optional<uint64_t> * out)153 static bool parse(const std::string& s, std::optional<uint64_t>* out) {
154 uint64_t val;
155 if (base::ParseUint(s, &val)) {
156 *out = val;
157 return true;
158 }
159 return false;
160 }
161
162 // ---------------------- XmlNodeConverter definitions
163
164 // When serializing an object to an XML document, these parameters don't change until
165 // the object is fully serialized.
166 // These parameters are also passed to converters of child nodes so they see the same
167 // serialization parameters.
168 struct MutateNodeParam {
169 DocType* d;
170 SerializeFlags::Type flags = SerializeFlags::EVERYTHING;
171 };
172
173 // When deserializing an XML document to an object, these parameters don't change until
174 // the XML document is fully deserialized.
175 // * Except metaVersion, which is immediately modified when parsing top-level <manifest>
176 // or <compatibility-matrix>, and unchanged thereafter;
177 // see HalManifestConverter::BuildObject and CompatibilityMatrixConverter::BuildObject)
178 // These parameters are also passed to converters of child nodes so they see the same
179 // deserialization parameters.
180 struct BuildObjectParam {
181 std::string* error;
182 Version metaVersion;
183 std::string fileName;
184 };
185
186 template <typename Object>
187 struct XmlNodeConverter {
XmlNodeConverterandroid::vintf::XmlNodeConverter188 XmlNodeConverter() {}
~XmlNodeConverterandroid::vintf::XmlNodeConverter189 virtual ~XmlNodeConverter() {}
190
191 protected:
192 virtual void mutateNode(const Object& object, NodeType* root, const MutateNodeParam&) const = 0;
193 virtual bool buildObject(Object* object, NodeType* root, const BuildObjectParam&) const = 0;
194
195 public:
196 // Methods for other (usually parent) converters
197 // Name of the XML element.
198 virtual std::string elementName() const = 0;
199 // Serialize |o| into an XML element.
operator ()android::vintf::XmlNodeConverter200 inline NodeType* operator()(const Object& o, const MutateNodeParam& param) const {
201 NodeType* root = createNode(this->elementName(), param.d);
202 this->mutateNode(o, root, param);
203 return root;
204 }
205 // Deserialize XML element |root| into |object|.
operator ()android::vintf::XmlNodeConverter206 inline bool operator()(Object* object, NodeType* root, const BuildObjectParam& param) const {
207 if (nameOf(root) != this->elementName()) {
208 return false;
209 }
210 return this->buildObject(object, root, param);
211 }
212
213 // Public methods for android::vintf::fromXml / android::vintf::toXml.
214 // Serialize |o| into an XML string.
toXmlandroid::vintf::XmlNodeConverter215 inline std::string toXml(const Object& o, SerializeFlags::Type flags) const {
216 DocType* doc = createDocument();
217 appendChild(doc, (*this)(o, MutateNodeParam{doc, flags}));
218 std::string s = printDocument(doc);
219 deleteDocument(doc);
220 return s;
221 }
222 // Deserialize XML string |xml| into |o|.
fromXmlandroid::vintf::XmlNodeConverter223 inline bool fromXml(Object* o, const std::string& xml, std::string* error) const {
224 std::string errorBuffer;
225 if (error == nullptr) error = &errorBuffer;
226
227 auto doc = createDocument(xml);
228 if (doc == nullptr) {
229 *error = "Not a valid XML";
230 return false;
231 }
232 // For top-level <manifest> and <compatibility-matrix>, HalManifestConverter and
233 // CompatibilityMatrixConverter fills in metaversion and pass down to children.
234 // For other nodes, we don't know metaversion of the original XML, so just leave empty
235 // for maximum backwards compatibility.
236 BuildObjectParam buildObjectParam{error, {}, {}};
237 // Pass down filename for the current XML document.
238 if constexpr (std::is_base_of_v<WithFileName, Object>) {
239 // Get the last filename in case `o` keeps the list of filenames
240 std::string_view fileName{o->fileName()};
241 if (auto pos = fileName.rfind(':'); pos != fileName.npos) {
242 fileName.remove_prefix(pos + 1);
243 }
244 buildObjectParam.fileName = std::string(fileName);
245 }
246 bool ret = (*this)(o, getRootChild(doc), buildObjectParam);
247 deleteDocument(doc);
248 return ret;
249 }
250
251 // convenience methods for subclasses to implement virtual functions.
252
253 // All append* functions helps mutateNode() to serialize the object into XML.
254 template <typename T>
appendAttrandroid::vintf::XmlNodeConverter255 inline void appendAttr(NodeType *e, const std::string &attrName, const T &attr) const {
256 return appendStrAttr(e, attrName, ::android::vintf::to_string(attr));
257 }
258
appendAttrandroid::vintf::XmlNodeConverter259 inline void appendAttr(NodeType *e, const std::string &attrName, bool attr) const {
260 return appendStrAttr(e, attrName, attr ? "true" : "false");
261 }
262
263 // text -> <name>text</name>
appendTextElementandroid::vintf::XmlNodeConverter264 inline void appendTextElement(NodeType *parent, const std::string &name,
265 const std::string &text, DocType *d) const {
266 NodeType *c = createNode(name, d);
267 appendText(c, text, d);
268 appendChild(parent, c);
269 }
270
271 // text -> <name>text</name>
272 template<typename Array>
appendTextElementsandroid::vintf::XmlNodeConverter273 inline void appendTextElements(NodeType *parent, const std::string &name,
274 const Array &array, DocType *d) const {
275 for (const std::string &text : array) {
276 NodeType *c = createNode(name, d);
277 appendText(c, text, d);
278 appendChild(parent, c);
279 }
280 }
281
282 template <typename T, typename Array>
appendChildrenandroid::vintf::XmlNodeConverter283 inline void appendChildren(NodeType* parent, const XmlNodeConverter<T>& conv,
284 const Array& array, const MutateNodeParam& param) const {
285 for (const T &t : array) {
286 appendChild(parent, conv(t, param));
287 }
288 }
289
290 // All parse* functions helps buildObject() to deserialize XML to the object. Returns
291 // true if deserialization is successful, false if any error, and "error" will be
292 // set to error message.
293 template <typename T>
parseOptionalAttrandroid::vintf::XmlNodeConverter294 inline bool parseOptionalAttr(NodeType* root, const std::string& attrName, T&& defaultValue,
295 T* attr, std::string* /* error */) const {
296 std::string attrText;
297 bool success = getAttr(root, attrName, &attrText) &&
298 ::android::vintf::parse(attrText, attr);
299 if (!success) {
300 *attr = std::move(defaultValue);
301 }
302 return true;
303 }
304
305 template <typename T>
parseAttrandroid::vintf::XmlNodeConverter306 inline bool parseAttr(NodeType* root, const std::string& attrName, T* attr,
307 std::string* error) const {
308 std::string attrText;
309 bool ret = getAttr(root, attrName, &attrText) && ::android::vintf::parse(attrText, attr);
310 if (!ret) {
311 *error = "Could not find/parse attr with name \"" + attrName + "\" and value \"" +
312 attrText + "\" for element <" + elementName() + ">";
313 }
314 return ret;
315 }
316
parseAttrandroid::vintf::XmlNodeConverter317 inline bool parseAttr(NodeType* root, const std::string& attrName, std::string* attr,
318 std::string* error) const {
319 bool ret = getAttr(root, attrName, attr);
320 if (!ret) {
321 *error = "Could not find attr with name \"" + attrName + "\" for element <" +
322 elementName() + ">";
323 }
324 return ret;
325 }
326
parseTextElementandroid::vintf::XmlNodeConverter327 inline bool parseTextElement(NodeType* root, const std::string& elementName, std::string* s,
328 std::string* error) const {
329 NodeType *child = getChild(root, elementName);
330 if (child == nullptr) {
331 *error = "Could not find element with name <" + elementName + "> in element <" +
332 this->elementName() + ">";
333 return false;
334 }
335 *s = getText(child);
336 return true;
337 }
338
parseOptionalTextElementandroid::vintf::XmlNodeConverter339 inline bool parseOptionalTextElement(NodeType* root, const std::string& elementName,
340 std::string&& defaultValue, std::string* s,
341 std::string* /* error */) const {
342 NodeType* child = getChild(root, elementName);
343 *s = child == nullptr ? std::move(defaultValue) : getText(child);
344 return true;
345 }
346
parseTextElementsandroid::vintf::XmlNodeConverter347 inline bool parseTextElements(NodeType* root, const std::string& elementName,
348 std::vector<std::string>* v, std::string* /* error */) const {
349 auto nodes = getChildren(root, elementName);
350 v->resize(nodes.size());
351 for (size_t i = 0; i < nodes.size(); ++i) {
352 v->at(i) = getText(nodes[i]);
353 }
354 return true;
355 }
356
357 template <typename T>
parseChildandroid::vintf::XmlNodeConverter358 inline bool parseChild(NodeType* root, const XmlNodeConverter<T>& conv, T* t,
359 const BuildObjectParam& param) const {
360 NodeType *child = getChild(root, conv.elementName());
361 if (child == nullptr) {
362 *param.error = "Could not find element with name <" + conv.elementName() +
363 "> in element <" + this->elementName() + ">";
364 return false;
365 }
366 return conv(t, child, param);
367 }
368
369 template <typename T>
parseOptionalChildandroid::vintf::XmlNodeConverter370 inline bool parseOptionalChild(NodeType* root, const XmlNodeConverter<T>& conv,
371 T&& defaultValue, T* t, const BuildObjectParam& param) const {
372 NodeType *child = getChild(root, conv.elementName());
373 if (child == nullptr) {
374 *t = std::move(defaultValue);
375 return true;
376 }
377 return conv(t, child, param);
378 }
379
380 template <typename T>
parseOptionalChildandroid::vintf::XmlNodeConverter381 inline bool parseOptionalChild(NodeType* root, const XmlNodeConverter<T>& conv,
382 std::optional<T>* t, const BuildObjectParam& param) const {
383 NodeType* child = getChild(root, conv.elementName());
384 if (child == nullptr) {
385 *t = std::nullopt;
386 return true;
387 }
388 *t = std::make_optional<T>();
389 return conv(&**t, child, param);
390 }
391
392 template <typename T>
parseChildrenandroid::vintf::XmlNodeConverter393 inline bool parseChildren(NodeType* root, const XmlNodeConverter<T>& conv, std::vector<T>* v,
394 const BuildObjectParam& param) const {
395 auto nodes = getChildren(root, conv.elementName());
396 v->resize(nodes.size());
397 for (size_t i = 0; i < nodes.size(); ++i) {
398 if (!conv(&v->at(i), nodes[i], param)) {
399 *param.error = "Could not parse element with name <" + conv.elementName() +
400 "> in element <" + this->elementName() + ">: " + *param.error;
401 return false;
402 }
403 }
404 return true;
405 }
406
407 template <typename Container, typename T = typename Container::value_type,
408 typename = typename Container::key_compare>
parseChildrenandroid::vintf::XmlNodeConverter409 inline bool parseChildren(NodeType* root, const XmlNodeConverter<T>& conv, Container* s,
410 const BuildObjectParam& param) const {
411 std::vector<T> vec;
412 if (!parseChildren(root, conv, &vec, param)) {
413 return false;
414 }
415 s->clear();
416 s->insert(vec.begin(), vec.end());
417 if (s->size() != vec.size()) {
418 *param.error = "Duplicated elements <" + conv.elementName() + "> in element <" +
419 this->elementName() + ">";
420 s->clear();
421 return false;
422 }
423 return true;
424 }
425
426 template <typename K, typename V>
parseChildrenandroid::vintf::XmlNodeConverter427 inline bool parseChildren(NodeType* root, const XmlNodeConverter<std::pair<K, V>>& conv,
428 std::map<K, V>* s, const BuildObjectParam& param) const {
429 return parseChildren<std::map<K, V>, std::pair<K, V>>(root, conv, s, param);
430 }
431
parseTextandroid::vintf::XmlNodeConverter432 inline bool parseText(NodeType* node, std::string* s, std::string* /* error */) const {
433 *s = getText(node);
434 return true;
435 }
436
437 template <typename T>
parseTextandroid::vintf::XmlNodeConverter438 inline bool parseText(NodeType* node, T* s, std::string* error) const {
439 bool (*parser)(const std::string&, T*) = ::android::vintf::parse;
440 return parseText(node, s, {parser}, error);
441 }
442
443 template <typename T>
parseTextandroid::vintf::XmlNodeConverter444 inline bool parseText(NodeType* node, T* s,
445 const std::function<bool(const std::string&, T*)>& parse,
446 std::string* error) const {
447 std::string text = getText(node);
448 bool ret = parse(text, s);
449 if (!ret) {
450 *error = "Could not parse text \"" + text + "\" in element <" + elementName() + ">";
451 }
452 return ret;
453 }
454 };
455
456 template<typename Object>
457 struct XmlTextConverter : public XmlNodeConverter<Object> {
mutateNodeandroid::vintf::XmlTextConverter458 void mutateNode(const Object& object, NodeType* root,
459 const MutateNodeParam& param) const override {
460 appendText(root, ::android::vintf::to_string(object), param.d);
461 }
buildObjectandroid::vintf::XmlTextConverter462 bool buildObject(Object* object, NodeType* root, const BuildObjectParam& param) const override {
463 return this->parseText(root, object, param.error);
464 }
465 };
466
467 template <typename Pair, typename FirstConverter, typename SecondConverter>
468 struct XmlPairConverter : public XmlNodeConverter<Pair> {
mutateNodeandroid::vintf::XmlPairConverter469 void mutateNode(const Pair& object, NodeType* root,
470 const MutateNodeParam& param) const override {
471 appendChild(root, FirstConverter{}(object.first, param));
472 appendChild(root, SecondConverter{}(object.second, param));
473 }
buildObjectandroid::vintf::XmlPairConverter474 bool buildObject(Pair* object, NodeType* root, const BuildObjectParam& param) const override {
475 return this->parseChild(root, FirstConverter{}, &object->first, param) &&
476 this->parseChild(root, SecondConverter{}, &object->second, param);
477 }
478 };
479
480 // ---------------------- XmlNodeConverter definitions end
481
482 struct VersionConverter : public XmlTextConverter<Version> {
elementNameandroid::vintf::VersionConverter483 std::string elementName() const override { return "version"; }
484 };
485
486 struct VersionRangeConverter : public XmlTextConverter<VersionRange> {
elementNameandroid::vintf::VersionRangeConverter487 std::string elementName() const override { return "version"; }
488 };
489
490 // <version>100</version> <=> Version{kFakeAidlMajorVersion, 100}
491 struct AidlVersionConverter : public XmlNodeConverter<Version> {
elementNameandroid::vintf::AidlVersionConverter492 std::string elementName() const override { return "version"; }
mutateNodeandroid::vintf::AidlVersionConverter493 void mutateNode(const Version& object, NodeType* root,
494 const MutateNodeParam& param) const override {
495 appendText(root, aidlVersionToString(object), param.d);
496 }
buildObjectandroid::vintf::AidlVersionConverter497 bool buildObject(Version* object, NodeType* root,
498 const BuildObjectParam& param) const override {
499 return parseText(root, object, {parseAidlVersion}, param.error);
500 }
501 };
502
503 // <version>100</version> <=> VersionRange{kFakeAidlMajorVersion, 100, 100}
504 // <version>100-105</version> <=> VersionRange{kFakeAidlMajorVersion, 100, 105}
505 struct AidlVersionRangeConverter : public XmlNodeConverter<VersionRange> {
elementNameandroid::vintf::AidlVersionRangeConverter506 std::string elementName() const override { return "version"; }
mutateNodeandroid::vintf::AidlVersionRangeConverter507 void mutateNode(const VersionRange& object, NodeType* root,
508 const MutateNodeParam& param) const override {
509 appendText(root, aidlVersionRangeToString(object), param.d);
510 }
buildObjectandroid::vintf::AidlVersionRangeConverter511 bool buildObject(VersionRange* object, NodeType* root,
512 const BuildObjectParam& param) const override {
513 return parseText(root, object, {parseAidlVersionRange}, param.error);
514 }
515 };
516
517 struct TransportArchConverter : public XmlNodeConverter<TransportArch> {
elementNameandroid::vintf::TransportArchConverter518 std::string elementName() const override { return "transport"; }
mutateNodeandroid::vintf::TransportArchConverter519 void mutateNode(const TransportArch& object, NodeType* root,
520 const MutateNodeParam& param) const override {
521 if (object.arch != Arch::ARCH_EMPTY) {
522 appendAttr(root, "arch", object.arch);
523 }
524 if (object.ip.has_value()) {
525 appendAttr(root, "ip", *object.ip);
526 }
527 if (object.port.has_value()) {
528 appendAttr(root, "port", *object.port);
529 }
530 appendText(root, ::android::vintf::to_string(object.transport), param.d);
531 }
buildObjectandroid::vintf::TransportArchConverter532 bool buildObject(TransportArch* object, NodeType* root,
533 const BuildObjectParam& param) const override {
534 if (!parseOptionalAttr(root, "arch", Arch::ARCH_EMPTY, &object->arch, param.error) ||
535 !parseOptionalAttr(root, "ip", {}, &object->ip, param.error) ||
536 !parseOptionalAttr(root, "port", {}, &object->port, param.error) ||
537 !parseText(root, &object->transport, param.error)) {
538 return false;
539 }
540 if (!object->isValid(param.error)) {
541 return false;
542 }
543 return true;
544 }
545 };
546
547 struct KernelConfigTypedValueConverter : public XmlNodeConverter<KernelConfigTypedValue> {
elementNameandroid::vintf::KernelConfigTypedValueConverter548 std::string elementName() const override { return "value"; }
mutateNodeandroid::vintf::KernelConfigTypedValueConverter549 void mutateNode(const KernelConfigTypedValue& object, NodeType* root,
550 const MutateNodeParam& param) const override {
551 appendAttr(root, "type", object.mType);
552 appendText(root, ::android::vintf::to_string(object), param.d);
553 }
buildObjectandroid::vintf::KernelConfigTypedValueConverter554 bool buildObject(KernelConfigTypedValue* object, NodeType* root,
555 const BuildObjectParam& param) const override {
556 std::string stringValue;
557 if (!parseAttr(root, "type", &object->mType, param.error) ||
558 !parseText(root, &stringValue, param.error)) {
559 return false;
560 }
561 if (!::android::vintf::parseKernelConfigValue(stringValue, object)) {
562 *param.error = "Could not parse kernel config value \"" + stringValue + "\"";
563 return false;
564 }
565 return true;
566 }
567 };
568
569 struct KernelConfigKeyConverter : public XmlTextConverter<KernelConfigKey> {
elementNameandroid::vintf::KernelConfigKeyConverter570 std::string elementName() const override { return "key"; }
571 };
572
573 struct MatrixKernelConfigConverter : public XmlPairConverter<KernelConfig, KernelConfigKeyConverter,
574 KernelConfigTypedValueConverter> {
elementNameandroid::vintf::MatrixKernelConfigConverter575 std::string elementName() const override { return "config"; }
576 };
577
578 struct HalInterfaceConverter : public XmlNodeConverter<HalInterface> {
elementNameandroid::vintf::HalInterfaceConverter579 std::string elementName() const override { return "interface"; }
mutateNodeandroid::vintf::HalInterfaceConverter580 void mutateNode(const HalInterface& object, NodeType* root,
581 const MutateNodeParam& param) const override {
582 if (!object.name().empty()) {
583 appendTextElement(root, "name", object.name(), param.d);
584 }
585 appendTextElements(root, "instance", object.mInstances, param.d);
586 appendTextElements(root, "regex-instance", object.mRegexes, param.d);
587 }
buildObjectandroid::vintf::HalInterfaceConverter588 bool buildObject(HalInterface* object, NodeType* root,
589 const BuildObjectParam& param) const override {
590 std::vector<std::string> instances;
591 std::vector<std::string> regexes;
592 if (!parseOptionalTextElement(root, "name", {}, &object->mName, param.error) ||
593 !parseTextElements(root, "instance", &instances, param.error) ||
594 !parseTextElements(root, "regex-instance", ®exes, param.error)) {
595 return false;
596 }
597 bool success = true;
598 for (const auto& e : instances) {
599 if (!object->insertInstance(e, false /* isRegex */)) {
600 if (!param.error->empty()) *param.error += "\n";
601 *param.error += "Duplicated instance '" + e + "' in " + object->name();
602 success = false;
603 }
604 }
605 for (const auto& e : regexes) {
606 details::Regex regex;
607 if (!regex.compile(e)) {
608 if (!param.error->empty()) *param.error += "\n";
609 *param.error += "Invalid regular expression '" + e + "' in " + object->name();
610 success = false;
611 }
612 if (!object->insertInstance(e, true /* isRegex */)) {
613 if (!param.error->empty()) *param.error += "\n";
614 *param.error += "Duplicated regex-instance '" + e + "' in " + object->name();
615 success = false;
616 }
617 }
618 return success;
619 }
620 };
621
622 struct MatrixHalConverter : public XmlNodeConverter<MatrixHal> {
elementNameandroid::vintf::MatrixHalConverter623 std::string elementName() const override { return "hal"; }
mutateNodeandroid::vintf::MatrixHalConverter624 void mutateNode(const MatrixHal& object, NodeType* root,
625 const MutateNodeParam& param) const override {
626 appendAttr(root, "format", object.format);
627 appendAttr(root, "optional", object.optional);
628 // Only include update-via-apex if enabled
629 if (object.updatableViaApex) {
630 appendAttr(root, "updatable-via-apex", object.updatableViaApex);
631 }
632 appendTextElement(root, "name", object.name, param.d);
633 if (object.format == HalFormat::AIDL) {
634 // By default, buildObject() assumes a <version>0</version> tag if no <version> tag
635 // is specified. Don't output any <version> tag if there's only one <version>0</version>
636 // tag.
637 if (object.versionRanges.size() != 1 ||
638 object.versionRanges[0] != details::kDefaultAidlVersionRange) {
639 appendChildren(root, AidlVersionRangeConverter{}, object.versionRanges, param);
640 }
641 } else {
642 appendChildren(root, VersionRangeConverter{}, object.versionRanges, param);
643 }
644 appendChildren(root, HalInterfaceConverter{}, iterateValues(object.interfaces), param);
645 }
buildObjectandroid::vintf::MatrixHalConverter646 bool buildObject(MatrixHal* object, NodeType* root,
647 const BuildObjectParam& param) const override {
648 std::vector<HalInterface> interfaces;
649 if (!parseOptionalAttr(root, "format", HalFormat::HIDL, &object->format, param.error) ||
650 !parseOptionalAttr(root, "optional", false /* defaultValue */, &object->optional,
651 param.error) ||
652 !parseOptionalAttr(root, "updatable-via-apex", false /* defaultValue */,
653 &object->updatableViaApex, param.error) ||
654 !parseTextElement(root, "name", &object->name, param.error) ||
655 !parseChildren(root, HalInterfaceConverter{}, &interfaces, param)) {
656 return false;
657 }
658 if (object->format == HalFormat::AIDL) {
659 if (!parseChildren(root, AidlVersionRangeConverter{}, &object->versionRanges, param)) {
660 return false;
661 }
662 // Insert fake version for AIDL HALs so that compatibility check for AIDL and other
663 // HAL formats can be unified.
664 if (object->versionRanges.empty()) {
665 object->versionRanges.push_back(details::kDefaultAidlVersionRange);
666 }
667 } else {
668 if (!parseChildren(root, VersionRangeConverter{}, &object->versionRanges, param)) {
669 return false;
670 }
671 }
672 for (auto&& interface : interfaces) {
673 std::string name{interface.name()};
674 auto res = object->interfaces.emplace(std::move(name), std::move(interface));
675 if (!res.second) {
676 *param.error = "Duplicated interface entry \"" + res.first->first +
677 "\"; if additional instances are needed, add them to the "
678 "existing <interface> node.";
679 return false;
680 }
681 }
682 if (!checkAdditionalRestrictionsOnHal(*object, param.error)) {
683 return false;
684 }
685
686 if (!object->isValid(param.error)) {
687 param.error->insert(0, "'" + object->name + "' is not a valid Matrix HAL: ");
688 return false;
689 }
690 return true;
691 }
692
693 private:
checkAdditionalRestrictionsOnHalandroid::vintf::MatrixHalConverter694 bool checkAdditionalRestrictionsOnHal(const MatrixHal& hal, std::string* error) const {
695 // Do not check for target-side libvintf to avoid restricting ability for upgrade
696 // accidentally.
697 if constexpr (kDevice) {
698 return true;
699 }
700 if (hal.getName() == "netutils-wrapper") {
701 if (hal.versionRanges.size() != 1) {
702 *error =
703 "netutils-wrapper HAL must specify exactly one version x.0, "
704 "but multiple <version> element is specified.";
705 return false;
706 }
707 const VersionRange& v = hal.versionRanges.at(0);
708 if (!v.isSingleVersion()) {
709 *error =
710 "netutils-wrapper HAL must specify exactly one version x.0, "
711 "but a range is provided. Perhaps you mean '" +
712 to_string(Version{v.majorVer, 0}) + "'?";
713 return false;
714 }
715 if (v.minMinor != 0) {
716 *error =
717 "netutils-wrapper HAL must specify exactly one version x.0, "
718 "but minor version is not 0. Perhaps you mean '" +
719 to_string(Version{v.majorVer, 0}) + "'?";
720 return false;
721 }
722 }
723 return true;
724 }
725 };
726
727 struct MatrixKernelConditionsConverter : public XmlNodeConverter<std::vector<KernelConfig>> {
elementNameandroid::vintf::MatrixKernelConditionsConverter728 std::string elementName() const override { return "conditions"; }
mutateNodeandroid::vintf::MatrixKernelConditionsConverter729 void mutateNode(const std::vector<KernelConfig>& object, NodeType* root,
730 const MutateNodeParam& param) const override {
731 appendChildren(root, MatrixKernelConfigConverter{}, object, param);
732 }
buildObjectandroid::vintf::MatrixKernelConditionsConverter733 bool buildObject(std::vector<KernelConfig>* object, NodeType* root,
734 const BuildObjectParam& param) const override {
735 return parseChildren(root, MatrixKernelConfigConverter{}, object, param);
736 }
737 };
738
739 struct MatrixKernelConverter : public XmlNodeConverter<MatrixKernel> {
elementNameandroid::vintf::MatrixKernelConverter740 std::string elementName() const override { return "kernel"; }
mutateNodeandroid::vintf::MatrixKernelConverter741 void mutateNode(const MatrixKernel& object, NodeType* root,
742 const MutateNodeParam& param) const override {
743 KernelVersion kv = object.mMinLts;
744 if (!param.flags.isKernelMinorRevisionEnabled()) {
745 kv.minorRev = 0u;
746 }
747 appendAttr(root, "version", kv);
748
749 if (object.getSourceMatrixLevel() != Level::UNSPECIFIED) {
750 appendAttr(root, "level", object.getSourceMatrixLevel());
751 }
752
753 if (!object.mConditions.empty()) {
754 appendChild(root, MatrixKernelConditionsConverter{}(object.mConditions, param));
755 }
756 if (param.flags.isKernelConfigsEnabled()) {
757 appendChildren(root, MatrixKernelConfigConverter{}, object.mConfigs, param);
758 }
759 }
buildObjectandroid::vintf::MatrixKernelConverter760 bool buildObject(MatrixKernel* object, NodeType* root,
761 const BuildObjectParam& param) const override {
762 Level sourceMatrixLevel = Level::UNSPECIFIED;
763 if (!parseAttr(root, "version", &object->mMinLts, param.error) ||
764 !parseOptionalAttr(root, "level", Level::UNSPECIFIED, &sourceMatrixLevel,
765 param.error) ||
766 !parseOptionalChild(root, MatrixKernelConditionsConverter{}, {}, &object->mConditions,
767 param) ||
768 !parseChildren(root, MatrixKernelConfigConverter{}, &object->mConfigs, param)) {
769 return false;
770 }
771 object->setSourceMatrixLevel(sourceMatrixLevel);
772 return true;
773 }
774 };
775
776 struct FqInstanceConverter : public XmlTextConverter<FqInstance> {
elementNameandroid::vintf::FqInstanceConverter777 std::string elementName() const override { return "fqname"; }
778 };
779
780 // Convert ManifestHal from and to XML. Returned object is guaranteed to have
781 // .isValid() == true.
782 struct ManifestHalConverter : public XmlNodeConverter<ManifestHal> {
elementNameandroid::vintf::ManifestHalConverter783 std::string elementName() const override { return "hal"; }
mutateNodeandroid::vintf::ManifestHalConverter784 void mutateNode(const ManifestHal& object, NodeType* root,
785 const MutateNodeParam& param) const override {
786 appendAttr(root, "format", object.format);
787 appendTextElement(root, "name", object.name, param.d);
788 if (!object.transportArch.empty()) {
789 appendChild(root, TransportArchConverter{}(object.transportArch, param));
790 }
791 if (object.format == HalFormat::AIDL) {
792 // By default, buildObject() assumes a <version>0</version> tag if no <version> tag
793 // is specified. Don't output any <version> tag if there's only one <version>0</version>
794 // tag.
795 if (object.versions.size() != 1 || object.versions[0] != details::kDefaultAidlVersion) {
796 appendChildren(root, AidlVersionConverter{}, object.versions, param);
797 }
798 } else {
799 appendChildren(root, VersionConverter{}, object.versions, param);
800 }
801 if (object.isOverride()) {
802 appendAttr(root, "override", object.isOverride());
803 }
804 if (const auto& apex = object.updatableViaApex(); apex.has_value()) {
805 appendAttr(root, "updatable-via-apex", apex.value());
806 }
807 if (param.flags.isFqnameEnabled()) {
808 std::set<std::string> simpleFqInstances;
809 object.forEachInstance([&simpleFqInstances](const auto& manifestInstance) {
810 simpleFqInstances.emplace(manifestInstance.getSimpleFqInstance());
811 return true;
812 });
813 appendTextElements(root, FqInstanceConverter{}.elementName(), simpleFqInstances,
814 param.d);
815 }
816 if (object.getMaxLevel() != Level::UNSPECIFIED) {
817 appendAttr(root, "max-level", object.getMaxLevel());
818 }
819 if (object.getMinLevel() != Level::UNSPECIFIED) {
820 appendAttr(root, "min-level", object.getMinLevel());
821 }
822 }
buildObjectandroid::vintf::ManifestHalConverter823 bool buildObject(ManifestHal* object, NodeType* root,
824 const BuildObjectParam& param) const override {
825 std::vector<HalInterface> interfaces;
826 if (!parseOptionalAttr(root, "format", HalFormat::HIDL, &object->format, param.error) ||
827 !parseOptionalAttr(root, "override", false, &object->mIsOverride, param.error) ||
828 !parseOptionalAttr(root, "updatable-via-apex", {}, &object->mUpdatableViaApex,
829 param.error) ||
830 !parseTextElement(root, "name", &object->name, param.error) ||
831 !parseOptionalChild(root, TransportArchConverter{}, {}, &object->transportArch,
832 param) ||
833 !parseOptionalAttr(root, "max-level", Level::UNSPECIFIED, &object->mMaxLevel,
834 param.error) ||
835 !parseOptionalAttr(root, "min-level", Level::UNSPECIFIED, &object->mMinLevel,
836 param.error)) {
837 return false;
838 }
839
840 std::string_view apexName = parseApexName(param.fileName);
841 if (!apexName.empty()) {
842 if (object->mUpdatableViaApex.has_value()) {
843 // When defined in APEX, updatable-via-apex can be either
844 // - ""(empty) : the HAL isn't updatable even if it's in APEX
845 // - {apex name}: the HAL is updtable via the current APEX
846 const std::string& updatableViaApex = object->mUpdatableViaApex.value();
847 if (!updatableViaApex.empty() && apexName.compare(updatableViaApex) != 0) {
848 *param.error = "Invalid APEX HAL " + object->name + ": updatable-via-apex " +
849 updatableViaApex + " doesn't match with the defining APEX " +
850 std::string(apexName) + "\n";
851 return false;
852 }
853 } else {
854 // Set updatable-via-apex to the defining APEX when it's not set explicitly.
855 // This should be set before calling insertInstances() which copies the current
856 // value to ManifestInstance.
857 object->mUpdatableViaApex = apexName;
858 }
859 }
860
861 switch (object->format) {
862 case HalFormat::HIDL: {
863 if (!parseChildren(root, VersionConverter{}, &object->versions, param))
864 return false;
865 if (object->transportArch.empty()) {
866 *param.error =
867 "HIDL HAL '" + object->name + "' should have <transport> defined.";
868 return false;
869 }
870 if (object->transportArch.transport == Transport::INET ||
871 object->transportArch.ip.has_value() ||
872 object->transportArch.port.has_value()) {
873 *param.error = "HIDL HAL '" + object->name +
874 "' should not have <transport> \"inet\" " +
875 "or ip or port attributes defined.";
876 return false;
877 }
878 } break;
879 case HalFormat::NATIVE: {
880 if (!parseChildren(root, VersionConverter{}, &object->versions, param))
881 return false;
882 if (!object->transportArch.empty()) {
883 *param.error =
884 "Native HAL '" + object->name + "' should not have <transport> defined.";
885 return false;
886 }
887 } break;
888 case HalFormat::AIDL: {
889 if (!object->transportArch.empty() &&
890 object->transportArch.transport != Transport::INET) {
891 if (param.metaVersion >= kMetaVersionAidlInet) {
892 *param.error = "AIDL HAL '" + object->name +
893 R"(' only supports "inet" or empty <transport>, found ")" +
894 to_string(object->transportArch) + "\"";
895 return false;
896 }
897 LOG(WARNING) << "Ignoring <transport> on manifest <hal format=\"aidl\"> "
898 << object->name << ". Only \"inet\" supported.";
899 object->transportArch = {};
900 }
901 if (!parseChildren(root, AidlVersionConverter{}, &object->versions, param)) {
902 return false;
903 }
904 // Insert fake version for AIDL HALs so that forEachInstance works.
905 if (object->versions.empty()) {
906 object->versions.push_back(details::kDefaultAidlVersion);
907 }
908 } break;
909 default: {
910 LOG(FATAL) << "Unhandled HalFormat "
911 << static_cast<typename std::underlying_type<HalFormat>::type>(
912 object->format);
913 } break;
914 }
915 if (!object->transportArch.isValid(param.error)) return false;
916
917 // Parse <fqname> into fqInstances list
918 std::set<FqInstance> fqInstances;
919 if (!parseChildren(root, FqInstanceConverter{}, &fqInstances, param)) {
920 return false;
921 }
922
923 // Handle deprecated <interface> x <instance>
924 if (!parseChildren(root, HalInterfaceConverter{}, &interfaces, param)) {
925 return false;
926 }
927 // Check duplicated <interface><name>
928 std::set<std::string> interface_names;
929 for (auto &&interface : interfaces) {
930 auto res = interface_names.emplace(interface.name());
931 if (!res.second) {
932 *param.error = "Duplicated interface entry \"" + *res.first +
933 "\"; if additional instances are needed, add them to the "
934 "existing <interface> node.";
935 return false;
936 }
937 }
938 // Turn <version> x <interface> x <instance> into <fqname>s; insert into
939 // fqInstances list.
940 bool convertedInstancesIntoFqnames = false;
941 for (const auto& v : object->versions) {
942 for (const auto& intf : interfaces) {
943 if (param.metaVersion >= kMetaVersionNoHalInterfaceInstance &&
944 (object->format == HalFormat::HIDL || object->format == HalFormat::AIDL) &&
945 !intf.hasAnyInstance()) {
946 *param.error +=
947 "<hal> " + object->name + " <interface> " + intf.name() +
948 " has no <instance>. Either specify <instance> or, "
949 "preferably, specify <fqname> and delete <version> and <interface>.";
950 return false;
951 }
952 bool cont = intf.forEachInstance(
953 [&v, &fqInstances, &convertedInstancesIntoFqnames, &object, ¶m](
954 const auto& interface, const auto& instance, bool /* isRegex */) {
955 auto fqInstance = details::convertLegacyInstanceIntoFqInstance(
956 object->name, v, interface, instance, object->format, param.error);
957
958 if (!fqInstance.has_value()) {
959 return false;
960 }
961
962 // Check for duplication in fqInstances.
963 // Before kMetaVersionNoHalInterfaceInstance: It is okay to have duplication
964 // between <interface> and <fqname>.
965 // After kMetaVersionNoHalInterfaceInstance: Duplication between
966 // <interface> and <fqname> is not allowed.
967 auto&& [it, inserted] = fqInstances.emplace(std::move(fqInstance.value()));
968 if (param.metaVersion >= kMetaVersionNoHalInterfaceInstance && !inserted) {
969 std::string debugString =
970 object->format == HalFormat::AIDL
971 ? toAidlFqnameString(object->name, interface, instance)
972 : toFQNameString(object->name, v, interface, instance);
973 *param.error = "Duplicated " + debugString +
974 " in <interface><instance> and <fqname>. ";
975 if constexpr (kDevice) {
976 *param.error +=
977 "(Did you copy source manifests to the device directly "
978 "without going through assemble_vintf, e.g. not using "
979 "DEVICE_MANIFEST_FILE or ODM_MANIFEST_FILES?)";
980 } else {
981 *param.error += "Remove deprecated <interface>.";
982 }
983 return false;
984 }
985
986 convertedInstancesIntoFqnames = true;
987 return true; // continue
988 });
989 if (!cont) {
990 return false;
991 }
992 }
993 }
994
995 if (!checkAdditionalRestrictionsOnHal(*object, param.error)) {
996 return false;
997 }
998
999 // For HIDL, if any <version> x <interface> x <instance> tuple, all <version>
1000 // tags can be cleared. <version> information is already in <fqname>'s.
1001 // For AIDL, <version> information is not in <fqname>, so don't clear them.
1002 // For HALs with only <version> but no <interface>
1003 // (e.g. native HALs like netutils-wrapper), <version> is kept.
1004 if (convertedInstancesIntoFqnames && object->format != HalFormat::AIDL) {
1005 object->versions.clear();
1006 }
1007
1008 std::set<FqInstance> fqInstancesToInsert;
1009 for (auto& e : fqInstances) {
1010 if (e.hasPackage()) {
1011 *param.error = "Should not specify package: \"" + e.string() + "\"";
1012 return false;
1013 }
1014 if (object->format == HalFormat::AIDL) {
1015 // <fqname> in AIDL HALs should not contain version.
1016 if (e.hasVersion()) {
1017 *param.error = "Should not specify version in <fqname> for AIDL HAL: \"" +
1018 e.string() + "\"";
1019 return false;
1020 }
1021 // Put in the fake kDefaultAidlVersion so that HalManifest can
1022 // store it in an FqInstance object with a non-empty package.
1023 FqInstance withFakeVersion;
1024 if (!withFakeVersion.setTo(details::kDefaultAidlVersion.majorVer,
1025 details::kDefaultAidlVersion.minorVer, e.getInterface(),
1026 e.getInstance())) {
1027 return false;
1028 }
1029 fqInstancesToInsert.emplace(std::move(withFakeVersion));
1030 } else {
1031 fqInstancesToInsert.emplace(std::move(e));
1032 }
1033 }
1034
1035 if (param.metaVersion >= kMetaVersionNoHalInterfaceInstance &&
1036 (object->format == HalFormat::HIDL || object->format == HalFormat::AIDL) &&
1037 fqInstancesToInsert.empty() && !object->isOverride()) {
1038 *param.error = "<hal> " + object->name + " has no instance. Fix by adding <fqname>.";
1039 return false;
1040 }
1041
1042 bool allowMajorVersionDup = param.metaVersion < kMetaVersionNoHalInterfaceInstance;
1043 if (!object->insertInstances(fqInstancesToInsert, allowMajorVersionDup, param.error)) {
1044 return false;
1045 }
1046
1047 if (!object->isValid(param.error)) {
1048 param.error->insert(0, "'" + object->name + "' is not a valid Manifest HAL: ");
1049 return false;
1050 }
1051
1052 return true;
1053 }
1054
1055 private:
checkAdditionalRestrictionsOnHalandroid::vintf::ManifestHalConverter1056 bool checkAdditionalRestrictionsOnHal(const ManifestHal& hal, std::string* error) const {
1057 // Do not check for target-side libvintf to avoid restricting upgrade accidentally.
1058 if constexpr (kDevice) {
1059 return true;
1060 }
1061 if (hal.getName() == "netutils-wrapper") {
1062 for (const Version& v : hal.versions) {
1063 if (v.minorVer != 0) {
1064 *error =
1065 "netutils-wrapper HAL must specify exactly one version x.0, "
1066 "but minor version is not 0. Perhaps you mean '" +
1067 to_string(Version{v.majorVer, 0}) + "'?";
1068 return false;
1069 }
1070 }
1071 }
1072 return true;
1073 }
1074 };
1075
1076 struct KernelSepolicyVersionConverter : public XmlTextConverter<KernelSepolicyVersion> {
elementNameandroid::vintf::KernelSepolicyVersionConverter1077 std::string elementName() const override { return "kernel-sepolicy-version"; }
1078 };
1079
1080 struct SepolicyVersionConverter : public XmlTextConverter<VersionRange> {
elementNameandroid::vintf::SepolicyVersionConverter1081 std::string elementName() const override { return "sepolicy-version"; }
1082 };
1083
1084 struct SepolicyConverter : public XmlNodeConverter<Sepolicy> {
elementNameandroid::vintf::SepolicyConverter1085 std::string elementName() const override { return "sepolicy"; }
mutateNodeandroid::vintf::SepolicyConverter1086 void mutateNode(const Sepolicy& object, NodeType* root,
1087 const MutateNodeParam& param) const override {
1088 appendChild(root, KernelSepolicyVersionConverter{}(object.kernelSepolicyVersion(), param));
1089 appendChildren(root, SepolicyVersionConverter{}, object.sepolicyVersions(), param);
1090 }
buildObjectandroid::vintf::SepolicyConverter1091 bool buildObject(Sepolicy* object, NodeType* root,
1092 const BuildObjectParam& param) const override {
1093 if (!parseChild(root, KernelSepolicyVersionConverter{}, &object->mKernelSepolicyVersion,
1094 param) ||
1095 !parseChildren(root, SepolicyVersionConverter{}, &object->mSepolicyVersionRanges,
1096 param)) {
1097 return false;
1098 }
1099 return true;
1100 }
1101 };
1102
1103 struct [[deprecated]] VndkVersionRangeConverter : public XmlTextConverter<VndkVersionRange> {
elementNameandroid::vintf::VndkVersionRangeConverter1104 std::string elementName() const override { return "version"; }
1105 };
1106
1107 struct VndkVersionConverter : public XmlTextConverter<std::string> {
elementNameandroid::vintf::VndkVersionConverter1108 std::string elementName() const override { return "version"; }
1109 };
1110
1111 struct VndkLibraryConverter : public XmlTextConverter<std::string> {
elementNameandroid::vintf::VndkLibraryConverter1112 std::string elementName() const override { return "library"; }
1113 };
1114
1115 struct [[deprecated]] VndkConverter : public XmlNodeConverter<Vndk> {
elementNameandroid::vintf::VndkConverter1116 std::string elementName() const override { return "vndk"; }
mutateNodeandroid::vintf::VndkConverter1117 void mutateNode(const Vndk& object, NodeType* root,
1118 const MutateNodeParam& param) const override {
1119 appendChild(root, VndkVersionRangeConverter{}(object.mVersionRange, param));
1120 appendChildren(root, VndkLibraryConverter{}, object.mLibraries, param);
1121 }
buildObjectandroid::vintf::VndkConverter1122 bool buildObject(Vndk* object, NodeType* root, const BuildObjectParam& param) const override {
1123 if (!parseChild(root, VndkVersionRangeConverter{}, &object->mVersionRange, param) ||
1124 !parseChildren(root, VndkLibraryConverter{}, &object->mLibraries, param)) {
1125 return false;
1126 }
1127 return true;
1128 }
1129 };
1130
1131 struct VendorNdkConverter : public XmlNodeConverter<VendorNdk> {
elementNameandroid::vintf::VendorNdkConverter1132 std::string elementName() const override { return "vendor-ndk"; }
mutateNodeandroid::vintf::VendorNdkConverter1133 void mutateNode(const VendorNdk& object, NodeType* root,
1134 const MutateNodeParam& param) const override {
1135 appendChild(root, VndkVersionConverter{}(object.mVersion, param));
1136 appendChildren(root, VndkLibraryConverter{}, object.mLibraries, param);
1137 }
buildObjectandroid::vintf::VendorNdkConverter1138 bool buildObject(VendorNdk* object, NodeType* root,
1139 const BuildObjectParam& param) const override {
1140 if (!parseChild(root, VndkVersionConverter{}, &object->mVersion, param) ||
1141 !parseChildren(root, VndkLibraryConverter{}, &object->mLibraries, param)) {
1142 return false;
1143 }
1144 return true;
1145 }
1146 };
1147
1148 struct SystemSdkVersionConverter : public XmlTextConverter<std::string> {
elementNameandroid::vintf::SystemSdkVersionConverter1149 std::string elementName() const override { return "version"; }
1150 };
1151
1152 struct SystemSdkConverter : public XmlNodeConverter<SystemSdk> {
elementNameandroid::vintf::SystemSdkConverter1153 std::string elementName() const override { return "system-sdk"; }
mutateNodeandroid::vintf::SystemSdkConverter1154 void mutateNode(const SystemSdk& object, NodeType* root,
1155 const MutateNodeParam& param) const override {
1156 appendChildren(root, SystemSdkVersionConverter{}, object.versions(), param);
1157 }
buildObjectandroid::vintf::SystemSdkConverter1158 bool buildObject(SystemSdk* object, NodeType* root,
1159 const BuildObjectParam& param) const override {
1160 return parseChildren(root, SystemSdkVersionConverter{}, &object->mVersions, param);
1161 }
1162 };
1163
1164 struct HalManifestSepolicyConverter : public XmlNodeConverter<Version> {
elementNameandroid::vintf::HalManifestSepolicyConverter1165 std::string elementName() const override { return "sepolicy"; }
mutateNodeandroid::vintf::HalManifestSepolicyConverter1166 void mutateNode(const Version& object, NodeType* root,
1167 const MutateNodeParam& param) const override {
1168 appendChild(root, VersionConverter{}(object, param));
1169 }
buildObjectandroid::vintf::HalManifestSepolicyConverter1170 bool buildObject(Version* object, NodeType* root,
1171 const BuildObjectParam& param) const override {
1172 return parseChild(root, VersionConverter{}, object, param);
1173 }
1174 };
1175
1176 struct ManifestXmlFileConverter : public XmlNodeConverter<ManifestXmlFile> {
elementNameandroid::vintf::ManifestXmlFileConverter1177 std::string elementName() const override { return "xmlfile"; }
mutateNodeandroid::vintf::ManifestXmlFileConverter1178 void mutateNode(const ManifestXmlFile& object, NodeType* root,
1179 const MutateNodeParam& param) const override {
1180 appendTextElement(root, "name", object.name(), param.d);
1181 appendChild(root, VersionConverter{}(object.version(), param));
1182 if (!object.overriddenPath().empty()) {
1183 appendTextElement(root, "path", object.overriddenPath(), param.d);
1184 }
1185 }
buildObjectandroid::vintf::ManifestXmlFileConverter1186 bool buildObject(ManifestXmlFile* object, NodeType* root,
1187 const BuildObjectParam& param) const override {
1188 if (!parseTextElement(root, "name", &object->mName, param.error) ||
1189 !parseChild(root, VersionConverter{}, &object->mVersion, param) ||
1190 !parseOptionalTextElement(root, "path", {}, &object->mOverriddenPath, param.error)) {
1191 return false;
1192 }
1193 return true;
1194 }
1195 };
1196
1197 struct StringKernelConfigKeyConverter : public XmlTextConverter<std::string> {
elementNameandroid::vintf::StringKernelConfigKeyConverter1198 std::string elementName() const override { return "key"; }
1199 };
1200
1201 struct KernelConfigValueConverter : public XmlTextConverter<std::string> {
elementNameandroid::vintf::KernelConfigValueConverter1202 std::string elementName() const override { return "value"; }
1203 };
1204
1205 struct StringKernelConfigConverter
1206 : public XmlPairConverter<std::pair<std::string, std::string>, StringKernelConfigKeyConverter,
1207 KernelConfigValueConverter> {
elementNameandroid::vintf::StringKernelConfigConverter1208 std::string elementName() const override { return "config"; }
1209 };
1210
1211 struct KernelInfoConverter : public XmlNodeConverter<KernelInfo> {
elementNameandroid::vintf::KernelInfoConverter1212 std::string elementName() const override { return "kernel"; }
mutateNodeandroid::vintf::KernelInfoConverter1213 void mutateNode(const KernelInfo& object, NodeType* root,
1214 const MutateNodeParam& param) const override {
1215 if (object.version() != KernelVersion{}) {
1216 appendAttr(root, "version", object.version());
1217 }
1218 if (object.level() != Level::UNSPECIFIED) {
1219 appendAttr(root, "target-level", object.level());
1220 }
1221 if (param.flags.isKernelConfigsEnabled()) {
1222 appendChildren(root, StringKernelConfigConverter{}, object.configs(), param);
1223 }
1224 }
buildObjectandroid::vintf::KernelInfoConverter1225 bool buildObject(KernelInfo* object, NodeType* root,
1226 const BuildObjectParam& param) const override {
1227 return parseOptionalAttr(root, "version", {}, &object->mVersion, param.error) &&
1228 parseOptionalAttr(root, "target-level", Level::UNSPECIFIED, &object->mLevel,
1229 param.error) &&
1230 parseChildren(root, StringKernelConfigConverter{}, &object->mConfigs, param);
1231 }
1232 };
1233
1234 struct HalManifestConverter : public XmlNodeConverter<HalManifest> {
elementNameandroid::vintf::HalManifestConverter1235 std::string elementName() const override { return "manifest"; }
mutateNodeandroid::vintf::HalManifestConverter1236 void mutateNode(const HalManifest& object, NodeType* root,
1237 const MutateNodeParam& param) const override {
1238 if (param.flags.isMetaVersionEnabled()) {
1239 // Append the current metaversion of libvintf because the XML file
1240 // is generated with libvintf @ current meta version.
1241 appendAttr(root, "version", kMetaVersion);
1242 }
1243 if (param.flags.isSchemaTypeEnabled()) {
1244 appendAttr(root, "type", object.mType);
1245 }
1246
1247 if (param.flags.isHalsEnabled()) {
1248 appendChildren(root, ManifestHalConverter{}, object.getHals(), param);
1249 }
1250 if (object.mType == SchemaType::DEVICE) {
1251 if (param.flags.isSepolicyEnabled()) {
1252 if (object.device.mSepolicyVersion != Version{}) {
1253 appendChild(root, HalManifestSepolicyConverter{}(object.device.mSepolicyVersion,
1254 param));
1255 }
1256 }
1257 if (object.mLevel != Level::UNSPECIFIED) {
1258 this->appendAttr(root, "target-level", object.mLevel);
1259 }
1260
1261 if (param.flags.isKernelEnabled()) {
1262 if (!!object.kernel()) {
1263 appendChild(root, KernelInfoConverter{}(*object.kernel(), param));
1264 }
1265 }
1266 } else if (object.mType == SchemaType::FRAMEWORK) {
1267 if (param.flags.isVndkEnabled()) {
1268 #pragma clang diagnostic push
1269 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
1270 appendChildren(root, VndkConverter{}, object.framework.mVndks, param);
1271 #pragma clang diagnostic pop
1272
1273 appendChildren(root, VendorNdkConverter{}, object.framework.mVendorNdks, param);
1274 }
1275 if (param.flags.isSsdkEnabled()) {
1276 if (!object.framework.mSystemSdk.empty()) {
1277 appendChild(root, SystemSdkConverter{}(object.framework.mSystemSdk, param));
1278 }
1279 }
1280 }
1281
1282 if (param.flags.isXmlFilesEnabled()) {
1283 appendChildren(root, ManifestXmlFileConverter{}, object.getXmlFiles(), param);
1284 }
1285 }
buildObjectandroid::vintf::HalManifestConverter1286 bool buildObject(HalManifest* object, NodeType* root,
1287 const BuildObjectParam& constParam) const override {
1288 BuildObjectParam param = constParam;
1289 if (!parseAttr(root, "version", ¶m.metaVersion, param.error)) return false;
1290 if (param.metaVersion > kMetaVersion) {
1291 *param.error = "Unrecognized manifest.version " + to_string(param.metaVersion) +
1292 " (libvintf@" + to_string(kMetaVersion) + ")";
1293 return false;
1294 }
1295 object->mSourceMetaVersion = param.metaVersion;
1296
1297 if (!parseAttr(root, "type", &object->mType, param.error)) {
1298 return false;
1299 }
1300
1301 std::vector<ManifestHal> hals;
1302 if (!parseChildren(root, ManifestHalConverter{}, &hals, param)) {
1303 return false;
1304 }
1305 for (auto&& hal : hals) {
1306 hal.setFileName(object->fileName());
1307 }
1308
1309 if (object->mType == SchemaType::DEVICE) {
1310 // tags for device hal manifest only.
1311 // <sepolicy> can be missing because it can be determined at build time, not hard-coded
1312 // in the XML file.
1313 if (!parseOptionalChild(root, HalManifestSepolicyConverter{}, {},
1314 &object->device.mSepolicyVersion, param)) {
1315 return false;
1316 }
1317
1318 if (!parseOptionalAttr(root, "target-level", Level::UNSPECIFIED, &object->mLevel,
1319 param.error)) {
1320 return false;
1321 }
1322
1323 if (!parseOptionalChild(root, KernelInfoConverter{}, &object->device.mKernel, param)) {
1324 return false;
1325 }
1326 } else if (object->mType == SchemaType::FRAMEWORK) {
1327 #pragma clang diagnostic push
1328 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
1329 if (!parseChildren(root, VndkConverter{}, &object->framework.mVndks, param)) {
1330 return false;
1331 }
1332 for (const auto& vndk : object->framework.mVndks) {
1333 if (!vndk.mVersionRange.isSingleVersion()) {
1334 *param.error = "vndk.version " + to_string(vndk.mVersionRange) +
1335 " cannot be a range for manifests";
1336 return false;
1337 }
1338 }
1339 #pragma clang diagnostic pop
1340
1341 if (!parseChildren(root, VendorNdkConverter{}, &object->framework.mVendorNdks, param)) {
1342 return false;
1343 }
1344
1345 std::set<std::string> vendorNdkVersions;
1346 for (const auto& vendorNdk : object->framework.mVendorNdks) {
1347 if (vendorNdkVersions.find(vendorNdk.version()) != vendorNdkVersions.end()) {
1348 *param.error = "Duplicated manifest.vendor-ndk.version " + vendorNdk.version();
1349 return false;
1350 }
1351 vendorNdkVersions.insert(vendorNdk.version());
1352 }
1353
1354 if (!parseOptionalChild(root, SystemSdkConverter{}, {}, &object->framework.mSystemSdk,
1355 param)) {
1356 return false;
1357 }
1358 }
1359 for (auto &&hal : hals) {
1360 std::string description{hal.name};
1361 if (!object->add(std::move(hal), param.error)) {
1362 param.error->insert(0, "Duplicated manifest.hal entry " + description + ": ");
1363 return false;
1364 }
1365 }
1366
1367 std::vector<ManifestXmlFile> xmlFiles;
1368 if (!parseChildren(root, ManifestXmlFileConverter{}, &xmlFiles, param)) {
1369 return false;
1370 }
1371 for (auto&& xmlFile : xmlFiles) {
1372 std::string description{xmlFile.name()};
1373 if (!object->addXmlFile(std::move(xmlFile))) {
1374 *param.error = "Duplicated manifest.xmlfile entry " + description +
1375 "; entries cannot have duplicated name and version";
1376 return false;
1377 }
1378 }
1379
1380 return true;
1381 }
1382 };
1383
1384 struct AvbVersionConverter : public XmlTextConverter<Version> {
elementNameandroid::vintf::AvbVersionConverter1385 std::string elementName() const override { return "vbmeta-version"; }
1386 };
1387
1388 struct AvbConverter : public XmlNodeConverter<Version> {
elementNameandroid::vintf::AvbConverter1389 std::string elementName() const override { return "avb"; }
mutateNodeandroid::vintf::AvbConverter1390 void mutateNode(const Version& object, NodeType* root,
1391 const MutateNodeParam& param) const override {
1392 appendChild(root, AvbVersionConverter{}(object, param));
1393 }
buildObjectandroid::vintf::AvbConverter1394 bool buildObject(Version* object, NodeType* root,
1395 const BuildObjectParam& param) const override {
1396 return parseChild(root, AvbVersionConverter{}, object, param);
1397 }
1398 };
1399
1400 struct MatrixXmlFileConverter : public XmlNodeConverter<MatrixXmlFile> {
elementNameandroid::vintf::MatrixXmlFileConverter1401 std::string elementName() const override { return "xmlfile"; }
mutateNodeandroid::vintf::MatrixXmlFileConverter1402 void mutateNode(const MatrixXmlFile& object, NodeType* root,
1403 const MutateNodeParam& param) const override {
1404 appendTextElement(root, "name", object.name(), param.d);
1405 appendAttr(root, "format", object.format());
1406 appendAttr(root, "optional", object.optional());
1407 appendChild(root, VersionRangeConverter{}(object.versionRange(), param));
1408 if (!object.overriddenPath().empty()) {
1409 appendTextElement(root, "path", object.overriddenPath(), param.d);
1410 }
1411 }
buildObjectandroid::vintf::MatrixXmlFileConverter1412 bool buildObject(MatrixXmlFile* object, NodeType* root,
1413 const BuildObjectParam& param) const override {
1414 if (!parseTextElement(root, "name", &object->mName, param.error) ||
1415 !parseAttr(root, "format", &object->mFormat, param.error) ||
1416 !parseOptionalAttr(root, "optional", false, &object->mOptional, param.error) ||
1417 !parseChild(root, VersionRangeConverter{}, &object->mVersionRange, param) ||
1418 !parseOptionalTextElement(root, "path", {}, &object->mOverriddenPath, param.error)) {
1419 return false;
1420 }
1421 return true;
1422 }
1423 };
1424
1425 struct CompatibilityMatrixConverter : public XmlNodeConverter<CompatibilityMatrix> {
elementNameandroid::vintf::CompatibilityMatrixConverter1426 std::string elementName() const override { return "compatibility-matrix"; }
mutateNodeandroid::vintf::CompatibilityMatrixConverter1427 void mutateNode(const CompatibilityMatrix& object, NodeType* root,
1428 const MutateNodeParam& param) const override {
1429 if (param.flags.isMetaVersionEnabled()) {
1430 appendAttr(root, "version", kMetaVersion);
1431 }
1432 if (param.flags.isSchemaTypeEnabled()) {
1433 appendAttr(root, "type", object.mType);
1434 }
1435
1436 if (param.flags.isHalsEnabled()) {
1437 appendChildren(root, MatrixHalConverter{}, iterateValues(object.mHals), param);
1438 }
1439 if (object.mType == SchemaType::FRAMEWORK) {
1440 if (param.flags.isKernelEnabled()) {
1441 appendChildren(root, MatrixKernelConverter{}, object.framework.mKernels, param);
1442 }
1443 if (param.flags.isSepolicyEnabled()) {
1444 if (!(object.framework.mSepolicy == Sepolicy{})) {
1445 appendChild(root, SepolicyConverter{}(object.framework.mSepolicy, param));
1446 }
1447 }
1448 if (param.flags.isAvbEnabled()) {
1449 if (!(object.framework.mAvbMetaVersion == Version{})) {
1450 appendChild(root, AvbConverter{}(object.framework.mAvbMetaVersion, param));
1451 }
1452 }
1453 if (object.mLevel != Level::UNSPECIFIED) {
1454 this->appendAttr(root, "level", object.mLevel);
1455 }
1456 } else if (object.mType == SchemaType::DEVICE) {
1457 if (param.flags.isVndkEnabled()) {
1458 #pragma clang diagnostic push
1459 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
1460 if (!(object.device.mVndk == Vndk{})) {
1461 appendChild(root, VndkConverter{}(object.device.mVndk, param));
1462 }
1463 #pragma clang diagnostic pop
1464
1465 if (!(object.device.mVendorNdk == VendorNdk{})) {
1466 appendChild(root, VendorNdkConverter{}(object.device.mVendorNdk, param));
1467 }
1468 }
1469
1470 if (param.flags.isSsdkEnabled()) {
1471 if (!object.device.mSystemSdk.empty()) {
1472 appendChild(root, SystemSdkConverter{}(object.device.mSystemSdk, param));
1473 }
1474 }
1475 }
1476
1477 if (param.flags.isXmlFilesEnabled()) {
1478 appendChildren(root, MatrixXmlFileConverter{}, object.getXmlFiles(), param);
1479 }
1480 }
buildObjectandroid::vintf::CompatibilityMatrixConverter1481 bool buildObject(CompatibilityMatrix* object, NodeType* root,
1482 const BuildObjectParam& constParam) const override {
1483 BuildObjectParam param = constParam;
1484 if (!parseAttr(root, "version", ¶m.metaVersion, param.error)) return false;
1485 if (param.metaVersion > kMetaVersion) {
1486 *param.error = "Unrecognized compatibility-matrix.version " +
1487 to_string(param.metaVersion) + " (libvintf@" + to_string(kMetaVersion) +
1488 ")";
1489 return false;
1490 }
1491
1492 std::vector<MatrixHal> hals;
1493 if (!parseAttr(root, "type", &object->mType, param.error) ||
1494 !parseChildren(root, MatrixHalConverter{}, &hals, param)) {
1495 return false;
1496 }
1497
1498 if (object->mType == SchemaType::FRAMEWORK) {
1499 // <avb> and <sepolicy> can be missing because it can be determined at build time, not
1500 // hard-coded in the XML file.
1501 if (!parseChildren(root, MatrixKernelConverter{}, &object->framework.mKernels, param) ||
1502 !parseOptionalChild(root, SepolicyConverter{}, {}, &object->framework.mSepolicy,
1503 param) ||
1504 !parseOptionalChild(root, AvbConverter{}, {}, &object->framework.mAvbMetaVersion,
1505 param)) {
1506 return false;
1507 }
1508
1509 std::set<Version> seenKernelVersions;
1510 for (const auto& kernel : object->framework.mKernels) {
1511 Version minLts(kernel.minLts().version, kernel.minLts().majorRev);
1512 if (seenKernelVersions.find(minLts) != seenKernelVersions.end()) {
1513 continue;
1514 }
1515 if (!kernel.conditions().empty()) {
1516 *param.error = "First <kernel> for version " + to_string(minLts) +
1517 " must have empty <conditions> for backwards compatibility.";
1518 return false;
1519 }
1520 seenKernelVersions.insert(minLts);
1521 }
1522
1523 if (!parseOptionalAttr(root, "level", Level::UNSPECIFIED, &object->mLevel,
1524 param.error)) {
1525 return false;
1526 }
1527
1528 } else if (object->mType == SchemaType::DEVICE) {
1529 // <vndk> can be missing because it can be determined at build time, not hard-coded
1530 // in the XML file.
1531 #pragma clang diagnostic push
1532 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
1533 if (!parseOptionalChild(root, VndkConverter{}, {}, &object->device.mVndk, param)) {
1534 return false;
1535 }
1536 #pragma clang diagnostic pop
1537
1538 if (!parseOptionalChild(root, VendorNdkConverter{}, {}, &object->device.mVendorNdk,
1539 param)) {
1540 return false;
1541 }
1542
1543 if (!parseOptionalChild(root, SystemSdkConverter{}, {}, &object->device.mSystemSdk,
1544 param)) {
1545 return false;
1546 }
1547 }
1548
1549 for (auto &&hal : hals) {
1550 if (!object->add(std::move(hal))) {
1551 *param.error = "Duplicated compatibility-matrix.hal entry";
1552 return false;
1553 }
1554 }
1555
1556 std::vector<MatrixXmlFile> xmlFiles;
1557 if (!parseChildren(root, MatrixXmlFileConverter{}, &xmlFiles, param)) {
1558 return false;
1559 }
1560 for (auto&& xmlFile : xmlFiles) {
1561 if (!xmlFile.optional()) {
1562 *param.error = "compatibility-matrix.xmlfile entry " + xmlFile.name() +
1563 " has to be optional for compatibility matrix version 1.0";
1564 return false;
1565 }
1566 std::string description{xmlFile.name()};
1567 if (!object->addXmlFile(std::move(xmlFile))) {
1568 *param.error = "Duplicated compatibility-matrix.xmlfile entry " + description;
1569 return false;
1570 }
1571 }
1572
1573 return true;
1574 }
1575 };
1576
1577 #define CREATE_CONVERT_FN(type) \
1578 std::string toXml(const type& o, SerializeFlags::Type flags) { \
1579 return type##Converter{}.toXml(o, flags); \
1580 } \
1581 bool fromXml(type* o, const std::string& xml, std::string* error) { \
1582 return type##Converter{}.fromXml(o, xml, error); \
1583 }
1584
1585 // Create convert functions for public usage.
1586 CREATE_CONVERT_FN(HalManifest)
1587 CREATE_CONVERT_FN(CompatibilityMatrix)
1588
1589 // Create convert functions for internal usage.
1590 CREATE_CONVERT_FN(KernelInfo)
1591
1592 // Create convert functions for testing.
1593 CREATE_CONVERT_FN(Version)
1594 CREATE_CONVERT_FN(KernelConfigTypedValue)
1595 CREATE_CONVERT_FN(MatrixHal)
1596 CREATE_CONVERT_FN(ManifestHal)
1597
1598 #undef CREATE_CONVERT_FN
1599
1600 } // namespace vintf
1601 } // namespace android
1602