Fix resetting prepared statement

[platform/core/security/security-manager.git] / src / common / privilege_db.cpp

diff --git a/src/common/privilege_db.cpp b/src/common/privilege_db.cpp
index 2ca3c3a..0498f21 100644 (file)
--- a/src/common/privilege_db.cpp
+++ b/src/common/privilege_db.cpp
@@ -76,11 +76,22 @@ void PrivilegeDb::initDataCommands()
     }
 }
 
-DB::SqlConnection::DataCommandAutoPtr & PrivilegeDb::getQuery(QueryType queryType)
+PrivilegeDb::StatementWrapper::StatementWrapper(DB::SqlConnection::DataCommandAutoPtr &ref)
+    : m_ref(ref) {}
+
+PrivilegeDb::StatementWrapper::~StatementWrapper()
 {
-    auto &command = m_commands.at(static_cast<size_t>(queryType));
-    command->Reset();
-    return command;
+    m_ref->Reset();
+}
+
+DB::SqlConnection::DataCommand* PrivilegeDb::StatementWrapper::operator->()
+{
+    return m_ref.get();
+}
+
+PrivilegeDb::StatementWrapper PrivilegeDb::getStatement(StmtType queryType)
+{
+    return StatementWrapper(m_commands.at(static_cast<size_t>(queryType)));
 }
 
 PrivilegeDb::~PrivilegeDb()
@@ -119,8 +130,8 @@ void PrivilegeDb::RollbackTransaction(void)
 bool PrivilegeDb::PkgIdExists(const std::string &pkgId)
 {
     return try_catch<bool>([&] {
-        auto &command = getQuery(QueryType::EPkgIdExists);
-        command->BindString(1, pkgId.c_str());
+        auto command = getStatement(StmtType::EPkgIdExists);
+        command->BindString(1, pkgId);
         return command->Step();
     });
 }
