From 51342eb4206998b74615f3a7956ffb584a03e1a1 Mon Sep 17 00:00:00 2001 From: Adrian Szyndela Date: Wed, 28 Oct 2020 10:11:29 +0100 Subject: [PATCH] serialization: use new interface for operations Change-Id: Idfd52382dd4b3acd4d158d7604468e9fcc297a9b --- src/internal/storage_backend_flatbuffers.cpp | 149 +++++++++++++++------------ src/internal/storage_backend_flatbuffers.hpp | 4 +- 2 files changed, 87 insertions(+), 66 deletions(-) diff --git a/src/internal/storage_backend_flatbuffers.cpp b/src/internal/storage_backend_flatbuffers.cpp index 6aedb60..07b1213 100644 --- a/src/internal/storage_backend_flatbuffers.cpp +++ b/src/internal/storage_backend_flatbuffers.cpp @@ -41,30 +41,31 @@ ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::makeDecisionItem(const D } boost::string_ref StorageBackendFlatbuffers::toStringRef(const flatbuffers::String *str) const { - return boost::string_ref(str->c_str(), str->size()); + return boost::string_ref(stringGetCStr(str), stringGetSize(str)); } template bool StorageBackendFlatbuffers::match(const T &match, const I *i) const { - return match.match(makeMessageType(i->type()), - toStringRef(i->interface()), - toStringRef(i->path()), - toStringRef(i->member()), - toStringRef(i->name()), - i->is_name_prefix(), - makeDecision(i->decision()->decision())); + return match.match(makeMessageType(itemSrGetMessageType(i)), + toStringRef(itemSrGetInterface(i)), + toStringRef(itemSrGetPath(i)), + toStringRef(itemSrGetMember(i)), + toStringRef(itemSrGetName(i)), + itemSrGetIsNamePrefix(i), + makeDecision(decisionItemGetDecision(itemGetDecisionItem(i)))); } bool StorageBackendFlatbuffers::match(const ldp_xml_parser::MatchItemAccess &match, const FB::ItemAccess *item) const { - return match.match(makeBusAccessType(item->type()), item->uid(), item->gid()); + return match.match(makeBusAccessType(itemAccessGetType(item)), itemAccessGetUid(item), itemAccessGetGid(item)); } template ::policy_type> ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItem(const T &item, const P *policy) const { - const auto *v = policy->items(); - for (auto it = v->rbegin(); it != v->rend(); ++it) { - if (match(item, *it)) - return makeDecisionItem((*it)->decision()); + const auto *v = policyGetItems(policy); + auto rend = containerGetReverseIteratorEnd(v); + for (auto rit = containerGetReverseIterator(v); rit != rend; ++rit) { + if (match(item, *rit)) + return makeDecisionItem(itemGetDecisionItem(*rit)); } return ldp_xml_parser::Decision::ANY; } @@ -73,20 +74,25 @@ auto StorageBackendFlatbuffers::getDecisionItemFromTree(const FB::PolicyOwnNode const tokenizer::iterator &tokens_end, tokenizer::iterator &iterator) const { if (iterator == tokens_end) { - if (node->decision_item()->decision() != Decision_ANY) - return node->decision_item(); + if (makeDecision(decisionItemGetDecision(ownNodeGetDecisionItem(node))) != ldp_xml_parser::Decision::ANY) + return ownNodeGetDecisionItem(node); else - return node->prefix_decision_item(); + return ownNodeGetPrefixDecisionItem(node); } - auto child = node->children()->LookupByKey(iterator->c_str()); - if (nullptr == child) - return node->prefix_decision_item(); + auto children = ownNodeGetChildren(node); + + if (containerEmpty(children)) + return ownNodeGetPrefixDecisionItem(node); + + auto child = containerLookupByKey(children, iterator->c_str()); + if (!child.first) + return ownNodeGetPrefixDecisionItem(node); ++iterator; - const DecisionItem *child_decision = getDecisionItemFromTree(child, tokens_end, iterator); - if (child_decision->decision() == Decision_ANY) - return node->prefix_decision_item(); + auto child_decision = getDecisionItemFromTree(child.second, tokens_end, iterator); + if (makeDecision(decisionItemGetDecision(child_decision)) == ldp_xml_parser::Decision::ANY) + return ownNodeGetPrefixDecisionItem(node); return child_decision; } @@ -100,69 +106,73 @@ ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItem(const ld boost::char_separator separator("."); tokenizer tokens(item.getName(), separator); - auto node = policy->tree(); - if (nullptr == node) - return ldp_xml_parser::Decision::ANY; - auto iterator = tokens.begin(); - return makeDecisionItem(getDecisionItemFromTree(node, tokens.end(), iterator)); + return makeDecisionItem(getDecisionItemFromTree(policyGetTree(policy), tokens.end(), iterator)); } -template ::policy_type> -ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemMaybeNull(const T &item, const P *policyPair) const { - if (nullptr == policyPair) +template +ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItem(const MatchItem &item, const Map &map, id_t id) const { + if (containerEmpty(map)) return ldp_xml_parser::Decision::ANY; - return getDecisionItem(item, policyPair->policy()); + + auto elem = containerLookupByKey(map, id); + if (!elem.first) + return ldp_xml_parser::Decision::ANY; + return getDecisionItem(item, setUserGroupGetPolicy(elem.second)); } ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemFromSendIndex(const MatchItemSend &item, const FB::PolicySend *policy) const { - const auto *index = policy->index(); - - if (!index || index->size() == 0) // this indicates version earlier than LDP2 + if (!policyHasIndex(policy)) return getDecisionItem(item, policy); // make it old way for old databases - std::pair currentBest(nullptr, 0); + auto index = policyGetIndex(policy); - auto updateCurrentBest = [&](const flatbuffers::Vector *vec) { + uint32_t currentBest = 0; + + auto updateCurrentBest = [¤tBest, &item, &policy, this](const auto &vec) { // look from the back, the rule is the same as for the full database // we now only check among less elements, because the database is indexed to small lists // item_scores are in increasing order in the index, and they serve also as ids of the policy rules - for (auto item_score_it = vec->rbegin(); item_score_it != vec->rend(); item_score_it++) { - const auto *fb_item = policy->items()->Get(*item_score_it - 1); // rules are indexed/scored from 1 - if (*item_score_it > currentBest.second && match(item, fb_item)) { - currentBest.first = fb_item; - currentBest.second = *item_score_it; + for (auto item_score_it = containerGetReverseIterator(vec); + item_score_it != containerGetReverseIteratorEnd(vec); + item_score_it++) { + auto db_items = policyGetItems(policy); + auto db_item = containerLookupByIndex(db_items, *item_score_it - 1); // rules are indexed/scored from 1 + if (*item_score_it > currentBest && match(item, db_item)) { + currentBest = *item_score_it; return; - } else if (*item_score_it <= currentBest.second) { + } else if (*item_score_it <= currentBest) { // there is no need to look further as we can't improve the score anymore return; } } }; - auto searchAndUpdateCurrentBest = [&](boost::string_ref name_ref) { + auto searchAndUpdateCurrentBest = [¤tBest, &index, &updateCurrentBest, this](boost::string_ref name_ref) { // we need to create C-string for flatbuffers lookups // boost::string_ref gives us correct start, but possibly NUL-terminated in a wrong place, as it does not modify // input string and keeps only the length std::string name(name_ref.data(), name_ref.size()); + if (containerEmpty(index)) + return; + // check if there are any rules for the name - const auto *fit = index->LookupByKey(name.c_str()); - if (!fit) + auto fit = containerLookupByKey(index, name.c_str()); + if (!fit.first) return; // check if there's any chance to get better score - if (fit->best_score() <= currentBest.second) + if (policyIndexGetBestScore(fit.second) <= currentBest) return; // look for better score - updateCurrentBest(fit->item_refs()); + updateCurrentBest(policyIndexGetItemRefs(fit.second)); }; - const auto *prefixIndex = policy->prefix_index(); - assert(prefixIndex); + auto prefixIndex = policyGetPrefixIndex(policy); // iterate over names for (const auto &name: item.getNames()) { @@ -177,11 +187,13 @@ ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemFromSendI searchAndUpdateCurrentBest(""); // if a matching rule was found, return the decision - if (currentBest.first) - return makeDecisionItem(currentBest.first->decision()); + if (currentBest > 0) { + auto db_item = containerLookupByIndex(policyGetItems(policy), currentBest - 1); + return makeDecisionItem(itemGetDecisionItem(db_item)); + } // or if no matching rule was not found, return the default decision - return ldp_xml_parser::DecisionItem(ldp_xml_parser::Decision::ANY); + return ldp_xml_parser::Decision::ANY; } void StorageBackendFlatbuffers::release() { @@ -222,7 +234,7 @@ bool StorageBackendFlatbuffers::initFromData(const uint8_t *mem, size_t size, bo template <> \ auto StorageBackendFlatbuffers::getPolicySet() const { \ assert(file); \ - return file->m_##t##_set(); \ + return fileGet##T##Set(getFile()); \ } TYPE_HELPER(Own, own) @@ -232,45 +244,54 @@ TYPE_HELPER(Access, access) template <> ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextMandatory(const MatchItemSend &item) const { - return getDecisionItemFromSendIndex(item, getPolicySet()->context_mandatory()); + return getDecisionItemFromSendIndex(item, setGetContextMandatory(getPolicySet())); } template <> ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextDefault(const MatchItemSend &item) const { - return getDecisionItemFromSendIndex(item, getPolicySet()->context_default()); + return getDecisionItemFromSendIndex(item, setGetContextDefault(getPolicySet())); } template <> ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemUser(uid_t uid, const MatchItemSend &item) const { - auto *policyPair = getPolicySet()->user()->LookupByKey(uid); - if (nullptr == policyPair) + auto map = setGetUser(getPolicySet()); + + if (containerEmpty(map)) return ldp_xml_parser::Decision::ANY; - return getDecisionItemFromSendIndex(item, policyPair->policy()); + + auto elem = containerLookupByKey(map, uid); + if (!elem.first) + return ldp_xml_parser::Decision::ANY; + return getDecisionItemFromSendIndex(item, setUserGroupGetPolicy(elem.second)); } template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextMandatory(const T &item) const { - return getDecisionItem(item, getPolicySet()->context_mandatory()); + return getDecisionItem(item, setGetContextMandatory(getPolicySet())); } template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextDefault(const T &item) const { - return getDecisionItem(item, getPolicySet()->context_default()); + return getDecisionItem(item, setGetContextDefault(getPolicySet())); } template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemUser(uid_t uid, const T &item) const { - return getDecisionItemMaybeNull(item, getPolicySet()->user()->LookupByKey(uid)); + return getDecisionItem(item, setGetUser(getPolicySet()), uid); } - template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemGroup(gid_t gid, const T &item) const { - return getDecisionItemMaybeNull(item, getPolicySet()->group()->LookupByKey(gid)); + return getDecisionItem(item, setGetGroup(getPolicySet()), gid); } template bool StorageBackendFlatbuffers::existsPolicyForGroup(gid_t gid) const { - return getPolicySet()->group()->LookupByKey(gid) != nullptr; + auto map = setGetGroup(getPolicySet()); + + if (containerEmpty(map)) + return false; + + return containerLookupByKey(map, gid).first; } #define T_INSTANTIATION(T) \ diff --git a/src/internal/storage_backend_flatbuffers.hpp b/src/internal/storage_backend_flatbuffers.hpp index f831282..536808a 100644 --- a/src/internal/storage_backend_flatbuffers.hpp +++ b/src/internal/storage_backend_flatbuffers.hpp @@ -218,8 +218,8 @@ private: ldp_xml_parser::DecisionItem getDecisionItemFromSendIndex(const ldp_xml_parser::MatchItemSend &item, const FB::PolicySend *policy) const; - template - ldp_xml_parser::DecisionItem getDecisionItemMaybeNull(const T &item, const P *policyPair) const; + template + ldp_xml_parser::DecisionItem getDecisionItem(const MatchItem &item, const Map &map, id_t id) const; auto getDecisionItemFromTree(const FB::PolicyOwnNode *node, const tokenizer::iterator &tokens_end, -- 2.7.4