refactoring: make two checkers for two buses

This changes NaivePolicyChecker to contain only one database
per object. Thus, we need to have two NaivePolicyCheckers.
It changes relation between NaivePolicyChecker and NaivePolicyDb to
1:1 relation. It will help with removal of NaivePolicyDb.

After this, each bus (session and system) has its own, dedicated checker.

Change-Id: I7b07db0803b001e5a591a090d259666de2f7074b

diff --git a/src/internal/internal.cpp b/src/internal/internal.cpp
index d5dcd22..d1c75fc 100644 (file)
--- a/src/internal/internal.cpp
+++ b/src/internal/internal.cpp
@@ -36,7 +36,7 @@ static const char* get_str(const char* const szstr) {
 
 int __internal_init(BusType bus_type, const char* const config_name)
 {
-       auto ok = policy_checker().initDb(bus_type, get_str(config_name));
+       auto ok = policy_checker(bus_type).initDb(get_str(config_name));
        if (tslog::enabled())
                memory_dump(bus_type);
        return ok ? 0 : -1;
@@ -46,7 +46,7 @@ pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 void memory_dump(BusType bus_type)
 {
-       policy_checker().printContent(bus_type);
+       policy_checker(bus_type).printContent();
 }
 
 void __internal_init_once()
@@ -65,7 +65,7 @@ void __internal_init_flush_logs()
 
 void __internal_init_sup_group(BusType bus_type, uid_t uid, gid_t gid)
 {
-       policy_checker().updateGroupDb(bus_type, uid, gid);
+       policy_checker(bus_type).updateGroupDb(uid, gid);
 }
 
 void __internal_enter()
@@ -85,7 +85,7 @@ int __internal_can_open(BusType bus_type,
                                                gid_t group,
                                                const char* const label)
 {
-       return static_cast<int>(policy_checker().check(bus_type, bus_owner, user, group, label));
+       return static_cast<int>(policy_checker(bus_type).check(bus_owner, user, group, label));
 }
 
 int __internal_can_send(BusType bus_type,
@@ -103,7 +103,7 @@ int __internal_can_send(BusType bus_type,
                tslog::log_verbose("Destination too long: ", destination, "\n");
                return false;
        }
-       return static_cast<int>(policy_checker().check(bus_type, user, group, label, matcher));
+       return static_cast<int>(policy_checker(bus_type).check(user, group, label, matcher));
 }
 
 int __internal_can_send_multi_dest(BusType bus_type,
@@ -122,7 +122,7 @@ int __internal_can_send_multi_dest(BusType bus_type,
                while (destination[i]) {
                        matcher.addName(destination[i++]);
                }
-       return static_cast<int>(policy_checker().check(bus_type, user, group, label, matcher));
+       return static_cast<int>(policy_checker(bus_type).check(user, group, label, matcher));
 }
 
 int __internal_can_recv(BusType bus_type,
@@ -140,7 +140,7 @@ int __internal_can_recv(BusType bus_type,
                tslog::log_verbose("Sender too long: ", sender, "\n");
                return false;
        }
-       return static_cast<int>(policy_checker().check(bus_type, user, group, label, matcher));
+       return static_cast<int>(policy_checker(bus_type).check(user, group, label, matcher));
 }
 
 int __internal_can_recv_multi(BusType bus_type,
@@ -159,7 +159,7 @@ int __internal_can_recv_multi(BusType bus_type,
                while (sender[i]) {
                        matcher.addName(sender[i++]);
                }
-       return static_cast<int>(policy_checker().check(bus_type, user, group, label, matcher));
+       return static_cast<int>(policy_checker(bus_type).check(user, group, label, matcher));
 }
 
 
@@ -169,5 +169,5 @@ int __internal_can_own(BusType bus_type,
                                           const char* const label,
                                           const char* const service)
 {
-       return static_cast<int>(policy_checker().check(bus_type, user, group, label, MatchItemOwn(service)));
+       return static_cast<int>(policy_checker(bus_type).check(user, group, label, MatchItemOwn(service)));
 }

diff --git a/src/internal/naive_policy_checker.cpp b/src/internal/naive_policy_checker.cpp
index ab7f78f..ea6d111 100644 (file)
--- a/src/internal/naive_policy_checker.cpp
+++ b/src/internal/naive_policy_checker.cpp
@@ -9,11 +9,8 @@
 
 using namespace ldp_xml_parser;
 
-DEF_NODESTRUCT_GLOBAL(ldp_xml_parser::NaivePolicyChecker, policy_checker)
-
-NaivePolicyDb& NaivePolicyChecker::getPolicyDb(BusType type) {
-       return m_bus_db[type];
-}
+DEF_NODESTRUCT_GLOBAL(ldp_xml_parser::NaivePolicyChecker, policy_checker_system)
+DEF_NODESTRUCT_GLOBAL(ldp_xml_parser::NaivePolicyChecker, policy_checker_session)
 
 DecisionResult NaivePolicyChecker::parseDecision(const DecisionItem& decision,
                                                                           uid_t uid,
@@ -40,9 +37,9 @@ DecisionResult NaivePolicyChecker::parseDecision(const DecisionItem& decision,
        return DecisionResult::DENY;
 }
 
-DecisionItem NaivePolicyChecker::checkItemAccess(BusType bus_type, const MatchItemAccess& item)
+DecisionItem NaivePolicyChecker::checkItemAccess(const MatchItemAccess& item)
 {
-       const NaivePolicyDb& policy_db = getPolicyDb(bus_type);
+       const NaivePolicyDb& policy_db = getPolicyDb();
 
        DecisionItem ret = policy_db.getDecisionItemContextMandatory(item);
        // access rules can be defined only in default/mandatory context
@@ -54,13 +51,12 @@ DecisionItem NaivePolicyChecker::checkItemAccess(BusType bus_type, const MatchIt
        return ret;
 }
 
-DecisionResult NaivePolicyChecker::check(BusType bus_type,
-                                                          uid_t bus_owner,
+DecisionResult NaivePolicyChecker::check(uid_t bus_owner,
                                                           uid_t uid,
                                                           gid_t gid,
                                                           const char* const label) {
-       const auto &gids = *getPolicyDb(bus_type).getGroups<MatchItemAccess>(uid, gid);
-       auto ret = checkItemAccess(bus_type, MatchItemAccess(uid, gids));
+       const auto &gids = *getPolicyDb().getGroups<MatchItemAccess>(uid, gid);
+       auto ret = checkItemAccess(MatchItemAccess(uid, gids));
        if (ret.getDecision() == Decision::ANY) {
                if (bus_owner == uid) {
                        ret = Decision::ALLOW;
@@ -70,21 +66,20 @@ DecisionResult NaivePolicyChecker::check(BusType bus_type,
 }
 
 template <typename T>
-DecisionResult NaivePolicyChecker::check(BusType bus_type,
-                                                          uid_t uid,
+DecisionResult NaivePolicyChecker::check(uid_t uid,
                                                           gid_t gid,
                                                           const char* const label,
                                                           const T &matchItem) {
-       auto ret = checkItem(bus_type, uid, gid, matchItem);
+       auto ret = checkItem(uid, gid, matchItem);
        return parseDecision(ret, uid, label);
 }
-template DecisionResult NaivePolicyChecker::check(BusType, uid_t, gid_t, const char *, const MatchItemOwn &);
-template DecisionResult NaivePolicyChecker::check(BusType, uid_t, gid_t, const char *, const MatchItemSend &);
-template DecisionResult NaivePolicyChecker::check(BusType, uid_t, gid_t, const char *, const MatchItemReceive &);
+template DecisionResult NaivePolicyChecker::check(uid_t, gid_t, const char *, const MatchItemOwn &);
+template DecisionResult NaivePolicyChecker::check(uid_t, gid_t, const char *, const MatchItemSend &);
+template DecisionResult NaivePolicyChecker::check(uid_t, gid_t, const char *, const MatchItemReceive &);
 
 template<typename T>
-DecisionItem NaivePolicyChecker::checkItem(BusType bus_type, uid_t uid, gid_t gid, const T& item) {
-       const NaivePolicyDb& policy_db = getPolicyDb(bus_type);
+DecisionItem NaivePolicyChecker::checkItem(uid_t uid, gid_t gid, const T& item) {
+       const NaivePolicyDb& policy_db = getPolicyDb();
 
        DecisionItem ret = policy_db.getDecisionItemContextMandatory(item);
 
@@ -92,7 +87,7 @@ DecisionItem NaivePolicyChecker::checkItem(BusType bus_type, uid_t uid, gid_t gi
                ret = policy_db.getDecisionItemUser(uid, item);
 
        if (ret.getDecision() == Decision::ANY)
-               ret = checkGroupPolicies<T>(policy_db, uid, gid, item);
+               ret = checkGroupPolicies<T>(uid, gid, item);
 
        if (ret.getDecision() == Decision::ANY)
                ret = policy_db.getDecisionItemContextDefault(item);
@@ -101,7 +96,9 @@ DecisionItem NaivePolicyChecker::checkItem(BusType bus_type, uid_t uid, gid_t gi
 }
 
 template<typename T>
-DecisionItem NaivePolicyChecker::checkGroupPolicies(const NaivePolicyDb& policy_db, uid_t uid, gid_t gid, const T& item) {
+DecisionItem NaivePolicyChecker::checkGroupPolicies(uid_t uid, gid_t gid, const T& item) {
+       const NaivePolicyDb& policy_db = getPolicyDb();
+
        const auto *sgroups = policy_db.getGroups<T>(uid, gid);
        if (sgroups == nullptr)
                return Decision::ANY;
@@ -115,17 +112,17 @@ DecisionItem NaivePolicyChecker::checkGroupPolicies(const NaivePolicyDb& policy_
        return Decision::ANY;
 }
 
-void NaivePolicyChecker::updateGroupDb(BusType bus_type, uid_t uid, gid_t gid)
+void NaivePolicyChecker::updateGroupDb(uid_t uid, gid_t gid)
 {
-       getPolicyDb(bus_type).initializeGroups(uid, gid);
+       getPolicyDb().initializeGroups(uid, gid);
 }
 
-bool NaivePolicyChecker::initDb(BusType bus_type, const char *config_name)
+bool NaivePolicyChecker::initDb(const char *config_name)
 {
-       return getPolicyDb(bus_type).init(config_name);
+       return getPolicyDb().init(config_name);
 }
 
-void NaivePolicyChecker::printContent(BusType bus_type)
+void NaivePolicyChecker::printContent()
 {
-       getPolicyDb(bus_type).printContent();
+       getPolicyDb().printContent();
 }

diff --git a/src/internal/naive_policy_checker.hpp b/src/internal/naive_policy_checker.hpp
index e1a6e5a..b4004aa 100644 (file)
--- a/src/internal/naive_policy_checker.hpp
+++ b/src/internal/naive_policy_checker.hpp
@@ -36,7 +36,7 @@ namespace ldp_xml_parser
        private:
 
                /** Policy databases for system and session bus */
-               NaivePolicyDb m_bus_db[2];
+               NaivePolicyDb m_bus_db;
 
                /** Parses delivered decision. In case of Decision::CHECK calls cynara.
                 * \param[in] decision Decision from checkers
@@ -51,7 +51,6 @@ namespace ldp_xml_parser
                                                   const char* label) const;
 
                /** Checks policy for a given own, send or receive item
-                * \param[in] bus_type Bus type (system/session)
                 * \param[in] uid User id
                 * \param[in] gid User group id
                 * \param[in] item Item to check
@@ -59,57 +58,50 @@ namespace ldp_xml_parser
                 * \ingroup Implementation
                 */
                template<typename T>
-               DecisionItem checkItem(BusType bus_type,
-                                          uid_t uid,
+               DecisionItem checkItem(uid_t uid,
                                           gid_t gid,
                                           const T& item);
 
                /** Checks policy for a given access item
-                * \param[in] bus_type Bus type (system/session)
                 * \param[in] item Item to check
                 * \return Returns deny=0, allow=1 or cynara error
                 * \ingroup Implementation
                 */
-               DecisionItem checkItemAccess(BusType bus_type, const MatchItemAccess &item);
+               DecisionItem checkItemAccess(const MatchItemAccess &item);
 
                template<typename T>
-               DecisionItem checkGroupPolicies(const NaivePolicyDb& policy_db,
-                                               uid_t uid,
+               DecisionItem checkGroupPolicies(uid_t uid,
                                                gid_t gid,
                                                const T& item);
 
        public:
                /** Retrieves policy db
-                * \param[in] type Type of database (system/session bus)
                 * \return Returns reference to chosen bus policy db
                 */
-               NaivePolicyDb& getPolicyDb(BusType type);
+               NaivePolicyDb& getPolicyDb() { return m_bus_db; }
 
                /** Clears all db data, useful for reloading configuration
                 * during testing.
                 */
-               bool initDb(BusType bus_type, const char *filename);
+               bool initDb(const char *filename);
 
-               void updateGroupDb(BusType bus_type, uid_t uid, gid_t gid);
+               void updateGroupDb(uid_t uid, gid_t gid);
 
                /** Prints to stderr the structures and the amount of their memory */
-               void printContent(BusType bus_type);
+               void printContent();
 
                /** Checks access/open policy for given item
-                * \param[in] bus_type Bus type (system/session)
                 * \param[in] uid User id
                 * \param[in] gid User group id
                 * \return Returns deny=0, allow=1 or cynara error
                 * \ingroup Implementation
                 */
-               DecisionResult check(BusType bus_type,
-                                  uid_t bus_owner,
+               DecisionResult check(uid_t bus_owner,
                                   uid_t uid,
                                   gid_t gid,
                                   const char* const label);
 
                /** Checks send/receive/ownership policy for given item
-                * \param[in] bus_type Bus type (system/session)
                 * \param[in] uid User id
                 * \param[in] gid User group id
                 * \param[in] label User label
@@ -118,14 +110,20 @@ namespace ldp_xml_parser
                 * \ingroup Implementation
                 */
                template <typename T>
-               DecisionResult check(BusType bus_type,
-                                  uid_t uid,
+               DecisionResult check(uid_t uid,
                                   gid_t gid,
                                   const char* const label,
                                   const T &matchItem);
        };
 }
 
-DCL_NODESTRUCT_GLOBAL(ldp_xml_parser::NaivePolicyChecker, policy_checker)
+DCL_NODESTRUCT_GLOBAL(ldp_xml_parser::NaivePolicyChecker, policy_checker_system)
+DCL_NODESTRUCT_GLOBAL(ldp_xml_parser::NaivePolicyChecker, policy_checker_session)
+
+inline ldp_xml_parser::NaivePolicyChecker &policy_checker(BusType bus_type) {
+       if (SESSION_BUS == bus_type)
+               return policy_checker_session();
+       return policy_checker_system();
+}
 
 #endif

diff --git a/src/internal/serializer.cpp b/src/internal/serializer.cpp
index af69580..1d9970d 100644 (file)
--- a/src/internal/serializer.cpp
+++ b/src/internal/serializer.cpp
@@ -83,8 +83,8 @@ struct Serializer::type_helper<PolicyAccess> {
        static constexpr auto create_item = &FB::CreateItemAccess;
 };
 
-uint8_t* Serializer::serialize(const BusType bus_type, size_t &size) {
-       m_db = &policy_checker().getPolicyDb(bus_type);
+uint8_t* Serializer::serialize(const NaivePolicyDb &db, size_t &size) {
+       m_db = &db;
 
        auto own_set = serialize_set<PolicyOwn>();
        auto send_set = serialize_set<PolicySend>();
@@ -110,7 +110,7 @@ uint8_t* Serializer::serialize(const std::string config_path, size_t &size) {
        if (__internal_init(BusType::SYSTEM_BUS, config_path.c_str()) != 0)
                cout << "internal_init error" << endl;
 
-       return serialize(BusType::SYSTEM_BUS, size);
+       return serialize(policy_checker_system().getPolicyDb(), size);
 }
 
 void Serializer::serialize(const std::string config_path, ostream &output) {

diff --git a/src/internal/serializer.hpp b/src/internal/serializer.hpp
index 12be5b0..582687a 100644 (file)
--- a/src/internal/serializer.hpp
+++ b/src/internal/serializer.hpp
@@ -69,7 +69,7 @@ namespace ldp_xml_parser
                           FbOff<TFP> context_mandatory)
                             -> FbOff<typename type_helper<TP>::set>;
     public:
-       uint8_t *serialize(const BusType bus_type, size_t &size);
+       uint8_t *serialize(const NaivePolicyDb &db, size_t &size);
        uint8_t *serialize(const std::string config_path, size_t &size);
        void serialize(const std::string config_path, ostream &output);
        friend class SerializerTests;

diff --git a/src/stest_performance.cpp b/src/stest_performance.cpp
index 48e503b..f37b7ad 100644 (file)
--- a/src/stest_performance.cpp
+++ b/src/stest_performance.cpp
@@ -189,7 +189,7 @@ void run_x_times(std::function<void(void)> func, size_t times) {
 
 void run_policy_db(const char *conf_file, size_t count) {
        __internal_init(SYSTEM_BUS, conf_file);
-       auto &db = policy_checker().getPolicyDb(SYSTEM_BUS);
+       auto &db = policy_checker_system().getPolicyDb();
 
        printf("XML:\n");
        run_x_times([&db](){ send_prefix_test(db); }, count);

diff --git a/src/test-libdbuspolicy1-access-deny-gdi.cpp b/src/test-libdbuspolicy1-access-deny-gdi.cpp
index f42a5f7..5e6046d 100644 (file)
--- a/src/test-libdbuspolicy1-access-deny-gdi.cpp
+++ b/src/test-libdbuspolicy1-access-deny-gdi.cpp
@@ -94,7 +94,7 @@ bool run_tests_for_bus(const DB &db, const BusType bus_type, const std::vector<A
        for (const auto& test : test_setup) {
                __internal_init_sup_group(bus_type, test.user, test.group);
 
-               auto *policydb = &policy_checker().getPolicyDb(bus_type);
+               auto *policydb = &policy_checker(bus_type).getPolicyDb();
 
                const auto &gids = *policydb->getGroups<MatchItemAccess>(test.user, test.group);
                auto m_item = MatchItemAccess(test.user, gids);
@@ -130,8 +130,8 @@ bool run_policy_db(const std::pair<TestBusSetup, TestBusSetup> access_test) {
                __internal_init(SESSION_BUS, session_bus_setup.first.c_str());
        }
 
-       auto *sys_db = &policy_checker().getPolicyDb(SYSTEM_BUS);
-       auto *ses_db = &policy_checker().getPolicyDb(SESSION_BUS);
+       auto *sys_db = &policy_checker_system().getPolicyDb();
+       auto *ses_db = &policy_checker_session().getPolicyDb();
 
        printf("POLICY_DB:\n");
        return run_tests_for_bus(*sys_db, SYSTEM_BUS, system_bus_setup.second, i, passed) &&

diff --git a/src/test-libdbuspolicy1-method-gdi.cpp b/src/test-libdbuspolicy1-method-gdi.cpp
index 16c6c45..64ae2c6 100644 (file)
--- a/src/test-libdbuspolicy1-method-gdi.cpp
+++ b/src/test-libdbuspolicy1-method-gdi.cpp
@@ -121,7 +121,7 @@ bool method_test(DB &db) {
 
 bool run_policy_db() {
        __internal_init(SYSTEM_BUS, "tests/default_allow/system.conf");
-       auto &db = policy_checker().getPolicyDb(SYSTEM_BUS);
+       auto &db = policy_checker_system().getPolicyDb();
        printf("POLICY_DB:\n");
        return method_test(db);
 }

diff --git a/src/test-libdbuspolicy1-ownership-deny-gdi.cpp b/src/test-libdbuspolicy1-ownership-deny-gdi.cpp
index 3bee8f6..af4bc20 100644 (file)
--- a/src/test-libdbuspolicy1-ownership-deny-gdi.cpp
+++ b/src/test-libdbuspolicy1-ownership-deny-gdi.cpp
@@ -175,7 +175,7 @@ bool ownership_test(const DB &db) {
 
 bool run_policy_db() {
        __internal_init(SYSTEM_BUS, "tests/default_deny/system.conf");
-       auto &db = policy_checker().getPolicyDb(SYSTEM_BUS);
+       auto &db = policy_checker_system().getPolicyDb();
        printf("POLICY_DB:\n");
        return ownership_test(db);
 }

diff --git a/src/test-libdbuspolicy1-ownership-gdi.cpp b/src/test-libdbuspolicy1-ownership-gdi.cpp
index 9a3e00a..f517685 100644 (file)
--- a/src/test-libdbuspolicy1-ownership-gdi.cpp
+++ b/src/test-libdbuspolicy1-ownership-gdi.cpp
@@ -101,7 +101,7 @@ bool ownership_test(const DB &db) {
 
 bool run_policy_db() {
        __internal_init(SYSTEM_BUS, "tests/default_allow/system.conf");
-       auto &db = policy_checker().getPolicyDb(SYSTEM_BUS);
+       auto &db = policy_checker_system().getPolicyDb();
        printf("POLICY DB:\n");
        return ownership_test(db);
 }

diff --git a/src/test-libdbuspolicy1-send_destination_prefix-deny-gdi.cpp b/src/test-libdbuspolicy1-send_destination_prefix-deny-gdi.cpp
index 45938c5..a7e96d1 100644 (file)
--- a/src/test-libdbuspolicy1-send_destination_prefix-deny-gdi.cpp
+++ b/src/test-libdbuspolicy1-send_destination_prefix-deny-gdi.cpp
@@ -183,7 +183,7 @@ bool send_prefix_test(const DB &db)
 
 bool run_policy_db() {
        __internal_init(SYSTEM_BUS, "tests/default_deny/system.conf");
-       auto &db = policy_checker().getPolicyDb(SYSTEM_BUS);
+       auto &db = policy_checker_system().getPolicyDb();
        printf("POLICY_DB:\n");
        return send_prefix_test(db);
 }

diff --git a/src/test-libdbuspolicy1-signal-gdi.cpp b/src/test-libdbuspolicy1-signal-gdi.cpp
index 5f7f04d..dcf39aa 100644 (file)
--- a/src/test-libdbuspolicy1-signal-gdi.cpp
+++ b/src/test-libdbuspolicy1-signal-gdi.cpp
@@ -77,7 +77,7 @@ bool signal_test(const DB &db) {
 
 bool run_policy_db() {
        __internal_init(SYSTEM_BUS, "tests/default_allow/system.conf");
-       auto &db = policy_checker().getPolicyDb(SYSTEM_BUS);
+       auto &db = policy_checker_system().getPolicyDb();
 
        printf("POLICY_DB:\n");
        return signal_test(db);