@@ -128,8 +139,8 @@ bool PrivilegeDb::PkgIdExists(const std::string &pkgId)
 bool PrivilegeDb::GetAppPkgId(const std::string &appId, std::string &pkgId)
 {
     return try_catch<bool>([&] {
-        auto &command = getQuery(QueryType::EGetPkgId);
-        command->BindString(1, appId.c_str());
+        auto command = getStatement(StmtType::EGetPkgId);
+        command->BindString(1, appId);
 
         if (!command->Step()) {
             // No application with such appId
@@ -147,14 +158,14 @@ void PrivilegeDb::AddApplication(const std::string &appId,
         const std::string &pkgId, uid_t uid)
 {
     try_catch<void>([&] {
-        auto &command = getQuery(QueryType::EAddApplication);
-        command->BindString(1, appId.c_str());
-        command->BindString(2, pkgId.c_str());
+        auto command = getStatement(StmtType::EAddApplication);
+        command->BindString(1, appId);
+        command->BindString(2, pkgId);
         command->BindInteger(3, static_cast<unsigned int>(uid));
 
         if (command->Step()) {
             LogDebug("Unexpected SQLITE_ROW answer to query: " <<
-                    Queries.at(QueryType::EAddApplication));
+                    Queries.at(StmtType::EAddApplication));
         };
 
         LogDebug("Added appId: " << appId << ", pkgId: " << pkgId);
@@ -171,13 +182,13 @@ void PrivilegeDb::RemoveApplication(const std::string &appId, uid_t uid,
             return;
         }
 
-        auto &command = getQuery(QueryType::ERemoveApplication);
-        command->BindString(1, appId.c_str());
+        auto command = getStatement(StmtType::ERemoveApplication);
+        command->BindString(1, appId);
         command->BindInteger(2, static_cast<unsigned int>(uid));
 
         if (command->Step()) {
             LogDebug("Unexpected SQLITE_ROW answer to query: " <<
-                    Queries.at(QueryType::ERemoveApplication));
+                    Queries.at(StmtType::ERemoveApplication));
         };
 
         LogDebug("Removed appId: " << appId);
@@ -190,8 +201,8 @@ void PrivilegeDb::GetPkgPrivileges(const std::string &pkgId, uid_t uid,
         std::vector<std::string> &currentPrivileges)
 {
     try_catch<void>([&] {
-        auto &command = getQuery(QueryType::EGetPkgPrivileges);
-        command->BindString(1, pkgId.c_str());
+        auto command = getStatement(StmtType::EGetPkgPrivileges);
+        command->BindString(1, pkgId);
         command->BindInteger(2, static_cast<unsigned int>(uid));
 
         while (command->Step()) {
@@ -206,11 +217,9 @@ void PrivilegeDb::GetAppPrivileges(const std::string &appId, uid_t uid,
         std::vector<std::string> &currentPrivileges)
 {
     try_catch<void>([&] {
-        DB::SqlConnection::DataCommandAutoPtr &command =
-                m_commands.at(static_cast<size_t>(QueryType::EGetAppPrivileges));
+        auto command = getStatement(StmtType::EGetAppPrivileges);
 
-        command->Reset();
-        command->BindString(1, appId.c_str());
+        command->BindString(1, appId);
         command->BindInteger(2, static_cast<unsigned int>(uid));
         currentPrivileges.clear();
 
@@ -225,12 +234,12 @@ void PrivilegeDb::GetAppPrivileges(const std::string &appId, uid_t uid,
 void PrivilegeDb::RemoveAppPrivileges(const std::string &appId, uid_t uid)
 {
     try_catch<void>([&] {
-        auto &command = getQuery(QueryType::ERemoveAppPrivileges);
-        command->BindString(1, appId.c_str());
+        auto command = getStatement(StmtType::ERemoveAppPrivileges);
+        command->BindString(1, appId);
         command->BindInteger(2, static_cast<unsigned int>(uid));
         if (command->Step()) {
             LogDebug("Unexpected SQLITE_ROW answer to query: " <<
-                    Queries.at(QueryType::ERemoveAppPrivileges));
+                    Queries.at(StmtType::ERemoveAppPrivileges));
         }
 
         LogDebug("Removed all privileges for appId: " << appId);
@@ -241,14 +250,14 @@ void PrivilegeDb::UpdateAppPrivileges(const std::string &appId, uid_t uid,
         const std::vector<std::string> &privileges)
 {
     try_catch<void>([&] {
-        auto &command = getQuery(QueryType::EAddAppPrivileges);
-        command->BindString(1, appId.c_str());
+        auto command = getStatement(StmtType::EAddAppPrivileges);
+        command->BindString(1, appId);
         command->BindInteger(2, static_cast<unsigned int>(uid));
 
         RemoveAppPrivileges(appId, uid);
 
         for (const auto &privilege : privileges) {
-            command->BindString(3, privilege.c_str());
+            command->BindString(3, privilege);
             command->Step();
             command->Reset();
             LogDebug("Added privilege: " << privilege << " to appId: " << appId);
@@ -260,8 +269,8 @@ void PrivilegeDb::GetPrivilegeGroups(const std::string &privilege,
         std::vector<std::string> &groups)
 {
    try_catch<void>([&] {
-        auto &command = getQuery(QueryType::EGetPrivilegeGroups);
-        command->BindString(1, privilege.c_str());
+        auto command = getStatement(StmtType::EGetPrivilegeGroups);
+        command->BindString(1, privilege);
 
         while (command->Step()) {
             std::string groupName = command->GetColumnString(0);
@@ -274,7 +283,7 @@ void PrivilegeDb::GetPrivilegeGroups(const std::string &privilege,
 void PrivilegeDb::GetUserApps(uid_t uid, std::vector<std::string> &apps)
 {
    try_catch<void>([&] {
-        auto &command = getQuery(QueryType::EGetUserApps);
+        auto command = getStatement(StmtType::EGetUserApps);
         command->BindInteger(1, static_cast<unsigned int>(uid));
         apps.clear();
         while (command->Step()) {
@@ -289,11 +298,9 @@ void PrivilegeDb::GetAppIdsForPkgId(const std::string &pkgId,
         std::vector<std::string> &appIds)
 {
     try_catch<void>([&] {
-        DB::SqlConnection::DataCommandAutoPtr &command =
-                m_commands.at(static_cast<size_t>(QueryType::EGetAppsInPkg));
+        auto command = getStatement(StmtType::EGetAppsInPkg);
 
-        command->Reset();
-        command->BindString(1, pkgId.c_str());
+        command->BindString(1, pkgId);
         appIds.clear();
 
         while (command->Step()) {
@@ -304,4 +311,79 @@ void PrivilegeDb::GetAppIdsForPkgId(const std::string &pkgId,
     });
 }
 
+void PrivilegeDb::GetDefaultMapping(const std::string &version_from,
+                                    const std::string &version_to,
+                                    std::vector<std::string> &mappings)
+{
+    try_catch<void>([&] {
+        auto command = getStatement(StmtType::EGetDefaultMappings);
+        command->BindString(1, version_from);
+        command->BindString(2, version_to);
+
+        mappings.clear();
+        while (command->Step()) {
+            std::string mapping = command->GetColumnString(0);
+            LogDebug("Default Privilege from version " << version_from
+                    <<" to version " << version_to << " is " << mapping);
+            mappings.push_back(mapping);
+        }
+    });
+}
+
+void PrivilegeDb::GetPrivilegeMappings(const std::string &version_from,
+                                       const std::string &version_to,
+                                       const std::string &privilege,
+                                       std::vector<std::string> &mappings)
+{
+    try_catch<void>([&] {
+        auto command = getStatement(StmtType::EGetPrivilegeMappings);
+        command->BindString(1, version_from);
+        command->BindString(2, version_to);
+        command->BindString(3, privilege);
+
+        mappings.clear();
+        while (command->Step()) {
+            std::string mapping = command->GetColumnString(0);
+            LogDebug("Privilege " << privilege << " in version " << version_from
+                    <<" has mapping " << mapping << " in version " << version_to);
+            mappings.push_back(mapping);
+        }
+    });
+}
+
+void PrivilegeDb::GetPrivilegesMappings(const std::string &version_from,
+                                        const std::string &version_to,
+                                        const std::vector<std::string> &privileges,
+                                        std::vector<std::string> &mappings)
+{
+    try_catch<void>([&] {
+        auto deleteCmd = getStatement(StmtType::EDeletePrivilegesToMap);
+        deleteCmd->Step();
+
+        auto insertCmd = getStatement(StmtType::EInsertPrivilegeToMap);
+        for (auto &privilege : privileges) {
+            if (privilege.empty())
+                continue;
+            insertCmd->BindString(1, privilege);
+            insertCmd->Step();
+            insertCmd->Reset();
+        }
+
+        insertCmd->BindNull(1);
+        insertCmd->Step();
+
+        auto queryCmd = getStatement(StmtType::EGetPrivilegesMappings);
+        queryCmd->BindString(1, version_from);
+        queryCmd->BindString(2, version_to);
+
+        mappings.clear();
+        while (queryCmd->Step()) {
+            std::string mapping = queryCmd->GetColumnString(0);
+            LogDebug("Privilege set  in version " << version_from
+                     <<" has mapping " << mapping << " in version " << version_to);
+             mappings.push_back(mapping);
+        }
+    });
+}
+
 } //namespace SecurityManager