| // Copyright 2019 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "libipp/ipp_parser.h" |
| #include <set> |
| |
| #include "libipp/frame.h" |
| #include "libipp/ipp_encoding.h" |
| |
| namespace ipp { |
| |
| namespace { |
| |
| // This parameter defines how deep can be a package with recursive collections. |
| // A collection placed directly in attributes group has level 1, each |
| // sub-collection belonging directly to it has level 2 etc.. |
| constexpr int kMaxCollectionLevel = 16; |
| |
| // Decodes 1-, 2- or 4-bytes integers (two's-complement binary encoding). |
| // Returns false if (data.size() != BytesCount) or (out == nullptr). |
| template <size_t BytesCount> |
| bool LoadInteger(const std::vector<uint8_t>& data, int32_t* out) { |
| if ((data.size() != BytesCount) || (out == nullptr)) |
| return false; |
| const uint8_t* ptr = data.data(); |
| ParseSignedInteger<BytesCount>(&ptr, out); |
| return true; |
| } |
| |
| // Reads simple string from buf. |
| std::string LoadString(const std::vector<uint8_t>& buf) { |
| return std::string(buf.data(), buf.data() + buf.size()); |
| } |
| |
| // Reads textWithLanguage/nameWithLanguage (see [rfc8010], section 3.9) from |
| // buf. Returns false if given content is invalid or (out == nullptr). |
| bool LoadStringWithLanguage(const std::vector<uint8_t>& buf, |
| ipp::StringWithLanguage* out) { |
| // The shortest possible value has 4 bytes: 2 times 2-bytes zero. |
| if ((buf.size() < 4) || (out == nullptr)) |
| return false; |
| const uint8_t* ptr = buf.data(); |
| size_t length; |
| if (!ParseUnsignedInteger<2>(&ptr, &length)) |
| return false; |
| if (buf.size() < 4 + length) |
| return false; |
| out->language.assign(ptr, ptr + length); |
| ptr += length; |
| if (!ParseUnsignedInteger<2>(&ptr, &length)) |
| return false; |
| if (buf.size() != 4 + out->language.size() + length) |
| return false; |
| out->value.assign(ptr, ptr + length); |
| return true; |
| } |
| |
| // Reads dateTime (see [rfc8010]) from buf. |
| // Fails when binary representation has invalid size or (out == nullptr). |
| bool LoadDateTime(const std::vector<uint8_t>& buf, ipp::DateTime* out) { |
| if ((buf.size() != 11) || (out == nullptr)) |
| return false; |
| const uint8_t* ptr = buf.data(); |
| return (ParseUnsignedInteger<2>(&ptr, &out->year) && |
| ParseUnsignedInteger<1>(&ptr, &out->month) && |
| ParseUnsignedInteger<1>(&ptr, &out->day) && |
| ParseUnsignedInteger<1>(&ptr, &out->hour) && |
| ParseUnsignedInteger<1>(&ptr, &out->minutes) && |
| ParseUnsignedInteger<1>(&ptr, &out->seconds) && |
| ParseUnsignedInteger<1>(&ptr, &out->deci_seconds) && |
| ParseUnsignedInteger<1>(&ptr, &out->UTC_direction) && |
| ParseUnsignedInteger<1>(&ptr, &out->UTC_hours) && |
| ParseUnsignedInteger<1>(&ptr, &out->UTC_minutes)); |
| } |
| |
| // Reads resolution (see [rfc8010]) from buf. |
| // Fails when binary representation has invalid size or (out == nullptr). |
| bool LoadResolution(const std::vector<uint8_t>& buf, ipp::Resolution* out) { |
| if ((buf.size() != 9) || (out == nullptr)) |
| return false; |
| const uint8_t* ptr = buf.data(); |
| ParseSignedInteger<4>(&ptr, &out->xres); |
| ParseSignedInteger<4>(&ptr, &out->yres); |
| int8_t units; |
| ParseSignedInteger<1>(&ptr, &units); |
| out->units = static_cast<Resolution::Units>(units); |
| return true; |
| } |
| |
| // Reads rangeOfInteger (see [rfc8010]) from buf. |
| // Fails when binary representation has invalid size or (out == nullptr). |
| bool LoadRangeOfInteger(const std::vector<uint8_t>& buf, |
| ipp::RangeOfInteger* out) { |
| if ((buf.size() != 8) || (out == nullptr)) |
| return false; |
| const uint8_t* ptr = buf.data(); |
| ParseSignedInteger<4>(&ptr, &out->min_value); |
| ParseSignedInteger<4>(&ptr, &out->max_value); |
| return true; |
| } |
| |
| // Scope guard to control the context path. Constructor adds new a element to |
| // the path while destructor removes it from the path. |
| class ContextPathGuard { |
| public: |
| ContextPathGuard(AttrPath* path, uint16_t index) : path_(path) { |
| path_->PushBack(index, ""); |
| } |
| ~ContextPathGuard() { path_->PopBack(); } |
| |
| private: |
| ContextPathGuard(const ContextPathGuard&) = delete; |
| ContextPathGuard(ContextPathGuard&&) = delete; |
| ContextPathGuard& operator=(const ContextPathGuard&) = delete; |
| ContextPathGuard& operator=(ContextPathGuard&&) = delete; |
| AttrPath* path_; |
| }; |
| |
| // Return true if source type can be used in attribute of target type. |
| bool IsConvertibleTo(const ipp::ValueTag source, const ipp::ValueTag target) { |
| if (source == target) |
| return true; |
| if (source == ipp::ValueTag::integer && |
| target == ipp::ValueTag::rangeOfInteger) |
| return true; |
| if (source == ipp::ValueTag::integer && target == ipp::ValueTag::enum_) |
| return true; |
| if (source == ipp::ValueTag::nameWithoutLanguage && |
| target == ipp::ValueTag::nameWithLanguage) |
| return true; |
| if (source == ipp::ValueTag::textWithoutLanguage && |
| target == ipp::ValueTag::textWithLanguage) |
| return true; |
| return false; |
| } |
| |
| // Parses two bytes from `ptr` and move it forward by 2 bytes. |
| uint16_t ParseUInt16(const uint8_t*& ptr) { |
| uint16_t val = *ptr; |
| val <<= 8; |
| val += *++ptr; |
| ++ptr; |
| return val; |
| } |
| |
| } // namespace |
| |
| void Parser::LogParserError(ParserCode error_code, const uint8_t* ptr) { |
| ssize_t buf_offset = -1; |
| if (ptr != nullptr && ptr >= buffer_begin_ && ptr <= buffer_end_) { |
| // Current position in the buffer. |
| buf_offset = ptr - buffer_begin_; |
| } |
| log_->AddParserError({parser_context_, error_code, buf_offset}); |
| } |
| |
| void Parser::LogParserErrors(const std::vector<ParserCode>& error_codes) { |
| for (ParserCode error_code : error_codes) { |
| LogParserError(error_code); |
| } |
| } |
| |
| // Temporary representation of an attribute's value parsed from TNVs. |
| struct RawValue { |
| // original tag (IsValid(tag)) |
| ValueTag tag; |
| // original data, empty when (tag == collection), content not verified |
| std::vector<uint8_t> data; |
| // (not nullptr) <=> (tag == collection) |
| std::unique_ptr<RawCollection> collection; |
| // create as standard value |
| RawValue(ValueTag tag, const std::vector<uint8_t>& data) |
| : tag(tag), data(data) {} |
| // create as collection |
| explicit RawValue(RawCollection* coll) |
| : tag(ValueTag::collection), collection(coll) {} |
| }; |
| |
| struct RawCollection; |
| |
| // Temporary representation of an attribute parsed from TNVs. |
| struct RawAttribute { |
| // verified (non-empty) |
| std::string name; |
| // parsed values (see RawValue) |
| std::vector<RawValue> values; |
| explicit RawAttribute(const std::string& name) : name(name) {} |
| }; |
| |
| // Temporary representation of a collection parsed from TNVs. |
| struct RawCollection { |
| // parsed attributes (may have duplicate names) |
| std::vector<RawAttribute> attributes; |
| }; |
| |
| // Parse a value of type `attr_type` from `raw_value` to `output` when possible. |
| // Returns true <=> parsing was successful. All spotted errors are added to |
| // `errors`. |
| template <typename ApiType> |
| bool LoadAttrValue(ValueTag attr_type, |
| const RawValue& raw_value, |
| ApiType& output, |
| std::vector<ParserCode>& errors); |
| |
| template <> |
| bool LoadAttrValue<std::string>(ValueTag attr_type, |
| const RawValue& raw_value, |
| std::string& output, |
| std::vector<ParserCode>& errors) { |
| if (!IsString(raw_value.tag) && raw_value.tag != ValueTag::octetString) { |
| errors.push_back(ParserCode::kValueMismatchTagOmitted); |
| return false; |
| } |
| output = LoadString(raw_value.data); |
| if (attr_type != raw_value.tag) |
| errors.push_back(ParserCode::kValueMismatchTagConverted); |
| return true; |
| } |
| |
| template <> |
| bool LoadAttrValue<int32_t>(ValueTag attr_type, |
| const RawValue& raw_value, |
| int32_t& output, |
| std::vector<ParserCode>& errors) { |
| switch (raw_value.tag) { |
| case ValueTag::boolean: { |
| if (!LoadInteger<1>(raw_value.data, &output)) { |
| errors.push_back(ParserCode::kValueInvalidSize); |
| return false; |
| } |
| if (attr_type != ValueTag::boolean) { |
| errors.push_back(ParserCode::kValueMismatchTagConverted); |
| } |
| if (output < 0 || output > 1) { |
| output = 1; |
| errors.push_back(ParserCode::kBooleanValueOutOfRange); |
| } |
| return true; |
| } |
| case ValueTag::integer: |
| case ValueTag::enum_: { |
| if (!LoadInteger<4>(raw_value.data, &output)) { |
| errors.push_back(ParserCode::kValueInvalidSize); |
| return false; |
| } |
| if (attr_type != raw_value.tag) { |
| errors.push_back(ParserCode::kValueMismatchTagConverted); |
| } |
| return true; |
| } |
| default: |
| errors.push_back(ParserCode::kValueMismatchTagOmitted); |
| return false; |
| } |
| } |
| |
| template <> |
| bool LoadAttrValue<DateTime>(ValueTag attr_type, |
| const RawValue& raw_value, |
| DateTime& output, |
| std::vector<ParserCode>& errors) { |
| if (raw_value.tag != ValueTag::dateTime) { |
| errors.push_back(ParserCode::kValueMismatchTagOmitted); |
| return false; |
| } |
| if (!LoadDateTime(raw_value.data, &output)) { |
| errors.push_back(ParserCode::kValueInvalidSize); |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool LoadAttrValue<Resolution>(ValueTag attr_type, |
| const RawValue& raw_value, |
| Resolution& output, |
| std::vector<ParserCode>& errors) { |
| if (raw_value.tag != ValueTag::resolution) { |
| errors.push_back(ParserCode::kValueMismatchTagOmitted); |
| return false; |
| } |
| if (!LoadResolution(raw_value.data, &output)) { |
| errors.push_back(ParserCode::kValueInvalidSize); |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool LoadAttrValue<RangeOfInteger>(ValueTag attr_type, |
| const RawValue& raw_value, |
| RangeOfInteger& output, |
| std::vector<ParserCode>& errors) { |
| if (raw_value.tag == ValueTag::integer) { |
| if (!LoadInteger<4>(raw_value.data, &output.min_value)) { |
| errors.push_back(ParserCode::kValueInvalidSize); |
| return false; |
| } |
| output.max_value = output.min_value; |
| return true; |
| } |
| if (raw_value.tag != ValueTag::rangeOfInteger) { |
| errors.push_back(ParserCode::kValueMismatchTagOmitted); |
| return false; |
| } |
| if (!LoadRangeOfInteger(raw_value.data, &output)) { |
| errors.push_back(ParserCode::kValueInvalidSize); |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool LoadAttrValue<StringWithLanguage>(ValueTag attr_type, |
| const RawValue& raw_value, |
| StringWithLanguage& output, |
| std::vector<ParserCode>& errors) { |
| if (raw_value.tag == ValueTag::nameWithLanguage || |
| raw_value.tag == ValueTag::textWithLanguage) { |
| if (!LoadStringWithLanguage(raw_value.data, &output)) { |
| errors.push_back(ParserCode::kValueInvalidSize); |
| return false; |
| } |
| if (raw_value.tag != attr_type) { |
| errors.push_back(ParserCode::kValueMismatchTagConverted); |
| } |
| return true; |
| } |
| if (IsString(raw_value.tag)) { |
| output.language.clear(); |
| output.value = LoadString(raw_value.data); |
| if (raw_value.tag == ValueTag::nameWithoutLanguage && |
| attr_type != ValueTag::nameWithLanguage) { |
| errors.push_back(ParserCode::kValueMismatchTagConverted); |
| } |
| if (raw_value.tag == ValueTag::textWithoutLanguage && |
| attr_type != ValueTag::textWithLanguage) { |
| errors.push_back(ParserCode::kValueMismatchTagConverted); |
| } |
| return true; |
| } |
| errors.push_back(ParserCode::kValueMismatchTagOmitted); |
| return false; |
| } |
| |
| // Parse an attribute of type `attr_type` from `raw_attr` and add it to `coll` |
| // when possible. Return a list of parser errors. `coll` must not be nullptr. |
| template <typename ApiType> |
| std::vector<ParserCode> LoadAttrValues(Collection* coll, |
| ValueTag attr_type, |
| const RawAttribute& raw_attr) { |
| std::vector<ParserCode> errors; |
| std::vector<ApiType> vals; |
| vals.reserve(raw_attr.values.size()); |
| for (const RawValue& raw_value : raw_attr.values) { |
| ApiType val; |
| if (LoadAttrValue<ApiType>(attr_type, raw_value, val, errors)) { |
| vals.push_back(std::move(val)); |
| } |
| } |
| if (vals.empty()) { |
| errors.push_back(ParserCode::kAttributeNoValues); |
| } else { |
| const Code err = coll->AddAttr(raw_attr.name, attr_type, vals); |
| if (err != Code::kOK) { |
| errors.push_back(ParserCode::kErrorWhenAddingAttribute); |
| } |
| } |
| return errors; |
| } |
| |
| bool Parser::SaveFrameToPackage(Frame* package) { |
| for (size_t i = 0; i < frame_->groups_tags_.size(); ++i) { |
| GroupTag gn = frame_->groups_tags_[i]; |
| parser_context_ = AttrPath(gn); |
| parser_context_.PushBack(package->Groups(gn).size(), ""); |
| CollsView::iterator coll; |
| Code err = package->AddGroup(gn, coll); |
| if (err != Code::kOK) { |
| LogParserError(ParserCode::kErrorWhenAddingGroup); |
| continue; |
| } |
| RawCollection raw_coll; |
| if (!ParseRawGroup(&(frame_->groups_content_[i]), &raw_coll)) { |
| return false; |
| } |
| DecodeCollection(&raw_coll, &*coll); |
| } |
| package->SetData(std::move(frame_->data_)); |
| return true; |
| } |
| |
| bool Parser::ReadFrameFromBuffer(const uint8_t* ptr, |
| const uint8_t* const buf_end) { |
| parser_context_ = AttrPath(AttrPath::kHeader); |
| buffer_begin_ = ptr; |
| buffer_end_ = buf_end; |
| if (buf_end - ptr < 9) { |
| LogParserError(ParserCode::kUnexpectedEndOfFrame, ptr); |
| return false; |
| } |
| frame_->version_ = ParseUInt16(ptr); |
| ParseSignedInteger<2>(&ptr, &frame_->operation_id_or_status_code_); |
| ParseSignedInteger<4>(&ptr, &frame_->request_id_); |
| while (*ptr != end_of_attributes_tag) { |
| GroupTag group_tag = static_cast<GroupTag>(*ptr); |
| parser_context_ = AttrPath(group_tag); |
| if (!IsValid(group_tag)) { |
| // begin-attribute-group-tag was expected. |
| LogParserError(ParserCode::kGroupTagWasExpected, ptr); |
| return false; |
| } |
| if (frame_->groups_tags_.size() >= kMaxCountOfAttributeGroups) { |
| LogParserError(ParserCode::kLimitOnGroupsCountExceeded, ptr); |
| return false; |
| } |
| frame_->groups_tags_.push_back(group_tag); |
| frame_->groups_content_.resize(frame_->groups_tags_.size()); |
| ++ptr; |
| if (!ReadTNVsFromBuffer(&ptr, buf_end, &(frame_->groups_content_.back()))) |
| return false; |
| if (ptr >= buf_end) { |
| // begin-attribute-group-tag or end-of-attributes-tag was expected. |
| LogParserError(ParserCode::kUnexpectedEndOfFrame); |
| return false; |
| } |
| } |
| ++ptr; |
| frame_->data_.assign(ptr, buf_end); |
| ptr = buf_end; |
| return true; |
| } |
| |
| // Parses TNVs from given buffer until the end of the buffer is reached or next |
| // begin-attribute-group-tag is spotted. The pointer ptr is shifted accordingly. |
| // returns true <=> (ptr == buf_end) or (*ptr is begin-attribute-group-tag) |
| // returns false <=> parsing error occurs, ptr points to incorrect field |
| // Parsed TNVs are added to the end of |tnvs|. If |tnvs| is nullptr then no |
| // output is saved but parsing occurs as usual. |
| bool Parser::ReadTNVsFromBuffer(const uint8_t** ptr2, |
| const uint8_t* const buf_end, |
| std::list<TagNameValue>* tnvs) { |
| const uint8_t*& ptr = *ptr2; |
| while ((ptr < buf_end) && (*ptr > max_begin_attribute_group_tag)) { |
| TagNameValue tnv; |
| |
| if (buf_end - ptr < 5) { |
| // Expected at least 1-byte tag, 2-bytes name-length and 2-bytes |
| // value-length. |
| LogParserError(ParserCode::kUnexpectedEndOfFrame, ptr); |
| return false; |
| } |
| // *ptr is a ValueTag because it was already checked in while (...) |
| tnv.tag = *ptr; |
| ++ptr; |
| int length = 0; |
| if (!ParseUnsignedInteger<2>(&ptr, &length)) { |
| LogParserError(ParserCode::kNegativeNameLengthInTNV, ptr); |
| return false; |
| } |
| if (buf_end - ptr < length + 2) { |
| // Expected at least `length`-bytes name and 2-bytes value-length. |
| LogParserError(ParserCode::kUnexpectedEndOfFrame, ptr); |
| return false; |
| } |
| tnv.name.assign(ptr, ptr + length); |
| ptr += length; |
| if (!ParseUnsignedInteger<2>(&ptr, &length)) { |
| LogParserError(ParserCode::kNegativeValueLengthInTNV, ptr); |
| return false; |
| } |
| if (buf_end - ptr < length) { |
| LogParserError(ParserCode::kUnexpectedEndOfFrame, ptr); |
| return false; |
| } |
| tnv.value.assign(ptr, ptr + length); |
| ptr += length; |
| if (tnvs != nullptr) |
| tnvs->push_back(std::move(tnv)); |
| } |
| return true; |
| } |
| |
| void Parser::ResetContent() { |
| buffer_begin_ = nullptr; |
| buffer_end_ = nullptr; |
| parser_context_ = AttrPath(AttrPath::kHeader); |
| } |
| |
| // Parses single attribute's value and add it to |attr|. |tnv| is the first TNV |
| // with the value, |tnvs| contains all following TNVs. Both |tnvs| and |attr| |
| // cannot be nullptr. |coll_level| denotes how "deep" is the collection that |
| // contains the attribute; attributes defined directly in the attributes group |
| // have level 0. Returns false <=> critical parsing error was spotted. |
| // See section 3.5.2 from rfc8010 for details. |
| bool Parser::ParseRawValue(int coll_level, |
| const TagNameValue& tnv, |
| std::list<TagNameValue>* tnvs, |
| RawAttribute* attr) { |
| // Is it correct attribute's value tag? If not then fail. |
| if (tnv.tag == endCollection_value_tag || |
| tnv.tag == memberAttrName_value_tag) { |
| LogParserError(ParserCode::kTNVWithUnexpectedValueTag); |
| return false; |
| } |
| // Is it a collection ? |
| if (tnv.tag == begCollection_value_tag) { |
| ContextPathGuard path_update(&parser_context_, attr->values.size()); |
| if (!tnv.value.empty()) { |
| LogParserError(ParserCode::kEmptyValueExpectedInTNV); |
| return false; |
| } |
| std::unique_ptr<RawCollection> coll(new RawCollection); |
| if (!ParseRawCollection(coll_level + 1, tnvs, coll.get())) |
| return false; |
| attr->values.emplace_back(coll.release()); |
| return true; |
| } |
| ValueTag type = static_cast<ValueTag>(tnv.tag); |
| if (!IsValid(type)) { |
| // unknown attribute's syntax |
| LogParserError(ParserCode::kUnsupportedValueTag); |
| return true; |
| } |
| attr->values.emplace_back(type, tnv.value); |
| return true; |
| } |
| |
| // Parses single collections from given TNVs. |coll_level| denotes how "deep" |
| // the collection is; collections defined directly in the attributes group |
| // have level 1. Both |tnvs| and |coll| cannot be nullptr. |
| // Returns false <=> critical parsing error was spotted. |
| bool Parser::ParseRawCollection(int coll_level, |
| std::list<TagNameValue>* tnvs, |
| RawCollection* coll) { |
| if (coll_level > kMaxCollectionLevel) { |
| LogParserError(ParserCode::kLimitOnCollectionsLevelExceeded); |
| return false; |
| } |
| while (true) { |
| if (tnvs->empty()) { |
| LogParserError(ParserCode::kUnexpectedEndOfGroup); |
| return false; |
| } |
| TagNameValue tnv = tnvs->front(); |
| tnvs->pop_front(); |
| // exit if the end of the collection was reached |
| if (tnv.tag == endCollection_value_tag) { |
| if (!tnv.name.empty()) { |
| LogParserError(ParserCode::kEmptyNameExpectedInTNV); |
| return false; |
| } |
| if (!tnv.value.empty()) { |
| LogParserError(ParserCode::kEmptyValueExpectedInTNV); |
| return false; |
| } |
| return true; |
| } |
| // still here, so we parse an attribute (collection's member) |
| if (tnv.tag != memberAttrName_value_tag) { |
| LogParserError(ParserCode::kTNVWithUnexpectedValueTag); |
| return false; |
| } |
| // parse name & create attribute |
| const std::string name = LoadString(tnv.value); |
| parser_context_.Back().attribute_name = name; |
| if (!tnv.name.empty()) { |
| LogParserError(ParserCode::kEmptyNameExpectedInTNV); |
| return false; |
| } |
| if (name.empty()) { |
| LogParserErrors({ParserCode::kAttributeNameIsEmpty}); |
| return false; |
| } |
| coll->attributes.emplace_back(name); |
| RawAttribute* attr = &coll->attributes.back(); |
| // parse tag |
| if (tnvs->empty()) { |
| LogParserError(ParserCode::kUnexpectedEndOfGroup); |
| return false; |
| } |
| // parse all values |
| while (!tnvs->empty() && tnvs->front().tag != endCollection_value_tag && |
| tnvs->front().tag != memberAttrName_value_tag) { |
| tnv = tnvs->front(); |
| tnvs->pop_front(); |
| if (!tnv.name.empty()) { |
| LogParserError(ParserCode::kEmptyNameExpectedInTNV); |
| return false; |
| } |
| if (!ParseRawValue(coll_level, tnv, tnvs, attr)) |
| return false; |
| } |
| } |
| } |
| |
| // Parses attributes group from given TNVs and saves it to |coll|. Both |tnvs| |
| // and |coll| cannot be nullptr. Returns false <=> critical parsing error was |
| // spotted. |
| bool Parser::ParseRawGroup(std::list<TagNameValue>* tnvs, RawCollection* coll) { |
| while (!tnvs->empty()) { |
| TagNameValue tnv = tnvs->front(); |
| tnvs->pop_front(); |
| // parse name & create attribute |
| const std::string name = LoadString(tnv.name); |
| parser_context_.Back().attribute_name = name; |
| if (name.empty()) { |
| LogParserErrors({ParserCode::kAttributeNameIsEmpty}); |
| return false; |
| } |
| coll->attributes.emplace_back(name); |
| RawAttribute* attr = &coll->attributes.back(); |
| // parse all values |
| while (true) { |
| // parse value |
| if (!ParseRawValue(0 /*collection level*/, tnv, tnvs, attr)) |
| return false; |
| // go to the next value or attribute |
| if (tnvs->empty() || !tnvs->front().name.empty()) |
| break; // end of the attribute |
| // next value |
| tnv = tnvs->front(); |
| tnvs->pop_front(); |
| } |
| } |
| return true; |
| } |
| |
| // Converts a collection/group saved in |raw_coll| to |coll|. Both |raw_coll| |
| // and |coll| must not be nullptr. |
| void Parser::DecodeCollection(RawCollection* raw_coll, Collection* coll) { |
| for (RawAttribute& raw_attr : raw_coll->attributes) { |
| // Tries to match the attribute to existing one by name. |
| parser_context_.Back().attribute_name = raw_attr.name; |
| if (coll->GetAttr(raw_attr.name) != coll->end()) { |
| // The attribute exists. |
| LogParserErrors({ParserCode::kAttributeNameConflict}); |
| continue; |
| } |
| |
| if (raw_attr.values.empty()) { |
| LogParserErrors({ParserCode::kAttributeNoValues}); |
| continue; |
| } |
| |
| // Tries to detect an attribute's type. |
| ValueTag detected_type = raw_attr.values.front().tag; |
| for (auto& raw_val : raw_attr.values) |
| if (IsConvertibleTo(detected_type, raw_val.tag)) |
| detected_type = raw_val.tag; |
| |
| // Is it an attribute with Ouf-Of-Band value? Then set it and finish. |
| if (IsOutOfBand(detected_type)) { |
| if (raw_attr.values.size() > 1) { |
| LogParserError(ParserCode::kOutOfBandAttributeWithManyValues); |
| } |
| if (!raw_attr.values.front().data.empty()) { |
| LogParserError(ParserCode::kOutOfBandValueWithNonEmptyData); |
| } |
| const Code err = coll->AddAttr(raw_attr.name, detected_type); |
| if (err != Code::kOK) { |
| LogParserErrors({ParserCode::kErrorWhenAddingAttribute}); |
| } |
| continue; |
| } |
| |
| // It is a collection? |
| if (detected_type == ValueTag::collection) { |
| std::vector<ParserCode> errors; |
| std::vector<RawCollection*> raw_colls; |
| raw_colls.reserve(raw_attr.values.size()); |
| for (const RawValue& raw_value : raw_attr.values) { |
| if (raw_value.collection) { |
| raw_colls.push_back(raw_value.collection.get()); |
| } else { |
| errors.push_back(ParserCode::kValueMismatchTagOmitted); |
| } |
| } |
| CollsView colls; |
| Code err = coll->AddAttr(raw_attr.name, raw_colls.size(), colls); |
| if (err == Code::kOK) { |
| for (size_t i = 0; i < colls.size(); ++i) { |
| ContextPathGuard path_update(&parser_context_, i); |
| DecodeCollection(raw_colls[i], &colls[i]); |
| } |
| } else { |
| errors.push_back(ParserCode::kErrorWhenAddingAttribute); |
| } |
| LogParserErrors(errors); |
| continue; |
| } |
| |
| // It is an attribute with standard values. Parse the values and create |
| // a new attribute. |
| if (IsInteger(detected_type)) { |
| LogParserErrors(LoadAttrValues<int32_t>(coll, detected_type, raw_attr)); |
| continue; |
| } |
| if (IsString(detected_type) || detected_type == ValueTag::octetString) { |
| LogParserErrors( |
| LoadAttrValues<std::string>(coll, detected_type, raw_attr)); |
| continue; |
| } |
| switch (detected_type) { |
| case ValueTag::dateTime: |
| LogParserErrors( |
| LoadAttrValues<DateTime>(coll, detected_type, raw_attr)); |
| break; |
| case ValueTag::resolution: |
| LogParserErrors( |
| LoadAttrValues<Resolution>(coll, detected_type, raw_attr)); |
| break; |
| case ValueTag::rangeOfInteger: |
| LogParserErrors( |
| LoadAttrValues<RangeOfInteger>(coll, detected_type, raw_attr)); |
| break; |
| case ValueTag::nameWithLanguage: |
| case ValueTag::textWithLanguage: |
| LogParserErrors( |
| LoadAttrValues<StringWithLanguage>(coll, detected_type, raw_attr)); |
| break; |
| default: |
| LogParserErrors({ParserCode::kErrorWhenAddingAttribute}); |
| break; |
| } |
| } |
| } |
| |
| } // namespace ipp |
