#include "print_content.hpp"
#include "serialized_convert.hpp"
#include "serializer.hpp"
-#include "storage_backend_serialized.hpp"
+#include "storage_backend_flatbuffers.hpp"
#include "transaction_guard.hpp"
#include "tslog.hpp"
#include <boost/tokenizer.hpp>
} // anonymous namespace
-class StorageBackendSerialized::StorageBackendSerializedImpl {
+class StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl {
int fd{-1};
uint8_t *mem{static_cast<decltype(mem)>(MAP_FAILED)};
size_t length{0};
const M *getPolicySet();
};
-ldp_xml_parser::DecisionItem StorageBackendSerialized::StorageBackendSerializedImpl::getDecisionFromSendIndex(const MatchItemSend &item,
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::getDecisionFromSendIndex(const MatchItemSend &item,
const FB::PolicySend *policy) {
const auto *index = policy->index();
return ldp_xml_parser::DecisionItem(ldp_xml_parser::Decision::ANY);
}
-void StorageBackendSerialized::StorageBackendSerializedImpl::releaseMMap() {
+void StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::releaseMMap() {
assert(MAP_FAILED != mem);
assert(0 != length);
length = 0;
}
-void StorageBackendSerialized::StorageBackendSerializedImpl::releaseFD() {
+void StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::releaseFD() {
assert(-1 != fd);
if (close(fd) != 0)
fd = -1;
}
-void StorageBackendSerialized::StorageBackendSerializedImpl::release() {
+void StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::release() {
if (-1 != fd) { // we need to check it, because we may have initialized the storage directly from File *
releaseMMap();
releaseFD();
file = nullptr;
}
-bool StorageBackendSerialized::StorageBackendSerializedImpl::init(const char *filename, bool verify) {
+bool StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::init(const char *filename, bool verify) {
assert(nullptr == file);
auto err = [filename] (const char *what) {
return true;
}
-bool StorageBackendSerialized::StorageBackendSerializedImpl::initFromData(const uint8_t *mem, size_t size, bool verify) {
+bool StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::initFromData(const uint8_t *mem, size_t size, bool verify) {
assert(nullptr == file);
if (verify) {
return file != nullptr;
}
-bool StorageBackendSerialized::StorageBackendSerializedImpl::initFromXML(const char *config_name) {
+bool StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::initFromXML(const char *config_name) {
assert(nullptr == file);
assert(nullptr == serializer.get());
return initFromData(data, serialized_size, false);
}
-void StorageBackendSerialized::StorageBackendSerializedImpl::printContent(const bool xml_format) const {
+void StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::printContent(const bool xml_format) const {
print_content::use_xml_format(xml_format);
std::cerr << *file;
}
typedef FB::Policy##T policy_type; \
}; \
template <> \
- auto StorageBackendSerialized::StorageBackendSerializedImpl::getPolicySet<ldp_xml_parser::MatchItem##T>() \
+ auto StorageBackendFlatbuffers::StorageBackendFlatbuffersImpl::getPolicySet<ldp_xml_parser::MatchItem##T>() \
-> const typename type_helper<ldp_xml_parser::MatchItem##T>::policy_set_type * { \
assert(file); \
return file->m_##t##_set(); \
TYPE_HELPER(Receive, receive)
TYPE_HELPER(Access, access)
-bool StorageBackendSerialized::init(const char *filename, bool verify) {
+bool StorageBackendFlatbuffers::init(const char *filename, bool verify) {
return pimpl->init(filename, verify);
}
-bool StorageBackendSerialized::initFromData(const uint8_t *serialized_data, size_t length, bool verify) {
+bool StorageBackendFlatbuffers::initFromData(const uint8_t *serialized_data, size_t length, bool verify) {
return pimpl->initFromData(serialized_data, length, verify);
}
-bool StorageBackendSerialized::initFromXML(const char *config_name) {
+bool StorageBackendFlatbuffers::initFromXML(const char *config_name) {
return pimpl->initFromXML(config_name);
}
-void StorageBackendSerialized::release() {
+void StorageBackendFlatbuffers::release() {
pimpl->release();
}
-void StorageBackendSerialized::printContent(const bool xml_format) const {
+void StorageBackendFlatbuffers::printContent(const bool xml_format) const {
pimpl->printContent(xml_format);
}
template <typename T>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextMandatory(const T &item) const {
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextMandatory(const T &item) const {
return getDecisionItem(item, pimpl->getPolicySet<T>()->context_mandatory());
}
template <>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextMandatory(const MatchItemSend &item) const {
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextMandatory(const MatchItemSend &item) const {
return pimpl->getDecisionFromSendIndex(item, pimpl->getPolicySet<MatchItemSend>()->context_mandatory());
}
template <>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextDefault(const MatchItemSend &item) const {
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextDefault(const MatchItemSend &item) const {
return pimpl->getDecisionFromSendIndex(item, pimpl->getPolicySet<MatchItemSend>()->context_default());
}
template <>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemUser(uid_t uid, const MatchItemSend &item) const {
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemUser(uid_t uid, const MatchItemSend &item) const {
auto *policyPair = pimpl->getPolicySet<MatchItemSend>()->user()->LookupByKey(uid);
if (nullptr == policyPair)
return ldp_xml_parser::Decision::ANY;
}
template <typename T>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextDefault(const T &item) const {
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextDefault(const T &item) const {
return getDecisionItem(item, pimpl->getPolicySet<T>()->context_default());
}
template <typename T>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemUser(uid_t uid, const T &item) const {
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemUser(uid_t uid, const T &item) const {
return getDecisionItemMaybeNull(item, pimpl->getPolicySet<T>()->user()->LookupByKey(uid));
}
template <typename T>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemGroup(gid_t gid, const T &item) const {
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemGroup(gid_t gid, const T &item) const {
return getDecisionItemMaybeNull(item, pimpl->getPolicySet<T>()->group()->LookupByKey(gid));
}
template <typename T>
-bool StorageBackendSerialized::existsPolicyForGroup(gid_t gid) const {
+bool StorageBackendFlatbuffers::existsPolicyForGroup(gid_t gid) const {
return pimpl->getPolicySet<T>()->group()->LookupByKey(gid) != nullptr;
}
#define T_INSTANTIATION(T) \
- template ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextMandatory(const ldp_xml_parser::MatchItem##T &item) const; \
- template ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextDefault(const ldp_xml_parser::MatchItem##T &item) const;
+ template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextMandatory(const ldp_xml_parser::MatchItem##T &item) const; \
+ template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextDefault(const ldp_xml_parser::MatchItem##T &item) const;
T_INSTANTIATION(Own)
T_INSTANTIATION(Send)
#undef T_INSTANTIATION
#define T_INSTANTIATION2(T) \
- template ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemUser(uid_t uid, const ldp_xml_parser::MatchItem##T &item) const; \
- template ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemGroup(gid_t gid, const ldp_xml_parser::MatchItem##T &item) const; \
- template bool StorageBackendSerialized::existsPolicyForGroup<ldp_xml_parser::MatchItem##T>(gid_t) const;
+ template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemUser(uid_t uid, const ldp_xml_parser::MatchItem##T &item) const; \
+ template ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemGroup(gid_t gid, const ldp_xml_parser::MatchItem##T &item) const; \
+ template bool StorageBackendFlatbuffers::existsPolicyForGroup<ldp_xml_parser::MatchItem##T>(gid_t) const;
T_INSTANTIATION2(Own)
T_INSTANTIATION2(Send)
#undef T_INSTANTIATION2
-StorageBackendSerialized::StorageBackendSerialized()
- : pimpl{new StorageBackendSerializedImpl} {
+StorageBackendFlatbuffers::StorageBackendFlatbuffers()
+ : pimpl{new StorageBackendFlatbuffersImpl} {
}
-StorageBackendSerialized::~StorageBackendSerialized() {
+StorageBackendFlatbuffers::~StorageBackendFlatbuffers() {
pimpl->release();
}
--- /dev/null
+/*
+ * 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 "policy.hpp"
+
+#include <memory>
+
+namespace ldp_serialized {
+
+class StorageBackendFlatbuffers {
+ class StorageBackendFlatbuffersImpl;
+ std::unique_ptr<StorageBackendFlatbuffersImpl> pimpl;
+public:
+ StorageBackendFlatbuffers();
+ ~StorageBackendFlatbuffers();
+
+ bool init(const char *filename, bool verify = false);
+ bool initFromData(const uint8_t *serialized_data, size_t length, bool verify = false);
+ bool initFromXML(const char *config_name);
+ 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;
+
+};
+
+}
-/*
- * 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 "policy.hpp"
-
-#include <memory>
+#include "storage_backend_flatbuffers.hpp"
namespace ldp_serialized {
-
-class StorageBackendSerialized {
- class StorageBackendSerializedImpl;
- std::unique_ptr<StorageBackendSerializedImpl> pimpl;
-public:
- StorageBackendSerialized();
- ~StorageBackendSerialized();
-
- bool init(const char *filename, bool verify = false);
- bool initFromData(const uint8_t *serialized_data, size_t length, bool verify = false);
- bool initFromXML(const char *config_name);
- 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;
-
-};
-
+using StorageBackendSerialized = StorageBackendFlatbuffers;
}