path: root/src/internal/storage_backend_flatbuffers.hpp

/*
 * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/
#pragma once

#include "include/fb_generated.h"
#include "policy.hpp"
#include "serialization_traits.hpp"
#include <boost/tokenizer.hpp>
#include <memory>

namespace ldp_serialized {

class StorageBackendFlatbuffers {
public:
	StorageBackendFlatbuffers();
	~StorageBackendFlatbuffers();

	bool initFromData(const uint8_t *serialized_data, size_t length, bool verify);
	void release();

	void printContent(const bool xml_format = false) const;

	// Supported template parameters are:
	// MatchPolicyOwn, MatchPolicySend, MatchPolicyReceive
	// and - only for Contexts - MatchPolicyAccess
	template <typename T>
	ldp_xml_parser::DecisionItem getDecisionItemContextMandatory(const T &item) const;
	template <typename T>
	ldp_xml_parser::DecisionItem getDecisionItemContextDefault(const T &item) const;
	template <typename T>
	ldp_xml_parser::DecisionItem getDecisionItemUser(uid_t uid, const T &item) const;
	template <typename T>
	ldp_xml_parser::DecisionItem getDecisionItemGroup(gid_t gid, const T &item) const;

	// This works with T set to MatchItemOwn, MatchItemSend or MatchItemReceive
	// This is needed for filtering mapGroups. Check NaivePolicyChecker.
	template <typename T>
	bool existsPolicyForGroup(gid_t gid) const;

	const FB::File *getFile() const
	{ return file; }

	auto fileGetOwnSet(const FB::File *file) const
	{ return file->m_own_set(); }
	auto fileGetSendSet(const FB::File *file) const
	{ return file->m_send_set(); }
	auto fileGetReceiveSet(const FB::File *file) const
	{ return file->m_receive_set(); }
	auto fileGetAccessSet(const FB::File *file) const
	{ return file->m_access_set(); }

	template <typename Set>
	auto setGetContextDefault(const Set *set) const
	{ return set->context_default(); }

	template <typename Set>
	auto setGetContextMandatory(const Set *set) const
	{ return set->context_mandatory(); }

	template <typename Set>
	auto setGetUser(const Set *set) const
	{ return set->user(); }

	template <typename Set>
	auto setGetGroup(const Set *set) const
	{ return set->group(); }

	template <typename SetUserGroup>
	auto setUserGroupGetId(const SetUserGroup *set_user_group) const
	{ return set_user_group->id(); }

	template <typename SetUserGroup>
	auto setUserGroupGetPolicy(const SetUserGroup *set_user_group) const
	{ return set_user_group->policy(); }

	template <typename Policy>
	auto policyGetTree(const Policy *policy) const
	{ return policy->tree(); }

	template <typename Policy>
	auto policyGetItems(const Policy *policy) const
	{ return policy->items(); }

	template <typename Policy>
	auto policyHasIndex(const Policy *policy) const
	{ return policy->index() != nullptr && policy->index()->size() > 0; }

	template <typename Policy>
	auto policyGetIndex(const Policy *policy) const
	{ return policy->index(); }

	template <typename Policy>
	auto policyGetPrefixIndex(const Policy *policy) const
	{ return policy->prefix_index(); }

	auto policyIndexGetBestScore(const FB::NameScoresPair *p) const
	{ return p->best_score(); }

	auto policyIndexGetItemRefs(const FB::NameScoresPair *p) const
	{ return p->item_refs(); }

	template <typename Container>
	auto containerGetReverseIterator(const Container *container) const
	{ return container->rbegin(); }

	template <typename Container>
	auto containerGetReverseIteratorEnd(const Container *container) const
	{ return container->rend(); }

	template <typename Container>
	auto containerGetIterator(const Container *container) const
	{ return container->begin(); }

	template <typename Container>
	auto containerGetIteratorEnd(const Container *container) const
	{ return container->end(); }

	template <typename Container>
	auto containerGetSize(const Container *container) const
	{ return container->size(); }

	template <typename Container>
	auto containerLookupByIndex(const Container *container, size_t index) const
	{ return container->Get(index); }

	template <typename Container>
	auto containerEmpty(const Container *container) const
	{ return container->size() == 0; }

	template <typename Container, typename Key>
	auto containerLookupByKey(const Container *container, Key key) const {
		auto elem = container->LookupByKey(key);
		return std::make_pair(elem != nullptr, elem);
	}

	auto decisionItemGetDecision(const FB::DecisionItem *item) const
	{ return item->decision(); }

	auto decisionItemGetPrivilege(const FB::DecisionItem *item) const
	{ return item->privilege(); }

	auto ownNodeGetToken(const FB::PolicyOwnNode *node) const
	{ return node->token(); }

	auto ownNodeGetDecisionItem(const FB::PolicyOwnNode *node) const
	{ return node->decision_item(); }

	auto ownNodeGetPrefixDecisionItem(const FB::PolicyOwnNode *node) const
	{ return node->prefix_decision_item(); }

	auto ownNodeGetChildren(const FB::PolicyOwnNode *node) const
	{ return node->children(); }

	auto itemAccessGetType(const FB::ItemAccess *item) const
	{ return item->type(); }

	auto itemAccessGetUid(const FB::ItemAccess *item) const
	{ return item->uid(); }

	auto itemAccessGetGid(const FB::ItemAccess *item) const
	{ return item->gid(); }

	template <typename ItemSR>
	auto itemSrGetName(const ItemSR *item) const
	{ return item->name(); }

	template <typename ItemSR>
	auto itemSrGetIsNamePrefix(const ItemSR *item) const
	{ return item->is_name_prefix(); }

	template <typename ItemSR>
	auto itemSrGetInterface(const ItemSR *item) const
	{ return item->interface(); }

	template <typename ItemSR>
	auto itemSrGetMember(const ItemSR *item) const
	{ return item->member(); }

	template <typename ItemSR>
	auto itemSrGetPath(const ItemSR *item) const
	{ return item->path(); }

	template <typename ItemSR>
	auto itemSrGetMessageType(const ItemSR *item) const
	{ return item->type(); }

	template <typename Item>
	auto itemGetDecisionItem(const Item *item) const
	{ return item->decision(); }

	const char *stringGetCStr(const flatbuffers::String *str) const
	{ return str->c_str(); }

	size_t stringGetSize(const flatbuffers::String *str) const
	{ return str->size(); }

	typedef boost::tokenizer<boost::char_separator<char>> tokenizer;

private:
	const FB::File *file{nullptr};

	template <typename MatchItem>
	auto getPolicySet() const;

	template <typename T, typename P>
	ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P *policy) const;

	ldp_xml_parser::DecisionItem getDecisionItemFromSendIndex(const ldp_xml_parser::MatchItemSend &item, const FB::PolicySend *policy) const;

	template <typename T, typename P>
	ldp_xml_parser::DecisionItem getDecisionItemMaybeNull(const T &item, const P *policyPair) const;

	auto getDecisionItemFromTree(const FB::PolicyOwnNode *node,
	                             const tokenizer::iterator &tokens_end,
	                             tokenizer::iterator &iterator) const;

	template <typename T, typename I>
	bool match(const T &match, const I *i) const;

	bool match(const ldp_xml_parser::MatchItemAccess &match, const FB::ItemAccess *item) const;

	boost::string_ref toStringRef(const flatbuffers::String *str) const;
};

}

namespace ldp_serialization {
template <> struct HasUserGroup<const FB::OwnSet *>
{ typedef std::true_type result; };
template <> struct HasUserGroup<const FB::SendSet *>
{ typedef std::true_type result; };
template <> struct HasUserGroup<const FB::ReceiveSet *>
{ typedef std::true_type result; };
template <> struct HasUserGroup<const FB::AccessSet *>
{ typedef std::false_type result; };

template <> struct PolicyContentType<const FB::PolicyOwn *>
{ typedef TreeType result; };
template <> struct PolicyContentType<const FB::PolicySend *>
{ typedef ItemsType result; };
template <> struct PolicyContentType<const FB::PolicyReceive *>
{ typedef ItemsType result; };
template <> struct PolicyContentType<const FB::PolicyAccess *>
{ typedef ItemsType result; };

template <> struct PolicyHasIndex<const FB::PolicySend *>
{ typedef std::true_type result; };

template <> struct ItemType<const FB::ItemSend *>
{ typedef SendType result; };
template <> struct ItemType<const FB::ItemReceive *>
{ typedef ReceiveType result; };
template <> struct ItemType<const FB::ItemAccess *>
{ typedef AccessType result; };
}